update changelog for release v0.7.5-beta [no ci]

plex scanner improvement (#1193 )
* fix crash with some plex multi-episode files * comments cleanup
2023-03-05 10:12:21 -06:00 · 2023-03-03 06:08:42 -06:00 · 2023-03-02 22:49:21 -06:00 · 2023-03-02 20:57:38 -06:00 · 2023-03-02 20:13:34 -06:00 · 2023-03-02 06:00:36 -06:00
644 changed files with 85829 additions and 8110 deletions
@@ -33,10 +33,10 @@ jobs:
    strategy:
      matrix:
        include:
-          - os: macos-latest
+          - os: macos-11
            kind: macOS
            target: osx-x64
-          - os: macos-latest
+          - os: macos-11
            kind: macOS
            target: osx-arm64
    steps:
@@ -47,9 +47,9 @@ jobs:
          submodules: true

      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v2
+        uses: actions/setup-dotnet@v3
        with:
-          dotnet-version: 6.0.x
+          dotnet-version: 7.0.x

      - name: Setup Node.js
        uses: actions/setup-node@v3
@@ -57,7 +57,7 @@ jobs:
          node-version: '14'

      - name: Cache NPM dependencies
-        uses: bahmutov/npm-install@v1.4.5
+        uses: bahmutov/npm-install@v1.8.28
        with:
          working-directory: ErsatzTV/client-app

@@ -81,7 +81,10 @@ jobs:

      - name: Build
        shell: bash
-        run: dotnet publish ErsatzTV/ErsatzTV.csproj --framework net6.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+        run: |
+          sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true

      - name: Bundle
        shell: bash
@@ -131,6 +134,7 @@ jobs:

      - name: Delete old release assets
        uses: mknejp/delete-release-assets@v1
+        if: ${{ inputs.release_tag == 'develop' }}
        with:
          token: ${{ secrets.gh_token }}
          tag: ${{ inputs.release_tag }}
@@ -173,17 +177,23 @@ jobs:
          fetch-depth: 0

      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v2
+        uses: actions/setup-dotnet@v3
        with:
-          dotnet-version: 6.0.x
+          dotnet-version: 7.0.x

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '14'

+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+        if: ${{ matrix.kind == 'windows' }}
+
      - name: Cache NPM dependencies
-        uses: bahmutov/npm-install@v1.4.5
+        uses: bahmutov/npm-install@v1.8.28
        with:
          working-directory: ErsatzTV/client-app

@@ -193,12 +203,12 @@ jobs:
      - name: Install dependencies
        run: dotnet restore -r "${{ matrix.target }}"

-      - uses: suisei-cn/actions-download-file@v1
+      - uses: suisei-cn/actions-download-file@v1.3.0
        if: ${{ matrix.kind == 'windows' }}
        id: downloadffmpeg
        name: Download ffmpeg
        with:
-          url: "https://github.com/GyanD/codexffmpeg/releases/download/5.0/ffmpeg-5.0-full_build.7z"
+          url: "https://github.com/GyanD/codexffmpeg/releases/download/6.0/ffmpeg-6.0-full_build.7z"
          target: ffmpeg/

      - name: Build
@@ -209,11 +219,15 @@ jobs:
          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV

          # Build everything
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net6.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true

          # Build Windows launcher
          if [ "${{ matrix.kind }}" == "windows" ]; then
-            dotnet publish ErsatzTV-Windows/ErsatzTV-Windows.csproj --framework net6.0-windows --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+            cargo build --manifest-path=ErsatzTV-Windows/Cargo.toml --release --all-features
+            ls -l ErsatzTV-Windows/target/release
+            mv ErsatzTV-Windows/target/release/ersatztv_windows.exe "$release_name/ErsatzTV-Windows.exe"
          fi

          # Download ffmpeg
@@ -237,6 +251,7 @@ jobs:

      - name: Delete old release assets
        uses: mknejp/delete-release-assets@v1
+        if: ${{ inputs.release_tag == 'develop' }}
        with:
          token: ${{ secrets.gh_token }}
          tag: ${{ inputs.release_tag }}
@@ -2,20 +2,21 @@
 on:
  pull_request:
 jobs:
-  build_and_test:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ windows-latest, ubuntu-latest, macos-latest ]
+  build_and_test_windows:
+    runs-on: windows-latest
    steps:
      - name: Get the sources
        uses: actions/checkout@v3

      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v2
+        uses: actions/setup-dotnet@v3
        with:
-          dotnet-version: 6.0.x
+          dotnet-version: 7.0.x
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable

      - name: Clean
        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -23,6 +24,67 @@ jobs:
      - name: Install dependencies
        run: dotnet restore

+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --no-restore --verbosity normal
+
+      - name: Build Windows
+        run: |
+          cd ErsatzTV-Windows
+          cargo build --release --all-features
+  build_and_test_linux:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v3
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --no-restore --verbosity normal
+  build_and_test_mac:
+    runs-on: macos-11
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
      - name: Build
        run: dotnet build --configuration Release --no-restore

@@ -5,6 +5,293 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

 ## [Unreleased]

+## [0.7.5-beta] - 2023-03-05
+### Added
+- Use AV1 hardware-accelerated decoder with VAAPI, QSV, NVIDIA when available
+- Use VP9 hardware-accelerated decoder with VAAPI when available
+
+### Fixed
+- Align default docker image (no acceleration) with new images from [ErsatzTV-ffmpeg](https://github.com/jasongdove/ErsatzTV-ffmpeg)
+- Fix some transcoding pipelines that use software decoders
+- Improve VAAPI encoder capability detection on newer hardware
+- Fix trash page to properly display episodes with missing metadata or titles
+- Fix playback of content with yuv444p10le pixel format
+- Fix case where some multi-episode files from Plex would crash the scanner
+
+### Changed
+- Upgrade all docker images and windows builds to ffmpeg 6.0
+- Plex, Jellyfin and Emby libraries now retrieve all metadata and statistics from the media server
+  - File systems will no longer be periodically scanned for libraries using these media sources
+- Plex, Jellyfin and Emby libraries now direct stream content when files are not found on ErsatzTV's file system
+  - Content will still be normalized according to the Channel and FFmpeg Profile settings
+  - Streaming from disk is preferred, so every playback attempt will first check the local file system
+- Use libvpl instead of libmfx to provide intel acceleration in vaapi docker images
+- Search queries no longer remove duplicate results as this was causing incorrect behavior
+- Prioritize audio streams that are flagged as "default" over number of audio channels
+    - For example, a video with a stereo commentary track and a mono "default" track will now prefer the "default" track
+- Support many more season folder names with local television libraries
+
+## [0.7.4-beta] - 2023-02-12
+### Added
+- Add button to copy/clone schedule from schedules table
+- Synchronize episode tags and genres from Jellyfin, Emby and Local show libraries
+- Add `Deep Scan` button to Jellyfin and Emby libraries
+  - This is now required to update some metadata for existing libraries, when targeted updates are not possible
+  - For example, if you already have tags and genres on your episodes in Jellyfin or Emby, you will need to deep scan each library to update that metadata on existing items in ErsatzTV
+
+### Fixed
+- Fix many QSV pipeline bugs
+- Fix MPEG2 video format with QSV and VAAPI acceleration
+- Fix playback of content with undefined colorspace
+- Fix NVIDIA color normalization with VP9 sources
+- Fix fallback filler looping
+- Fix bug where some libraries would never scan
+- Fix filler ordering so post-roll is properly scheduled after padded mid-roll
+- Fix pre/post-roll filler padding when used with mid-roll
+  - This caused overlapping schedule items, fallback filler that was too long, etc.
+
+### Changed
+- Merge generated `Other Video` folder tags with tags from sidecar NFO
+- Prioritize audio streams that are flagged as "default" when multiple candidate streams are available
+  - For example, a video with a stereo commentary track and a stereo "default" track will now prefer the "default" track 
+
+## [0.7.3-beta] - 2023-01-25
+### Added
+- Attempt to release memory periodically
+- Add OpenID Connect (OIDC) support (e.g. Keycloak, Authelia, Auth0)
+  - This only protects the management UI; all streaming endpoints will continue to allow anonymous access 
+  - This can be configured with the following env vars (note the double underscore separator `__`)
+    - `OIDC__AUTHORITY`
+    - `OIDC__CLIENTID`
+    - `OIDC__CLIENTSECRET`
+    - `OIDC__LOGOUTURI` (optional, needed for Auth0, use `https://{auth0-domain}/v2/logout?client_id={auth0-client-id}` with proper values for domain and client-id)
+- Add *experimental* alternate schedule system
+  - This allows a single playout to dynamically select a schedule based on date criteria, for example:
+    - Weekday vs weekend schedules
+    - Summer vs fall schedules
+    - Shark week schedules
+  - Alternate schedules can be managed by clicking the calendar icon in the playout list
+  - Playouts contain a prioritized (top to bottom) list of alternate schedules
+  - Whenever a playout is built for a given day, ErsatzTV will check for a matching schedule from top to bottom
+  - A given day must match all alternate schedule parameters; wildcards (`*any*`) will always match
+    - Day of week
+    - Day of month
+    - Month
+  - The lowest priority (bottom) item will always match all parameters, and can be considered a "default" or "fallback" schedule 
+
+### Fixed
+- Fix schedule editor crashing due to bad music video artist data
+- Fix bug where playouts would not maintain smart collection progress on schedules that use multiple smart collections
+- Fix library scanning on osx-arm64
+- Fix ability to remove some media server libraries from ErsatzTV
+
+### Changed
+- Always use software pipeline for error display
+  - This ensures errors will display even when hardware acceleration is misconfigured
+- Call scanner process only when scanning is required based on library refresh interval
+- Use lower process priority for scanner process with unforced (automatic) library scans
+- Disable V2 UI and APIs by default
+  - V2 UI can be re-enabled by setting the env var `ETV_UI_V2` to any value
+
+## [0.7.2-beta] - 2023-01-05
+### Fixed
+- Fix VAAPI encoding in docker by switching to non-free driver
+
+### Changed
+- Rewrite log page to read directly from log files instead of sqlite
+
+## [0.7.1-beta] - 2023-01-03
+### Added
+- Add new music video credit templates
+
+### Fixed
+- Fix many transcoding failures caused by the colorspace filter
+- Fix song playback with VAAPI and NVENC
+- Fix edge case where some local movies would not automatically be restored from trash
+- Fix synchronizing Jellyfin and Emby collection items
+- Fix saving some external subtitle records to database 
+
+### Changed
+- Upgrade to dotnet 7
+- Upgrade all docker images to ubuntu jammy and ffmpeg 5.1.2
+- Limit library scan interval between 0 and 1,000,000
+  - 0 means do not automatically scan libraries
+  - 1 to 999,999 means scan if it has been that many hours since the last scan
+- Use new `ErsatzTV.Scanner` process for scanning all libraries
+  - This should reduce the ongoing memory footprint
+
+## [0.7.0-beta] - 2022-12-11
+### Fixed
+- Fix removing Jellyfin and Emby libraries that have been deleted from the source media server
+- Fix `Work-Ahead HLS Segmenter Limit` setting to properly limit number of channels that can work-ahead at once
+- Include base path value in generated channel playlist (M3U) and channel guide (XMLTV) links
+- Fix parsing song metadata from OGG audio files
+- Properly unlock/re-enable trakt list operations after an operation is canceled
+
+### Added
+- Add (required) bit depth normalization option to ffmpeg profile
+  - This can help if your card only supports e.g. h264 encoding, normalizing to 8 bits will allow the hardware encoder to be used
+- Extract font attachments after extracting text subtitles
+  - This should improve SubStation Alpha subtitle rendering
+- Detect VAAPI capabilities and fallback to software decoding/encoding as needed
+- Add audio stream selector scripts for episodes and movies
+  - This will let you customize which audio stream is selected for playback
+  - Episodes are passed the following data:
+    - `channelNumber`
+    - `channelName`
+    - `showTitle`
+    - `showGuids`: array of string ids like `imdb_1234` or `tvdb_1234`
+    - `seasonNumber`
+    - `episodeNumber`
+    - `episodeGuids`: array of string ids like `imdb_1234` or `tvdb_1234`
+    - `preferredLanguageCodes`: array of string preferred language codes configured for the channel
+    - `audioStreams`: array of audio stream data, each containing
+      - `index`: the stream's index number, this is what the function needs to return
+      - `channels`: the number of audio channels
+      - `codec`: the audio codec
+      - `isDefault`: bool indicating whether the stream is flagged as default
+      - `isForced`: bool indicating whether the stream is flagged as forced
+      - `language`: the stream's language
+      - `title`: the stream's title
+  - Movies are passed the following data:
+      - `channelNumber`
+      - `channelName`
+      - `title`
+      - `guids`: array of string ids like `imdb_1234` or `tvdb_1234`
+    - `preferredLanguageCodes`: array of string preferred language codes configured for the channel
+    - `audioStreams`: array of audio stream data, each containing
+        - `index`: the stream's index number, this is what the function needs to return
+        - `channels`: the number of audio channels
+        - `codec`: the audio codec
+        - `isDefault`: bool indicating whether the stream is flagged as default
+        - `isForced`: bool indicating whether the stream is flagged as forced
+        - `language`: the stream's language
+        - `title`: the stream's title
+- Add new fields to search index
+  - `video_codec`: the video codec
+  - `video_bit_depth`: the number of bits in the video stream's pixel format, e.g. 8 or 10
+  - `video_dynamic_range`: the video's dynamic range, either `sdr` or `hdr`
+
+### Changed
+- Change `Multi-Episode Shuffle` scripting system to use Javascript instead of Lua
+
+## [0.6.9-beta] - 2022-10-21
+### Fixed
+- Fix bug where tail or fallback filler would sometimes schedule much longer than expected
+  - This only happened with fixed start schedule items following a schedule item with tail or fallback filler
+- Fix NFO reader bug that caused inaccurate warning messages about invalid XML and incomplete metadata
+- Fix reverse proxy SSL termination support by supporting `X-Forwarded-Proto` header
+- Fix automatic playout reset scheduling
+  - Playouts would reset every 30 minutes between midnight and the configured time, instead of only at the configured time
+- XMLTV: properly group schedule items with `Custom Title` followed by item(s) with `Guide Mode` set to `Filler`
+
+### Added
+- Add music video credits template system
+  - Templates are selected in each channel's settings 
+  - Templates should be copied from `_default.ass.sbntxt` which is located in the config subfolder `templates/music-video-credits`
+    - Copy the file, give it any name ending with `.ass.sbntext`, and only make edits to the copied file
+  - The default template will be extracted and overwritten every time ErsatzTV is started
+  - The template is an [Advanced SubStation Alpha](http://www.tcax.org/docs/ass-specs.htm) file using [scribian](https://github.com/scriban/scriban/tree/master/doc) template syntax
+  - The following fields are available for use in the template:
+    - `resolution`: the ffmpeg profile's resolution, which is used for margin calculations
+    - `title`: the title of the music video
+    - `track`: the music video's track number
+    - `album`: the music video's album
+    - `plot`: the music video's plot
+    - `release_date`: the music video's release date
+    - `artist`: the music videos artist (the parent folder)
+    - `all_artists`: a list of additional artists from the music video's sidecar NFO metadata file
+    - `duration`: the timespan duration of the music video, which can be used to calculate timing of additional subtitles
+    - `stream_seek`: the timespan that ffmpeg will seek into the media item before beginning playback
+- Add `Multi-Episode Shuffle` playout order for `Television Show` schedule items
+  - The purpose of this playout order is to improve randomization for shows that normally have intro, multiple episodes, and outro
+  - This playout order requires splitting the parts into individual files (e.g. splitting `s01e01-03.mkv` into `s01e01.mkv`, `s01e02.mkv` and `s01e03.mkv`)
+  - This playout order requires a lua script in the config subfolder `scripts/multi-episode-shuffle`
+  - The lua script should be named for the television show's guid, e.g. `tvdb_12345.lua` or `imdb_tt123456789.lua`
+  - The script defines the number of parts that each un-split file typically contains
+  - The script also defines a function to map each episode to a part number (or no part number i.e. `nil` if an episode has not been split)
+  - All groups of part numbers (i.e. all part 1s, all part 2s) will be shuffled
+  - The playout order will then schedule a random part 1 followed by a random part 2, etc
+    - Un-split (`nil`) episodes will be randomly placed between re-combined parts (e.g. part1, part2, part3, un-split, part1, part2, part3)
+- Add `ETV_BASE_URL` environment variable to support reverse proxies that use paths (e.g. `/ersatztv`)
+
+### Changed
+- No longer place watermarks within content by default (e.g. within 4:3 content padded to a 16:9 resolution)
+  - This can be re-enabled if desired using the `Place Within Source Content` checkbox in watermark settings
+
+## [0.6.8-beta] - 2022-10-05
+### Fixed
+- Fix typo introduced in `0.6.7-beta` that stopped QSV HEVC encoder from working
+- Fix scaling logic for `Nvidia` acceleration and software mode
+- Attempt to position watermarks within content (not over added black padding)
+- Fix search results for `Other Videos` when NFO metadata is used
+- Properly synchronize tags from Emby movies and shows
+- Properly sync updated file paths from Plex
+- Fix numeric range search queries (e.g. `minutes:[5 TO 10]`, `minutes:[* TO 3]`)
+
+### Added
+- Add `QSV Device` option to ffmpeg profile on linux
+- Add guids to search index (e.g. `imdb:tt000000`, `tvdb:12345`)
+
+## [0.6.7-beta] - 2022-09-05
+### Fixed
+- When all audio streams are selected with `HLS Direct`, explicitly copy them without transcoding
+  - This only happens when the channel does not have a `Preferred Audio Language`
+- Fix scanner crash caused by invalid mtime
+- `VAAPI`: Downgrade libva from 2.15 to 2.14
+- Fix bug with XMLTV that caused some filler to display with primary content details
+- Multiple fixes for content scaling with `Nvidia`, `Qsv` and `Vaapi` accelerations
+- Properly scale image-based subtitles
+- Fix bug where a schedule containing a single item (fixed start and flood) would never finish building a playout
+  - Logic was also added to detect infinite playout build loops in the future and stop them
+- Fix bug where `Other Videos` wouldn't be included in scheduling mode `Shuffle In Order`
+
+### Added
+- Add `Preferred Audio Title` feature
+    - Preference can be configured in channel settings and overridden on schedule items
+    - When a title is specified, audio streams that contain that title (case-insensitive search) will be prioritized
+    - This can be helpful for creating channels that use commentary tracks
+    - External tooling exists to easily update title/name metadata if your audio streams don't already have this metadata
+- Add `Amf` hardware acceleration option for AMD GPUs on Windows
+- Add `QSV Extra Hardware Frames` parameter for tuning QSV acceleration
+  - Performance may improve on some systems after doubling or halving the default value of `64`
+
+## [0.6.6-beta] - 2022-08-17
+### Fixed
+- Use MIME Type `application/x-mpegurl` for all playlists instead of `application/vnd.apple.mpegurl`
+- Replace `setsar` filter with `setdar` filter
+  - `setsar` caused issues scaling between two different aspect ratios
+    - For example, some 4:3 content would appear stretched when scaled to a 16:9 resolution
+  - `setdar` is now only used when aspect ratios match 
+- Prioritize aspect ratio from container when video stream contains conflicting aspect ratio
+  - This is usually caused by bad authoring, but the change should improve scaling behavior for edge cases
+
+### Added
+- Support DSD audio file formats (DFF and DSF) in local song libraries
+- Support OGG audio file formats (OGG, OPUS, OGA, OGX, SPX) in local song libraries
+
+### Changed
+- Always return playlist after a maximum of 8 seconds while starting up an HLS Segmenter session
+- Use multi-variant playlists instead of redirects for HLS Segmenter sessions
+- Upgrade ffmpeg from 5.0 to 5.1 in most docker images (not ARM variants)
+    - Upgrading from 5.0 to 5.1 is also recommended for other installations (Windows, Linux)
+
+## [0.6.5-beta] - 2022-08-02
+### Fixed
+- Fix database initializer; fresh installs with v0.6.4-beta are missing some config data and should upgrade
+
+## [0.6.4-beta] - 2022-07-28
+### Fixed
+- Fix subtitle stream selection when subtitle language is different than audio language
+- Fix bug with unsupported AAC channel layouts
+- Fix NVIDIA second-gen maxwell capabilities detection
+- Return distinct search results for episodes and other videos that have the same title
+  - For example, two other videos both named `Trailer` would previously have displayed as one item in search results
+- Fix schedules that would begin to repeat the same content in the same order after a couple of days
+
+### Added
+- Add `640x480` resolution
+
 ## [0.6.3-beta] - 2022-07-04
 ### Fixed
 - Maintain stream continuity when playout is rebuilt for a channel that is actively being streamed
@@ -1264,7 +1551,20 @@ 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.6.2-beta...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.5-beta...HEAD
+[0.7.5-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.4-beta...v0.7.5-beta
+[0.7.4-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.3-beta...v0.7.4-beta
+[0.7.3-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.2-beta...v0.7.3-beta
+[0.7.2-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.1-beta...v0.7.2-beta
+[0.7.1-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.0-beta...v0.7.1-beta
+[0.7.0-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.9-beta...v0.7.0-beta
+[0.6.9-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.8-beta...v0.6.9-beta
+[0.6.8-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.7-beta...v0.6.8-beta
+[0.6.7-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.6-beta...v0.6.7-beta
+[0.6.6-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.5-beta...v0.6.6-beta
+[0.6.5-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.4-beta...v0.6.5-beta
+[0.6.4-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.3-beta...v0.6.4-beta
+[0.6.3-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.2-beta...v0.6.3-beta
 [0.6.2-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.1-beta...v0.6.2-beta
 [0.6.1-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.0-beta...v0.6.1-beta
 [0.6.0-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.8-beta...v0.6.0-beta
@@ -1363,4 +1663,4 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 [0.0.5-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.4-prealpha...v0.0.5-prealpha
 [0.0.4-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.3-prealpha...v0.0.4-prealpha
 [0.0.3-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.1-prealpha...v0.0.3-prealpha
-[0.0.1-prealpha]: https://github.com/jasongdove/ErsatzTV/releases/tag/v0.0.1-prealpha
+[0.0.1-prealpha]: https://github.com/jasongdove/ErsatzTV/releases/tag/v0.0.1-prealpha
@@ -0,0 +1,2 @@
+target/
+
@@ -0,0 +1,19 @@
+[package]
+name = "ersatztv_windows"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tray-item = { git = "https://github.com/olback/tray-item-rs" }
+special-folder = { git = "https://github.com/masinc/special-folder-rs" }
+process_path = "0.1.4"
+
+[dependencies.windows]
+version = "0.43.0"
+features = [
+    "Win32_System_Console",
+    "Win32_Foundation"
+]
+
+[build-dependencies]
+windres = "*"
@@ -1,33 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <OutputType>WinExe</OutputType>
-        <TargetFramework>net6.0-windows</TargetFramework>
-        <RootNamespace>ErsatzTV_Windows</RootNamespace>
-        <Nullable>enable</Nullable>
-        <UseWindowsForms>true</UseWindowsForms>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <ApplicationIcon>Ersatztv.ico</ApplicationIcon>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <Content Include="Ersatztv.ico">
-        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-      </Content>
-    </ItemGroup>
-
-    <ItemGroup>
-      <PackageReference Include="CliWrap" Version="3.4.4" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\ErsatzTV.Core\ErsatzTV.Core.csproj" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <Compile Update="Program.cs">
-        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-      </Compile>
-    </ItemGroup>
-
-</Project>
@@ -1,14 +0,0 @@
-namespace ErsatzTV_Windows;
-
-public static class Program
-{
-    /// <summary>
-    ///  The main entry point for the application.
-    /// </summary>
-    [STAThread]
-    public static void Main()
-    {
-        ApplicationConfiguration.Initialize();
-        Application.Run(new TrayApplicationContext());
-    }
-}
@@ -1,81 +0,0 @@
-using ErsatzTV.Core;
-using System.Diagnostics;
-using CliWrap;
-
-namespace ErsatzTV_Windows;
-
-public class TrayApplicationContext : ApplicationContext
-{
-    private readonly NotifyIcon _trayIcon;
-    private readonly CancellationTokenSource _tokenSource;
-
-    public TrayApplicationContext()
-    {
-        _trayIcon = new NotifyIcon
-        {
-            Icon = new Icon("./Ersatztv.ico"),
-            ContextMenuStrip = new ContextMenuStrip(),
-            Visible = true
-        };
-
-        _tokenSource = new CancellationTokenSource();
-
-        AddMenuItem("Launch Web UI", LaunchWebUI);
-        AddMenuItem("Show Logs", ShowLogs);
-        _trayIcon.ContextMenuStrip.Items.Add(new ToolStripSeparator());
-        AddMenuItem("Exit", Exit);
-
-        string folder = AppContext.BaseDirectory;
-        string exe = Path.Combine(folder, "ErsatzTV.exe");
-
-        if (File.Exists(exe))
-        {
-
-            Cli.Wrap(exe)
-                .WithWorkingDirectory(folder)
-                .WithValidation(CommandResultValidation.None)
-                .ExecuteAsync(_tokenSource.Token);
-        }
-    }
-
-    private void AddMenuItem(string name, EventHandler action)
-    {
-        var item = new ToolStripMenuItem(name);
-        item.Click += action;
-        _trayIcon.ContextMenuStrip.Items.Add(item);
-    }
-
-    private void LaunchWebUI(object? sender, EventArgs e)
-    {
-        var process = new Process();
-        process.StartInfo.UseShellExecute = true;
-        process.StartInfo.FileName = "http://localhost:8409";
-        process.Start();
-    }
-
-    private void ShowLogs(object? sender, EventArgs e)
-    {
-        if (!Directory.Exists(FileSystemLayout.LogsFolder))
-        {
-            Directory.CreateDirectory(FileSystemLayout.LogsFolder);
-        }
-
-        var process = new Process();
-        process.StartInfo.UseShellExecute = true;
-        process.StartInfo.FileName = FileSystemLayout.LogsFolder;
-        process.Start();
-    }
-
-    protected override void Dispose(bool disposing)
-    {
-        _tokenSource?.Cancel();
-        base.Dispose(disposing);
-    }
-
-    private void Exit(object? sender, EventArgs e)
-    {
-        // Hide tray icon, otherwise it will remain shown until user mouses over it
-        _trayIcon.Visible = false;
-        Application.Exit();
-    }
-}
@@ -0,0 +1,5 @@
+use windres::Build;
+
+fn main() {
+    Build::new().compile("ersatztv_windows.rc").unwrap();
+}
@@ -0,0 +1,2 @@
+id ICON "ersatztv.ico"
+ersatztv-icon ICON "ersatztv.ico"
@@ -0,0 +1,112 @@
+#![windows_subsystem = "windows"]
+
+use special_folder::SpecialFolder;
+use std::fs;
+use std::os::windows::process::CommandExt;
+use std::process::Child;
+use std::process::Command;
+use std::process::Stdio;
+use windows::Win32::System::Console;
+use {std::sync::mpsc, tray_item::TrayItem};
+
+const CREATE_NO_WINDOW: u32 = 0x08000000;
+
+enum Message {
+    Exit,
+}
+
+fn main() {
+    let mut tray = TrayItem::new("ErsatzTV", "ersatztv-icon").unwrap();
+
+    let (tx, rx) = mpsc::channel();
+
+    tray.add_menu_item("Launch Web UI", || {
+        let _ = Command::new("cmd")
+            .creation_flags(CREATE_NO_WINDOW)
+            .arg("/C")
+            .arg("start")
+            .arg("http://localhost:8409")
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn();
+    })
+        .unwrap();
+
+    tray.add_menu_item("Show Logs", || {
+        let path = SpecialFolder::LocalApplicationData
+            .get()
+            .unwrap()
+            .join("ersatztv")
+            .join("logs");
+        match path.to_str() {
+            None => {}
+            Some(folder) => {
+                fs::create_dir_all(folder).unwrap();
+                let _ = Command::new("cmd")
+                    .creation_flags(CREATE_NO_WINDOW)
+                    .arg("/C")
+                    .arg("start")
+                    .arg(folder)
+                    .stdin(Stdio::null())
+                    .stdout(Stdio::null())
+                    .stderr(Stdio::null())
+                    .spawn();
+            }
+        }
+    })
+        .unwrap();
+
+    tray.inner_mut().add_separator().unwrap();
+
+    tray.add_menu_item("Exit", move || {
+        tx.send(Message::Exit).unwrap();
+    })
+        .unwrap();
+
+    let path = process_path::get_executable_path();
+    let mut child: Option<Child> = None;
+    match path {
+        None => {}
+        Some(path) => {
+            let etv = path.parent().unwrap().join("ErsatzTV.exe");
+            if etv.exists() {
+                match etv.to_str() {
+                    None => {}
+                    Some(etv) => {
+                        child = Some(
+                            Command::new(etv)
+                                .creation_flags(CREATE_NO_WINDOW)
+                                .stdin(Stdio::null())
+                                .stdout(Stdio::null())
+                                .stderr(Stdio::null())
+                                .spawn()
+                                .unwrap(),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    loop {
+        match rx.recv() {
+            Ok(Message::Exit) => {
+                match child {
+                    None => {}
+                    Some(mut child) => {
+                        unsafe {
+                            if Console::AttachConsole(child.id()) == true
+                            {
+                                Console::GenerateConsoleCtrlEvent(Console::CTRL_C_EVENT, 0);
+                            }
+                        }
+                        child.wait().unwrap();
+                    }
+                }
+                break;
+            }
+            _ => {}
+        }
+    }
+}
@@ -1,22 +1,44 @@
 using ErsatzTV.Application.MediaItems;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaItems.Mapper;

 namespace ErsatzTV.Application.Artists;

 public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
 {
-    private readonly IArtistRepository _artistRepository;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;

-    public GetAllArtistsHandler(IArtistRepository artistRepository) => _artistRepository = artistRepository;
+    public GetAllArtistsHandler(IDbContextFactory<TvContext> dbContextFactory)
+    {
+        _dbContextFactory = dbContextFactory;
+    }

-    public Task<List<NamedMediaItemViewModel>> Handle(
+    public async Task<List<NamedMediaItemViewModel>> Handle(
        GetAllArtists request,
-        CancellationToken cancellationToken) =>
-        _artistRepository.GetAllArtists()
-            .Map(
-                list => list.Filter(
-                    a => !string.IsNullOrWhiteSpace(
-                        a.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => string.Empty))))
-            .Map(list => list.Map(ProjectToViewModel).ToList());
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<Artist> allArtists = await dbContext.Artists
+            .AsNoTracking()
+            .Include(a => a.ArtistMetadata)
+            .ToListAsync(cancellationToken: cancellationToken);
+            
+        return allArtists.Bind(a => ProjectArtist(a)).ToList();
+    }
+
+    private static Option<NamedMediaItemViewModel> ProjectArtist(Artist a)
+    {
+        foreach (ArtistMetadata metadata in a.ArtistMetadata.HeadOrNone())
+        {
+            if (!string.IsNullOrWhiteSpace(metadata.Title))
+            {
+                return ProjectToViewModel(a);
+            }
+        }
+
+        return None;
+    }
 }
@@ -11,10 +11,12 @@ public record ChannelViewModel(
    int FFmpegProfileId,
    string Logo,
    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
    StreamingMode StreamingMode,
    int? WatermarkId,
    int? FallbackFillerId,
    int PlayoutCount,
    string PreferredSubtitleLanguageCode,
    ChannelSubtitleMode SubtitleMode,
-    ChannelMusicVideoCreditsMode MusicVideoCreditsMode);
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate);
@@ -12,9 +12,11 @@ public record CreateChannel
    int FFmpegProfileId,
    string Logo,
    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
    StreamingMode StreamingMode,
    int? WatermarkId,
    int? FallbackFillerId,
    string PreferredSubtitleLanguageCode,
    ChannelSubtitleMode SubtitleMode,
-    ChannelMusicVideoCreditsMode MusicVideoCreditsMode) : IRequest<Either<BaseError, CreateChannelResult>>;
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, CreateChannelResult>>;
@@ -71,9 +71,11 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
                    StreamingMode = request.StreamingMode,
                    Artwork = artwork,
                    PreferredAudioLanguageCode = preferredAudioLanguageCode,
+                    PreferredAudioTitle = request.PreferredAudioTitle,
                    PreferredSubtitleLanguageCode = preferredSubtitleLanguageCode,
                    SubtitleMode = request.SubtitleMode,
-                    MusicVideoCreditsMode = request.MusicVideoCreditsMode
+                    MusicVideoCreditsMode = request.MusicVideoCreditsMode,
+                    MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate
                };

                foreach (int id in watermarkId)
@@ -13,9 +13,11 @@ public record UpdateChannel
    int FFmpegProfileId,
    string Logo,
    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
    StreamingMode StreamingMode,
    int? WatermarkId,
    int? FallbackFillerId,
    string PreferredSubtitleLanguageCode,
    ChannelSubtitleMode SubtitleMode,
-    ChannelMusicVideoCreditsMode MusicVideoCreditsMode) : IRequest<Either<BaseError, ChannelViewModel>>;
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, ChannelViewModel>>;
@@ -15,13 +15,13 @@ namespace ErsatzTV.Application.Channels;
 public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
 {
    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly ChannelWriter<ISubtitleWorkerRequest> _ffmpegWorkerChannel;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;

    public UpdateChannelHandler(
-        ChannelWriter<ISubtitleWorkerRequest> ffmpegWorkerChannel,
+        ChannelWriter<IBackgroundServiceRequest> workerChannel,
        IDbContextFactory<TvContext> dbContextFactory)
    {
-        _ffmpegWorkerChannel = ffmpegWorkerChannel;
+        _workerChannel = workerChannel;
        _dbContextFactory = dbContextFactory;
    }

@@ -31,7 +31,7 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
    {
        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
    }

    private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
@@ -42,9 +42,11 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
        c.Categories = update.Categories;
        c.FFmpegProfileId = update.FFmpegProfileId;
        c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;
+        c.PreferredAudioTitle = update.PreferredAudioTitle;
        c.PreferredSubtitleLanguageCode = update.PreferredSubtitleLanguageCode;
        c.SubtitleMode = update.SubtitleMode;
        c.MusicVideoCreditsMode = update.MusicVideoCreditsMode;
+        c.MusicVideoCreditsTemplate = update.MusicVideoCreditsTemplate;
        c.Artwork ??= new List<Artwork>();

        if (!string.IsNullOrWhiteSpace(update.Logo))
@@ -83,7 +85,7 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr

            foreach (Playout playout in maybePlayout)
            {
-                await _ffmpegWorkerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
+                await _workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
            }
        }

@@ -15,13 +15,15 @@ internal static class Mapper
            channel.FFmpegProfileId,
            GetLogo(channel),
            channel.PreferredAudioLanguageCode,
+            channel.PreferredAudioTitle,
            channel.StreamingMode,
            channel.WatermarkId,
            channel.FallbackFillerId,
            channel.Playouts?.Count ?? 0,
            channel.PreferredSubtitleLanguageCode,
            channel.SubtitleMode,
-            channel.MusicVideoCreditsMode);
+            channel.MusicVideoCreditsMode,
+            channel.MusicVideoCreditsTemplate);

    internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
        new(
@@ -2,4 +2,4 @@

 namespace ErsatzTV.Application.Channels;

-public record GetChannelGuide(string Scheme, string Host) : IRequest<ChannelGuide>;
+public record GetChannelGuide(string Scheme, string Host, string BaseUrl) : IRequest<ChannelGuide>;
@@ -19,5 +19,11 @@ public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGu

    public Task<ChannelGuide> Handle(GetChannelGuide request, CancellationToken cancellationToken) =>
        _channelRepository.GetAllForGuide()
-            .Map(channels => new ChannelGuide(_recyclableMemoryStreamManager, request.Scheme, request.Host, channels));
+            .Map(
+                channels => new ChannelGuide(
+                    _recyclableMemoryStreamManager,
+                    request.Scheme,
+                    request.Host,
+                    request.BaseUrl,
+                    channels));
 }
@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelNameByPlayoutId(int PlayoutId) : IRequest<Option<string>>;
@@ -0,0 +1,24 @@
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelNameByPlayoutIdHandler : IRequestHandler<GetChannelNameByPlayoutId, Option<string>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetChannelNameByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory)
+    {
+        _dbContextFactory = dbContextFactory;
+    }
+
+    public async Task<Option<string>> Handle(GetChannelNameByPlayoutId request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.Playouts
+            .Include(p => p.Channel)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.PlayoutId)
+            .MapT(p => p.Channel.Name);
+    }
+}
@@ -2,4 +2,4 @@

 namespace ErsatzTV.Application.Channels;

-public record GetChannelPlaylist(string Scheme, string Host, string Mode) : IRequest<ChannelPlaylist>;
+public record GetChannelPlaylist(string Scheme, string Host, string BaseUrl, string Mode) : IRequest<ChannelPlaylist>;
@@ -14,7 +14,7 @@ public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, Cha
    public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
        _channelRepository.GetAll()
            .Map(channels => EnsureMode(channels, request.Mode))
-            .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, channels));
+            .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, request.BaseUrl, channels));

    private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
    {
@@ -2,4 +2,4 @@

 namespace ErsatzTV.Application.Configuration;

-public record SaveConfigElementByKey(ConfigElementKey Key, string Value) : IRequest<Unit>;
+public record SaveConfigElementByKey(ConfigElementKey Key, string Value) : IRequest;
@@ -2,16 +2,15 @@

 namespace ErsatzTV.Application.Configuration;

-public class SaveConfigElementByKeyHandler : IRequestHandler<SaveConfigElementByKey, Unit>
+public class SaveConfigElementByKeyHandler : IRequestHandler<SaveConfigElementByKey>
 {
    private readonly IConfigElementRepository _configElementRepository;

    public SaveConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
        _configElementRepository = configElementRepository;

-    public async Task<Unit> Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
+    public async Task Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
    {
        await _configElementRepository.Upsert(request.Key, request.Value);
-        return Unit.Default;
    }
 }
@@ -24,8 +24,8 @@ public class UpdateLibraryRefreshIntervalHandler :

    private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
        Optional(request.LibraryRefreshInterval)
-            .Where(lri => lri > 0)
+            .Where(lri => lri is >= 0 and < 1_000_000)
            .Map(_ => Unit.Default)
-            .ToValidation<BaseError>("Tuner count must be greater than zero")
+            .ToValidation<BaseError>("Library refresh interval must be zero or greated")
            .AsTask();
 }
@@ -0,0 +1,98 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.FFmpeg.Runtime;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Emby;
+
+public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchronizeEmbyLibraryById>,
+    IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
+{
+    public CallEmbyLibraryScannerHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IConfigElementRepository configElementRepository,
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>.Handle(
+        ForceSynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    Task<Either<BaseError, string>> IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>.Handle(
+        SynchronizeEmbyLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(
+        ISynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = await Validate(request);
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error =>
+            {
+                foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
+                {
+                    return Task.FromResult<Either<BaseError, string>>(scanIsNotRequired);
+                }
+
+                return Task.FromResult<Either<BaseError, string>>(error.Join());
+            });
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        ISynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-emby", request.EmbyLibraryId.ToString()
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+
+        if (request.DeepScan)
+        {
+            arguments.Add("--deep");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+
+    protected override async Task<DateTimeOffset> GetLastScan(
+        TvContext dbContext,
+        ISynchronizeEmbyLibraryById request)
+    {
+        return await dbContext.EmbyLibraries
+            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyLibraryId)
+            .Match(l => l.LastScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
+    }
+
+    protected override bool ScanIsRequired(
+        DateTimeOffset lastScan,
+        int libraryRefreshInterval,
+        ISynchronizeEmbyLibraryById request)
+    {
+        if (lastScan == SystemTime.MaxValueUtc)
+        {
+            return false;
+        }
+
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
+        return request.ForceScan || (libraryRefreshInterval > 0 && nextScan < DateTimeOffset.Now);
+    }
+}
@@ -1,6 +0,0 @@
-using ErsatzTV.Core;
-
-namespace ErsatzTV.Application.Emby;
-
-public record SynchronizeEmbyCollections(int EmbyMediaSourceId) : IRequest<Either<BaseError, Unit>>,
-    IEmbyBackgroundServiceRequest;
@@ -2,19 +2,20 @@

 namespace ErsatzTV.Application.Emby;

-public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>,
-    IEmbyBackgroundServiceRequest
+public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>, IEmbyBackgroundServiceRequest
 {
    int EmbyLibraryId { get; }
    bool ForceScan { get; }
+    bool DeepScan { get; }
 }

 public record SynchronizeEmbyLibraryByIdIfNeeded(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
 {
    public bool ForceScan => false;
+    public bool DeepScan => false;
 }

-public record ForceSynchronizeEmbyLibraryById(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
+public record ForceSynchronizeEmbyLibraryById(int EmbyLibraryId, bool DeepScan) : ISynchronizeEmbyLibraryById
 {
    public bool ForceScan => true;
 }
@@ -1,3 +1,3 @@
 namespace ErsatzTV.Application.Emby;

-public record EmbyConnectionParametersViewModel(string Address);
+public record EmbyConnectionParametersViewModel(string Address, string ApiKey);
@@ -1,5 +1,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
 using Microsoft.Extensions.Caching.Memory;

@@ -9,14 +11,17 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
    Either<BaseError, EmbyConnectionParametersViewModel>>
 {
    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IEmbySecretStore _embySecretStore;
    private readonly IMemoryCache _memoryCache;

    public GetEmbyConnectionParametersHandler(
        IMemoryCache memoryCache,
-        IMediaSourceRepository mediaSourceRepository)
+        IMediaSourceRepository mediaSourceRepository,
+        IEmbySecretStore embySecretStore)
    {
        _memoryCache = memoryCache;
        _mediaSourceRepository = mediaSourceRepository;
+        _embySecretStore = embySecretStore;
    }

    public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
@@ -30,7 +35,7 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect

        Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
            await Validate()
-                .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address))
+                .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address, cp.ApiKey))
                .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());

        return maybeParameters.Match(
@@ -44,7 +49,8 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect

    private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
        EmbyMediaSourceMustExist()
-            .BindT(MediaSourceMustHaveActiveConnection);
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveApiKey);

    private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
        _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
@@ -59,8 +65,21 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
        return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
            .ToValidation<BaseError>("Emby media source requires an active connection");
    }
+    
+    private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+        ConnectionParameters connectionParameters)
+    {
+        EmbySecrets secrets = await _embySecretStore.ReadSecrets();
+        return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+            .Where(match => match)
+            .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+            .ToValidation<BaseError>("Emby media source requires an api key");
+    }

    private record ConnectionParameters(
        EmbyMediaSource EmbyMediaSource,
-        EmbyConnection ActiveConnection);
+        EmbyConnection ActiveConnection)
+    {
+        public string ApiKey { get; set; }
+    }
 }
@@ -1,22 +1,23 @@
 <Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net7.0</TargetFramework>
        <NoWarn>VSTHRD200</NoWarn>
        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>

    <ItemGroup>
      <PackageReference Include="Bugsnag" Version="3.1.0" />
-      <PackageReference Include="CliWrap" Version="3.4.4" />
+      <PackageReference Include="CliWrap" Version="3.6.0" />
      <PackageReference Include="Humanizer.Core" Version="2.14.1" />
-      <PackageReference Include="MediatR" Version="10.0.1" />
-      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="6.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.2.32">
+      <PackageReference Include="MediatR" Version="12.0.0" />
+      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.5.22">
        <PrivateAssets>all</PrivateAssets>
        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      </PackageReference>
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
+      <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="2.0.0" />
      <PackageReference Include="Winista.MimeDetect" Version="1.0.1" />
    </ItemGroup>

@@ -40,5 +40,6 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=streaming_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=subtitles_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=television_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=templates_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Cqueries/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
@@ -10,8 +10,10 @@ public record CreateFFmpegProfile(
    HardwareAccelerationKind HardwareAcceleration,
    VaapiDriver VaapiDriver,
    string VaapiDevice,
+    int? QsvExtraHardwareFrames,
    int ResolutionId,
    FFmpegProfileVideoFormat VideoFormat,
+    FFmpegProfileBitDepth BitDepth,
    int VideoBitrate,
    int VideoBufferSize,
    FFmpegProfileAudioFormat AudioFormat,
@@ -44,8 +44,10 @@ public class CreateFFmpegProfileHandler :
                HardwareAcceleration = request.HardwareAcceleration,
                VaapiDriver = request.VaapiDriver,
                VaapiDevice = request.VaapiDevice,
+                QsvExtraHardwareFrames = request.QsvExtraHardwareFrames,
                ResolutionId = resolutionId,
                VideoFormat = request.VideoFormat,
+                BitDepth = request.BitDepth,
                VideoBitrate = request.VideoBitrate,
                VideoBufferSize = request.VideoBufferSize,
                AudioFormat = request.AudioFormat,
@@ -15,7 +15,7 @@ public class NewFFmpegProfileHandler : IRequestHandler<NewFFmpegProfile, FFmpegP

    public async Task<FFmpegProfileViewModel> Handle(NewFFmpegProfile request, CancellationToken cancellationToken)
    {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);

        int defaultResolutionId = await dbContext.ConfigElements
            .GetValue<int>(ConfigElementKey.FFmpegDefaultResolutionId)
@@ -11,8 +11,10 @@ public record UpdateFFmpegProfile(
    HardwareAccelerationKind HardwareAcceleration,
    VaapiDriver VaapiDriver,
    string VaapiDevice,
+    int? QsvExtraHardwareFrames,
    int ResolutionId,
    FFmpegProfileVideoFormat VideoFormat,
+    FFmpegProfileBitDepth BitDepth,
    int VideoBitrate,
    int VideoBufferSize,
    FFmpegProfileAudioFormat AudioFormat,
@@ -20,7 +20,7 @@ public class
    {
        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, p => ApplyUpdateRequest(dbContext, p, request));
+        return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request));
    }

    private async Task<UpdateFFmpegProfileResult> ApplyUpdateRequest(
@@ -33,8 +33,15 @@ public class
        p.HardwareAcceleration = update.HardwareAcceleration;
        p.VaapiDriver = update.VaapiDriver;
        p.VaapiDevice = update.VaapiDevice;
+        p.QsvExtraHardwareFrames = update.QsvExtraHardwareFrames;
        p.ResolutionId = update.ResolutionId;
        p.VideoFormat = update.VideoFormat;
+        
+        // mpeg2video only supports 8-bit content
+        p.BitDepth = update.VideoFormat == FFmpegProfileVideoFormat.Mpeg2Video
+            ? FFmpegProfileBitDepth.EightBit
+            : update.BitDepth;
+        
        p.VideoBitrate = update.VideoBitrate;
        p.VideoBufferSize = update.VideoBufferSize;
        p.AudioFormat = update.AudioFormat;
@@ -52,7 +52,7 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
            UseShellExecute = false
        };

-        var test = new Process
+        using var test = new Process
        {
            StartInfo = startInfo
        };
@@ -11,8 +11,10 @@ public record FFmpegProfileViewModel(
    HardwareAccelerationKind HardwareAcceleration,
    VaapiDriver VaapiDriver,
    string VaapiDevice,
+    int? QsvExtraHardwareFrames,
    ResolutionViewModel Resolution,
    FFmpegProfileVideoFormat VideoFormat,
+    FFmpegProfileBitDepth BitDepth,
    int VideoBitrate,
    int VideoBufferSize,
    FFmpegProfileAudioFormat AudioFormat,
@@ -14,8 +14,10 @@ internal static class Mapper
            profile.HardwareAcceleration,
            profile.VaapiDriver,
            profile.VaapiDevice,
+            profile.QsvExtraHardwareFrames,
            Project(profile.Resolution),
            profile.VideoFormat,
+            profile.BitDepth,
            profile.VideoBitrate,
            profile.VideoBufferSize,
            profile.AudioFormat,
@@ -0,0 +1,5 @@
+namespace ErsatzTV.Application;
+
+public interface ISearchIndexBackgroundServiceRequest
+{
+}
@@ -1,5 +0,0 @@
-namespace ErsatzTV.Application;
-
-public interface ISubtitleWorkerRequest
-{
-}
@@ -0,0 +1,98 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.FFmpeg.Runtime;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Jellyfin;
+
+public class CallJellyfinLibraryScannerHandler : CallLibraryScannerHandler<ISynchronizeJellyfinLibraryById>,
+    IRequestHandler<ForceSynchronizeJellyfinLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizeJellyfinLibraryByIdIfNeeded, Either<BaseError, string>>
+{
+    public CallJellyfinLibraryScannerHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IConfigElementRepository configElementRepository,
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizeJellyfinLibraryById, Either<BaseError, string>>.Handle(
+        ForceSynchronizeJellyfinLibraryById request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    Task<Either<BaseError, string>> IRequestHandler<SynchronizeJellyfinLibraryByIdIfNeeded, Either<BaseError, string>>.Handle(
+        SynchronizeJellyfinLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(
+        ISynchronizeJellyfinLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = await Validate(request);
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error =>
+            {
+                foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
+                {
+                    return Task.FromResult<Either<BaseError, string>>(scanIsNotRequired);
+                }
+
+                return Task.FromResult<Either<BaseError, string>>(error.Join());
+            });
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        ISynchronizeJellyfinLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-jellyfin", request.JellyfinLibraryId.ToString()
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+        
+        if (request.DeepScan)
+        {
+            arguments.Add("--deep");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+
+    protected override async Task<DateTimeOffset> GetLastScan(
+        TvContext dbContext,
+        ISynchronizeJellyfinLibraryById request)
+    {
+        return await dbContext.JellyfinLibraries
+            .SelectOneAsync(l => l.Id, l => l.Id == request.JellyfinLibraryId)
+            .Match(l => l.LastScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
+    }
+
+    protected override bool ScanIsRequired(
+        DateTimeOffset lastScan,
+        int libraryRefreshInterval,
+        ISynchronizeJellyfinLibraryById request)
+    {
+        if (lastScan == SystemTime.MaxValueUtc)
+        {
+            return false;
+        }
+
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
+        return request.ForceScan || (libraryRefreshInterval > 0 && nextScan < DateTimeOffset.Now);
+    }
+}
@@ -1,6 +0,0 @@
-using ErsatzTV.Core;
-
-namespace ErsatzTV.Application.Jellyfin;
-
-public record SynchronizeJellyfinCollections(int JellyfinMediaSourceId) : IRequest<Either<BaseError, Unit>>,
-    IJellyfinBackgroundServiceRequest;
@@ -7,14 +7,17 @@ public interface ISynchronizeJellyfinLibraryById : IRequest<Either<BaseError, st
 {
    int JellyfinLibraryId { get; }
    bool ForceScan { get; }
+    bool DeepScan { get; }
 }

 public record SynchronizeJellyfinLibraryByIdIfNeeded(int JellyfinLibraryId) : ISynchronizeJellyfinLibraryById
 {
    public bool ForceScan => false;
+    public bool DeepScan => false;
 }

-public record ForceSynchronizeJellyfinLibraryById(int JellyfinLibraryId) : ISynchronizeJellyfinLibraryById
+public record ForceSynchronizeJellyfinLibraryById
+    (int JellyfinLibraryId, bool DeepScan) : ISynchronizeJellyfinLibraryById
 {
    public bool ForceScan => true;
 }
@@ -0,0 +1,180 @@
+using System.Runtime.InteropServices;
+using System.Threading.Channels;
+using CliWrap;
+using ErsatzTV.Application.Search;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.MediaSources;
+using ErsatzTV.Core.Metadata;
+using ErsatzTV.FFmpeg.Runtime;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Serilog;
+using Serilog.Events;
+using Serilog.Formatting.Compact.Reader;
+
+namespace ErsatzTV.Application.Libraries;
+
+public abstract class CallLibraryScannerHandler<TRequest>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly ChannelWriter<ISearchIndexBackgroundServiceRequest> _channel;
+    private readonly IMediator _mediator;
+    private readonly IRuntimeInfo _runtimeInfo;
+    private string _libraryName;
+
+    protected CallLibraryScannerHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IConfigElementRepository configElementRepository,
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+    {
+        _dbContextFactory = dbContextFactory;
+        _configElementRepository = configElementRepository;
+        _channel = channel;
+        _mediator = mediator;
+        _runtimeInfo = runtimeInfo;
+    }
+
+    protected async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        List<string> arguments,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            using var forcefulCts = new CancellationTokenSource();
+
+            await using CancellationTokenRegistration link = cancellationToken.Register(
+                () => forcefulCts.CancelAfter(TimeSpan.FromSeconds(10))
+            );
+
+            CommandResult process = await Cli.Wrap(scanner)
+                .WithArguments(arguments)
+                .WithValidation(CommandResultValidation.None)
+                .WithStandardErrorPipe(PipeTarget.ToDelegate(ProcessLogOutput))
+                .WithStandardOutputPipe(PipeTarget.ToDelegate(ProcessProgressOutput))
+                .ExecuteAsync(forcefulCts.Token, cancellationToken);
+
+            if (process.ExitCode != 0)
+            {
+                return BaseError.New($"ErsatzTV.Scanner exited with code {process.ExitCode}");
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // do nothing
+        }
+
+        return _libraryName ?? string.Empty;
+    }
+
+    private static void ProcessLogOutput(string s)
+    {
+        if (!string.IsNullOrWhiteSpace(s))
+        {
+            try
+            {
+                // make a new log event to force using local time
+                // because the compact json writer used by the scanner
+                // writes in UTC
+                LogEvent logEvent = LogEventReader.ReadFromString(s);
+                Log.Write(
+                    new LogEvent(
+                        logEvent.Timestamp.ToLocalTime(),
+                        logEvent.Level,
+                        logEvent.Exception,
+                        logEvent.MessageTemplate,
+                        logEvent.Properties.Map(pair => new LogEventProperty(pair.Key, pair.Value))));
+            }
+            catch
+            {
+                Console.WriteLine(s);
+            }
+        }
+    }
+
+    private async Task ProcessProgressOutput(string s)
+    {
+        if (!string.IsNullOrWhiteSpace(s))
+        {
+            try
+            {
+                ScannerProgressUpdate progressUpdate = JsonConvert.DeserializeObject<ScannerProgressUpdate>(s);
+                if (progressUpdate != null)
+                {
+                    if (!string.IsNullOrWhiteSpace(progressUpdate.LibraryName))
+                    {
+                        _libraryName = progressUpdate.LibraryName;
+                    }
+
+                    if (progressUpdate.PercentComplete is not null)
+                    {
+                        var progress = new LibraryScanProgress(
+                            progressUpdate.LibraryId,
+                            progressUpdate.PercentComplete.Value);
+
+                        await _mediator.Publish(progress);
+                    }
+
+                    if (progressUpdate.ItemsToReindex.Length > 0)
+                    {
+                        var reindex = new ReindexMediaItems(progressUpdate.ItemsToReindex);
+                        await _channel.WriteAsync(reindex);
+                    }
+
+                    if (progressUpdate.ItemsToRemove.Length > 0)
+                    {
+                        var remove = new RemoveMediaItems(progressUpdate.ItemsToRemove);
+                        await _channel.WriteAsync(remove);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Logger.Warning(ex, "Unable to process scanner progress update");
+            }
+        }
+    }
+
+    protected abstract Task<DateTimeOffset> GetLastScan(TvContext dbContext, TRequest request);
+    protected abstract bool ScanIsRequired(DateTimeOffset lastScan, int libraryRefreshInterval, TRequest request);
+
+    protected async Task<Validation<BaseError, string>> Validate(TRequest request)
+    {
+        int libraryRefreshInterval = await _configElementRepository
+            .GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+            .IfNoneAsync(0);
+
+        libraryRefreshInterval = Math.Clamp(libraryRefreshInterval, 0, 999_999);
+        
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        
+        DateTimeOffset lastScan = await GetLastScan(dbContext, request);
+        if (!ScanIsRequired(lastScan, libraryRefreshInterval, request))
+        {
+            return new ScanIsNotRequired();
+        }
+
+        string executable = _runtimeInfo.IsOSPlatform(OSPlatform.Windows)
+            ? "ErsatzTV.Scanner.exe"
+            : "ErsatzTV.Scanner";
+        
+        string processFileName = Environment.ProcessPath ?? string.Empty;
+        if (!string.IsNullOrWhiteSpace(processFileName))
+        {
+            string localFileName = Path.Combine(Path.GetDirectoryName(processFileName) ?? string.Empty, executable);
+            if (File.Exists(localFileName))
+            {
+                return localFileName;
+            }
+        }
+
+        return BaseError.New("Unable to locate ErsatzTV.Scanner executable");
+    }
+}
@@ -2,7 +2,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -17,11 +17,11 @@ public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath,
    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
    private readonly ILogger<MoveLocalLibraryPathHandler> _logger;
    private readonly ISearchIndex _searchIndex;
-    private readonly ISearchRepository _searchRepository;
+    private readonly ICachingSearchRepository _searchRepository;

    public MoveLocalLibraryPathHandler(
        ISearchIndex searchIndex,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
        IFallbackMetadataProvider fallbackMetadataProvider,
        IDbContextFactory<TvContext> dbContextFactory,
        ILogger<MoveLocalLibraryPathHandler> logger)
@@ -3,8 +3,6 @@
 namespace ErsatzTV.Application.Logs;

 public record LogEntryViewModel(
-    int Id,
-    DateTime Timestamp,
+    DateTimeOffset Timestamp,
    LogEventLevel Level,
-    string Exception,
    string Message);
@@ -1,42 +1,31 @@
-using ErsatzTV.Core.Domain;
-using Newtonsoft.Json.Linq;
+using System.Text.RegularExpressions;
 using Serilog.Events;

 namespace ErsatzTV.Application.Logs;

-internal static class Mapper
+internal partial class Mapper
 {
-    internal static LogEntryViewModel ProjectToViewModel(LogEntry logEntry)
+    [GeneratedRegex(@"(.*)\[(DBG|INF|WRN|ERR|FTL)\](.*)")]
+    private static partial Regex LogEntryRegex();
+    
+    internal static Option<LogEntryViewModel> ProjectToViewModel(string line)
    {
-        string message = logEntry.RenderedMessage;
-        if (!string.IsNullOrWhiteSpace(logEntry.Properties))
+        Match match = LogEntryRegex().Match(line);
+        if (!match.Success)
        {
-            foreach (KeyValuePair<string, JToken> property in JObject.Parse(logEntry.Properties))
-            {
-                var token = $"{{{property.Key}}}";
-                if (message.Contains(token))
-                {
-                    message = message.Replace(token, property.Value.ToString());
-                }
-
-                var destructureToken = $"{{@{property.Key}}}";
-                if (message.Contains(destructureToken))
-                {
-                    message = message.Replace(destructureToken, property.Value.ToString());
-                }
-            }
+            return None;
        }

-        if (!Enum.TryParse(logEntry.Level, out LogEventLevel level))
+        var timestamp = DateTimeOffset.Parse(match.Groups[1].Value);
+        LogEventLevel level = match.Groups[2].Value switch
        {
-            level = LogEventLevel.Debug;
-        }
+            "FTL" => LogEventLevel.Fatal,
+            "ERR" => LogEventLevel.Error,
+            "WRN" => LogEventLevel.Warning,
+            "INF" => LogEventLevel.Information,
+            _ => LogEventLevel.Debug
+        };

-        return new LogEntryViewModel(
-            logEntry.Id,
-            logEntry.Timestamp,
-            level,
-            logEntry.Exception,
-            message);
+        return new LogEntryViewModel(timestamp, level, match.Groups[3].Value);
    }
 }
@@ -1,10 +1,9 @@
 using System.Linq.Expressions;
-using ErsatzTV.Core.Domain;

 namespace ErsatzTV.Application.Logs;

-public record GetRecentLogEntries(int PageNum, int PageSize) : IRequest<PagedLogEntriesViewModel>
+public record GetRecentLogEntries(int PageNum, int PageSize, string Filter) : IRequest<PagedLogEntriesViewModel>
 {
-    public Expression<Func<LogEntry, object>> SortExpression { get; set; }
-    public Option<bool> SortDescending { get; set; }
+    public Expression<Func<LogEntryViewModel, object>> SortExpression { get; init; }
+    public Option<bool> SortDescending { get; init; }
 }
@@ -1,40 +1,66 @@
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Metadata;
 using static ErsatzTV.Application.Logs.Mapper;

 namespace ErsatzTV.Application.Logs;

 public class GetRecentLogEntriesHandler : IRequestHandler<GetRecentLogEntries, PagedLogEntriesViewModel>
 {
-    private readonly IDbContextFactory<LogContext> _dbContextFactory;
+    private readonly ILocalFileSystem _localFileSystem;

-    public GetRecentLogEntriesHandler(IDbContextFactory<LogContext> dbContextFactory) =>
-        _dbContextFactory = dbContextFactory;
+    public GetRecentLogEntriesHandler(ILocalFileSystem localFileSystem)
+    {
+        _localFileSystem = localFileSystem;
+    }

-    public async Task<PagedLogEntriesViewModel> Handle(
+    public Task<PagedLogEntriesViewModel> Handle(
        GetRecentLogEntries request,
        CancellationToken cancellationToken)
    {
-        await using LogContext logContext = _dbContextFactory.CreateDbContext();
-        int count = await logContext.LogEntries.CountAsync(cancellationToken);
+        // get most recent file
+        string logFileName = _localFileSystem.ListFiles(FileSystemLayout.LogsFolder)
+            .OrderDescending()
+            .FirstOrDefault();

-        IOrderedQueryable<LogEntry> ordered = logContext.LogEntries
-            .OrderByDescending(le => le.Id);
-
-        foreach (bool descending in request.SortDescending)
+        if (logFileName is not null)
        {
-            ordered = descending
-                ? logContext.LogEntries.OrderByDescending(request.SortExpression).ThenByDescending(le => le.Id)
-                : logContext.LogEntries.OrderBy(request.SortExpression).ThenByDescending(le => le.Id);
+            IQueryable<LogEntryViewModel> entries = ReadFrom(logFileName)
+                .Bind(line => ProjectToViewModel(line))
+                .AsQueryable();
+
+            if (!string.IsNullOrWhiteSpace(request.Filter))
+            {
+                entries = entries.Filter(
+                    le => le.Level.ToString().Contains(request.Filter, StringComparison.OrdinalIgnoreCase) ||
+                          le.Message.Contains(request.Filter, StringComparison.OrdinalIgnoreCase));
+            }
+
+            int count = entries.Count();
+
+            IOrderedQueryable<LogEntryViewModel> ordered = request.SortDescending.Match(
+                descending => descending
+                    ? entries.OrderByDescending(request.SortExpression).ThenByDescending(le => le.Timestamp)
+                    : entries.OrderBy(request.SortExpression).ThenByDescending(le => le.Timestamp),
+                () => entries.OrderByDescending(le => le.Timestamp));
+
+            var page = ordered
+                .Skip(request.PageNum * request.PageSize)
+                .Take(request.PageSize)
+                .ToList();
+
+            return new PagedLogEntriesViewModel(count, page).AsTask();
        }

-        List<LogEntryViewModel> page = await ordered
-            .Skip(request.PageNum * request.PageSize)
-            .Take(request.PageSize)
-            .ToListAsync(cancellationToken)
-            .Map(list => list.Map(ProjectToViewModel).ToList());
+        return new PagedLogEntriesViewModel(0, new List<LogEntryViewModel>()).AsTask();
+    }

-        return new PagedLogEntriesViewModel(count, page);
+    private static IEnumerable<string> ReadFrom(string file)
+    {
+        using FileStream fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+        using var reader = new StreamReader(fs);
+        while (reader.ReadLine() is { } line)
+        {
+            yield return line;
+        }
    }
 }
@@ -1,4 +1,5 @@
-using ErsatzTV.Core;
+using Bugsnag;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -8,13 +9,16 @@ namespace ErsatzTV.Application.Maintenance;

 public class EmptyTrashHandler : IRequestHandler<EmptyTrash, Either<BaseError, Unit>>
 {
+    private readonly IClient _client;
    private readonly IMediaItemRepository _mediaItemRepository;
    private readonly ISearchIndex _searchIndex;

    public EmptyTrashHandler(
+        IClient client,
        IMediaItemRepository mediaItemRepository,
        ISearchIndex searchIndex)
    {
+        _client = client;
        _mediaItemRepository = mediaItemRepository;
        _searchIndex = searchIndex;
    }
@@ -39,7 +43,7 @@ public class EmptyTrashHandler : IRequestHandler<EmptyTrash, Either<BaseError, U

        foreach (string type in types)
        {
-            SearchResult result = await _searchIndex.Search($"type:{type} AND (state:FileNotFound)", 0, 0);
+            SearchResult result = _searchIndex.Search(_client, $"type:{type} AND (state:FileNotFound)", 0, 0);
            ids.AddRange(result.Items.Map(i => i.Id));
        }

@@ -0,0 +1,6 @@
+namespace ErsatzTV.Application.Maintenance;
+
+public record ReleaseMemory(bool ForceAggressive) : IRequest, IBackgroundServiceRequest
+{
+    public DateTimeOffset RequestTime = DateTimeOffset.Now;
+}
@@ -0,0 +1,50 @@
+using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.Application.Maintenance;
+
+public class ReleaseMemoryHandler : IRequestHandler<ReleaseMemory>
+{
+    private static long _lastRelease;
+    
+    private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
+    private readonly ILogger<ReleaseMemoryHandler> _logger;
+
+    public ReleaseMemoryHandler(
+        IFFmpegSegmenterService ffmpegSegmenterService,
+        ILogger<ReleaseMemoryHandler> logger)
+    {
+        _ffmpegSegmenterService = ffmpegSegmenterService;
+        _logger = logger;
+    }
+
+    public Task Handle(ReleaseMemory request, CancellationToken cancellationToken)
+    {
+        if (!request.ForceAggressive && _lastRelease > request.RequestTime.Ticks)
+        {
+            // we've already released since the request was created, so don't bother
+            return Task.CompletedTask;
+        }
+
+        bool hasActiveWorkers = _ffmpegSegmenterService.SessionWorkers.Any() || FFmpegProcess.ProcessCount > 0;
+        if (request.ForceAggressive || !hasActiveWorkers)
+        {
+            _logger.LogDebug("Starting aggressive garbage collection");
+            GC.Collect(2, GCCollectionMode.Aggressive, blocking: true, compacting: true);
+        }
+        else
+        {
+            _logger.LogDebug("Starting garbage collection");
+            GC.Collect(2, GCCollectionMode.Forced, blocking: false);
+        }
+
+        GC.WaitForPendingFinalizers();
+        GC.Collect();
+
+        _logger.LogDebug("Completed garbage collection");
+        Interlocked.Exchange(ref _lastRelease, DateTimeOffset.Now.Ticks);
+
+        return Task.CompletedTask;
+    }
+}
@@ -2,7 +2,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Metadata;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Infrastructure.Data;
@@ -18,7 +18,7 @@ public class AddTraktListHandler : TraktCommandBase, IRequestHandler<AddTraktLis

    public AddTraktListHandler(
        ITraktApiClient traktApiClient,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
        ISearchIndex searchIndex,
        IFallbackMetadataProvider fallbackMetadataProvider,
        IDbContextFactory<TvContext> dbContextFactory,
@@ -2,7 +2,7 @@
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Metadata;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Infrastructure.Data;
@@ -17,11 +17,11 @@ public class DeleteTraktListHandler : TraktCommandBase, IRequestHandler<DeleteTr
    private readonly IEntityLocker _entityLocker;
    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
    private readonly ISearchIndex _searchIndex;
-    private readonly ISearchRepository _searchRepository;
+    private readonly ICachingSearchRepository _searchRepository;

    public DeleteTraktListHandler(
        ITraktApiClient traktApiClient,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
        ISearchIndex searchIndex,
        IFallbackMetadataProvider fallbackMetadataProvider,
        IDbContextFactory<TvContext> dbContextFactory,
@@ -2,7 +2,7 @@
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Metadata;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Infrastructure.Data;
@@ -19,7 +19,7 @@ public class MatchTraktListItemsHandler : TraktCommandBase,

    public MatchTraktListItemsHandler(
        ITraktApiClient traktApiClient,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
        ISearchIndex searchIndex,
        IFallbackMetadataProvider fallbackMetadataProvider,
        IDbContextFactory<TvContext> dbContextFactory,
@@ -1,7 +1,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Core.Trakt;
@@ -17,11 +17,11 @@ public abstract class TraktCommandBase
    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
    private readonly ILogger _logger;
    private readonly ISearchIndex _searchIndex;
-    private readonly ISearchRepository _searchRepository;
+    private readonly ICachingSearchRepository _searchRepository;

    protected TraktCommandBase(
        ITraktApiClient traktApiClient,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
        ISearchIndex searchIndex,
        IFallbackMetadataProvider fallbackMetadataProvider,
        ILogger logger)
@@ -0,0 +1,94 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.FFmpeg.Runtime;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaSources;
+
+public class CallLocalLibraryScannerHandler : CallLibraryScannerHandler<IScanLocalLibrary>,
+    IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>,
+    IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>
+{
+    public CallLocalLibraryScannerHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IConfigElementRepository configElementRepository,
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>.Handle(
+        ForceScanLocalLibrary request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    Task<Either<BaseError, string>> IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>.Handle(
+        ScanLocalLibraryIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(IScanLocalLibrary request, CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = await Validate(request);
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error =>
+            {
+                foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
+                {
+                    return Task.FromResult<Either<BaseError, string>>(scanIsNotRequired);
+                }
+
+                return Task.FromResult<Either<BaseError, string>>(error.Join());
+            });
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        IScanLocalLibrary request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-local", request.LibraryId.ToString()
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+
+    protected override async Task<DateTimeOffset> GetLastScan(TvContext dbContext, IScanLocalLibrary request)
+    {
+        var libraryPaths = await dbContext.LibraryPaths
+            .Filter(lp => lp.LibraryId == request.LibraryId)
+            .ToListAsync();
+        
+        var minDateTime = libraryPaths.Any()
+            ? libraryPaths.Min(lp => lp.LastScan ?? SystemTime.MinValueUtc)
+            : SystemTime.MaxValueUtc;
+
+        return new DateTimeOffset(minDateTime, TimeSpan.Zero);
+    }
+
+    protected override bool ScanIsRequired(
+        DateTimeOffset lastScan,
+        int libraryRefreshInterval,
+        IScanLocalLibrary request)
+    {
+        if (lastScan == SystemTime.MaxValueUtc)
+        {
+            return false;
+        }
+
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
+        return request.ForceScan || (libraryRefreshInterval > 0 && nextScan < DateTimeOffset.Now);
+    }
+}
@@ -1,232 +0,0 @@
-using System.Diagnostics;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Locking;
-using ErsatzTV.Core.Interfaces.Metadata;
-using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.Core.Metadata;
-using Humanizer;
-using Microsoft.Extensions.Logging;
-
-namespace ErsatzTV.Application.MediaSources;
-
-public class ScanLocalLibraryHandler : IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>,
-    IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>
-{
-    private readonly IConfigElementRepository _configElementRepository;
-    private readonly IEntityLocker _entityLocker;
-    private readonly ILibraryRepository _libraryRepository;
-    private readonly ILogger<ScanLocalLibraryHandler> _logger;
-    private readonly IMediator _mediator;
-    private readonly IMovieFolderScanner _movieFolderScanner;
-    private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
-    private readonly IOtherVideoFolderScanner _otherVideoFolderScanner;
-    private readonly ISongFolderScanner _songFolderScanner;
-    private readonly ITelevisionFolderScanner _televisionFolderScanner;
-
-    public ScanLocalLibraryHandler(
-        ILibraryRepository libraryRepository,
-        IConfigElementRepository configElementRepository,
-        IMovieFolderScanner movieFolderScanner,
-        ITelevisionFolderScanner televisionFolderScanner,
-        IMusicVideoFolderScanner musicVideoFolderScanner,
-        IOtherVideoFolderScanner otherVideoFolderScanner,
-        ISongFolderScanner songFolderScanner,
-        IEntityLocker entityLocker,
-        IMediator mediator,
-        ILogger<ScanLocalLibraryHandler> logger)
-    {
-        _libraryRepository = libraryRepository;
-        _configElementRepository = configElementRepository;
-        _movieFolderScanner = movieFolderScanner;
-        _televisionFolderScanner = televisionFolderScanner;
-        _musicVideoFolderScanner = musicVideoFolderScanner;
-        _otherVideoFolderScanner = otherVideoFolderScanner;
-        _songFolderScanner = songFolderScanner;
-        _entityLocker = entityLocker;
-        _mediator = mediator;
-        _logger = logger;
-    }
-
-    Task<Either<BaseError, string>> IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>.Handle(
-        ForceScanLocalLibrary request,
-        CancellationToken cancellationToken) => Handle(request, cancellationToken);
-
-    Task<Either<BaseError, string>> IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>.Handle(
-        ScanLocalLibraryIfNeeded request,
-        CancellationToken cancellationToken) => Handle(request, cancellationToken);
-
-    private Task<Either<BaseError, string>> Handle(IScanLocalLibrary request, CancellationToken cancellationToken) =>
-        Validate(request)
-            .MapT(parameters => PerformScan(parameters, cancellationToken).Map(_ => parameters.LocalLibrary.Name))
-            .Bind(v => v.ToEitherAsync());
-
-    private async Task<Unit> PerformScan(RequestParameters parameters, CancellationToken cancellationToken)
-    {
-        (LocalLibrary localLibrary, string ffprobePath, string ffmpegPath, bool forceScan,
-            int libraryRefreshInterval) = parameters;
-
-        try
-        {
-            var sw = new Stopwatch();
-            sw.Start();
-
-            var scanned = false;
-
-            for (var i = 0; i < localLibrary.Paths.Count; i++)
-            {
-                LibraryPath libraryPath = localLibrary.Paths[i];
-
-                decimal progressMin = (decimal)i / localLibrary.Paths.Count;
-                decimal progressMax = (decimal)(i + 1) / localLibrary.Paths.Count;
-
-                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
-                DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
-                if (forceScan || nextScan < DateTimeOffset.Now)
-                {
-                    scanned = true;
-
-                    Either<BaseError, Unit> result = localLibrary.MediaKind switch
-                    {
-                        LibraryMediaKind.Movies =>
-                            await _movieFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffmpegPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        LibraryMediaKind.Shows =>
-                            await _televisionFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffmpegPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        LibraryMediaKind.MusicVideos =>
-                            await _musicVideoFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffmpegPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        LibraryMediaKind.OtherVideos =>
-                            await _otherVideoFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffmpegPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        LibraryMediaKind.Songs =>
-                            await _songFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffprobePath,
-                                ffmpegPath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        _ => Unit.Default
-                    };
-
-                    if (result.IsRight)
-                    {
-                        libraryPath.LastScan = DateTime.UtcNow;
-                        await _libraryRepository.UpdateLastScan(libraryPath);
-                    }
-                }
-
-                await _mediator.Publish(new LibraryScanProgress(libraryPath.LibraryId, progressMax), cancellationToken);
-            }
-
-            sw.Stop();
-
-            if (scanned)
-            {
-                _logger.LogDebug(
-                    "Scan of library {Name} completed in {Duration}",
-                    localLibrary.Name,
-                    sw.Elapsed.Humanize());
-            }
-            else
-            {
-                _logger.LogDebug(
-                    "Skipping unforced scan of local media library {Name}",
-                    localLibrary.Name);
-            }
-
-            await _mediator.Publish(new LibraryScanProgress(localLibrary.Id, 0), cancellationToken);
-
-            return Unit.Default;
-        }
-        finally
-        {
-            _entityLocker.UnlockLibrary(localLibrary.Id);
-        }
-    }
-
-    private async Task<Validation<BaseError, RequestParameters>> Validate(IScanLocalLibrary request)
-    {
-        Validation<BaseError, LocalLibrary> libraryResult = await LocalLibraryMustExist(request);
-        Validation<BaseError, string> ffprobePathResult = await ValidateFFprobePath();
-        Validation<BaseError, string> ffmpegPathResult = await ValidateFFmpegPath();
-        Validation<BaseError, int> refreshIntervalResult = await ValidateLibraryRefreshInterval();
-
-        try
-        {
-            return (libraryResult, ffprobePathResult, ffmpegPathResult, refreshIntervalResult)
-                .Apply(
-                    (library, ffprobePath, ffmpegPath, libraryRefreshInterval) => new RequestParameters(
-                        library,
-                        ffprobePath,
-                        ffmpegPath,
-                        request.ForceScan,
-                        libraryRefreshInterval));
-        }
-        finally
-        {
-            // ensure we unlock the library if any validation is unsuccessful
-            foreach (LocalLibrary library in libraryResult.SuccessToSeq())
-            {
-                if (ffprobePathResult.IsFail || ffmpegPathResult.IsFail || refreshIntervalResult.IsFail)
-                {
-                    _entityLocker.UnlockLibrary(library.Id);
-                }
-            }
-        }
-    }
-
-    private Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
-        IScanLocalLibrary request) =>
-        _libraryRepository.Get(request.LibraryId)
-            .Map(maybeLibrary => maybeLibrary.Map(ms => ms as LocalLibrary))
-            .Map(v => v.ToValidation<BaseError>($"Local library {request.LibraryId} does not exist."));
-
-    private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
-        _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
-            .FilterT(File.Exists)
-            .Map(
-                ffprobePath =>
-                    ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
-
-    private Task<Validation<BaseError, string>> ValidateFFmpegPath() =>
-        _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath)
-            .FilterT(File.Exists)
-            .Map(
-                ffmpegPath =>
-                    ffmpegPath.ToValidation<BaseError>("FFmpeg path does not exist on the file system"));
-
-    private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
-        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
-            .FilterT(lri => lri > 0)
-            .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
-
-    private record RequestParameters(
-        LocalLibrary LocalLibrary,
-        string FFprobePath,
-        string FFmpegPath,
-        bool ForceScan,
-        int LibraryRefreshInterval);
-}
@@ -1,3 +0,0 @@
-namespace ErsatzTV.Application.MediaSources;
-
-public record LocalMediaSourceViewModel(int Id) : MediaSourceViewModel(Id, "Local");
@@ -17,7 +17,7 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
    private readonly IClient _client;
    private readonly IDbContextFactory<TvContext> _dbContextFactory;
    private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
-    private readonly ChannelWriter<ISubtitleWorkerRequest> _ffmpegWorkerChannel;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
    private readonly IPlayoutBuilder _playoutBuilder;

    public BuildPlayoutHandler(
@@ -25,13 +25,13 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
        IDbContextFactory<TvContext> dbContextFactory,
        IPlayoutBuilder playoutBuilder,
        IFFmpegSegmenterService ffmpegSegmenterService,
-        ChannelWriter<ISubtitleWorkerRequest> ffmpegWorkerChannel)
+        ChannelWriter<IBackgroundServiceRequest> workerChannel)
    {
        _client = client;
        _dbContextFactory = dbContextFactory;
        _playoutBuilder = playoutBuilder;
        _ffmpegSegmenterService = ffmpegSegmenterService;
-        _ffmpegWorkerChannel = ffmpegWorkerChannel;
+        _workerChannel = workerChannel;
    }

    public async Task<Either<BaseError, Unit>> Handle(BuildPlayout request, CancellationToken cancellationToken)
@@ -56,7 +56,7 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
                _ffmpegSegmenterService.PlayoutUpdated(playout.Channel.Number);
            }

-            await _ffmpegWorkerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
+            await _workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
        }
        catch (Exception ex)
        {
@@ -75,8 +75,41 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
        dbContext.Playouts
            .Include(p => p.Channel)
            .Include(p => p.Items)
+            
+            .Include(p => p.ProgramScheduleAlternates)
+            .ThenInclude(a => a.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.Collection)
+            .Include(p => p.ProgramScheduleAlternates)
+            .ThenInclude(a => a.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.MediaItem)
+            .Include(p => p.ProgramScheduleAlternates)
+            .ThenInclude(a => a.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.PreRollFiller)
+            .Include(p => p.ProgramScheduleAlternates)
+            .ThenInclude(a => a.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.MidRollFiller)
+            .Include(p => p.ProgramScheduleAlternates)
+            .ThenInclude(a => a.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.PostRollFiller)
+            .Include(p => p.ProgramScheduleAlternates)
+            .ThenInclude(a => a.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.TailFiller)
+            .Include(p => p.ProgramScheduleAlternates)
+            .ThenInclude(a => a.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.FallbackFiller)
+            
+            .Include(p => p.ProgramScheduleAnchors)
+            .ThenInclude(psa => psa.EnumeratorState)
            .Include(p => p.ProgramScheduleAnchors)
            .ThenInclude(a => a.MediaItem)
+
            .Include(p => p.ProgramSchedule)
            .ThenInclude(ps => ps.Items)
            .ThenInclude(psi => psi.Collection)
@@ -98,6 +131,7 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
            .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."));
 }
@@ -0,0 +1,9 @@
+namespace ErsatzTV.Application.Playouts;
+
+public record ReplacePlayoutAlternateSchedule(
+    int Id,
+    int Index,
+    int ProgramScheduleId,
+    List<DayOfWeek> DaysOfWeek,
+    List<int> DaysOfMonth,
+    List<int> MonthsOfYear);
@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Playouts;
+
+public record ReplacePlayoutAlternateScheduleItems
+    (int PlayoutId, List<ReplacePlayoutAlternateSchedule> Items) : IRequest<Either<BaseError, Unit>>;
@@ -0,0 +1,158 @@
+using System.Threading.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.Application.Playouts;
+
+public class ReplacePlayoutAlternateScheduleItemsHandler :
+    IRequestHandler<ReplacePlayoutAlternateScheduleItems, Either<BaseError, Unit>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly ILogger<ReplacePlayoutAlternateScheduleItemsHandler> _logger;
+
+    public ReplacePlayoutAlternateScheduleItemsHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        ChannelWriter<IBackgroundServiceRequest> channel,
+        ILogger<ReplacePlayoutAlternateScheduleItemsHandler> logger)
+    {
+        _dbContextFactory = dbContextFactory;
+        _channel = channel;
+        _logger = logger;
+    }
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        ReplacePlayoutAlternateScheduleItems request,
+        CancellationToken cancellationToken)
+    {
+        // TODO: validate that items is not empty
+
+        try
+        {
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            Option<Playout> maybePlayout = await dbContext.Playouts
+                .Include(p => p.ProgramSchedule)
+                .Include(p => p.ProgramScheduleAlternates)
+                .ThenInclude(p => p.ProgramSchedule)
+                .SelectOneAsync(p => p.Id, p => p.Id == request.PlayoutId);
+
+            foreach (Playout playout in maybePlayout)
+            {
+                var existingScheduleMap = new Dictionary<DateTimeOffset, ProgramSchedule>();
+                var daysToCheck = new List<DateTimeOffset>();
+                
+                Option<PlayoutItem> maybeLastPlayoutItem = await dbContext.PlayoutItems
+                    .Filter(pi => pi.PlayoutId == request.PlayoutId)
+                    .OrderByDescending(pi => pi.Start)
+                    .FirstOrDefaultAsync(cancellationToken)
+                    .Map(Optional);
+
+                foreach (PlayoutItem lastPlayoutItem in maybeLastPlayoutItem)
+                {
+                    DateTimeOffset start = DateTimeOffset.Now;
+                    daysToCheck = Enumerable.Range(0, (lastPlayoutItem.StartOffset - start).Days + 1)
+                        .Select(d => start.AddDays(d))
+                        .ToList();
+
+                    foreach (DateTimeOffset dayToCheck in daysToCheck)
+                    {
+                        ProgramSchedule schedule = PlayoutScheduleSelector.GetProgramScheduleFor(
+                            playout.ProgramSchedule,
+                            playout.ProgramScheduleAlternates,
+                            dayToCheck);
+
+                        existingScheduleMap.Add(dayToCheck, schedule);
+                    }
+                }
+
+                // exclude highest index
+                int maxIndex = request.Items.Map(x => x.Index).Max();
+                ReplacePlayoutAlternateSchedule highest = request.Items.First(x => x.Index == maxIndex);
+
+                ProgramScheduleAlternate[] existing = playout.ProgramScheduleAlternates.ToArray();
+
+                var incoming = request.Items.Except(new[] { highest }).ToList();
+
+                var toAdd = incoming.Filter(x => existing.All(e => e.Id != x.Id)).ToList();
+                var toRemove = existing.Filter(e => incoming.All(m => m.Id != e.Id)).ToList();
+                var toUpdate = incoming.Except(toAdd).ToList();
+
+                playout.ProgramScheduleAlternates.RemoveAll(toRemove.Contains);
+
+                foreach (ReplacePlayoutAlternateSchedule add in toAdd)
+                {
+                    playout.ProgramScheduleAlternates.Add(
+                        new ProgramScheduleAlternate
+                        {
+                            PlayoutId = playout.Id,
+                            Index = add.Index,
+                            ProgramScheduleId = add.ProgramScheduleId,
+                            DaysOfWeek = add.DaysOfWeek,
+                            DaysOfMonth = add.DaysOfMonth,
+                            MonthsOfYear = add.MonthsOfYear
+                        });
+                }
+
+                foreach (ReplacePlayoutAlternateSchedule update in toUpdate)
+                {
+                    foreach (ProgramScheduleAlternate ex in existing.Filter(x => x.Id == update.Id))
+                    {
+                        ex.Index = update.Index;
+                        ex.ProgramScheduleId = update.ProgramScheduleId;
+                        ex.DaysOfWeek = update.DaysOfWeek;
+                        ex.DaysOfMonth = update.DaysOfMonth;
+                        ex.MonthsOfYear = update.MonthsOfYear;
+                    }
+                }
+
+                // save highest index directly to playout
+                if (playout.ProgramScheduleId != highest.ProgramScheduleId)
+                {
+                    playout.ProgramScheduleId = highest.ProgramScheduleId;
+                }
+
+                await dbContext.SaveChangesAsync(cancellationToken);
+
+                foreach (PlayoutItem _ in maybeLastPlayoutItem)
+                {
+                    foreach (DateTimeOffset dayToCheck in daysToCheck)
+                    {
+                        ProgramSchedule schedule = PlayoutScheduleSelector.GetProgramScheduleFor(
+                            playout.ProgramSchedule,
+                            playout.ProgramScheduleAlternates,
+                            dayToCheck);
+
+                        if (existingScheduleMap.TryGetValue(dayToCheck, out ProgramSchedule existingValue) &&
+                            existingValue.Id != schedule.Id)
+                        {
+                            _logger.LogInformation(
+                                "Alternate schedule change detected for day {Day}, schedule {One} => {Two}; will refresh playout",
+                                dayToCheck,
+                                existingValue.Name,
+                                schedule.Name);
+
+                            await _channel.WriteAsync(
+                                new BuildPlayout(request.PlayoutId, PlayoutBuildMode.Refresh),
+                                cancellationToken);
+
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            return Unit.Default;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error saving alternate schedule items");
+            return BaseError.New(ex.Message);
+        }
+    }
+}
@@ -10,6 +10,16 @@ internal static class Mapper
            playoutItem.StartOffset,
            GetDisplayDuration(playoutItem.FinishOffset - playoutItem.StartOffset));

+    internal static PlayoutAlternateScheduleViewModel ProjectToViewModel(
+        ProgramScheduleAlternate programScheduleAlternate) =>
+        new(
+            programScheduleAlternate.Id,
+            programScheduleAlternate.Index,
+            programScheduleAlternate.ProgramScheduleId,
+            programScheduleAlternate.DaysOfWeek,
+            programScheduleAlternate.DaysOfMonth,
+            programScheduleAlternate.MonthsOfYear);
+
    private static string GetDisplayTitle(PlayoutItem playoutItem)
    {
        switch (playoutItem.MediaItem)
@@ -0,0 +1,9 @@
+namespace ErsatzTV.Application.Playouts;
+
+public record PlayoutAlternateScheduleViewModel(
+    int Id,
+    int Index,
+    int ProgramScheduleId,
+    ICollection<DayOfWeek> DaysOfWeek,
+    ICollection<int> DaysOfMonth,
+    ICollection<int> MonthsOfYear);
@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Playouts;
+
+public record GetPlayoutAlternateSchedules(int PlayoutId) : IRequest<List<PlayoutAlternateScheduleViewModel>>;
@@ -0,0 +1,53 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Playouts.Mapper;
+
+namespace ErsatzTV.Application.Playouts;
+
+public class GetPlayoutAlternateSchedulesHandler :
+    IRequestHandler<GetPlayoutAlternateSchedules, List<PlayoutAlternateScheduleViewModel>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetPlayoutAlternateSchedulesHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<PlayoutAlternateScheduleViewModel>> Handle(
+        GetPlayoutAlternateSchedules request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<PlayoutAlternateScheduleViewModel> result = await dbContext.ProgramScheduleAlternates
+            .Filter(psa => psa.PlayoutId == request.PlayoutId)
+            .Include(psa => psa.ProgramSchedule)
+            .Map(psa => ProjectToViewModel(psa))
+            .ToListAsync(cancellationToken);
+
+        Option<ProgramSchedule> maybeDefaultSchedule = await dbContext.Playouts
+            .Include(p => p.ProgramSchedule)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.PlayoutId)
+            .MapT(p => p.ProgramSchedule);
+
+        foreach (ProgramSchedule defaultSchedule in maybeDefaultSchedule)
+        {
+            var psa = new ProgramScheduleAlternate
+            {
+                Id = -1,
+                PlayoutId = request.PlayoutId,
+                ProgramScheduleId = defaultSchedule.Id,
+                ProgramSchedule = defaultSchedule,
+                Index = result.Map(i => i.Index).DefaultIfEmpty().Max() + 1,
+                DaysOfMonth = ProgramScheduleAlternate.AllDaysOfMonth(),
+                DaysOfWeek = ProgramScheduleAlternate.AllDaysOfWeek(),
+                MonthsOfYear = ProgramScheduleAlternate.AllMonthsOfYear()
+            };
+
+            result.Add(ProjectToViewModel(psa));
+        }
+
+        return result;
+    }
+}
@@ -0,0 +1,98 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.FFmpeg.Runtime;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Plex;
+
+public class CallPlexLibraryScannerHandler : CallLibraryScannerHandler<ISynchronizePlexLibraryById>,
+    IRequestHandler<ForceSynchronizePlexLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizePlexLibraryByIdIfNeeded, Either<BaseError, string>>
+{
+    public CallPlexLibraryScannerHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IConfigElementRepository configElementRepository,
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizePlexLibraryById, Either<BaseError, string>>.Handle(
+        ForceSynchronizePlexLibraryById request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    Task<Either<BaseError, string>> IRequestHandler<SynchronizePlexLibraryByIdIfNeeded, Either<BaseError, string>>.Handle(
+        SynchronizePlexLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(
+        ISynchronizePlexLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = await Validate(request);
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error =>
+            {
+                foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
+                {
+                    return Task.FromResult<Either<BaseError, string>>(scanIsNotRequired);
+                }
+
+                return Task.FromResult<Either<BaseError, string>>(error.Join());
+            });
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        ISynchronizePlexLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-plex", request.PlexLibraryId.ToString()
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+
+        if (request.DeepScan)
+        {
+            arguments.Add("--deep");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+
+    protected override async Task<DateTimeOffset> GetLastScan(
+        TvContext dbContext,
+        ISynchronizePlexLibraryById request)
+    {
+        return await dbContext.PlexLibraries
+            .SelectOneAsync(l => l.Id, l => l.Id == request.PlexLibraryId)
+            .Match(l => l.LastScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
+    }
+
+    protected override bool ScanIsRequired(
+        DateTimeOffset lastScan,
+        int libraryRefreshInterval,
+        ISynchronizePlexLibraryById request)
+    {
+        if (lastScan == SystemTime.MaxValueUtc)
+        {
+            return false;
+        }
+
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
+        return request.ForceScan || (libraryRefreshInterval > 0 && nextScan < DateTimeOffset.Now);
+    }
+}
@@ -26,6 +26,7 @@ public record AddProgramScheduleItem(
    int? FallbackFillerId,
    int? WatermarkId,
    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
    string PreferredSubtitleLanguageCode,
    ChannelSubtitleMode? SubtitleMode) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>,
    IProgramScheduleItemRequest;
@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record CopyProgramSchedule
+    (int ProgramScheduleId, string Name) : IRequest<Either<BaseError, ProgramScheduleViewModel>>;
@@ -0,0 +1,103 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.ProgramSchedules.Mapper;
+
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class
+    CopyProgramScheduleHandler : IRequestHandler<CopyProgramSchedule, Either<BaseError, ProgramScheduleViewModel>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CopyProgramScheduleHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, ProgramScheduleViewModel>> Handle(
+        CopyProgramSchedule request,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
+            return await validation.Apply(p => PerformCopy(dbContext, p, request, cancellationToken));
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    private async Task<ProgramScheduleViewModel> PerformCopy(
+        TvContext dbContext,
+        ProgramSchedule schedule,
+        CopyProgramSchedule request,
+        CancellationToken cancellationToken)
+    {
+        DetachEntity(dbContext, schedule);
+        schedule.Name = request.Name;
+
+        // no playouts, no alternates
+        schedule.Playouts = new List<Playout>();
+        schedule.ProgramScheduleAlternates = new List<ProgramScheduleAlternate>();
+
+        foreach (ProgramScheduleItem item in schedule.Items)
+        {
+            DetachEntity(dbContext, item);
+            item.ProgramScheduleId = 0;
+            item.ProgramSchedule = schedule;
+        }
+
+        await dbContext.ProgramSchedules.AddAsync(schedule, cancellationToken);
+        await dbContext.ProgramScheduleItems.AddRangeAsync(schedule.Items, cancellationToken);
+
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return ProjectToViewModel(schedule);
+    }
+
+    private static async Task<Validation<BaseError, ProgramSchedule>> Validate(
+        TvContext dbContext,
+        CopyProgramSchedule request) =>
+        (await ScheduleMustExist(dbContext, request), await ValidateName(dbContext, request))
+        .Apply((programSchedule, _) => programSchedule);
+
+    private static Task<Validation<BaseError, ProgramSchedule>> ScheduleMustExist(
+        TvContext dbContext,
+        CopyProgramSchedule request) =>
+        dbContext.ProgramSchedules
+            .AsNoTracking()
+            .Include(ps => ps.Items)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.ProgramScheduleId)
+            .Map(o => o.ToValidation<BaseError>("Schedule does not exist."));
+
+    private static async Task<Validation<BaseError, string>> ValidateName(
+        TvContext dbContext,
+        CopyProgramSchedule request)
+    {
+        List<string> allNames = await dbContext.ProgramSchedules
+            .Map(ps => ps.Name)
+            .ToListAsync();
+
+        Validation<BaseError, string> result1 = request.NotEmpty(c => c.Name)
+            .Bind(_ => request.NotLongerThan(50)(c => c.Name));
+
+        var result2 = Optional(request.Name)
+            .Where(name => !allNames.Contains(name))
+            .ToValidation<BaseError>("Schedule name must be unique");
+
+        return (result1, result2).Apply((_, _) => request.Name);
+    }
+
+    private static void DetachEntity<T>(DbContext db, T entity) where T : class
+    {
+        db.Entry(entity).State = EntityState.Detached;
+        if (entity.GetType().GetProperty("Id") is not null)
+        {
+            entity.GetType().GetProperty("Id")!.SetValue(entity, 0);
+        }
+    }
+}
@@ -17,10 +17,10 @@ public class CreateProgramScheduleHandler :
        CreateProgramSchedule request,
        CancellationToken cancellationToken)
    {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);

        Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, ps => PersistProgramSchedule(dbContext, ps));
+        return await validation.Apply(ps => PersistProgramSchedule(dbContext, ps));
    }

    private static async Task<CreateProgramScheduleResult> PersistProgramSchedule(
@@ -24,6 +24,7 @@ public interface IProgramScheduleItemRequest
    int? FallbackFillerId { get; }
    int? WatermarkId { get; }
    string PreferredAudioLanguageCode { get; }
+    string PreferredAudioTitle { get; }
    string PreferredSubtitleLanguageCode { get; }
    ChannelSubtitleMode? SubtitleMode { get; }
 }
@@ -55,6 +55,7 @@ public abstract class ProgramScheduleItemCommandBase
            {
                case PlaybackOrder.Chronological:
                case PlaybackOrder.Random:
+                case PlaybackOrder.MultiEpisodeShuffle:
                    return BaseError.New($"Invalid playback order for multi collection: '{item.PlaybackOrder}'");
                case PlaybackOrder.Shuffle:
                case PlaybackOrder.ShuffleInOrder:
@@ -180,6 +181,7 @@ public abstract class ProgramScheduleItemCommandBase
                FallbackFillerId = item.FallbackFillerId,
                WatermarkId = item.WatermarkId,
                PreferredAudioLanguageCode = item.PreferredAudioLanguageCode,
+                PreferredAudioTitle = item.PreferredAudioTitle,
                PreferredSubtitleLanguageCode = item.PreferredSubtitleLanguageCode,
                SubtitleMode = item.SubtitleMode
            },
@@ -203,6 +205,7 @@ public abstract class ProgramScheduleItemCommandBase
                FallbackFillerId = item.FallbackFillerId,
                WatermarkId = item.WatermarkId,
                PreferredAudioLanguageCode = item.PreferredAudioLanguageCode,
+                PreferredAudioTitle = item.PreferredAudioTitle,
                PreferredSubtitleLanguageCode = item.PreferredSubtitleLanguageCode,
                SubtitleMode = item.SubtitleMode
            },
@@ -227,6 +230,7 @@ public abstract class ProgramScheduleItemCommandBase
                FallbackFillerId = item.FallbackFillerId,
                WatermarkId = item.WatermarkId,
                PreferredAudioLanguageCode = item.PreferredAudioLanguageCode,
+                PreferredAudioTitle = item.PreferredAudioTitle,
                PreferredSubtitleLanguageCode = item.PreferredSubtitleLanguageCode,
                SubtitleMode = item.SubtitleMode
            },
@@ -252,6 +256,7 @@ public abstract class ProgramScheduleItemCommandBase
                FallbackFillerId = item.FallbackFillerId,
                WatermarkId = item.WatermarkId,
                PreferredAudioLanguageCode = item.PreferredAudioLanguageCode,
+                PreferredAudioTitle = item.PreferredAudioTitle,
                PreferredSubtitleLanguageCode = item.PreferredSubtitleLanguageCode,
                SubtitleMode = item.SubtitleMode
            },
@@ -26,6 +26,7 @@ public record ReplaceProgramScheduleItem(
    int? FallbackFillerId,
    int? WatermarkId,
    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
    string PreferredSubtitleLanguageCode,
    ChannelSubtitleMode? SubtitleMode) : IProgramScheduleItemRequest;

@@ -63,6 +63,7 @@ internal static class Mapper
                        ? Watermarks.Mapper.ProjectToViewModel(duration.Watermark)
                        : null,
                    duration.PreferredAudioLanguageCode,
+                    duration.PreferredAudioTitle,
                    duration.PreferredSubtitleLanguageCode,
                    duration.SubtitleMode),
            ProgramScheduleItemFlood flood =>
@@ -110,6 +111,7 @@ internal static class Mapper
                        ? Watermarks.Mapper.ProjectToViewModel(flood.Watermark)
                        : null,
                    flood.PreferredAudioLanguageCode,
+                    flood.PreferredAudioTitle,
                    flood.PreferredSubtitleLanguageCode,
                    flood.SubtitleMode),
            ProgramScheduleItemMultiple multiple =>
@@ -158,6 +160,7 @@ internal static class Mapper
                        ? Watermarks.Mapper.ProjectToViewModel(multiple.Watermark)
                        : null,
                    multiple.PreferredAudioLanguageCode,
+                    multiple.PreferredAudioTitle,
                    multiple.PreferredSubtitleLanguageCode,
                    multiple.SubtitleMode),
            ProgramScheduleItemOne one =>
@@ -205,6 +208,7 @@ internal static class Mapper
                        ? Watermarks.Mapper.ProjectToViewModel(one.Watermark)
                        : null,
                    one.PreferredAudioLanguageCode,
+                    one.PreferredAudioTitle,
                    one.PreferredSubtitleLanguageCode,
                    one.SubtitleMode),
            _ => throw new NotSupportedException(
@@ -30,6 +30,7 @@ public record ProgramScheduleItemDurationViewModel : ProgramScheduleItemViewMode
        FillerPresetViewModel fallbackFiller,
        WatermarkViewModel watermark,
        string preferredAudioLanguageCode,
+        string preferredAudioTitle,
        string preferredSubtitleLanguageCode,
        ChannelSubtitleMode? subtitleMode) : base(
        id,
@@ -52,6 +53,7 @@ public record ProgramScheduleItemDurationViewModel : ProgramScheduleItemViewMode
        fallbackFiller,
        watermark,
        preferredAudioLanguageCode,
+        preferredAudioTitle,
        preferredSubtitleLanguageCode,
        subtitleMode)
    {
@@ -28,6 +28,7 @@ public record ProgramScheduleItemFloodViewModel : ProgramScheduleItemViewModel
        FillerPresetViewModel fallbackFiller,
        WatermarkViewModel watermark,
        string preferredAudioLanguageCode,
+        string preferredAudioTitle,
        string preferredSubtitleLanguageCode,
        ChannelSubtitleMode? subtitleMode) : base(
        id,
@@ -50,6 +51,7 @@ public record ProgramScheduleItemFloodViewModel : ProgramScheduleItemViewModel
        fallbackFiller,
        watermark,
        preferredAudioLanguageCode,
+        preferredAudioTitle,
        preferredSubtitleLanguageCode,
        subtitleMode)
    {
@@ -29,6 +29,7 @@ public record ProgramScheduleItemMultipleViewModel : ProgramScheduleItemViewMode
        FillerPresetViewModel fallbackFiller,
        WatermarkViewModel watermark,
        string preferredAudioLanguageCode,
+        string preferredAudioTitle,
        string preferredSubtitleLanguageCode,
        ChannelSubtitleMode? subtitleMode) : base(
        id,
@@ -51,6 +52,7 @@ public record ProgramScheduleItemMultipleViewModel : ProgramScheduleItemViewMode
        fallbackFiller,
        watermark,
        preferredAudioLanguageCode,
+        preferredAudioTitle,
        preferredSubtitleLanguageCode,
        subtitleMode) =>
        Count = count;
@@ -28,6 +28,7 @@ public record ProgramScheduleItemOneViewModel : ProgramScheduleItemViewModel
        FillerPresetViewModel fallbackFiller,
        WatermarkViewModel watermark,
        string preferredAudioLanguageCode,
+        string preferredAudioTitle,
        string preferredSubtitleLanguageCode,
        ChannelSubtitleMode? subtitleMode) : base(
        id,
@@ -50,6 +51,7 @@ public record ProgramScheduleItemOneViewModel : ProgramScheduleItemViewModel
        fallbackFiller,
        watermark,
        preferredAudioLanguageCode,
+        preferredAudioTitle,
        preferredSubtitleLanguageCode,
        subtitleMode)
    {
@@ -27,6 +27,7 @@ public abstract record ProgramScheduleItemViewModel(
    FillerPresetViewModel FallbackFiller,
    WatermarkViewModel Watermark,
    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
    string PreferredSubtitleLanguageCode,
    ChannelSubtitleMode? SubtitleMode)
 {
@@ -1,3 +1,3 @@
 namespace ErsatzTV.Application.Search;

-public record RebuildSearchIndex : IRequest<Unit>, IBackgroundServiceRequest;
+public record RebuildSearchIndex : IRequest, IBackgroundServiceRequest;
@@ -3,24 +3,25 @@ using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using Humanizer;
 using Microsoft.Extensions.Logging;

 namespace ErsatzTV.Application.Search;

-public class RebuildSearchIndexHandler : IRequestHandler<RebuildSearchIndex, Unit>
+public class RebuildSearchIndexHandler : IRequestHandler<RebuildSearchIndex>
 {
    private readonly IConfigElementRepository _configElementRepository;
    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
    private readonly ILocalFileSystem _localFileSystem;
    private readonly ILogger<RebuildSearchIndexHandler> _logger;
    private readonly ISearchIndex _searchIndex;
-    private readonly ISearchRepository _searchRepository;
+    private readonly ICachingSearchRepository _searchRepository;

    public RebuildSearchIndexHandler(
        ISearchIndex searchIndex,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
        IConfigElementRepository configElementRepository,
        ILocalFileSystem localFileSystem,
        IFallbackMetadataProvider fallbackMetadataProvider,
@@ -34,7 +35,7 @@ public class RebuildSearchIndexHandler : IRequestHandler<RebuildSearchIndex, Uni
        _fallbackMetadataProvider = fallbackMetadataProvider;
    }

-    public async Task<Unit> Handle(RebuildSearchIndex request, CancellationToken cancellationToken)
+    public async Task Handle(RebuildSearchIndex request, CancellationToken cancellationToken)
    {
        _logger.LogInformation("Initializing search index");

@@ -62,7 +63,5 @@ public class RebuildSearchIndexHandler : IRequestHandler<RebuildSearchIndex, Uni
        {
            _logger.LogInformation("Search index is already version {Version}", _searchIndex.Version);
        }
-
-        return Unit.Default;
    }
 }
@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Search;
+
+public record ReindexMediaItems(IReadOnlyCollection<int> MediaItemIds) : IRequest,
+    ISearchIndexBackgroundServiceRequest;
@@ -0,0 +1,28 @@
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
+using ErsatzTV.Core.Interfaces.Search;
+
+namespace ErsatzTV.Application.Search;
+
+public class ReindexMediaItemsHandler : IRequestHandler<ReindexMediaItems>
+{
+    private readonly ICachingSearchRepository _cachingSearchRepository;
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
+    private readonly ISearchIndex _searchIndex;
+
+    public ReindexMediaItemsHandler(
+        ICachingSearchRepository cachingSearchRepository,
+        IFallbackMetadataProvider fallbackMetadataProvider,
+        ISearchIndex searchIndex)
+    {
+        _cachingSearchRepository = cachingSearchRepository;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
+        _searchIndex = searchIndex;
+    }
+
+    public async Task Handle(ReindexMediaItems request, CancellationToken cancellationToken)
+    {
+        await _searchIndex.RebuildItems(_cachingSearchRepository, _fallbackMetadataProvider, request.MediaItemIds);
+        _searchIndex.Commit();
+    }
+}
@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Search;
+
+public record RemoveMediaItems(IReadOnlyCollection<int> MediaItemIds) : IRequest,
+    ISearchIndexBackgroundServiceRequest;
@@ -0,0 +1,16 @@
+using ErsatzTV.Core.Interfaces.Search;
+
+namespace ErsatzTV.Application.Search;
+
+public class RemoveMediaItemsHandler : IRequestHandler<RemoveMediaItems>
+{
+    private readonly ISearchIndex _searchIndex;
+
+    public RemoveMediaItemsHandler(ISearchIndex searchIndex) => _searchIndex = searchIndex;
+
+    public async Task Handle(RemoveMediaItems request, CancellationToken cancellationToken)
+    {
+        await _searchIndex.RemoveItems(request.MediaItemIds);
+        _searchIndex.Commit();
+    }
+}
@@ -1,29 +1,33 @@
-using ErsatzTV.Core.Interfaces.Search;
+using Bugsnag;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Search;

 namespace ErsatzTV.Application.Search;

-public class
-    QuerySearchIndexAllItemsHandler : IRequestHandler<QuerySearchIndexAllItems, SearchResultAllItemsViewModel>
+public class QuerySearchIndexAllItemsHandler : IRequestHandler<QuerySearchIndexAllItems, SearchResultAllItemsViewModel>
 {
+    private readonly IClient _client;
    private readonly ISearchIndex _searchIndex;

-    public QuerySearchIndexAllItemsHandler(ISearchIndex searchIndex) => _searchIndex = searchIndex;
+    public QuerySearchIndexAllItemsHandler(IClient client, ISearchIndex searchIndex)
+    {
+        _client = client;
+        _searchIndex = searchIndex;
+    }

-    public async Task<SearchResultAllItemsViewModel> Handle(
+    public Task<SearchResultAllItemsViewModel> Handle(
        QuerySearchIndexAllItems request,
        CancellationToken cancellationToken) =>
-        new(
-            await GetIds(SearchIndex.MovieType, request.Query),
-            await GetIds(SearchIndex.ShowType, request.Query),
-            await GetIds(SearchIndex.SeasonType, request.Query),
-            await GetIds(SearchIndex.EpisodeType, request.Query),
-            await GetIds(SearchIndex.ArtistType, request.Query),
-            await GetIds(SearchIndex.MusicVideoType, request.Query),
-            await GetIds(SearchIndex.OtherVideoType, request.Query),
-            await GetIds(SearchIndex.SongType, request.Query));
+        new SearchResultAllItemsViewModel(
+            GetIds(SearchIndex.MovieType, request.Query),
+            GetIds(SearchIndex.ShowType, request.Query),
+            GetIds(SearchIndex.SeasonType, request.Query),
+            GetIds(SearchIndex.EpisodeType, request.Query),
+            GetIds(SearchIndex.ArtistType, request.Query),
+            GetIds(SearchIndex.MusicVideoType, request.Query),
+            GetIds(SearchIndex.OtherVideoType, request.Query),
+            GetIds(SearchIndex.SongType, request.Query)).AsTask();

-    private Task<List<int>> GetIds(string type, string query) =>
-        _searchIndex.Search($"type:{type} AND ({query})", 0, 0)
-            .Map(result => result.Items.Map(i => i.Id).ToList());
+    private List<int> GetIds(string type, string query) =>
+        _searchIndex.Search(_client, $"type:{type} AND ({query})", 0, 0).Items.Map(i => i.Id).ToList();
 }
@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -6,15 +7,15 @@ using static ErsatzTV.Application.MediaCards.Mapper;

 namespace ErsatzTV.Application.Search;

-public class
-    QuerySearchIndexArtistsHandler : IRequestHandler<QuerySearchIndexArtists, ArtistCardResultsViewModel
-    >
+public class QuerySearchIndexArtistsHandler : IRequestHandler<QuerySearchIndexArtists, ArtistCardResultsViewModel>
 {
    private readonly IArtistRepository _artistRepository;
+    private readonly IClient _client;
    private readonly ISearchIndex _searchIndex;

-    public QuerySearchIndexArtistsHandler(ISearchIndex searchIndex, IArtistRepository artistRepository)
+    public QuerySearchIndexArtistsHandler(IClient client, ISearchIndex searchIndex, IArtistRepository artistRepository)
    {
+        _client = client;
        _searchIndex = searchIndex;
        _artistRepository = artistRepository;
    }
@@ -23,7 +24,8 @@ public class
        QuerySearchIndexArtists request,
        CancellationToken cancellationToken)
    {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
            request.Query,
            (request.PageNumber - 1) * request.PageSize,
            request.PageSize);
@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Emby;
@@ -24,10 +25,12 @@ public class
    private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
    private readonly IMediaSourceRepository _mediaSourceRepository;
    private readonly IPlexPathReplacementService _plexPathReplacementService;
+    private readonly IClient _client;
    private readonly ISearchIndex _searchIndex;
    private readonly ITelevisionRepository _televisionRepository;

    public QuerySearchIndexEpisodesHandler(
+        IClient client,
        ISearchIndex searchIndex,
        ITelevisionRepository televisionRepository,
        IMediaSourceRepository mediaSourceRepository,
@@ -37,6 +40,7 @@ public class
        IFallbackMetadataProvider fallbackMetadataProvider,
        IDbContextFactory<TvContext> dbContextFactory)
    {
+        _client = client;
        _searchIndex = searchIndex;
        _televisionRepository = televisionRepository;
        _mediaSourceRepository = mediaSourceRepository;
@@ -51,7 +55,8 @@ public class
        QuerySearchIndexEpisodes request,
        CancellationToken cancellationToken)
    {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
            request.Query,
            (request.PageNumber - 1) * request.PageSize,
            request.PageSize);
@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
@@ -11,13 +12,16 @@ public class QuerySearchIndexMoviesHandler : IRequestHandler<QuerySearchIndexMov
 {
    private readonly IMediaSourceRepository _mediaSourceRepository;
    private readonly IMovieRepository _movieRepository;
+    private readonly IClient _client;
    private readonly ISearchIndex _searchIndex;

    public QuerySearchIndexMoviesHandler(
+        IClient client,
        ISearchIndex searchIndex,
        IMovieRepository movieRepository,
        IMediaSourceRepository mediaSourceRepository)
    {
+        _client = client;
        _searchIndex = searchIndex;
        _movieRepository = movieRepository;
        _mediaSourceRepository = mediaSourceRepository;
@@ -27,7 +31,8 @@ public class QuerySearchIndexMoviesHandler : IRequestHandler<QuerySearchIndexMov
        QuerySearchIndexMovies request,
        CancellationToken cancellationToken)
    {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
            request.Query,
            (request.PageNumber - 1) * request.PageSize,
            request.PageSize);
@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Emby;
@@ -18,15 +19,18 @@ public class
    private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
    private readonly IMusicVideoRepository _musicVideoRepository;
    private readonly IPlexPathReplacementService _plexPathReplacementService;
+    private readonly IClient _client;
    private readonly ISearchIndex _searchIndex;

    public QuerySearchIndexMusicVideosHandler(
+        IClient client,
        ISearchIndex searchIndex,
        IMusicVideoRepository musicVideoRepository,
        IPlexPathReplacementService plexPathReplacementService,
        IJellyfinPathReplacementService jellyfinPathReplacementService,
        IEmbyPathReplacementService embyPathReplacementService)
    {
+        _client = client;
        _searchIndex = searchIndex;
        _musicVideoRepository = musicVideoRepository;
        _plexPathReplacementService = plexPathReplacementService;
@@ -38,7 +42,8 @@ public class
        QuerySearchIndexMusicVideos request,
        CancellationToken cancellationToken)
    {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
            request.Query,
            (request.PageNumber - 1) * request.PageSize,
            request.PageSize);
@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -11,10 +12,15 @@ public class
        OtherVideoCardResultsViewModel>
 {
    private readonly IOtherVideoRepository _otherVideoRepository;
+    private readonly IClient _client;
    private readonly ISearchIndex _searchIndex;

-    public QuerySearchIndexOtherVideosHandler(ISearchIndex searchIndex, IOtherVideoRepository otherVideoRepository)
+    public QuerySearchIndexOtherVideosHandler(
+        IClient client,
+        ISearchIndex searchIndex,
+        IOtherVideoRepository otherVideoRepository)
    {
+        _client = client;
        _searchIndex = searchIndex;
        _otherVideoRepository = otherVideoRepository;
    }
@@ -23,7 +29,8 @@ public class
        QuerySearchIndexOtherVideos request,
        CancellationToken cancellationToken)
    {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
            request.Query,
            (request.PageNumber - 1) * request.PageSize,
            request.PageSize);
@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
@@ -11,14 +12,17 @@ public class
    QuerySearchIndexSeasonsHandler : IRequestHandler<QuerySearchIndexSeasons, TelevisionSeasonCardResultsViewModel>
 {
    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IClient _client;
    private readonly ISearchIndex _searchIndex;
    private readonly ITelevisionRepository _televisionRepository;

    public QuerySearchIndexSeasonsHandler(
+        IClient client,
        ISearchIndex searchIndex,
        ITelevisionRepository televisionRepository,
        IMediaSourceRepository mediaSourceRepository)
    {
+        _client = client;
        _searchIndex = searchIndex;
        _televisionRepository = televisionRepository;
        _mediaSourceRepository = mediaSourceRepository;
@@ -28,7 +32,8 @@ public class
        QuerySearchIndexSeasons request,
        CancellationToken cancellationToken)
    {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
            request.Query,
            (request.PageNumber - 1) * request.PageSize,
            request.PageSize);
@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
@@ -11,14 +12,17 @@ public class
    QuerySearchIndexShowsHandler : IRequestHandler<QuerySearchIndexShows, TelevisionShowCardResultsViewModel>
 {
    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IClient _client;
    private readonly ISearchIndex _searchIndex;
    private readonly ITelevisionRepository _televisionRepository;

    public QuerySearchIndexShowsHandler(
+        IClient client,
        ISearchIndex searchIndex,
        ITelevisionRepository televisionRepository,
        IMediaSourceRepository mediaSourceRepository)
    {
+        _client = client;
        _searchIndex = searchIndex;
        _televisionRepository = televisionRepository;
        _mediaSourceRepository = mediaSourceRepository;
@@ -28,7 +32,8 @@ public class
        QuerySearchIndexShows request,
        CancellationToken cancellationToken)
    {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
            request.Query,
            (request.PageNumber - 1) * request.PageSize,
            request.PageSize);
--- a/Show More
+++ b/Show More