fix(api): standardize error response contract

refs #46

.claude/skills/ersatztv/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: ersatztv
+description: ErsatzTV custom IPTV channel management — REST API, SQLite DB, Jellyfin integration, FFmpeg profiles. Use when managing custom TV channels.
+---
+
+# ErsatzTV Channel Management
+
+Container: `ersatztv` | Port: `8409` | IP: `172.16.238.11` (may change on restart)
+Web UI: internal only (`http://localhost:8409` via SSH)
+SQLite DB: `~/downloadswarm/ersatztv/ersatztv.sqlite3` on jazz (owned by root — use `sudo sqlite3`)
+Image: `ghcr.io/ersatztv/ersatztv:latest` (v26.3.0, repo archived Feb 2026)
+
+## Architecture
+
+ErsatzTV uses **MediatR + Blazor** (not REST for mutations). The REST API is limited:
+- **GET endpoints**: channels, collections, schedules, playouts, shows, movies, artists, ffmpeg profiles, health, search, watermarks
+- **POST endpoints**: library scan, playout reset, show scan
+- **No REST CRUD for channels/collections/schedules** — must use SQLite DB directly
+
+## REST API
+
+```bash
+# Via docker exec
+docker exec ersatztv curl -s http://localhost:8409/api/ENDPOINT
+```
+
+### Read Endpoints (GET)
+```
+/api/channels              # List channels
+/api/collections            # List collections
+/api/schedules              # List schedules
+/api/playouts               # List playouts
+/api/shows                  # List shows
+/api/movies                 # List movies
+/api/artists                # List artists
+/api/search                 # Search items
+/api/ffmpeg/profiles        # FFmpeg profiles
+/api/watermarks             # Watermarks
+/iptv/channels.m3u          # M3U playlist (for Jellyfin)
+/iptv/xmltv.xml             # XMLTV guide data
+```
+
+### Mutation Endpoints (POST)
+```bash
+# Library scan
+POST /api/libraries/{id}/scan
+
+# Scan single show
+POST /api/libraries/{id}/scan-show \
+  -H "Content-Type: application/json" -d '{"ShowTitle":"Name","DeepScan":false}'
+
+# Reset channel playout (rebuilds schedule)
+POST /api/channels/{channelNumber}/playout/reset
+```
+
+## SQLite DB Operations
+
+```bash
+# Read queries (safe while running, WAL mode)
+sudo sqlite3 ~/downloadswarm/ersatztv/ersatztv.sqlite3 "QUERY"
+
+# Write queries — stop container first
+docker stop ersatztv
+sudo sqlite3 ~/downloadswarm/ersatztv/ersatztv.sqlite3 "QUERY"
+docker start ersatztv
+```
+
+### Key Queries
+```sql
+-- List channels
+SELECT Id, Number, Name FROM Channel ORDER BY CAST(Number AS INTEGER);
+
+-- List collections with item counts
+SELECT c.Id, c.Name, COUNT(ci.Id) as items FROM Collection c LEFT JOIN CollectionItem ci ON ci.CollectionId = c.Id GROUP BY c.Id;
+
+-- List schedules
+SELECT Id, Name FROM ProgramSchedule;
+
+-- Playout (channel-schedule links)
+SELECT p.Id, c.Number, c.Name, ps.Name as Schedule FROM Playout p JOIN Channel c ON p.ChannelId = c.Id LEFT JOIN ProgramSchedule ps ON p.ProgramScheduleId = ps.Id;
+
+-- Media counts
+SELECT 'Shows' as type, COUNT(*) FROM Show UNION ALL SELECT 'Movies', COUNT(*) FROM Movie UNION ALL SELECT 'Episodes', COUNT(*) FROM Episode UNION ALL SELECT 'MusicVideos', COUNT(*) FROM MusicVideo;
+
+-- Jellyfin source
+SELECT jms.Id, jc.Address, jms.ServerName FROM JellyfinMediaSource jms JOIN JellyfinConnection jc ON jc.JellyfinMediaSourceId = jms.Id;
+
+-- Library sync status
+SELECT l.Id, l.Name, l.MediaKind, jl.ShouldSyncItems FROM Library l JOIN JellyfinLibrary jl ON jl.Id = l.Id;
+```
+
+### Channel Setup Workflow (DB)
+
+**Show-specific channel** (single TV show, shuffled):
+```sql
+-- 1. Schedule
+INSERT INTO ProgramSchedule (Id, FixedStartTimeBehavior, KeepMultiPartEpisodesTogether, Name, RandomStartPoint, ShuffleScheduleItems, TreatCollectionsAsShows)
+VALUES (<id>, 0, 0, '<name>', 1, 0, 1);
+-- 2. Schedule item (CollectionType=1 for Show, PlaybackOrder=3 for Shuffle)
+INSERT INTO ProgramScheduleItem (Id, CollectionType, FillWithGroupMode, GuideMode, "Index", MarathonGroupBy, MarathonShuffleGroups, MarathonShuffleItems, MediaItemId, PlaybackOrder, ProgramScheduleId)
+VALUES (<id>, 1, 0, 0, 0, 0, 0, 0, <show_id>, 3, <schedule_id>);
+INSERT INTO ProgramScheduleOneItem (Id) VALUES (<item_id>);
+-- 3. Channel
+INSERT INTO Channel (Id, Categories, FFmpegProfileId, FallbackFillerId, "Group", IdleBehavior, IsEnabled, MirrorSourceChannelId, MusicVideoCreditsMode, MusicVideoCreditsTemplate, Name, Number, PlayoutMode, PlayoutOffset, PlayoutSource, PreferredAudioLanguageCode, PreferredAudioTitle, PreferredSubtitleLanguageCode, ShowInEpg, SongVideoMode, SortNumber, StreamSelector, StreamSelectorMode, StreamingMode, SubtitleMode, TranscodeMode, UniqueId, WatermarkId)
+VALUES (<id>, '', 1, NULL, '<category>', 0, 1, NULL, 0, NULL, '<name>', '<number>', 0, NULL, 0, NULL, NULL, 'eng', 1, 0, <number>.0, NULL, 0, 4, 2, 0, lower(hex(randomblob(4)))||'-'||lower(hex(randomblob(2)))||'-4'||substr(lower(hex(randomblob(2))),2)||'-'||lower(hex(randomblob(2)))||'-'||lower(hex(randomblob(6))), 1);
+-- 4. Playout
+INSERT INTO Playout (Id, ChannelId, ProgramScheduleId, ScheduleKind, Seed)
+VALUES (<id>, <channel_id>, <schedule_id>, 0, abs(random()) % 1000000);
+```
+
+**Collection-based channel** (multiple shows, shuffled):
+```sql
+-- 1. Collection + items (MediaItemId = Show.Id)
+INSERT INTO Collection (Id, Name, UseCustomPlaybackOrder) VALUES (<id>, '<name>', 0);
+INSERT INTO CollectionItem (CollectionId, MediaItemId) VALUES (<coll_id>, <show_id>);
+-- 2. Schedule (same as above but CollectionType=0, CollectionId set instead of MediaItemId)
+INSERT INTO ProgramScheduleItem (Id, CollectionId, CollectionType, ..., PlaybackOrder, ProgramScheduleId)
+VALUES (<id>, <coll_id>, 0, ..., 3, <schedule_id>);
+-- 3-4. Channel + Playout same as show-specific
+```
+
+After creating: `POST /api/channels/{number}/playout/reset`
+
+## Volume Mounts (matches Jellyfin)
+
+| Host Path | Container Path |
+|-----------|---------------|
+| `~/downloadswarm/ersatztv` | `/config` |
+| `/mnt/teramind/episodes` | `/data/tvshows` (ro) |
+| `/mnt/episodes` | `/data/episodes` (ro) |
+| `/mnt/media/movies` | `/data/movies` (ro) |
+| `/mnt/media/standup` | `/data/standup` (ro) |
+| `/mnt/media/music_videos` | `/data/music` (ro) |
+
+## FFmpeg & Hardware
+
+- QSV (Intel Quick Sync) hardware acceleration
+- Resolution: 1920x1080, H264, AAC stereo
+- Device: `/dev/dri` passed through
+- HardwareAccelerationKind: 0=None, 1=Qsv, 2=Nvenc, 3=Vaapi, 4=VideoToolbox, 5=Amf
+
+## Jellyfin Integration
+
+- Secrets: `/config/jellyfin-secrets.json` (`{"Address":"http://jellyfin:8096","ApiKey":"978033be716d46678a5d3c54ae0e0ff9"}`)
+- Libraries: Movies(10), TV Shows(11), Music Videos(8), Standup(9)
+- `JellyfinLibrary.ShouldSyncItems` must be `1` for scans to work
+
+## Gotchas
+
+- DB owned by root — always use `sudo sqlite3`
+- WAL mode: reads OK while running, stop container for writes
+- No REST API for channel/collection/schedule CRUD — DB scripting only
+- Secrets file uses PascalCase JSON (`Address`, `ApiKey`)
+- Scanner is separate binary (`ErsatzTV.Scanner`) — check with `docker top ersatztv | grep Scanner`
+- EF TPT inheritance: `ProgramScheduleItem` has subtype tables (`ProgramScheduleOneItem`, etc.) — MUST insert into subtype table
+- External URL logos work for M3U but NOT for watermark burn-in (code checks `File.Exists()`)
+- `/api/health` returns Blazor HTML, not JSON — use `/api/channels` to verify API
+- PlaybackOrder enum: 3=Shuffle, 6=SeasonEpisode (use 3 for all channels)
+- CollectionType enum: 0=Collection, 1=Show (direct show reference via MediaItemId)
+- SubtitleMode: 0=None, 2=Burn-in. Set to 2 with PreferredSubtitleLanguageCode='eng' for non-music channels
+- MediaItem.State: 0=Normal, 1=FileNotFound — clean up state=1 items by deleting cascading deps
+- ProgramSchedule required NOT NULL columns: FixedStartTimeBehavior, KeepMultiPartEpisodesTogether, RandomStartPoint, ShuffleScheduleItems, TreatCollectionsAsShows
+- Channel required NOT NULL columns: SongVideoMode (set 0), plus all standard columns (see Channel table schema)
+- After schedule changes, rebuild playout: `POST /api/channels/{number}/playout/reset`
+- Playout `ScheduleKind` must be `1` (not `0`/None) — `0` causes "Cannot build playout type None" error
+- M3U `tvg-logo` URLs hardcode `http://localhost:8409` — Jellyfin can't fetch these from inside its container. Fix by downloading logos from ETV and base64-uploading to Jellyfin (see `docs/Docker/ErsatzTV.md` for script). Tracked in issue #171
+- Repo archived Feb 2026, v26.3.0 is final stable version. Maintainer welcomes forks

.claude/skills/jellyfin/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: jellyfin
+description: Jellyfin media server management — API for libraries, items, streaming, users. Use when managing media library or checking Jellyfin status.
+---
+
+# Jellyfin Management
+
+Container: `jellyfin` | Port: `8096` | IP: `172.16.238.20` (may change on restart)
+API Token: `978033be716d46678a5d3c54ae0e0ff9`
+Web UI: `https://jellyfin.tblindustries.be` (NO Authelia — native login, password: `coup1802`)
+Config: `/home/timothy/downloadswarm/jellyfin/` on jazz
+
+## Access Pattern
+
+```bash
+docker exec jellyfin curl -s 'http://localhost:8096/ENDPOINT' \
+  -H 'X-Emby-Token: 978033be716d46678a5d3c54ae0e0ff9'
+```
+
+## Volume Mounts
+
+| Host Path | Container Path | Content |
+|-----------|---------------|---------|
+| `/mnt/teramind/episodes` | `/data/tvshows` | TV shows |
+| `/mnt/episodes` | `/data/episodes` | More episodes |
+| `/mnt/media/movies` | `/data/movies` | Movies |
+| `/mnt/media/standup` | `/data/standup` | Standup |
+| `/mnt/media/music_videos` | `/data/music` | Music videos |
+| `/mnt/media/audio/music` | `/data/audio` | Music audio (ro) |
+
+## API Endpoints
+
+### System
+```
+GET  /System/Info                   # Server info, version
+GET  /System/Info/Public            # Public info (no auth needed)
+POST /System/Restart                # Restart server
+```
+
+### Items (Search & Browse)
+```bash
+# Search items
+GET /Items?includeItemTypes=Movie,Episode,Series&recursive=true&searchTerm=QUERY&fields=Path&limit=20
+
+# Get item details
+GET /Items?ids=ITEM_ID&fields=Path,MediaStreams,Overview
+
+# Get all movies
+GET /Items?includeItemTypes=Movie&recursive=true&fields=Path&limit=1000
+
+# Get series
+GET /Items?includeItemTypes=Series&recursive=true&fields=Path
+
+# Get episodes for a series
+GET /Shows/{seriesId}/Episodes?fields=Path,MediaStreams
+
+# Filter by library (parentId)
+GET /Items?parentId=LIBRARY_ID&recursive=true&fields=Path
+```
+
+### Libraries
+```
+GET  /Library/VirtualFolders        # List all libraries
+POST /Library/Refresh               # Trigger full library scan
+POST /Items/{id}/Refresh            # Refresh single item metadata
+```
+
+### Streaming
+```bash
+# Test stream URL
+GET /Videos/{itemId}/stream?static=true
+
+# Get playback info
+GET /Items/{itemId}/PlaybackInfo
+```
+
+### Users
+```
+GET  /Users                         # List users
+GET  /Users/{userId}                # User details
+```
+
+## Library IDs
+
+Check with: `curl -s -H "X-Emby-Token: TOKEN" http://localhost:8096/Library/VirtualFolders`
+
+## Live TV
+
+- **ErsatzTV** (channels <1000): M3U `http://ersatztv:8409/iptv/channels.m3u`, XMLTV `http://ersatztv:8409/iptv/xmltv.xml`
+- **Dispatcharr** (channels 1000+): IPTV stream manager on port 9191, separate tuner
+- Configured in Jellyfin Admin > Live TV
+- Guide refresh task ID: `bea9b218c97bbf98c5dc1303bdb9a0ca` — trigger via `POST /ScheduledTasks/Running/{id}`
+- **Logo fix after guide refresh**: ErsatzTV logos break (aspect ratio=0) because M3U uses `localhost:8409`. Fix script in `docs/Docker/ErsatzTV.md` downloads from ETV and base64-uploads to `POST /Items/{id}/Images/Primary` (body = base64, Content-Type = image/png)
+- **Image upload format**: Jellyfin expects base64-encoded body (NOT raw binary) for `POST /Items/{id}/Images/Primary`
+
+## Gotchas
+
+- **Passwords**: `coup1802` (NOT `ded89Lm4`) — Jellyfin has native auth, no Authelia
+- Auth header is `X-Emby-Token` (Jellyfin is an Emby fork)
+- Music videos are typed as "Movie" in Jellyfin
+- Music library at `/data/music` maps to `/mnt/media/music_videos` on host (not actual music)
+- Items return 404 on stream if source volume is unmounted
+- Jellyfin preserves item IDs across restarts unless files are renamed
+- Full library scan can take a long time — prefer targeted `/Items/{id}/Refresh`
+- `ffprobe` available in container for checking media streams: `docker exec jellyfin ffprobe -v quiet -print_format json -show_streams FILE`

.editorconfig

@@ -104,3 +104,19 @@ ij_json_wrap_long_lines = false
 [*.cs]
 # disable CA1848: Use the LoggerMessage delegates`
 dotnet_diagnostic.ca1848.severity = none
+
+# --- Static-analysis pack adoption (ersatztv#15) ---
+# Roslynator / SonarAnalyzer / Meziantou / AsyncFixer are referenced centrally
+# (Directory.Build.targets). Default every analyzer diagnostic to `suggestion` so the new
+# packs don't fail the TreatWarningsAsErrors build; high-value rules get promoted to
+# warning/error one at a time (see ersatztv#15 / docs/contributing.md). Explicit per-rule
+# severities (e.g. ca1848 above) still take precedence over this bulk default.
+dotnet_analyzer_diagnostic.severity = suggestion
+
+# Blazor components: analyzers run on .razor/.cshtml @code too, and TWAE would otherwise
+# turn their default-severity findings into build errors — keep them at suggestion as well.
+[*.razor]
+dotnet_analyzer_diagnostic.severity = suggestion
+
+[*.cshtml]
+dotnet_analyzer_diagnostic.severity = suggestion

.gitea/workflows/dependency-scan.yml

@@ -0,0 +1,58 @@
+name: Dependency vulnerability scan
+
+# Scheduled NuGet advisory scan — a Gitea-native stand-in for Dependabot (ersatztv#14).
+# Surfaces vulnerable direct/transitive packages on a schedule instead of only when a
+# `dotnet restore` happens to break. This is DETECTION ONLY; automated update PRs are
+# tracked separately (self-hosted Renovate — server-management#484).
+#
+# Scans the FULL solution (including the Scanner project, which the image build strips)
+# so coverage isn't narrower than the code we ship.
+#
+# NOTE: Gitea runs `schedule` triggers only from the default branch (main); the workflow
+# must be merged to main before the cron registers. Use `workflow_dispatch` to run on demand.
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Mondays 06:00 UTC
+    - cron: '0 6 * * 1'
+
+# Independent of the build pipeline's concurrency group; a stale scan can be cancelled.
+concurrency:
+  group: ersatztv-depscan
+  cancel-in-progress: true
+
+jobs:
+  scan:
+    name: NuGet vulnerable packages
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Restore
+        run: dotnet restore ErsatzTV.sln
+
+      - name: Scan for vulnerable packages (direct + transitive)
+        # bash + `set -euo pipefail` so a failing `dotnet list` (e.g. the audit source
+        # is unreachable while restore served from cache) fails the job instead of
+        # falling through to a false "no vulnerable packages" green.
+        shell: bash
+        run: |
+          set -euo pipefail
+          echo "Running: dotnet list package --vulnerable --include-transitive"
+          dotnet list ErsatzTV.sln package --vulnerable --include-transitive 2>&1 | tee depscan.txt
+          # `dotnet list package --vulnerable` exits 0 even when advisories exist, so detect
+          # findings by the report marker and fail the run if any are present. Expect this to
+          # be RED until ersatztv#8 clears the current NCalcSync / SQLitePCLRaw advisories;
+          # after that, a red run means a NEW advisory has appeared.
+          if grep -q "has the following vulnerable packages" depscan.txt; then
+            echo "::error::Vulnerable NuGet packages detected — see report above (tracked: ersatztv#8)."
+            exit 1
+          fi
+          echo "No vulnerable packages found."

.gitea/workflows/docker-build.yml

@@ -0,0 +1,251 @@
+name: Build ErsatzTV Image
+
+# Builds the fork's own amd64 image and pushes it to the Gitea container registry.
+#   pull_request      -> test job only (no image build/push)
+#   push to main      -> :latest + :<short-sha>   (test image; does NOT touch prod)
+#   push tag v*       -> :prod + :<version> + :<short-sha>   (prod release)
+#   workflow_dispatch -> manual run; only publishes when the ref is main or a v* tag
+#
+# Runner + registry provisioned in server-management#172. The Gitea registry is
+# HTTP-only, so BuildKit needs the inline `http = true` config below (it does not
+# inherit the host daemon's insecure-registries setting).
+#
+# `:latest` is intentionally the test/dev channel (per ersatztv#3); prod pins
+# `:prod`, never `:latest` (enforced in the prod compose — server-management#481).
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*'
+
+# Single runner on jazz: serialize all runs so the push-main-then-tag release
+# flow can't collide on the shared :buildcache tag or the smoke container.
+concurrency:
+  group: ersatztv-build
+  cancel-in-progress: false
+
+env:
+  REGISTRY: 192.168.1.95:3000
+  IMAGE: 192.168.1.95:3000/timothy/ersatztv
+
+jobs:
+  test:
+    name: Build & test (.NET)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Restore
+        run: dotnet restore
+
+      - name: Strip Scanner project ref (matches Docker build)
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --configuration Release --no-build --blame-hang-timeout "2m" --verbosity normal
+
+  migrations:
+    name: EF migration integrity (SQLite + MySql)
+    runs-on: ubuntu-latest
+    # Independent gate (not a 'needs' of build yet) so the new MySql-service dependency
+    # can't block image builds until it's proven reliable on the runner. Promote to a
+    # required check / build dependency once green. (ersatztv#13)
+    services:
+      mysql:
+        image: mysql:8.4
+        env:
+          MYSQL_ROOT_PASSWORD: ersatztv
+          MYSQL_DATABASE: ersatztv_migrations
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd="mysqladmin ping -h 127.0.0.1 -uroot -persatztv --silent"
+          --health-interval=5s
+          --health-timeout=5s
+          --health-retries=30
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Restore
+        run: dotnet restore
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Install dotnet-ef
+        run: dotnet tool install --global dotnet-ef --version 9.0.12
+
+      # SQLite is the prod provider; both checks validated locally.
+      - name: SQLite — model drift + apply all migrations to a fresh DB
+        run: |
+          set -euo pipefail
+          export PATH="$PATH:$HOME/.dotnet/tools"
+          echo "::group::SQLite model drift (has-pending-model-changes)"
+          dotnet ef migrations has-pending-model-changes --no-build --configuration Release \
+            --context TvContext --startup-project ErsatzTV --project ErsatzTV.Infrastructure.Sqlite -- --provider Sqlite
+          echo "::endgroup::"
+          echo "::group::SQLite apply all migrations to a fresh DB"
+          export ETV_CONFIG_FOLDER="$(mktemp -d)" ETV_TRANSCODE_FOLDER="$(mktemp -d)"
+          dotnet ef database update --no-build --configuration Release \
+            --context TvContext --startup-project ErsatzTV --project ErsatzTV.Infrastructure.Sqlite -- --provider Sqlite
+          echo "::endgroup::"
+
+      # MySql uses ServerVersion.AutoDetect (connects at config time), so it runs against the
+      # service container above. MySql__ConnectionString maps to config key "MySql:ConnectionString".
+      - name: MySql — model drift + apply all migrations to a fresh DB
+        env:
+          MySql__ConnectionString: "Server=mysql;Port=3306;Database=ersatztv_migrations;Uid=root;Pwd=ersatztv;"
+        run: |
+          set -euo pipefail
+          export PATH="$PATH:$HOME/.dotnet/tools"
+          echo "::group::MySql model drift (has-pending-model-changes)"
+          dotnet ef migrations has-pending-model-changes --no-build --configuration Release \
+            --context TvContext --startup-project ErsatzTV --project ErsatzTV.Infrastructure.MySql -- --provider MySql
+          echo "::endgroup::"
+          echo "::group::MySql apply all migrations to a fresh DB"
+          dotnet ef database update --no-build --configuration Release \
+            --context TvContext --startup-project ErsatzTV --project ErsatzTV.Infrastructure.MySql -- --provider MySql
+          echo "::endgroup::"
+
+  build:
+    name: Build & push image (amd64)
+    runs-on: ubuntu-latest
+    needs: [test, migrations]
+    if: github.event_name != 'pull_request'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Compute version and tags
+        id: meta
+        run: |
+          SHORT=$(git rev-parse --short HEAD)
+          if [ "${GITHUB_REF_TYPE}" = "tag" ]; then
+            VERSION="${GITHUB_REF_NAME#v}"
+            INFO_VERSION="${VERSION}"
+            TAGS=("${IMAGE}:prod" "${IMAGE}:${VERSION}" "${IMAGE}:${SHORT}")
+          else
+            DESC=$(git describe --tags --abbrev=0 2>/dev/null || echo v0.0.0)
+            INFO_VERSION="${DESC#v}-${SHORT}"
+            TAGS=("${IMAGE}:latest" "${IMAGE}:${SHORT}")
+          fi
+          echo "info_version=${INFO_VERSION}" >> "$GITHUB_OUTPUT"
+          echo "short=${SHORT}" >> "$GITHUB_OUTPUT"
+          {
+            echo "tags<<__EOT__"
+            printf '%s\n' "${TAGS[@]}"
+            echo "__EOT__"
+          } >> "$GITHUB_OUTPUT"
+          echo "INFO_VERSION=${INFO_VERSION}"
+          printf 'tag: %s\n' "${TAGS[@]}"
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          buildkitd-config-inline: |
+            [registry."192.168.1.95:3000"]
+              http = true
+
+      - name: Login to Gitea registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ secrets.REGISTRY_USER }}
+          password: ${{ secrets.REGISTRY_PASSWORD }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./docker/Dockerfile
+          platforms: linux/amd64
+          # only publish from main or a v* tag; other refs (e.g. branch dispatch) build only
+          push: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') }}
+          provenance: false
+          build-args: |
+            INFO_VERSION=${{ steps.meta.outputs.info_version }}
+          tags: ${{ steps.meta.outputs.tags }}
+          cache-from: type=registry,ref=192.168.1.95:3000/timothy/ersatztv:buildcache
+          cache-to: type=registry,ref=192.168.1.95:3000/timothy/ersatztv:buildcache,mode=max,ignore-error=true
+
+      - name: Smoke + IPTV E2E (assert key endpoints)
+        if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') }}
+        run: |
+          IMG="${IMAGE}:${{ steps.meta.outputs.short }}"
+          NAME="etv-smoke-${{ github.run_id }}"
+          trap 'docker rm -f "$NAME" >/dev/null 2>&1 || true' EXIT
+          echo "Pulling ${IMG}"
+          docker pull "$IMG"
+          docker run -d --name "$NAME" --memory 2g \
+            -e ETV_CONFIG_FOLDER=/tmp/etv/config \
+            -e ETV_TRANSCODE_FOLDER=/tmp/etv/transcode \
+            "$IMG"
+          # probe ErsatzTV's web server from inside the container (image ships python3)
+          cat > probe.py <<'PY'
+          import urllib.request, urllib.error, sys
+          try:
+              urllib.request.urlopen("http://localhost:8409/", timeout=3)
+          except urllib.error.HTTPError:
+              pass          # any HTTP status means the server is serving
+          except Exception:
+              sys.exit(1)   # not listening yet
+          PY
+          ok=0
+          for _ in $(seq 1 60); do
+            if [ -z "$(docker ps -q --filter name="$NAME" --filter status=running)" ]; then
+              echo "Container exited early"; break
+            fi
+            if docker exec -i "$NAME" python3 - < probe.py >/dev/null 2>&1; then
+              ok=1; break
+            fi
+            sleep 2
+          done
+          if [ "$ok" != "1" ]; then
+            echo "===== container logs (tail) ====="; docker logs "$NAME" 2>&1 | tail -n 40 || true
+            echo "Smoke test FAILED: ErsatzTV did not serve HTTP on :8409"
+            exit 1
+          fi
+          echo "HTTP ready; asserting key IPTV endpoints (ersatztv#16)"
+          # E2E: assert the real Jellyfin-facing surfaces serve a valid playlist + guide, not just
+          # that the app answers HTTP. xmltv.xml needs channels.xml, which the scheduler writes a
+          # few seconds after boot, so poll each endpoint until it returns 2xx with the right shape.
+          # urlopen() returns only on 2xx (raises on 4xx/5xx), so reaching sys.exit means status OK.
+          check() {
+            local path="$1" needle="$2" i
+            for i in $(seq 1 20); do
+              if docker exec "$NAME" python3 -c "import urllib.request,sys; b=urllib.request.urlopen('http://localhost:8409$path',timeout=5).read(512).decode('utf-8','replace'); sys.exit(0 if '$needle' in b else 1)" 2>/dev/null; then
+                echo "  OK   $path (2xx, contains '$needle')"; return 0
+              fi
+              sleep 3
+            done
+            echo "  FAIL $path (no 2xx containing '$needle' within timeout)"; return 1
+          }
+          if check "/iptv/channels.m3u" "#EXTM3U" && check "/iptv/xmltv.xml" "<tv"; then
+            echo "Smoke + IPTV E2E passed: channels.m3u + xmltv.xml serve a valid playlist + guide"
+          else
+            echo "===== container logs (tail) ====="; docker logs "$NAME" 2>&1 | tail -n 40 || true
+            exit 1
+          fi

.gitea/workflows/renovate.yml

@@ -0,0 +1,70 @@
+name: Renovate
+
+# Self-hosted Renovate for the ErsatzTV fork (server-management#484).
+#
+# Opens dependency-update PRs against this repo (managers: nuget via CPM, github-actions).
+# Runs on the shared Gitea act_runner (bumblebee). It supersedes the *proposing* half that
+# the dependency-scan.yml (ersatztv#14) deliberately left out — that scan stays as a cheap
+# in-repo detector for now.
+#
+# Config: repo-root renovate.json (package rules, grouping, automerge policy).
+# Bot identity + tokens are injected from repo Actions secrets:
+#   RENOVATE_TOKEN     — PAT of the dedicated `renovate` Gitea bot (write:repository,
+#                        read:user, write:issue, read:organization)
+#   GH_COM_TOKEN       — no-scope github.com PAT for changelog/release-note fetching
+#                        (Renovate needs this on non-GitHub platforms; optional, degrades
+#                        gracefully to anonymous if unset). Named GH_, not GITHUB_, because
+#                        Gitea reserves the GITHUB_ secret-name prefix.
+#
+# NOTE: Gitea runs `schedule` triggers ONLY from the default branch (main); this file must
+# be on main before the cron registers. Use workflow_dispatch to run on demand — it defaults
+# to a DRY RUN (logs only, no PRs); dispatch with "Dry run" cleared to create real PRs.
+
+on:
+  workflow_dispatch:
+    inputs:
+      dryRun:
+        description: 'Dry run (full = log only, no PRs; clear for a live run)'
+        type: choice
+        options:
+          - 'full'
+          - ''
+        default: 'full'
+      logLevel:
+        description: 'Log level'
+        type: choice
+        options:
+          - 'info'
+          - 'debug'
+        default: 'info'
+  schedule:
+    # Mondays 03:00 UTC — ahead of the 06:00 vulnerability scan
+    - cron: '0 3 * * 1'
+
+concurrency:
+  group: ersatztv-renovate
+  cancel-in-progress: false
+
+jobs:
+  renovate:
+    name: Renovate
+    runs-on: ubuntu-latest
+    container:
+      image: renovate/renovate:43
+    steps:
+      - name: Run Renovate
+        env:
+          RENOVATE_PLATFORM: gitea
+          RENOVATE_ENDPOINT: http://192.168.1.95:3000/api/v1
+          RENOVATE_TOKEN: ${{ secrets.RENOVATE_TOKEN }}
+          RENOVATE_GITHUB_COM_TOKEN: ${{ secrets.GH_COM_TOKEN }}
+          RENOVATE_REPOSITORIES: timothy/ersatztv
+          RENOVATE_AUTODISCOVER: 'false'
+          RENOVATE_GIT_AUTHOR: 'Renovate Bot <renovate@tblindustries.be>'
+          # Let the dockerfile manager query our HTTP-only Gitea container registry for the
+          # ersatztv-ffmpeg base image. Creds (reused from the image-push secrets) + insecureRegistry
+          # live here, NOT in renovate.json, so they stay out of the committed config.
+          RENOVATE_HOST_RULES: '[{"matchHost":"192.168.1.95:3000","hostType":"docker","username":"${{ secrets.REGISTRY_USER }}","password":"${{ secrets.REGISTRY_PASSWORD }}","insecureRegistry":true}]'
+          RENOVATE_DRY_RUN: ${{ inputs.dryRun }}
+          LOG_LEVEL: ${{ inputs.logLevel || 'info' }}
+        run: renovate

.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github: jasongdove
-custom: "https://www.paypal.me/jasongdove"

.github/dependabot.yml

@@ -1,26 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: nuget
-    directory: "/"
-    schedule:
-      interval: daily
-    assignees:
-      - jasongdove
-  - package-ecosystem: docker
-    directory: "/docker"
-    schedule:
-      interval: daily
-    assignees:
-      - jasongdove
-  - package-ecosystem: docker
-    directory: "/docker/nvidia"
-    schedule:
-      interval: daily
-    assignees:
-      - jasongdove
-  - package-ecosystem: docker
-    directory: "/docker/vaapi"
-    schedule:
-      interval: daily
-    assignees:
-      - jasongdove

.github/workflows/artifacts.yml

@@ -1,336 +0,0 @@
-name: Build Artifacts
-on:
-  workflow_call:
-    inputs:
-      release_tag:
-        description: 'Release tag'
-        required: true
-        type: string
-      release_version:
-        description: 'Release version number (e.g. v0.3.7-alpha)'
-        required: true
-        type: string
-      info_version:
-        description: 'Informational version number (e.g. 0.3.7-alpha)'
-        required: true
-        type: string
-    secrets:
-      apple_developer_certificate_p12_base64:
-        required: true
-      apple_developer_certificate_password:
-        required: true
-      ac_username:
-        required: true
-      ac_password:
-        required: true
-      gh_token:
-        required: true
-      azure_client_id:
-        required: true
-      azure_tenant_id:
-        required: true
-      azure_subscription_id:
-        required: true
-permissions:
-  id-token: write
-  contents: write
-jobs:
-  build_and_upload_mac:
-    name: Mac Build & Upload
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-          - os: macos-14
-            kind: macOS
-            target: osx-x64
-          - os: macos-14
-            kind: macOS
-            target: osx-arm64
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -r "${{ matrix.target}}"
-
-      - name: Import Code-Signing Certificates
-        uses: Apple-Actions/import-codesign-certs@v2
-        with:
-          p12-file-base64: ${{ secrets.apple_developer_certificate_p12_base64 }}
-          p12-password: ${{ secrets.apple_developer_certificate_password }}
-
-      - name: Calculate Release Name
-        shell: bash
-        run: |
-          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
-          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
-
-      - name: Build
-        shell: bash
-        run: |
-          sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -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 net10.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-
-      - name: Bundle
-        shell: bash
-        run: |
-          brew install coreutils
-          plutil -replace CFBundleShortVersionString -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
-          plutil -replace CFBundleVersion -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
-          scripts/macOS/bundle.sh
-
-      - name: Sign
-        shell: bash
-        run: scripts/macOS/sign.sh
-
-      - name: Create DMG
-        shell: bash
-        run: |
-          brew install create-dmg
-          create-dmg \
-            --volname "ErsatzTV" \
-            --volicon "artwork/ErsatzTV.icns" \
-            --window-pos 200 120 \
-            --window-size 800 400 \
-            --icon-size 100 \
-            --icon "ErsatzTV.app" 200 190 \
-            --hide-extension "ErsatzTV.app" \
-            --app-drop-link 600 185 \
-            --skip-jenkins \
-            --no-internet-enable \
-            "ErsatzTV.dmg" \
-            "ErsatzTV.app/"
-
-      - name: Notarize
-        shell: bash
-        run: |
-          xcrun notarytool submit ErsatzTV.dmg --apple-id "${{ secrets.ac_username }}" --password "${{ secrets.ac_password }}" --team-id 32MB98Q32R --wait
-          xcrun stapler staple ErsatzTV.dmg
-
-      - name: Cleanup
-        shell: bash
-        run: |
-          mv ErsatzTV.dmg "${{ env.RELEASE_NAME }}.dmg"
-          rm -r publish
-          rm -r ErsatzTV.app
-
-      - 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 }}
-          fail-if-no-assets: false
-          assets: "*${{ matrix.target }}.dmg"
-
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        with:
-          prerelease: false
-          tag_name: ${{ inputs.release_tag }}
-          files: "${{ env.RELEASE_NAME }}.dmg"
-        env:
-          GITHUB_TOKEN: ${{ secrets.gh_token }}
-
-  build_and_upload_linux:
-    name: Build & Upload Linux
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-x64
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-musl-x64
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-arm
-          - os: ubuntu-24.04-arm
-            kind: linux
-            target: linux-arm64
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -r "${{ matrix.target }}"
-
-      - name: Build
-        shell: bash
-        run: |
-          # Define some variables for things we need
-          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
-          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
-
-          # Build everything
-          sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -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 net10.0 --runtime "${{ matrix.target }}" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          mkdir "$release_name"
-          mv scanner/* "$release_name/"
-          mv main/* "$release_name/"
-          tar czvf "${release_name}.tar.gz" "$release_name"
-
-          # Delete output directory
-          rm -r "$release_name"
-
-      - 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 }}
-          fail-if-no-assets: false
-          assets: "*${{ matrix.target }}.tar.gz"
-
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        with:
-          prerelease: false
-          tag_name: ${{ inputs.release_tag }}
-          files: "${{ env.RELEASE_NAME }}.tar.gz"
-        env:
-          GITHUB_TOKEN: ${{ secrets.gh_token }}
-
-  build_dotnet_windows:
-    name: Build dotnet for Windows
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -r "win-x64"
-
-      - name: Build dotnet projects
-        shell: bash
-        run: |
-          sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "win-x64" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "win-x64" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-
-      - name: Upload .NET Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: dotnet-windows-build
-          path: |
-            scanner/
-            main/
-          retention-days: 1
-
-  package_and_upload_windows:
-    name: Package & Upload Windows
-    runs-on: windows-latest
-    needs: build_dotnet_windows
-    steps:
-      - name: Download dotnet artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: dotnet-windows-build
-          path: dotnet-build
-
-      - name: Azure login
-        uses: azure/login@v2
-        with:
-          client-id: ${{ secrets.azure_client_id }}
-          tenant-id: ${{ secrets.azure_tenant_id }}
-          subscription-id: ${{ secrets.azure_subscription_id }}
-          enable-AzPSSession: true
-
-      - name: Sign dotnet artifacts
-        uses: azure/trusted-signing-action@v0
-        with:
-          endpoint: https://eus.codesigning.azure.net/
-          trusted-signing-account-name: ArtifactSigning
-          certificate-profile-name: ErsatzTV
-          files-folder: ${{ github.workspace }}/dotnet-build
-          files-folder-recurse: true
-          files-folder-filter: ErsatzTV.exe,ErsatzTV.Scanner.exe
-          file-digest: SHA256
-          timestamp-rfc3161: http://timestamp.acs.microsoft.com
-          timestamp-digest: SHA256
-
-      - name: Download rust launcher
-        uses: suisei-cn/actions-download-file@v1.3.0
-        with:
-          url: "https://github.com/ErsatzTV/ErsatzTV-Windows/releases/download/v1.0.0/ErsatzTV-Windows.exe"
-          target: rust-build/
-
-      - name: Download ffmpeg
-        uses: suisei-cn/actions-download-file@v1.3.0
-        id: downloadffmpeg
-        with:
-          url: "https://github.com/ErsatzTV/ErsatzTV-ffmpeg/releases/download/7.1.1/ffmpeg-n7.1.1-56-gc2184b65d2-win64-gpl-7.1.zip"
-          target: ffmpeg/
-
-      - name: Package artifacts
-        shell: bash
-        run: |
-          release_name="ErsatzTV-${{ inputs.release_version }}-win-x64"
-          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
-          mkdir "$release_name"
-
-          mv dotnet-build/scanner/* "$release_name/"
-          mv dotnet-build/main/* "$release_name/"
-
-          # dotnet shouldn't copy the resources here, but it does
-          rm -rf "$release_name/Resources"
-
-          mv rust-build/ErsatzTV-Windows.exe "$release_name/ErsatzTV-Windows.exe"
-          7z e "ffmpeg/${{ steps.downloadffmpeg.outputs.filename }}" -o"$release_name" '*.exe' -r
-          rm -f "$release_name/ffplay.exe"
-
-          (cd "${release_name}" && 7z a "../${release_name}.zip" .)
-
-      - 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 }}
-          fail-if-no-assets: false
-          assets: "*win-x64.zip"
-
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        with:
-          prerelease: false
-          tag_name: ${{ inputs.release_tag }}
-          files: "${{ env.RELEASE_NAME }}.zip"
-        env:
-          GITHUB_TOKEN: ${{ secrets.gh_token }}

.github/workflows/ci.yml

@@ -1,62 +0,0 @@
-name: Build
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - main
-jobs:
-  calculate_version:
-    name: Calculate version information
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Extract Docker Tag
-        shell: bash
-        run: |
-          tag=$(git describe --tags --abbrev=0)
-          tag2="${tag:1}"
-          short=$(git rev-parse --short HEAD)
-          final="${tag2}-${short}"
-          echo "GIT_TAG=${final}" >> $GITHUB_ENV
-      - name: Extract Artifacts Version
-        shell: bash
-        run: |
-          tag=$(git describe --tags --abbrev=0)
-          short=$(git rev-parse --short HEAD)
-          final="${tag}-${short}"
-          echo "ARTIFACTS_VERSION=${final}" >> $GITHUB_ENV
-          echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
-    outputs:
-      git_tag: ${{ env.GIT_TAG }}
-      artifacts_version: ${{ env.ARTIFACTS_VERSION }}
-      info_version: ${{ env.INFO_VERSION }}
-  build_and_upload:
-    uses: ersatztv/ersatztv/.github/workflows/artifacts.yml@main
-    needs: calculate_version
-    with:
-      release_tag: develop
-      release_version: ${{ needs.calculate_version.outputs.artifacts_version }}
-      info_version: ${{ needs.calculate_version.outputs.info_version }}
-    secrets:
-      apple_developer_certificate_p12_base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
-      apple_developer_certificate_password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
-      ac_username: ${{ secrets.AC_USERNAME }}
-      ac_password: ${{ secrets.AC_PASSWORD }}
-      gh_token: ${{ secrets.GITHUB_TOKEN }}
-      azure_client_id: ${{ secrets.AZURE_CLIENT_ID }}
-      azure_tenant_id: ${{ secrets.AZURE_TENANT_ID }}
-      azure_subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-
-  build_images:
-    uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
-    needs: calculate_version
-    with:
-      base_version: develop
-      info_version: ${{ needs.calculate_version.outputs.git_tag }}
-      tag_version: ${{ github.sha }}
-    secrets:
-      docker_hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
-      docker_hub_access_token: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}

.github/workflows/docker.yml

@@ -1,141 +0,0 @@
-name: Build & Publish to Docker Hub
-on:
-  workflow_call:
-    inputs:
-      base_version:
-        description: 'Base version (latest or develop)'
-        required: true
-        type: string
-      info_version:
-        description: 'Informational version number (e.g. 0.3.7-alpha)'
-        required: true
-        type: string
-      tag_version:
-        description: 'Docker tag version (e.g. v0.3.7)'
-        required: true
-        type: string
-    secrets:
-      docker_hub_username:
-        required: true
-      docker_hub_access_token:
-        required: true
-jobs:
-  build_images:
-    name: Build ${{ matrix.name }} image
-    runs-on: ${{ matrix.os }}
-    if: contains(github.event.head_commit.message, '[no build]') == false
-    strategy:
-      matrix:
-        include:
-          - name: amd64
-            os: ubuntu-latest
-            path: ''
-            suffix: '-amd64'
-            platform: 'linux/amd64'
-          - name: arm32v7
-            os: ubuntu-latest
-            path: 'arm32v7/'
-            suffix: '-arm'
-            platform: 'linux/arm/v7'
-          - name: arm64
-            os: ubuntu-24.04-arm
-            path: 'arm64/'
-            suffix: '-arm64'
-            platform: 'linux/arm64'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up QEMU
-        if: ${{ matrix.name == 'arm32v7' }}
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.docker_hub_username }}
-          password: ${{ secrets.docker_hub_access_token }}
-
-      - name: Log in to the Container registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build and push by digest
-        id: build
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: ./docker/${{ matrix.path }}Dockerfile
-          push: true
-          provenance: false
-          platforms: ${{ matrix.platform }}
-          build-args: |
-            INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
-          outputs: |
-            type=image,name=jasongdove/ersatztv,name-canonical=true,push-by-digest=true
-            type=image,name=ghcr.io/ersatztv/ersatztv,name-canonical=true,push-by-digest=true
-
-      - name: Save digest to artifact
-        run: echo ${{ steps.build.outputs.digest }} > digest.txt
-
-      - name: Upload digest artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: digest-${{ matrix.name }}
-          path: digest.txt
-
-  merge_manifests:
-    name: Merge Manifests
-    runs-on: ubuntu-latest
-    needs: build_images
-    steps:
-      - name: Login to DockerHub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.docker_hub_username }}
-          password: ${{ secrets.docker_hub_access_token }}
-
-      - name: Log in to the Container registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Download all digest artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: digests/
-
-      - name: Read digests from artifacts
-        id: digests
-        run: |
-          AMD64_HASH=$(cat digests/digest-amd64/digest.txt)
-          ARM32V7_HASH=$(cat digests/digest-arm32v7/digest.txt)
-          ARM64_HASH=$(cat digests/digest-arm64/digest.txt)
-
-          DOCKER_HUB_DIGESTS="jasongdove/ersatztv@${AMD64_HASH} jasongdove/ersatztv@${ARM64_HASH} jasongdove/ersatztv@${ARM32V7_HASH}"
-          GHCR_DIGESTS="ghcr.io/ersatztv/ersatztv@${AMD64_HASH} ghcr.io/ersatztv/ersatztv@${ARM64_HASH} ghcr.io/ersatztv/ersatztv@${ARM32V7_HASH}"
-
-          echo "docker_hub_digests=${DOCKER_HUB_DIGESTS}" >> $GITHUB_OUTPUT
-          echo "ghcr_digests=${GHCR_DIGESTS}" >> $GITHUB_OUTPUT
-
-      - name: Create and push manifests
-        run: |
-          docker manifest create jasongdove/ersatztv:${{ inputs.base_version }} ${{ steps.digests.outputs.docker_hub_digests }}
-          docker manifest push jasongdove/ersatztv:${{ inputs.base_version }}
-          docker manifest create jasongdove/ersatztv:${{ inputs.tag_version }} ${{ steps.digests.outputs.docker_hub_digests }}
-          docker manifest push jasongdove/ersatztv:${{ inputs.tag_version }}
-
-          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }} ${{ steps.digests.outputs.ghcr_digests }}
-          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}
-          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }} ${{ steps.digests.outputs.ghcr_digests }}
-          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}

.github/workflows/issue-stale.yml

@@ -1,27 +0,0 @@
-name: 'Close stale issues'
-
-on:
-  schedule:
-    - cron: '30 1 * * *'
-  workflow_dispatch:
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/stale@v9
-        with:
-          ascending: true
-          days-before-stale: 120
-          days-before-pr-stale: -1
-          days-before-close: 21
-          days-before-pr-close: -1
-          operations-per-run: 500
-          exempt-issue-labels: 'regression,security,roadmap,future,feature,enhancement,confirmed'
-          stale-issue-label: 'stale'
-          stale-issue-message: |-
-            This issue has gone 120 days without an update and will be closed within 21 days if there is no new activity. To prevent this issue from being closed, please confirm the issue has not already been fixed by providing updated examples or logs.
-
-            If you have any questions you can use one of several ways to [contact us](https://ersatztv.org).
-          close-issue-message: |-
-            This issue was closed due to inactivity.

.github/workflows/pr.yml

@@ -1,118 +0,0 @@
-name: Pull Request
-on:
-  pull_request:
-jobs:
-  build_and_analyze:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.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 /p:EnableThreadingAnalyzers=true
-  build_and_test_windows:
-    runs-on: windows-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.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 --blame-hang-timeout "2m" --no-restore --verbosity normal
-  build_and_test_linux:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-            target: linux-x64
-          - os: ubuntu-latest
-            target: linux-musl-x64
-          - os: ubuntu-latest
-            target: linux-arm
-          - os: ubuntu-24.04-arm
-            target: linux-arm64
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -p:RestoreEnablePackagePruning=true -r "${{ matrix.target }}"
-
-      - name: Prep project file
-        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-
-      - name: Build
-        run: dotnet build ErsatzTV/ErsatzTV.csproj --runtime "${{ matrix.target }}" --configuration Release --no-restore && dotnet build --configuration Release --no-restore
-
-      - name: Test
-        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
-  build_and_test_mac:
-    runs-on: macos-14
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.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 --blame-hang-timeout "2m" --no-restore --verbosity normal

.github/workflows/release.yml

@@ -1,56 +0,0 @@
-name: Release
-on:
-  release:
-    types: [ published ]
-jobs:
-  calculate_version:
-    name: Calculate version information
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Extract Docker Tag
-        shell: bash
-        run: |
-          tag=$(git describe --tags --abbrev=0)
-          echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
-          echo "DOCKER_TAG=${tag}" >> $GITHUB_ENV
-      - name: Extract Artifacts Version
-        shell: bash
-        run: |
-          tag=$(git describe --tags --abbrev=0)
-          echo "ARTIFACTS_VERSION=${tag}" >> $GITHUB_ENV
-          echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
-    outputs:
-      git_tag: ${{ env.GIT_TAG }}
-      docker_tag: ${{ env.DOCKER_TAG }}
-      artifacts_version: ${{ env.ARTIFACTS_VERSION }}
-      info_version: ${{ env.INFO_VERSION }}
-  build_and_upload:
-    uses: ersatztv/ersatztv/.github/workflows/artifacts.yml@main
-    needs: calculate_version
-    with:
-      release_tag: ${{ needs.calculate_version.outputs.artifacts_version }}
-      release_version: ${{ needs.calculate_version.outputs.artifacts_version }}
-      info_version: ${{ needs.calculate_version.outputs.info_version }}
-    secrets:
-      apple_developer_certificate_p12_base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
-      apple_developer_certificate_password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
-      ac_username: ${{ secrets.AC_USERNAME }}
-      ac_password: ${{ secrets.AC_PASSWORD }}
-      gh_token: ${{ secrets.GITHUB_TOKEN }}
-      azure_client_id: ${{ secrets.AZURE_CLIENT_ID }}
-      azure_tenant_id: ${{ secrets.AZURE_TENANT_ID }}
-      azure_subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-  build_images:
-    uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
-    needs: calculate_version
-    with:
-      base_version: latest
-      info_version: ${{ needs.calculate_version.outputs.git_tag }}
-      tag_version: ${{ needs.calculate_version.outputs.docker_tag }}
-    secrets:
-      docker_hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
-      docker_hub_access_token: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}

.gitignore

@@ -3,6 +3,9 @@
 project.lock.json
 .DS_Store
 *.pyc
+
+# Claude Code
+.mcp/
 nupkg/
 
 # Visual Studio Code

.mcp.json

@@ -0,0 +1,56 @@
+{
+  "mcpServers": {
+    "docker-mcp": {
+      "command": "uvx",
+      "args": [
+        "mcp-server-docker"
+      ],
+      "env": {
+        "DOCKER_HOST": "ssh://timothy@192.168.1.99"
+      }
+    },
+    "ssh-mcp": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "ssh-mcp",
+        "--",
+        "--host=192.168.1.99",
+        "--user=timothy"
+      ],
+      "env": {}
+    },
+    "gitea": {
+      "command": "gitea-mcp-server",
+      "args": [
+        "-t", "stdio",
+        "-host", "http://192.168.1.95:3000",
+        "-token", "8341af0733ab9ce084ea7adf38b76aa9ebc3bd67"
+      ],
+      "env": {}
+    },
+    "csharp-lsp": {
+      "command": "/usr/local/share/dotnet/dotnet",
+      "args": [
+        "run",
+        "--project", "/Users/timothy/ersatztv/.mcp/csharp-lsp-mcp/csharp-lsp-mcp/src/CSharpLspMcp",
+        "-c", "Release"
+      ],
+      "env": {
+        "PATH": "/usr/local/share/dotnet:/Users/timothy/.dotnet/tools:/usr/bin:/bin:/usr/sbin:/sbin"
+      }
+    },
+    "nuget": {
+      "command": "/usr/local/share/dotnet/dotnet",
+      "args": [
+        "dnx",
+        "NuGet.Mcp.Server",
+        "--source", "https://api.nuget.org/v3/index.json",
+        "--yes"
+      ],
+      "env": {
+        "DOTNET_ROOT": "/usr/local/share/dotnet"
+      }
+    }
+  }
+}

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
+### Changed
+- Remove BugSnag error reporting integration
+- Remove developer's personal Trakt API key
+  - Users who want to continue to use Trakt must create an API app and set the `Client ID` as the environment variable `TRAKT__CLIENTID`
+
+### Fixed
+- Support adding trakt lists using `app.trakt.tv` domain (instead of just `trakt.tv`)
 
 ## [26.3.0] - 2026-02-24
 ### Added

CLAUDE.md

@@ -0,0 +1,96 @@
+# ErsatzTV Fork
+
+Custom IPTV channel server for Jellyfin. Forked from [ErsatzTV/ErsatzTV](https://github.com/ErsatzTV/ErsatzTV) after upstream archival (Feb 2026, v26.3.0). Our fork lives on [Gitea](http://192.168.1.95:3000/timothy/ersatztv).
+
+## Architecture
+
+- **Language**: C# / .NET 10, Blazor Server UI (MudBlazor)
+- **Pattern**: CQRS via MediatR — queries/commands in `ErsatzTV.Application/`
+- **Database**: EF Core (SQLite default, MySQL optional) — context in `ErsatzTV.Infrastructure/Data/TvContext.cs`
+- **Media**: FFmpeg via CliWrap, SkiaSharp for logo generation
+- **Functional C#**: Language Ext (Option, Either monads throughout)
+
+### Project Layout
+
+| Project | Role |
+|---------|------|
+| `ErsatzTV/` | ASP.NET Core host, Blazor pages, API controllers, DI setup |
+| `ErsatzTV.Application/` | MediatR handlers (business logic) |
+| `ErsatzTV.Core/` | Domain entities, interfaces, no infrastructure deps |
+| `ErsatzTV.Infrastructure/` | EF Core repos, data access |
+| `ErsatzTV.Infrastructure.Sqlite/` | SQLite-specific implementations |
+| `ErsatzTV.FFmpeg/` | FFmpeg process wrapper |
+| `ErsatzTV.Scanner/` | Media library scanning |
+
+### Key Files
+
+- **M3U generation**: `ErsatzTV.Core/Iptv/ChannelPlaylist.cs` → `ToM3U()`
+- **XMLTV generation**: `ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs`
+- **IPTV controller**: `ErsatzTV/Controllers/IptvController.cs` — `/iptv/*` routes
+- **Logo generation**: `ErsatzTV.Core/Images/ChannelLogoGenerator.cs`
+- **Channel entities**: `ErsatzTV.Core/Domain/Channel.cs`
+- **DB context**: `ErsatzTV.Infrastructure/Data/TvContext.cs`
+
+## Deployment
+
+- **Docker host**: jazz (192.168.1.99), container `ersatztv`, port 8409
+- **Config volume**: `~/downloadswarm/ersatztv/` on jazz → `/config` in container
+- **SQLite DB**: `/config/ersatztv.sqlite3` (WAL mode, root-owned)
+- **Images** (our fork, built by `.gitea/workflows/docker-build.yml` → `192.168.1.95:3000/timothy/ersatztv`): push to `main` → `:latest` + `:<sha>` (test image); push `v*` tag → `:prod` + `:<version>` + `:<sha>`. Prod container still runs upstream `ghcr.io/ersatztv/ersatztv:latest` pending cutover (server-management#481). Pipeline details: `docs/ci-cd.md`.
+
+## Development
+
+```bash
+# Build
+dotnet build ErsatzTV.sln
+
+# Run locally (needs FFmpeg in PATH)
+dotnet run --project ErsatzTV
+
+# Docker build
+docker build -f docker/Dockerfile -t ersatztv:dev .
+```
+
+## Conventions
+
+- **Read [`docs/contributing.md`](docs/contributing.md)** before non-trivial changes — it documents the established patterns (layering, CQRS handlers, LanguageExt, Blazor/MudBlazor, EF Core + dual-provider migrations, the FFmpeg pipeline, analyzers, testing) and the **deviation policy**: match the established style; diverge only with a concrete, stated reason.
+- Follow existing MediatR CQRS pattern for new features
+- Domain logic in `ErsatzTV.Core`, infrastructure in `ErsatzTV.Infrastructure`
+- Keep Blazor pages thin — delegate to MediatR handlers
+- Test with **NUnit** + Shouldly + NSubstitute (the existing `*.Tests` projects); xUnit is **not** used here
+- **Dependencies use Central Package Management**: versions live in the repo-root `Directory.Packages.props`; csproj reference packages by name only. Add/upgrade by editing the central `<PackageVersion>` — never put `Version=` back on a `<PackageReference>` (trips `NU1008`). See `docs/ci-cd.md` → Dependency management.
+- **DB migrations target BOTH providers**: a `TvContext` model change needs a migration in `ErsatzTV.Infrastructure.Sqlite` **and** `ErsatzTV.Infrastructure.MySql` — run `scripts/add-migration.sh <Name>` (does both). CI's `migrations` job enforces model-drift + apply-to-fresh-DB per provider. See `docs/ci-cd.md` → Migration integrity.
+- **Renovate** is live (`.gitea/workflows/renovate.yml`, weekly + `workflow_dispatch`): opens dependency-update + OSV vuln-fix PRs and a Dependency Dashboard issue; patch bumps to test/dev-only packages auto-merge once `Build & test` passes, the rest are manual. Cross-repo rollout: server-management#484. See `docs/ci-cd.md` → Dependency management.
+- **Versioning**: release tags are `vYY.<release-seq>.<patch>` (year · sequential release-within-year · patch) — inherited from upstream, **not** year.month. `v26.3.1` = our infra rebuild of upstream 26.3.0 (no app changes); `v26.4.0` is reserved for the first release with app changes. Never `[skip ci]` a commit you'll tag (it suppresses the release build). Full policy: `docs/ci-cd.md` → Versioning & releases.
+- Backlog tracked via [Gitea Issues](http://192.168.1.95:3000/timothy/ersatztv/issues)
+
+## Task Completion Protocol
+
+Every task that closes a Gitea issue MUST complete ALL of these before it is considered done. Use `/done <issue>` to run through this automatically.
+
+1. **Root cause** (bug fixes / incidents only): Document WHY the problem existed, not just what was changed. If root cause is unknown, say so explicitly and open a follow-up investigation issue. Fixing symptoms without understanding causes creates recurring problems.
+2. **Comment on issues** as you work — what you found, what approach you're taking, any deviations from the suggested fix.
+3. **Push changes**: `git push` all commits before closing. Use `fixes #N` in commit messages to auto-close where appropriate.
+4. **Close comment**: Add a structured closing comment on the issue covering: what was done, root cause (if applicable), files changed, anything deferred, follow-up issues created, and which docs were updated.
+5. **Close the issue** via API or `fixes #N` commit. Leave open with a comment only if partially addressed.
+6. **Update docs**: If the change affects operational behavior, update the relevant Obsidian docs (`~/homelab-docs/`), MEMORY.md, or CLAUDE.md inline — not as a follow-up.
+7. **Reply to reviewer** (if from adversarial review): Summary of done/deferred/questions. This triggers the next review cycle.
+
+## Project Boundaries
+
+**ersatztv OWNS**: ErsatzTV fork code (C#/.NET), channel/collection/schedule management, M3U/XMLTV generation, the ErsatzTV skill in server-management.
+
+**ersatztv does NOT own**:
+- Docker compose configs → server-management (`~/downloadswarm/stacks/ersatztv/`)
+- NFS mounts, Ansible, DNS, networking → server-management
+- Content sourcing (yt-dlp downloads, Sonarr/Radarr libraries) → media-management (planned)
+- Jellyfin skill → server-management (symlinked)
+
+**For infrastructure changes** (Docker, NFS, ports, Authelia): open an issue in `timothy/server-management`.
+
+**For content/media sourcing questions** (what goes into channels, yt-dlp pipelines): open an issue in `timothy/media-management` once it exists; for now, `timothy/server-management`.
+
+**For plan/audit reviews**: open `~/adversarial-reviewer` before significant architecture changes.
+
+**Full cross-project rules**: `~/homelab-docs/Operations/Project Boundaries.md` (https://docs.tblindustries.be).
+**ErsatzTV docs**: `~/homelab-docs/Docker/ErsatzTV.md` + project-local `docs/` (fork strategy, channels, M3U/XMLTV).

Directory.Build.props

@@ -3,5 +3,15 @@
         <InformationalVersion>develop</InformationalVersion>
         <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
         <AllowMissingPrunePackageData>true</AllowMissingPrunePackageData>
+        <!-- NuGet audit (on by default in .NET 10) reports vulnerable transitive
+             packages as NU1901-1904 warnings. Several projects set
+             TreatWarningsAsErrors=true, which would otherwise fail `dotnet restore`
+             on advisories we can't immediately fix. Demote low/moderate/high audit
+             advisories to warnings (still printed in build logs); NU1904 (critical)
+             stays an error so criticals still block. Track fixes separately.
+             WarningsAsErrors promotes NU1904 in EVERY project (even those without
+             TreatWarningsAsErrors), so "criticals block" actually holds repo-wide. -->
+        <WarningsNotAsErrors>$(WarningsNotAsErrors);NU1901;NU1902;NU1903</WarningsNotAsErrors>
+        <WarningsAsErrors>$(WarningsAsErrors);NU1904</WarningsAsErrors>
     </PropertyGroup>
 </Project>

Directory.Build.targets

@@ -6,10 +6,36 @@
     <ItemGroup>
         <PackageReference
             Include="Microsoft.VisualStudio.Threading.Analyzers"
-            Version="17.14.15"
             Condition="'$(EnableThreadingAnalyzers)' == 'true'">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
     </ItemGroup>
+
+    <!-- Curated static-analysis packs (ersatztv#15), applied to every project. Versions are
+         central (Directory.Packages.props / CPM). Guarded on CPM so the gitignored .mcp tool
+         (which opts out of CPM) doesn't pull versionless references. They start at `suggestion`
+         severity in .editorconfig so they don't fail the TreatWarningsAsErrors build; high-value
+         rules are promoted to warning/error incrementally. -->
+    <ItemGroup Condition="'$(ManagePackageVersionsCentrally)' == 'true'">
+        <PackageReference Include="Roslynator.Analyzers">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="SonarAnalyzer.CSharp">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Meziantou.Analyzer">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <!-- StyleCop.Analyzers intentionally omitted: its latest stable (1.1.118) crashes
+             (AD0001) on C# records and its rules overlap the existing .editorconfig/Roslynator.
+             Revisit via the record-compatible 1.2.0-beta if StyleCop is specifically wanted. (#15) -->
+        <PackageReference Include="AsyncFixer">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
 </Project>

Directory.Packages.props

@@ -0,0 +1,113 @@
+<Project>
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageVersion Include="AsyncFixer" Version="2.1.0" />
+    <PackageVersion Include="Blazored.FluentValidation" Version="2.2.0" />
+    <PackageVersion Include="BlazorSortable" Version="5.2.1" />
+    <PackageVersion Include="Blurhash.SkiaSharp" Version="2.0.0" />
+    <PackageVersion Include="Chronic.Core" Version="0.4.0" />
+    <PackageVersion Include="CliWrap" Version="3.10.0" />
+    <PackageVersion Include="coverlet.collector" Version="6.0.4" />
+    <PackageVersion Include="Dapper" Version="2.1.66" />
+    <PackageVersion Include="Destructurama.Attributed" Version="5.2.0" />
+    <PackageVersion Include="EFCore.BulkExtensions" Version="[9.0.2,10)" />
+    <PackageVersion Include="EFCore.BulkExtensions.MySql" Version="[9.0.2,10)" />
+    <PackageVersion Include="EFCore.BulkExtensions.Sqlite" Version="[9.0.2,10)" />
+    <PackageVersion Include="Elastic.Clients.Elasticsearch" Version="9.3.0" />
+    <PackageVersion Include="EntityFrameworkProfiler.Appender" Version="6.0.6049" />
+    <PackageVersion Include="FluentValidation" Version="12.1.1" />
+    <PackageVersion Include="FluentValidation.AspNetCore" Version="11.3.1" />
+    <PackageVersion Include="Flurl" Version="4.0.0" />
+    <PackageVersion Include="Hardware.Info" Version="101.1.1.1" />
+    <PackageVersion Include="Heron.MudCalendar" Version="3.4.0" />
+    <PackageVersion Include="HtmlSanitizer" Version="9.0.892" />
+    <PackageVersion Include="Humanizer.Core" Version="3.0.1" />
+    <PackageVersion Include="Jint" Version="4.5.0" />
+    <PackageVersion Include="JsonSchema.Net" Version="9.0.0" />
+    <PackageVersion Include="LanguageExt.Core" Version="4.4.9" />
+    <PackageVersion Include="LanguageExt.Transformers" Version="4.4.8" />
+    <PackageVersion Include="Lennox.NvEncSharp" Version="2.0.0" />
+    <PackageVersion Include="Lucene.Net" Version="4.8.0-beta00017" />
+    <PackageVersion Include="Lucene.Net.Analysis.Common" Version="4.8.0-beta00017" />
+    <PackageVersion Include="Lucene.Net.QueryParser" Version="4.8.0-beta00017" />
+    <PackageVersion Include="Markdig" Version="0.44.0" />
+    <PackageVersion Include="MediatR" Version="[12.5.0]" />
+    <PackageVersion Include="MediatR.Courier.DependencyInjection" Version="5.0.0" />
+    <PackageVersion Include="Meziantou.Analyzer" Version="3.0.115" />
+    <PackageVersion Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.2" />
+    <PackageVersion Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="10.0.2" />
+    <PackageVersion Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="10.0.2" />
+    <PackageVersion Include="Microsoft.AspNetCore.OpenApi" Version="10.0.2" />
+    <PackageVersion Include="Microsoft.AspNetCore.SpaServices.Extensions" Version="10.0.2" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="[9.0.12,10)" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="[9.0.12,10)" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="[9.0.12,10)" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="[9.0.12,10)" />
+    <PackageVersion Include="Microsoft.Extensions.ApiDescription.Server" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyModel" Version="[8.0.2]" />
+    <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.Http" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.Logging" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Debug" Version="10.0.7" />
+    <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.1" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+    <PackageVersion Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.14.15" />
+    <PackageVersion Include="MudBlazor" Version="8.15.0" />
+    <PackageVersion Include="NaturalSort.Extension" Version="4.4.1" />
+    <PackageVersion Include="NCalcSync" Version="6.3.2" />
+    <PackageVersion Include="NetArchTest.eNhancedEdition" Version="1.4.5" />
+    <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
+    <PackageVersion Include="Newtonsoft.Json.Schema" Version="4.0.1" />
+    <PackageVersion Include="NSubstitute" Version="5.3.0" />
+    <PackageVersion Include="NUnit" Version="4.4.0" />
+    <PackageVersion Include="NUnit.Analyzers" Version="4.11.2" />
+    <PackageVersion Include="NUnit3TestAdapter" Version="6.1.0" />
+    <PackageVersion Include="Pomelo.EntityFrameworkCore.MySql" Version="9.0.0" />
+    <PackageVersion Include="Refit" Version="9.0.2" />
+    <PackageVersion Include="Refit.HttpClientFactory" Version="9.0.2" />
+    <PackageVersion Include="Refit.Newtonsoft.Json" Version="9.0.2" />
+    <PackageVersion Include="Refit.Xml" Version="9.0.2" />
+    <PackageVersion Include="RichTextKit.Stbear" Version="0.4.167.3" />
+    <PackageVersion Include="Roslynator.Analyzers" Version="4.15.0" />
+    <PackageVersion Include="Scalar.AspNetCore" Version="2.12.32" />
+    <PackageVersion Include="Scriban.Signed" Version="6.5.2" />
+    <PackageVersion Include="Serilog" Version="4.3.0" />
+    <PackageVersion Include="Serilog.AspNetCore" Version="10.0.0" />
+    <PackageVersion Include="Serilog.Extensions.Hosting" Version="10.0.0" />
+    <PackageVersion Include="Serilog.Extensions.Logging" Version="10.0.0" />
+    <PackageVersion Include="Serilog.Formatting.Compact" Version="3.0.0" />
+    <PackageVersion Include="Serilog.Formatting.Compact.Reader" Version="4.0.0" />
+    <PackageVersion Include="Serilog.Settings.Configuration" Version="10.0.0" />
+    <PackageVersion Include="Serilog.Sinks.Console" Version="6.1.1" />
+    <PackageVersion Include="Serilog.Sinks.Debug" Version="3.0.0" />
+    <PackageVersion Include="Serilog.Sinks.File" Version="7.0.0" />
+    <PackageVersion Include="Shouldly" Version="4.3.0" />
+    <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.12" />
+    <PackageVersion Include="SkiaSharp" Version="3.119.1" />
+    <PackageVersion Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="3.119.1" />
+    <PackageVersion Include="SonarAnalyzer.CSharp" Version="10.27.0.140913" />
+    <!-- Direct pin to override EF Core 9's transitive SQLitePCLRaw 2.1.10 (vulnerable
+         bundled SQLite, GHSA-2m69-gcr7-jv3q). The 3.x line ships the patched native
+         (lib.e_sqlite3 3.50.3); core 3.0.3 satisfies Microsoft.Data.Sqlite's `>= 2.1.10`. (#8) -->
+    <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.3" />
+    <PackageVersion Include="System.CommandLine" Version="2.0.2" />
+    <PackageVersion Include="TagLibSharp" Version="2.3.0" />
+    <PackageVersion Include="Testably.Abstractions" Version="10.0.0" />
+    <PackageVersion Include="Testably.Abstractions.Testing" Version="5.1.0" />
+    <PackageVersion Include="TimeSpanParserUtil" Version="1.2.0" />
+    <PackageVersion Include="TimeZoneConverter" Version="7.2.0" />
+    <PackageVersion Include="VueCliMiddleware" Version="6.0.0" />
+    <PackageVersion Include="WebMarkupMin.Core" Version="2.20.1" />
+    <PackageVersion Include="Winista.MimeDetect" Version="1.1.0" />
+    <PackageVersion Include="YamlDotNet" Version="16.3.0" />
+  </ItemGroup>
+</Project>

ErsatzTV.Application/Channels/Commands/ChannelValidations.cs

@@ -0,0 +1,60 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Channels;
+
+/// <summary>
+///     Validation rules shared by <see cref="CreateChannelHandler" /> and
+///     <see cref="UpdateChannelHandler" />. These were previously enforced only by the Blazor page
+///     (<c>ChannelEditViewModelValidator</c>); porting them into the handlers makes them apply to
+///     the REST API as well. Failures map to HTTP 422.
+/// </summary>
+internal static class ChannelValidations
+{
+    /// <summary>
+    ///     A channel must belong to a non-empty group; the value is used as the M3U
+    ///     <c>group-title</c>. Mirrors the Blazor rule <c>RuleFor(x =&gt; x.Group).NotEmpty()</c>.
+    /// </summary>
+    internal static Validation<BaseError, string> ValidateGroup(string group)
+    {
+        // Use explicit returns (not a ternary): BaseError has an implicit string conversion, so a
+        // ternary would collapse both branches to BaseError and always produce a Fail.
+        if (string.IsNullOrWhiteSpace(group))
+        {
+            return BaseError.New("Channel group is required");
+        }
+
+        return group;
+    }
+
+    /// <summary>A disabled channel may not be shown in the EPG.</summary>
+    internal static Validation<BaseError, bool> ValidateShowInEpg(bool isEnabled, bool showInEpg)
+    {
+        if (!isEnabled && showInEpg)
+        {
+            return BaseError.New("Disabled channels cannot be shown in EPG");
+        }
+
+        return showInEpg;
+    }
+
+    /// <summary>
+    ///     A logo path that is an absolute URI must be a valid external (http/https) url.
+    ///     Relative/local logo paths and empty values are allowed.
+    /// </summary>
+    internal static Validation<BaseError, string> ValidateLogo(string logoPath)
+    {
+        if (string.IsNullOrWhiteSpace(logoPath))
+        {
+            return string.Empty;
+        }
+
+        bool isAbsoluteUri = Uri.TryCreate(logoPath, UriKind.Absolute, out _);
+        if (isAbsoluteUri && !Artwork.IsExternalUrl(logoPath))
+        {
+            return BaseError.New("External logo url is invalid");
+        }
+
+        return logoPath;
+    }
+}

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -8,6 +8,7 @@ using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Channels.ChannelValidations;
 using Channel = ErsatzTV.Core.Domain.Channel;
 
 namespace ErsatzTV.Application.Channels;
@@ -36,18 +37,23 @@ public class CreateChannelHandler(
         return new CreateChannelResult(channel.Id);
     }
 
-    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request, CancellationToken cancellationToken) =>
-        (ValidateName(request), await ValidateNumber(dbContext, request, cancellationToken),
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request, CancellationToken cancellationToken)
+    {
+        Validation<BaseError, Channel> channelValidation = (ValidateName(request), await ValidateNumber(dbContext, request, cancellationToken),
             await FFmpegProfileMustExist(dbContext, request, cancellationToken),
             await WatermarkMustExist(dbContext, request, cancellationToken),
             await FillerPresetMustExist(dbContext, request, cancellationToken),
-            await MirrorSourceMustBeValid(dbContext, request, cancellationToken))
+            await MirrorSourceMustBeValid(dbContext, request, cancellationToken),
+            ValidateShowInEpg(request.IsEnabled, request.ShowInEpg),
+            ValidateLogo(request.Logo?.Path))
         .Apply((
             name,
             number,
             ffmpegProfileId,
             watermarkId,
             fillerPresetId,
+            _,
+            _,
             _) =>
         {
             var artwork = new List<Artwork>();
@@ -125,6 +131,11 @@ public class CreateChannelHandler(
             return channel;
         });
 
+        // combine the page-only Group rule with the channel validation (keeps tuple arity within
+        // LanguageExt's supported applicative range while still accumulating all errors)
+        return (ValidateGroup(request.Group), channelValidation).Apply((_, channel) => channel);
+    }
+
     private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
         createChannel.NotEmpty(c => c.Name)
             .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
@@ -149,16 +160,20 @@ public class CreateChannelHandler(
             });
     }
 
-    private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
+    private static async Task<Validation<BaseError, int>> FFmpegProfileMustExist(
         TvContext dbContext,
         CreateChannel createChannel,
-        CancellationToken cancellationToken) =>
-        dbContext.FFmpegProfiles
-            .CountAsync(p => p.Id == createChannel.FFmpegProfileId, cancellationToken)
-            .Map(Optional)
-            .Filter(c => c > 0)
-            .MapT(_ => createChannel.FFmpegProfileId)
-            .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {createChannel.FFmpegProfileId} does not exist."));
+        CancellationToken cancellationToken)
+    {
+        bool exists = await dbContext.FFmpegProfiles
+            .AnyAsync(p => p.Id == createChannel.FFmpegProfileId, cancellationToken);
+        if (exists)
+        {
+            return createChannel.FFmpegProfileId;
+        }
+
+        return BaseError.New($"FFmpegProfile {createChannel.FFmpegProfileId} does not exist.");
+    }
 
     private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
         TvContext dbContext,
@@ -170,12 +185,14 @@ public class CreateChannelHandler(
             return Option<int>.None;
         }
 
-        return await dbContext.ChannelWatermarks
-            .CountAsync(w => w.Id == createChannel.WatermarkId, cancellationToken)
-            .Map(Optional)
-            .Filter(c => c > 0)
-            .MapT(_ => Optional(createChannel.WatermarkId))
-            .Map(o => o.ToValidation<BaseError>($"Watermark {createChannel.WatermarkId} does not exist."));
+        bool exists = await dbContext.ChannelWatermarks
+            .AnyAsync(w => w.Id == createChannel.WatermarkId, cancellationToken);
+        if (exists)
+        {
+            return Optional(createChannel.WatermarkId);
+        }
+
+        return BaseError.New($"Watermark {createChannel.WatermarkId} does not exist.");
     }
 
     private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
@@ -188,14 +205,15 @@ public class CreateChannelHandler(
             return Option<int>.None;
         }
 
-        return await dbContext.FillerPresets
+        bool exists = await dbContext.FillerPresets
             .Filter(fp => fp.FillerKind == FillerKind.Fallback)
-            .CountAsync(w => w.Id == createChannel.FallbackFillerId, cancellationToken)
-            .Map(Optional)
-            .Filter(c => c > 0)
-            .MapT(_ => Optional(createChannel.FallbackFillerId))
-            .Map(o => o.ToValidation<BaseError>(
-                $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
+            .AnyAsync(w => w.Id == createChannel.FallbackFillerId, cancellationToken);
+        if (exists)
+        {
+            return Optional(createChannel.FallbackFillerId);
+        }
+
+        return BaseError.New($"Fallback filler {createChannel.FallbackFillerId} does not exist.");
     }
 
     private static async Task<Validation<BaseError, Unit>> MirrorSourceMustBeValid(

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

@@ -1,6 +1,7 @@
 using System.IO.Abstractions;
 using System.Threading.Channels;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -31,8 +32,17 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
     public async Task<Either<BaseError, Unit>> Handle(DeleteChannel request, CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Channel> validation = await ChannelMustExist(dbContext, request, cancellationToken);
-        return await validation.Apply(c => DoDeletion(dbContext, c, cancellationToken));
+        Option<Channel> maybeChannel = await dbContext.Channels
+            .SelectOneAsync(c => c.Id, c => c.Id == request.ChannelId, cancellationToken);
+
+        return await maybeChannel.Match(
+            Some: async channel =>
+            {
+                await DoDeletion(dbContext, channel, cancellationToken);
+                return Right<BaseError, Unit>(Unit.Default);
+            },
+            None: () => Task.FromResult(
+                Left<BaseError, Unit>(new NotFoundError($"Channel {request.ChannelId} does not exist."))));
     }
 
     private async Task<Unit> DoDeletion(TvContext dbContext, Channel channel, CancellationToken cancellationToken)
@@ -54,14 +64,4 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
 
         return Unit.Default;
     }
-
-    private static async Task<Validation<BaseError, Channel>> ChannelMustExist(
-        TvContext dbContext,
-        DeleteChannel deleteChannel,
-        CancellationToken cancellationToken)
-    {
-        Option<Channel> maybeChannel = await dbContext.Channels
-            .SelectOneAsync(c => c.Id, c => c.Id == deleteChannel.ChannelId, cancellationToken);
-        return maybeChannel.ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.");
-    }
 }

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -4,10 +4,13 @@ using System.Threading.Channels;
 using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Channels.ChannelValidations;
 using static ErsatzTV.Application.Channels.Mapper;
 using Channel = ErsatzTV.Core.Domain.Channel;
 
@@ -24,8 +27,23 @@ public class UpdateChannelHandler(
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Channel> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
+
+        Option<Channel> maybeChannel = await dbContext.Channels
+            .Include(c => c.Artwork)
+            .Include(c => c.Watermark)
+            .Include(c => c.Playouts)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.ChannelId, cancellationToken);
+
+        return await maybeChannel.Match(
+            Some: async channel =>
+            {
+                Validation<BaseError, Channel> validation =
+                    await Validate(dbContext, request, channel, cancellationToken);
+                return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
+            },
+            None: () => Task.FromResult(
+                Left<BaseError, ChannelViewModel>(
+                    new NotFoundError($"Channel {request.ChannelId} does not exist."))));
     }
 
     private async Task<ChannelViewModel> ApplyUpdateRequest(
@@ -162,23 +180,82 @@ public class UpdateChannelHandler(
     private static async Task<Validation<BaseError, Channel>> Validate(
         TvContext dbContext,
         UpdateChannel request,
-        CancellationToken cancellationToken) =>
-        (await ChannelMustExist(dbContext, request, cancellationToken),
-            ValidateName(request),
+        Channel channel,
+        CancellationToken cancellationToken)
+    {
+        Validation<BaseError, Channel> channelValidation = (ValidateName(request),
             await ValidateNumber(dbContext, request, cancellationToken),
-            await MirrorSourceMustBeValid(dbContext, request, cancellationToken))
-        .Apply((channelToUpdate, _, _, _) => channelToUpdate);
+            await MirrorSourceMustBeValid(dbContext, request, cancellationToken),
+            ValidateShowInEpg(request.IsEnabled, request.ShowInEpg),
+            ValidateLogo(request.Logo?.Path))
+        .Apply((_, _, _, _, _) => channel);
 
-    private static Task<Validation<BaseError, Channel>> ChannelMustExist(
+        // combine the page-only Group rule plus the FK existence checks (FFmpeg profile / watermark /
+        // fallback filler) with the channel validation; splitting keeps tuple arity within
+        // LanguageExt's supported applicative range while still accumulating all errors
+        return (ValidateGroup(request.Group),
+            await FFmpegProfileMustExist(dbContext, request, cancellationToken),
+            await WatermarkMustExist(dbContext, request, cancellationToken),
+            await FillerPresetMustExist(dbContext, request, cancellationToken),
+            channelValidation)
+        .Apply((_, _, _, _, c) => c);
+    }
+
+    private static async Task<Validation<BaseError, int>> FFmpegProfileMustExist(
         TvContext dbContext,
-        UpdateChannel updateChannel,
-        CancellationToken cancellationToken) =>
-        dbContext.Channels
-            .Include(c => c.Artwork)
-            .Include(c => c.Watermark)
-            .Include(c => c.Playouts)
-            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
+        UpdateChannel request,
+        CancellationToken cancellationToken)
+    {
+        bool exists = await dbContext.FFmpegProfiles
+            .AnyAsync(p => p.Id == request.FFmpegProfileId, cancellationToken);
+        if (exists)
+        {
+            return request.FFmpegProfileId;
+        }
+
+        return BaseError.New($"FFmpegProfile {request.FFmpegProfileId} does not exist.");
+    }
+
+    private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
+        TvContext dbContext,
+        UpdateChannel request,
+        CancellationToken cancellationToken)
+    {
+        if (request.WatermarkId is null)
+        {
+            return Option<int>.None;
+        }
+
+        bool exists = await dbContext.ChannelWatermarks
+            .AnyAsync(w => w.Id == request.WatermarkId, cancellationToken);
+        if (exists)
+        {
+            return Optional(request.WatermarkId);
+        }
+
+        return BaseError.New($"Watermark {request.WatermarkId} does not exist.");
+    }
+
+    private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
+        TvContext dbContext,
+        UpdateChannel request,
+        CancellationToken cancellationToken)
+    {
+        if (request.FallbackFillerId is null)
+        {
+            return Option<int>.None;
+        }
+
+        bool exists = await dbContext.FillerPresets
+            .Filter(fp => fp.FillerKind == FillerKind.Fallback)
+            .AnyAsync(w => w.Id == request.FallbackFillerId, cancellationToken);
+        if (exists)
+        {
+            return Optional(request.FallbackFillerId);
+        }
+
+        return BaseError.New($"Fallback filler {request.FallbackFillerId} does not exist.");
+    }
 
     private static async Task<Validation<BaseError, Unit>> MirrorSourceMustBeValid(
         TvContext dbContext,

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -10,16 +10,15 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Bugsnag" Version="4.1.0" />
-        <PackageReference Include="CliWrap" Version="3.10.0" />
-        <PackageReference Include="Humanizer.Core" Version="3.0.1" />
-        <PackageReference Include="MediatR" Version="[12.5.0]" />
-        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
-        <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="4.0.0" />
-        <PackageReference Include="WebMarkupMin.Core" Version="2.20.1" />
-        <PackageReference Include="Winista.MimeDetect" Version="1.1.0" />
+        <PackageReference Include="CliWrap" />
+        <PackageReference Include="Humanizer.Core" />
+        <PackageReference Include="MediatR" />
+        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" />
+        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
+        <PackageReference Include="Newtonsoft.Json" />
+        <PackageReference Include="Serilog.Formatting.Compact.Reader" />
+        <PackageReference Include="WebMarkupMin.Core" />
+        <PackageReference Include="Winista.MimeDetect" />
     </ItemGroup>
 
     <ItemGroup>

ErsatzTV.Application/Maintenance/Commands/EmptyTrashHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -8,16 +7,13 @@ 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;
     }
@@ -27,7 +23,6 @@ public class EmptyTrashHandler : IRequestHandler<EmptyTrash, Either<BaseError, U
         CancellationToken cancellationToken)
     {
         SearchResult result = await _searchIndex.Search(
-            _client,
             "state:FileNotFound",
             string.Empty,
             0,

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Application.Search;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
@@ -42,8 +43,15 @@ public class AddItemsToCollectionHandler :
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Collection> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(c => ApplyAddItemsRequest(dbContext, c, request, cancellationToken));
+        Option<Collection> maybeCollection = await CollectionMustExist(dbContext, request, cancellationToken);
+        return await maybeCollection.Match(
+            Some: async collection =>
+            {
+                Validation<BaseError, Collection> validation = await Validate(dbContext, request, collection, cancellationToken);
+                return await validation.Apply(c => ApplyAddItemsRequest(dbContext, c, request, cancellationToken));
+            },
+            None: () => Task.FromResult<Either<BaseError, Unit>>(
+                new NotFoundError($"Collection {request.CollectionId} does not exist.")));
     }
 
     private async Task<Unit> ApplyAddItemsRequest(
@@ -89,22 +97,23 @@ public class AddItemsToCollectionHandler :
     private async Task<Validation<BaseError, Collection>> Validate(
         TvContext dbContext,
         AddItemsToCollection request,
+        Collection collection,
         CancellationToken cancellationToken) =>
-        (await CollectionMustExist(dbContext, request, cancellationToken),
-            await ValidateMovies(request),
+        (await ValidateMovies(request),
             await ValidateShows(request),
             await ValidateSeasons(request),
-            await ValidateEpisodes(request))
-        .Apply((collection, _, _, _, _) => collection);
+            await ValidateEpisodes(request),
+            await ValidateMediaItems(dbContext, request, cancellationToken))
+        .Apply((_, _, _, _, _) => collection);
 
-    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+    private static Task<Option<Collection>> CollectionMustExist(
         TvContext dbContext,
         AddItemsToCollection request,
         CancellationToken cancellationToken) =>
         dbContext.Collections
             .Include(c => c.MediaItems)
             .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+            .Map(identity);
 
     private Task<Validation<BaseError, Unit>> ValidateMovies(AddItemsToCollection request) =>
         _movieRepository.AllMoviesExist(request.MovieIds)
@@ -133,4 +142,30 @@ public class AddItemsToCollectionHandler :
             .Filter(v => v == true)
             .MapT(_ => Unit.Default)
             .Map(v => v.ToValidation<BaseError>("Episode does not exist"));
+
+    private static async Task<Validation<BaseError, Unit>> ValidateMediaItems(
+        TvContext dbContext,
+        AddItemsToCollection request,
+        CancellationToken cancellationToken)
+    {
+        List<int> ids = GetRequestedMediaItemIds(request).Distinct().ToList();
+        int existingCount = await dbContext.MediaItems
+            .CountAsync(mi => ids.Contains(mi.Id), cancellationToken);
+
+        return existingCount == ids.Count
+            ? Unit.Default
+            : BaseError.New("Media item does not exist");
+    }
+
+    private static IEnumerable<int> GetRequestedMediaItemIds(AddItemsToCollection request) =>
+        request.MovieIds
+            .Append(request.ShowIds)
+            .Append(request.SeasonIds)
+            .Append(request.EpisodeIds)
+            .Append(request.ArtistIds)
+            .Append(request.MusicVideoIds)
+            .Append(request.OtherVideoIds)
+            .Append(request.SongIds)
+            .Append(request.ImageIds)
+            .Append(request.RemoteStreamIds);
 }

ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs

@@ -110,10 +110,10 @@ public partial class AddTraktListHandler : TraktCommandBase, IRequestHandler<Add
         return maybeList.Map(_ => Unit.Default);
     }
 
-    [GeneratedRegex(@"https:\/\/trakt\.tv\/users\/([\w\-_]+)\/(?:lists\/)?([\w\-_]+)")]
+    [GeneratedRegex(@"https:\/\/(?:app\.)?trakt\.tv\/users\/([\w\-_]+)\/(?:lists\/)?([\w\-_]+)")]
     private static partial Regex UriTraktListRegex();
 
-    [GeneratedRegex(@"https:\/\/trakt\.tv\/lists\/([\w\-_]+)\/([\w\-_]+)")]
+    [GeneratedRegex(@"https:\/\/(?:app\.)?trakt\.tv\/lists\/([\w\-_]+)\/([\w\-_]+)")]
     private static partial Regex UriTraktListRegex2();
 
     [GeneratedRegex(@"([\w\-_]+)\/(?:lists\/)?([\w\-_]+)")]

ErsatzTV.Application/MediaCollections/Commands/DeleteCollectionHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -23,8 +24,11 @@ public class DeleteCollectionHandler : IRequestHandler<DeleteCollection, Either<
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Collection> validation = await CollectionMustExist(dbContext, request, cancellationToken);
-        return await validation.Apply(c => DoDeletion(dbContext, c, cancellationToken));
+        Option<Collection> maybeCollection = await CollectionMustExist(dbContext, request, cancellationToken);
+        return await maybeCollection.Match(
+            Some: collection => DoDeletion(dbContext, collection, cancellationToken).Map(Right<BaseError, Unit>),
+            None: () => Task.FromResult<Either<BaseError, Unit>>(
+                new NotFoundError($"Collection {request.CollectionId} does not exist.")));
     }
 
     private async Task<Unit> DoDeletion(TvContext dbContext, Collection collection, CancellationToken cancellationToken)
@@ -35,11 +39,11 @@ public class DeleteCollectionHandler : IRequestHandler<DeleteCollection, Either<
         return Unit.Default;
     }
 
-    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+    private static Task<Option<Collection>> CollectionMustExist(
         TvContext dbContext,
         DeleteCollection request,
         CancellationToken cancellationToken) =>
         dbContext.Collections
             .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>($"Collection {request.CollectionId} does not exist."));
+            .Map(identity);
 }

ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollectionHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
 using ErsatzTV.Infrastructure.Data;
@@ -29,11 +30,14 @@ public class DeleteSmartCollectionHandler : IRequestHandler<DeleteSmartCollectio
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, SmartCollection> validation = await SmartCollectionMustExist(
+        Option<SmartCollection> maybeSmartCollection = await SmartCollectionMustExist(
             dbContext,
             request,
             cancellationToken);
-        return await validation.Apply(c => DoDeletion(dbContext, c, cancellationToken));
+        return await maybeSmartCollection.Match(
+            Some: smartCollection => DoDeletion(dbContext, smartCollection, cancellationToken).Map(Right<BaseError, Unit>),
+            None: () => Task.FromResult<Either<BaseError, Unit>>(
+                new NotFoundError($"SmartCollection {request.SmartCollectionId} does not exist.")));
     }
 
     private async Task<Unit> DoDeletion(
@@ -48,11 +52,11 @@ public class DeleteSmartCollectionHandler : IRequestHandler<DeleteSmartCollectio
         return Unit.Default;
     }
 
-    private static Task<Validation<BaseError, SmartCollection>> SmartCollectionMustExist(
+    private static Task<Option<SmartCollection>> SmartCollectionMustExist(
         TvContext dbContext,
         DeleteSmartCollection request,
         CancellationToken cancellationToken) =>
         dbContext.SmartCollections
             .SelectOneAsync(c => c.Id, c => c.Id == request.SmartCollectionId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>($"SmartCollection {request.SmartCollectionId} does not exist."));
+            .Map(identity);
 }

ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Application.Search;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
@@ -35,20 +36,29 @@ public class RemoveItemsFromCollectionHandler : IRequestHandler<RemoveItemsFromC
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Collection> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(c => ApplyRemoveItemsRequest(dbContext, request, c, cancellationToken));
+        Option<Collection> maybeCollection = await CollectionMustExist(dbContext, request, cancellationToken);
+        return await maybeCollection.Match(
+            Some: collection => ApplyRemoveItemsRequest(dbContext, request, collection, cancellationToken),
+            None: () => Task.FromResult<Either<BaseError, Unit>>(
+                new NotFoundError($"Collection {request.MediaCollectionId} does not exist.")));
     }
 
-    private async Task<Unit> ApplyRemoveItemsRequest(
+    private async Task<Either<BaseError, Unit>> ApplyRemoveItemsRequest(
         TvContext dbContext,
         RemoveItemsFromCollection request,
         Collection collection,
         CancellationToken cancellationToken)
     {
+        List<int> requestedIds = request.MediaItemIds.Distinct().ToList();
         var itemsToRemove = collection.MediaItems
-            .Filter(m => request.MediaItemIds.Contains(m.Id))
+            .Filter(m => requestedIds.Contains(m.Id))
             .ToList();
 
+        if (itemsToRemove.Count != requestedIds.Count)
+        {
+            return new NotFoundError("Collection item does not exist.");
+        }
+
         itemsToRemove.ForEach(m => collection.MediaItems.Remove(m));
 
         if (itemsToRemove.Count != 0 && await dbContext.SaveChangesAsync(cancellationToken) > 0)
@@ -67,18 +77,12 @@ public class RemoveItemsFromCollectionHandler : IRequestHandler<RemoveItemsFromC
         return Unit.Default;
     }
 
-    private static Task<Validation<BaseError, Collection>> Validate(
-        TvContext dbContext,
-        RemoveItemsFromCollection request,
-        CancellationToken cancellationToken) =>
-        CollectionMustExist(dbContext, request, cancellationToken);
-
-    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+    private static Task<Option<Collection>> CollectionMustExist(
         TvContext dbContext,
         RemoveItemsFromCollection request,
         CancellationToken cancellationToken) =>
         dbContext.Collections
             .Include(c => c.MediaItems)
             .SelectOneAsync(c => c.Id, c => c.Id == request.MediaCollectionId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+            .Map(identity);
 }

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs

@@ -2,6 +2,7 @@
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Scheduling;
@@ -35,8 +36,15 @@ public class UpdateCollectionHandler : IRequestHandler<UpdateCollection, Either<
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Collection> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
+        Option<Collection> maybeCollection = await CollectionMustExist(dbContext, request, cancellationToken);
+        return await maybeCollection.Match(
+            Some: async collection =>
+            {
+                Validation<BaseError, Collection> validation = await Validate(dbContext, request, collection);
+                return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
+            },
+            None: () => Task.FromResult<Either<BaseError, Unit>>(
+                new NotFoundError($"Collection {request.CollectionId} does not exist.")));
     }
 
     private async Task<Unit> ApplyUpdateRequest(
@@ -69,17 +77,16 @@ public class UpdateCollectionHandler : IRequestHandler<UpdateCollection, Either<
     private static async Task<Validation<BaseError, Collection>> Validate(
         TvContext dbContext,
         UpdateCollection request,
-        CancellationToken cancellationToken) =>
-        (await CollectionMustExist(dbContext, request, cancellationToken), await ValidateName(dbContext, request))
-        .Apply((collectionToUpdate, _) => collectionToUpdate);
+        Collection collection) =>
+        (await ValidateName(dbContext, request)).Map(_ => collection);
 
-    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+    private static Task<Option<Collection>> CollectionMustExist(
         TvContext dbContext,
         UpdateCollection updateCollection,
         CancellationToken cancellationToken) =>
         dbContext.Collections
             .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.CollectionId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+            .Map(identity);
 
     private static async Task<Validation<BaseError, string>> ValidateName(
         TvContext dbContext,

ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollectionHandler.cs

@@ -2,6 +2,7 @@
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Scheduling;
@@ -41,8 +42,18 @@ public class
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, SmartCollection> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
+        Option<SmartCollection> maybeSmartCollection = await SmartCollectionMustExist(
+            dbContext,
+            request,
+            cancellationToken);
+        return await maybeSmartCollection.Match(
+            Some: async smartCollection =>
+            {
+                Validation<BaseError, SmartCollection> validation = await Validate(dbContext, request, smartCollection);
+                return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
+            },
+            None: () => Task.FromResult<Either<BaseError, UpdateSmartCollectionResult>>(
+                new NotFoundError($"SmartCollection {request.Id} does not exist.")));
     }
 
     private async Task<UpdateSmartCollectionResult> ApplyUpdateRequest(
@@ -73,16 +84,16 @@ public class
     private static Task<Validation<BaseError, SmartCollection>> Validate(
         TvContext dbContext,
         UpdateSmartCollection request,
-        CancellationToken cancellationToken) => ValidateName(dbContext, request)
-        .BindT(_ => SmartCollectionMustExist(dbContext, request, cancellationToken));
+        SmartCollection smartCollection) => ValidateName(dbContext, request)
+        .MapT(_ => smartCollection);
 
-    private static Task<Validation<BaseError, SmartCollection>> SmartCollectionMustExist(
+    private static Task<Option<SmartCollection>> SmartCollectionMustExist(
         TvContext dbContext,
         UpdateSmartCollection updateCollection,
         CancellationToken cancellationToken) =>
         dbContext.SmartCollections
             .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.Id, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("SmartCollection does not exist."));
+            .Map(identity);
 
     private static async Task<Validation<BaseError, string>> ValidateName(
         TvContext dbContext,

ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs

@@ -1,5 +1,4 @@
 using System.Threading.Channels;
-using Bugsnag;
 using EFCore.BulkExtensions;
 using ErsatzTV.Application.Channels;
 using ErsatzTV.Application.Subtitles;
@@ -22,7 +21,6 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
 {
     private readonly IBlockPlayoutBuilder _blockPlayoutBuilder;
     private readonly IBlockPlayoutFillerBuilder _blockPlayoutFillerBuilder;
-    private readonly IClient _client;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
     private readonly IEntityLocker _entityLocker;
     private readonly IExternalJsonPlayoutBuilder _externalJsonPlayoutBuilder;
@@ -35,7 +33,6 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
     private readonly IScriptedPlayoutBuilder _scriptedPlayoutBuilder;
 
     public BuildPlayoutHandler(
-        IClient client,
         IDbContextFactory<TvContext> dbContextFactory,
         IPlayoutBuilder playoutBuilder,
         IBlockPlayoutBuilder blockPlayoutBuilder,
@@ -49,7 +46,6 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
         ChannelWriter<IBackgroundServiceRequest> workerChannel,
         ILogger<BuildPlayoutHandler> logger)
     {
-        _client = client;
         _dbContextFactory = dbContextFactory;
         _playoutBuilder = playoutBuilder;
         _blockPlayoutBuilder = blockPlayoutBuilder;
@@ -348,7 +344,6 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
             newBuildStatus.Success = false;
             newBuildStatus.Message = $"Timeout building playout for channel {channelName}";
 
-            _client.Notify(ex);
             return BaseError.New(
                 $"Timeout building playout for channel {channelName}; this may be a bug!");
         }
@@ -359,7 +354,6 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
             newBuildStatus.Success = false;
             newBuildStatus.Message = $"Unexpected error building playout for channel {channelName}: {ex}";
 
-            _client.Notify(ex);
             return BaseError.New(
                 $"Unexpected error building playout for channel {channelName}: {ex.Message}");
         }

ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs

@@ -1,10 +1,9 @@
-using Bugsnag;
-using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Search;
 
 namespace ErsatzTV.Application.Search;
 
-public class QuerySearchIndexAllItemsHandler(IClient client, ISearchIndex searchIndex)
+public class QuerySearchIndexAllItemsHandler(ISearchIndex searchIndex)
     : IRequestHandler<QuerySearchIndexAllItems, SearchResultAllItemsViewModel>
 {
     public async Task<SearchResultAllItemsViewModel> Handle(
@@ -23,7 +22,7 @@ public class QuerySearchIndexAllItemsHandler(IClient client, ISearchIndex search
             await GetIds(LuceneSearchIndex.RemoteStreamType, request.Query, cancellationToken));
 
     private async Task<List<int>> GetIds(string type, string query, CancellationToken cancellationToken) =>
-        (await searchIndex.Search(client, $"type:{type} AND ({query})", string.Empty, 0, 0, cancellationToken)).Items
+        (await searchIndex.Search($"type:{type} AND ({query})", string.Empty, 0, 0, cancellationToken)).Items
         .Map(i => i.Id)
         .ToList();
 }

ErsatzTV.Application/Search/Queries/QuerySearchIndexArtistsHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
 using ErsatzTV.Infrastructure.Data;
@@ -9,7 +8,6 @@ using static ErsatzTV.Application.MediaCards.Mapper;
 namespace ErsatzTV.Application.Search;
 
 public class QuerySearchIndexArtistsHandler(
-    IClient client,
     ISearchIndex searchIndex,
     IDbContextFactory<TvContext> dbContextFactory)
     : IRequestHandler<QuerySearchIndexArtists, ArtistCardResultsViewModel>
@@ -19,7 +17,6 @@ public class QuerySearchIndexArtistsHandler(
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodesHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Emby;
@@ -17,7 +16,6 @@ namespace ErsatzTV.Application.Search;
 
 public class
     QuerySearchIndexEpisodesHandler(
-        IClient client,
         ISearchIndex searchIndex,
         IPlexPathReplacementService plexPathReplacementService,
         IJellyfinPathReplacementService jellyfinPathReplacementService,
@@ -31,7 +29,6 @@ public class
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/QuerySearchIndexImagesHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
 using ErsatzTV.Infrastructure.Data;
@@ -9,7 +8,6 @@ using static ErsatzTV.Application.MediaCards.Mapper;
 namespace ErsatzTV.Application.Search;
 
 public class QuerySearchIndexImagesHandler(
-    IClient client,
     ISearchIndex searchIndex,
     IDbContextFactory<TvContext> dbContextFactory)
     : IRequestHandler<QuerySearchIndexImages, ImageCardResultsViewModel>
@@ -19,7 +17,6 @@ public class QuerySearchIndexImagesHandler(
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/QuerySearchIndexMoviesHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -10,7 +9,6 @@ using static ErsatzTV.Application.MediaCards.Mapper;
 namespace ErsatzTV.Application.Search;
 
 public class QuerySearchIndexMoviesHandler(
-    IClient client,
     ISearchIndex searchIndex,
     IDbContextFactory<TvContext> dbContextFactory)
     : QuerySearchIndexHandlerBase, IRequestHandler<QuerySearchIndexMovies, MovieCardResultsViewModel>
@@ -20,7 +18,6 @@ public class QuerySearchIndexMoviesHandler(
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideosHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Emby;
@@ -15,7 +14,6 @@ namespace ErsatzTV.Application.Search;
 
 public class
     QuerySearchIndexMusicVideosHandler(
-        IClient client,
         ISearchIndex searchIndex,
         IPlexPathReplacementService plexPathReplacementService,
         IJellyfinPathReplacementService jellyfinPathReplacementService,
@@ -28,7 +26,6 @@ public class
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideosHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
 using ErsatzTV.Infrastructure.Data;
@@ -10,7 +9,6 @@ namespace ErsatzTV.Application.Search;
 
 public class
     QuerySearchIndexOtherVideosHandler(
-        IClient client,
         ISearchIndex searchIndex,
         IDbContextFactory<TvContext> dbContextFactory)
     : IRequestHandler<QuerySearchIndexOtherVideos, OtherVideoCardResultsViewModel>
@@ -20,7 +18,6 @@ public class
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/QuerySearchIndexRemoteStreamsHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
 using ErsatzTV.Infrastructure.Data;
@@ -9,7 +8,6 @@ using static ErsatzTV.Application.MediaCards.Mapper;
 namespace ErsatzTV.Application.Search;
 
 public class QuerySearchIndexRemoteStreamsHandler(
-    IClient client,
     ISearchIndex searchIndex,
     IDbContextFactory<TvContext> dbContextFactory)
     : IRequestHandler<QuerySearchIndexRemoteStreams, RemoteStreamCardResultsViewModel>
@@ -19,7 +17,6 @@ public class QuerySearchIndexRemoteStreamsHandler(
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasonsHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -11,7 +10,6 @@ namespace ErsatzTV.Application.Search;
 
 public class
     QuerySearchIndexSeasonsHandler(
-        IClient client,
         ISearchIndex searchIndex,
         IDbContextFactory<TvContext> dbContextFactory)
     : QuerySearchIndexHandlerBase, IRequestHandler<QuerySearchIndexSeasons, TelevisionSeasonCardResultsViewModel>
@@ -21,7 +19,6 @@ public class
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/QuerySearchIndexShowsHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -11,7 +10,6 @@ namespace ErsatzTV.Application.Search;
 
 public class
     QuerySearchIndexShowsHandler(
-        IClient client,
         ISearchIndex searchIndex,
         IDbContextFactory<TvContext> dbContextFactory)
     : QuerySearchIndexHandlerBase, IRequestHandler<QuerySearchIndexShows, TelevisionShowCardResultsViewModel>
@@ -21,7 +19,6 @@ public class
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/QuerySearchIndexSongsHandler.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
 using ErsatzTV.Infrastructure.Data;
@@ -8,7 +7,7 @@ using static ErsatzTV.Application.MediaCards.Mapper;
 
 namespace ErsatzTV.Application.Search;
 
-public class QuerySearchIndexSongsHandler(IClient client, ISearchIndex searchIndex, IDbContextFactory<TvContext> dbContextFactory)
+public class QuerySearchIndexSongsHandler(ISearchIndex searchIndex, IDbContextFactory<TvContext> dbContextFactory)
     : IRequestHandler<QuerySearchIndexSongs, SongCardResultsViewModel>
 {
     public async Task<SongCardResultsViewModel> Handle(
@@ -16,7 +15,6 @@ public class QuerySearchIndexSongsHandler(IClient client, ISearchIndex searchInd
         CancellationToken cancellationToken)
     {
         SearchResult searchResult = await searchIndex.Search(
-            client,
             request.Query,
             string.Empty,
             (request.PageNumber - 1) * request.PageSize,

ErsatzTV.Application/Search/Queries/SearchMoviesHandler.cs

@@ -1,6 +1,5 @@
 using System.Collections.Immutable;
 using System.Globalization;
-using Bugsnag;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Search;
@@ -11,10 +10,9 @@ using Microsoft.EntityFrameworkCore;
 namespace ErsatzTV.Application.Search;
 
 public class SearchMoviesHandler(
-    IClient client,
     ISearchIndex searchIndex,
     IDbContextFactory<TvContext> dbContextFactory)
-    : SearchUsingSearchIndexHandler(client, searchIndex), IRequestHandler<SearchMovies, List<NamedMediaItemViewModel>>
+    : SearchUsingSearchIndexHandler(searchIndex), IRequestHandler<SearchMovies, List<NamedMediaItemViewModel>>
 {
     public async Task<List<NamedMediaItemViewModel>> Handle(SearchMovies request, CancellationToken cancellationToken)
     {

ErsatzTV.Application/Search/Queries/SearchTelevisionSeasonsHandler.cs

@@ -1,6 +1,5 @@
 using System.Collections.Immutable;
 using System.Globalization;
-using Bugsnag;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
@@ -10,10 +9,9 @@ using Microsoft.EntityFrameworkCore;
 namespace ErsatzTV.Application.Search;
 
 public class SearchTelevisionSeasonsHandler(
-    IClient client,
     ISearchIndex searchIndex,
     IDbContextFactory<TvContext> dbContextFactory)
-    : SearchUsingSearchIndexHandler(client, searchIndex),
+    : SearchUsingSearchIndexHandler(searchIndex),
         IRequestHandler<SearchTelevisionSeasons, List<NamedMediaItemViewModel>>
 {
     public async Task<List<NamedMediaItemViewModel>> Handle(

ErsatzTV.Application/Search/Queries/SearchTelevisionShowsHandler.cs

@@ -1,6 +1,5 @@
 using System.Collections.Immutable;
 using System.Globalization;
-using Bugsnag;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Search;
@@ -11,10 +10,9 @@ using Microsoft.EntityFrameworkCore;
 namespace ErsatzTV.Application.Search;
 
 public class SearchTelevisionShowsHandler(
-    IClient client,
     ISearchIndex searchIndex,
     IDbContextFactory<TvContext> dbContextFactory)
-    : SearchUsingSearchIndexHandler(client, searchIndex),
+    : SearchUsingSearchIndexHandler(searchIndex),
         IRequestHandler<SearchTelevisionShows, List<NamedMediaItemViewModel>>
 {
     public async Task<List<NamedMediaItemViewModel>> Handle(

ErsatzTV.Application/Search/Queries/SearchUsingSearchIndexHandler.cs

@@ -1,18 +1,16 @@
 using System.Collections.Immutable;
-using Bugsnag;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Search;
 
 namespace ErsatzTV.Application.Search;
 
-public abstract class SearchUsingSearchIndexHandler(IClient client, ISearchIndex searchIndex)
+public abstract class SearchUsingSearchIndexHandler(ISearchIndex searchIndex)
 {
     private const int PageSize = 10;
 
     protected async Task<ImmutableHashSet<int>> Search(string type, string query, CancellationToken cancellationToken)
     {
         var searchResult = await searchIndex.Search(
-            client,
             $"type:{type} AND *{query.Replace(" ", @"\ ")}*",
             string.Empty,
             0,

ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs

@@ -1,6 +1,5 @@
 using System.IO.Abstractions;
 using System.Threading.Channels;
-using Bugsnag;
 using ErsatzTV.Application.Channels;
 using ErsatzTV.Application.Graphics;
 using ErsatzTV.Application.Maintenance;
@@ -22,7 +21,6 @@ namespace ErsatzTV.Application.Streaming;
 
 public class StartFFmpegSessionHandler : IRequestHandler<StartFFmpegSession, Either<BaseError, Unit>>
 {
-    private readonly IClient _client;
     private readonly IFileSystem _fileSystem;
     private readonly IConfigElementRepository _configElementRepository;
     private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
@@ -42,7 +40,6 @@ public class StartFFmpegSessionHandler : IRequestHandler<StartFFmpegSession, Eit
         IHlsInitSegmentCache hlsInitSegmentCache,
         IServiceScopeFactory serviceScopeFactory,
         IMediator mediator,
-        IClient client,
         IFileSystem fileSystem,
         ILocalFileSystem localFileSystem,
         ILogger<StartFFmpegSessionHandler> logger,
@@ -57,7 +54,6 @@ public class StartFFmpegSessionHandler : IRequestHandler<StartFFmpegSession, Eit
         _hlsInitSegmentCache = hlsInitSegmentCache;
         _serviceScopeFactory = serviceScopeFactory;
         _mediator = mediator;
-        _client = client;
         _fileSystem = fileSystem;
         _localFileSystem = localFileSystem;
         _logger = logger;
@@ -129,7 +125,6 @@ public class StartFFmpegSessionHandler : IRequestHandler<StartFFmpegSession, Eit
             _ => new HlsSessionWorker(
                 _serviceScopeFactory,
                 _graphicsEngine,
-                _client,
                 OutputFormatKind.Hls,
                 _hlsPlaylistFilter,
                 _hlsInitSegmentCache,

ErsatzTV.Application/Streaming/HlsSessionWorker.cs

@@ -5,7 +5,6 @@ using System.IO.Abstractions;
 using System.IO.Pipelines;
 using System.Text;
 using System.Timers;
-using Bugsnag;
 using CliWrap;
 using CliWrap.Buffered;
 using ErsatzTV.Application.Channels;
@@ -28,7 +27,6 @@ namespace ErsatzTV.Application.Streaming;
 public class HlsSessionWorker : IHlsSessionWorker
 {
     private static int _workAheadCount;
-    private readonly IClient _client;
     private readonly OutputFormatKind _outputFormatKind;
     private readonly IHlsInitSegmentCache _hlsInitSegmentCache;
     private readonly Dictionary<long, int> _discontinuityMap = [];
@@ -60,7 +58,6 @@ public class HlsSessionWorker : IHlsSessionWorker
     public HlsSessionWorker(
         IServiceScopeFactory serviceScopeFactory,
         IGraphicsEngine graphicsEngine,
-        IClient client,
         OutputFormatKind outputFormatKind,
         IHlsPlaylistFilter hlsPlaylistFilter,
         IHlsInitSegmentCache hlsInitSegmentCache,
@@ -73,7 +70,6 @@ public class HlsSessionWorker : IHlsSessionWorker
         _serviceScope = serviceScopeFactory.CreateScope();
         _mediator = _serviceScope.ServiceProvider.GetRequiredService<IMediator>();
         _graphicsEngine = graphicsEngine;
-        _client = client;
         _outputFormatKind = outputFormatKind;
         _hlsInitSegmentCache = hlsInitSegmentCache;
         _hlsPlaylistFilter = hlsPlaylistFilter;
@@ -660,15 +656,6 @@ public class HlsSessionWorker : IHlsSessionWorker
         {
             _logger.LogError(ex, "Error transcoding channel {Channel} - {Message}", _channelNumber, ex.Message);
 
-            try
-            {
-                _client.Notify(ex);
-            }
-            catch (Exception)
-            {
-                // do nothing
-            }
-
             return false;
         }
         finally

ErsatzTV.Application/Streaming/Queries/GetLastPtsTimeHandler.cs

@@ -1,6 +1,5 @@
 using System.IO.Abstractions;
 using System.Text;
-using Bugsnag;
 using CliWrap;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -13,7 +12,6 @@ using Newtonsoft.Json;
 namespace ErsatzTV.Application.Streaming;
 
 public class GetLastPtsTimeHandler(
-    IClient client,
     IFileSystem fileSystem,
     ITempFilePool tempFilePool,
     IConfigElementRepository configElementRepository,
@@ -181,9 +179,9 @@ public class GetLastPtsTimeHandler(
 
             logger.LogWarning("Transcode folder is in bad state; troubleshooting info saved to {File}", file);
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            client.Notify(ex);
+            // do nothing
         }
     }
 

ErsatzTV.Architecture.Tests/ErsatzTV.Architecture.Tests.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <NoWarn>VSTHRD200,CA1873</NoWarn>
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" />
+        <PackageReference Include="NetArchTest.eNhancedEdition" />
+        <PackageReference Include="NUnit" />
+        <PackageReference Include="NUnit3TestAdapter" />
+        <PackageReference Include="NUnit.Analyzers">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="coverlet.collector">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="Shouldly" />
+    </ItemGroup>
+
+    <!-- Reference every layer so its assembly lands in the test output for NetArchTest to analyze. -->
+    <ItemGroup>
+        <ProjectReference Include="..\ErsatzTV.Core\ErsatzTV.Core.csproj" />
+        <ProjectReference Include="..\ErsatzTV.FFmpeg\ErsatzTV.FFmpeg.csproj" />
+        <ProjectReference Include="..\ErsatzTV.Application\ErsatzTV.Application.csproj" />
+        <ProjectReference Include="..\ErsatzTV.Infrastructure\ErsatzTV.Infrastructure.csproj" />
+        <ProjectReference Include="..\ErsatzTV.Infrastructure.Sqlite\ErsatzTV.Infrastructure.Sqlite.csproj" />
+        <ProjectReference Include="..\ErsatzTV.Infrastructure.MySql\ErsatzTV.Infrastructure.MySql.csproj" />
+        <ProjectReference Include="..\ErsatzTV.Scanner\ErsatzTV.Scanner.csproj" />
+    </ItemGroup>
+
+</Project>

ErsatzTV.Architecture.Tests/LayeringTests.cs

@@ -0,0 +1,104 @@
+using System.Reflection;
+using NetArchTest.Rules;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Architecture.Tests;
+
+// Enforces the dependency direction of the solution's layers (see docs/ci-cd.md / contributors guide).
+// NetArchTest analyses the compiled assemblies, so a "just import it here" violation fails the build
+// instead of eroding the architecture over time. Rules below reflect the intended layering and the
+// current project-reference graph:
+//   FFmpeg (lowest) <- Core <- Infrastructure <- {Infrastructure.Sqlite, Infrastructure.MySql}
+//   Core <- Application;  everything <- ErsatzTV (host / composition root)
+[TestFixture]
+public class LayeringTests
+{
+    private static Assembly Core => Assembly.Load("ErsatzTV.Core");
+    private static Assembly FFmpeg => Assembly.Load("ErsatzTV.FFmpeg");
+    private static Assembly Application => Assembly.Load("ErsatzTV.Application");
+    private static Assembly Infrastructure => Assembly.Load("ErsatzTV.Infrastructure");
+
+    [Test]
+    public void Core_should_not_depend_on_outer_layers()
+    {
+        TestResult result = Types.InAssembly(Core)
+            .Should()
+            .NotHaveDependencyOnAny(
+                "ErsatzTV.Application",
+                "ErsatzTV.Infrastructure",
+                "ErsatzTV.Scanner")
+            .GetResult();
+
+        result.IsSuccessful.ShouldBeTrue(Describe(result));
+    }
+
+    [Test]
+    public void Core_should_not_depend_on_a_database_or_orm()
+    {
+        TestResult result = Types.InAssembly(Core)
+            .Should()
+            .NotHaveDependencyOnAny(
+                "Microsoft.EntityFrameworkCore",
+                "Pomelo.EntityFrameworkCore",
+                "Microsoft.Data.Sqlite",
+                "Dapper")
+            .GetResult();
+
+        result.IsSuccessful.ShouldBeTrue(Describe(result));
+    }
+
+    [Test]
+    public void FFmpeg_should_not_depend_on_other_layers()
+    {
+        TestResult result = Types.InAssembly(FFmpeg)
+            .Should()
+            .NotHaveDependencyOnAny(
+                "ErsatzTV.Core",
+                "ErsatzTV.Application",
+                "ErsatzTV.Infrastructure",
+                "ErsatzTV.Scanner")
+            .GetResult();
+
+        result.IsSuccessful.ShouldBeTrue(Describe(result));
+    }
+
+    [Test]
+    public void Application_should_not_depend_on_concrete_database_providers()
+    {
+        TestResult result = Types.InAssembly(Application)
+            .Should()
+            .NotHaveDependencyOnAny(
+                "ErsatzTV.Infrastructure.Sqlite",
+                "ErsatzTV.Infrastructure.MySql")
+            .GetResult();
+
+        result.IsSuccessful.ShouldBeTrue(Describe(result));
+    }
+
+    [Test]
+    public void Infrastructure_should_not_depend_on_application_or_concrete_providers()
+    {
+        TestResult result = Types.InAssembly(Infrastructure)
+            .Should()
+            .NotHaveDependencyOnAny(
+                "ErsatzTV.Application",
+                "ErsatzTV.Infrastructure.Sqlite",
+                "ErsatzTV.Infrastructure.MySql")
+            .GetResult();
+
+        result.IsSuccessful.ShouldBeTrue(Describe(result));
+    }
+
+    private static string Describe(TestResult result)
+    {
+        if (result.IsSuccessful)
+        {
+            return string.Empty;
+        }
+
+        IEnumerable<string> names = result.FailingTypes?.Select(t => t.FullName ?? t.Name)
+                                    ?? Enumerable.Empty<string>();
+        return "Layering violation — offending types:\n  " + string.Join("\n  ", names);
+    }
+}

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

@@ -7,26 +7,26 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Bugsnag" Version="4.1.0" />
-        <PackageReference Include="CliWrap" Version="3.10.0" />
-        <PackageReference Include="LanguageExt.Core" Version="4.4.9" />
-        <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="10.0.2" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
-        <PackageReference Include="NSubstitute" Version="5.3.0" />
-        <PackageReference Include="NUnit" Version="4.4.0" />
-        <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
-        <PackageReference Include="Serilog" Version="4.3.0" />
-        <PackageReference Include="Serilog.Extensions.Logging" Version="10.0.0" />
-        <PackageReference Include="Serilog.Sinks.Debug" Version="3.0.0" />
-        <PackageReference Include="Shouldly" Version="4.3.0" />
-        <PackageReference Include="Testably.Abstractions.Testing" Version="5.1.0" />
+        <PackageReference Include="CliWrap" />
+        <PackageReference Include="LanguageExt.Core" />
+        <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
+        <PackageReference Include="Microsoft.Extensions.Logging" />
+        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
+        <PackageReference Include="Microsoft.Extensions.Logging.Debug" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" />
+        <PackageReference Include="NSubstitute" />
+        <PackageReference Include="NUnit" />
+        <PackageReference Include="NUnit3TestAdapter" />
+        <PackageReference Include="Serilog" />
+        <PackageReference Include="Serilog.Extensions.Logging" />
+        <PackageReference Include="Serilog.Sinks.Debug" />
+        <PackageReference Include="Shouldly" />
+        <PackageReference Include="Testably.Abstractions.Testing" />
     </ItemGroup>
 
     <ItemGroup>
+        <ProjectReference Include="..\ErsatzTV.Application\ErsatzTV.Application.csproj" />
         <ProjectReference Include="..\ErsatzTV.Core\ErsatzTV.Core.csproj" />
         <ProjectReference Include="..\ErsatzTV.Infrastructure.Sqlite\ErsatzTV.Infrastructure.Sqlite.csproj" />
         <ProjectReference Include="..\ErsatzTV.Infrastructure\ErsatzTV.Infrastructure.csproj" />

ErsatzTV.Core.Tests/FFmpeg/CustomStreamSelectorTests.cs

@@ -571,7 +571,8 @@ public class CustomStreamSelectorTests
         }
 
         [Test]
-        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Content_Condition_Fail()
+        [SetCulture("en-US")]
+        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Content_Condition_Fail_SundayFirstCulture()
         {
             const string YAML =
                 """
@@ -608,7 +609,8 @@ public class CustomStreamSelectorTests
         }
 
         [Test]
-        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Content_Condition_Match()
+        [SetCulture("en-US")]
+        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Content_Condition_Match_SundayFirstCulture()
         {
             const string YAML =
                 """
@@ -651,7 +653,8 @@ public class CustomStreamSelectorTests
         }
 
         [Test]
-        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Fail_Before()
+        [SetCulture("en-US")]
+        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Fail_Before_SundayFirstCulture()
         {
             // saturday from 9pm-11pm
             const string YAML =
@@ -689,7 +692,8 @@ public class CustomStreamSelectorTests
         }
 
         [Test]
-        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Fail_After()
+        [SetCulture("en-US")]
+        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Fail_After_SundayFirstCulture()
         {
             // saturday from 9pm-11pm
             const string YAML =
@@ -727,7 +731,8 @@ public class CustomStreamSelectorTests
         }
 
         [Test]
-        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Fail_Wrong_Day()
+        [SetCulture("en-US")]
+        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Fail_Wrong_Day_SundayFirstCulture()
         {
             // saturday from 9pm-11pm
             const string YAML =
@@ -765,7 +770,8 @@ public class CustomStreamSelectorTests
         }
 
         [Test]
-        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Match()
+        [SetCulture("en-US")]
+        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Match_SundayFirstCulture()
         {
             // saturday from 9pm-11pm
             const string YAML =
@@ -810,7 +816,7 @@ public class CustomStreamSelectorTests
 
         [Test]
         [SetCulture("fr-FR")]
-        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Match_France()
+        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Match_MondayFirstCulture()
         {
             // saturday from 9pm-11pm
             const string YAML =
@@ -853,6 +859,45 @@ public class CustomStreamSelectorTests
             }
         }
 
+        [Test]
+        [SetCulture("fr-FR")]
+        public async Task Should_Select_English_Audio_No_Subtitles_Day_Of_Week_Time_Of_Day_Content_Condition_Fail_Wrong_Day_MondayFirstCulture()
+        {
+            // In a Monday-first culture, saturday is day 5 and sunday is day 6.
+            const string YAML =
+                """
+                ---
+                items:
+                  - audio_language: ["ja"]
+                    subtitle_language: ["eng"]
+                    content_condition: "day_of_week = 5 and (time_of_day_seconds >= 75600 and time_of_day_seconds < 82800)"
+
+                  - audio_language: ["eng"]
+                    disable_subtitles: true
+                """;
+
+            var fileSystem = new MockFileSystem();
+            fileSystem.Initialize()
+                .WithFile(TestFileName).Which(f => f.HasStringContent(YAML));
+            var streamSelector = new CustomStreamSelector(fileSystem, _logger);
+
+            var tz = TZConvert.GetTimeZoneInfo("America/Chicago");
+            var start = new DateTime(2026, 1, 11, 22, 0, 0, DateTimeKind.Unspecified); // sunday at 10:00pm
+            var dto = new DateTimeOffset(start, tz.GetUtcOffset(start));
+
+            StreamSelectorResult result = await streamSelector.SelectStreams(_channel, dto, _audioVersion, _subtitles);
+
+            result.AudioStream.IsSome.ShouldBeTrue();
+
+            foreach (MediaStream audioStream in result.AudioStream)
+            {
+                audioStream.Index.ShouldBe(1);
+                audioStream.Language.ShouldBe("eng");
+            }
+
+            result.Subtitle.IsSome.ShouldBeFalse();
+        }
+
         [Test]
         public async Task Should_Ignore_Blocked_Audio_Title()
         {

ErsatzTV.Core.Tests/Iptv/ChannelGuideGoldenTests.cs

@@ -0,0 +1,233 @@
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Iptv;
+using ErsatzTV.Infrastructure;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.IO;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using MockFileSystem = Testably.Abstractions.Testing.MockFileSystem;
+
+namespace ErsatzTV.Core.Tests.Iptv;
+
+// Golden-file tests that lock the XMLTV guide output GetChannelGuideHandler produces — the surface
+// Jellyfin/clients consume for EPG + channel/programme artwork. The handler reads pre-built cache
+// fragments (channels.xml + {number}.xml), substitutes {RequestBase}/{AccessTokenUri}, strips
+// internal etv: tags, hides ShowInEpg=false channels, then assembles via ChannelGuide.ToXml().
+//
+// This is the XMLTV counterpart to ChannelPlaylistGoldenTests (#11) and, like it, is the regression
+// net for the {RequestBase} host substitution at the heart of #1. Goldens live under Goldens/ and are
+// regenerated via the Regenerate_goldens test or ETV_UPDATE_GOLDENS=1 — review the diff before committing.
+//
+// The goldens faithfully enshrine current behaviour, including the raw unescaped "&text=" ampersand the
+// real _channel.sbntxt template emits (technically not well-formed XML). That is why the comparison is
+// string equality rather than XDocument.Parse — a parse guard would throw on today's legitimate output.
+[TestFixture]
+public class ChannelGuideGoldenTests
+{
+    private const string Scheme = "https";
+    private const string Host = "tv.example.com";
+
+    // channels.xml is NOT filtered by ShowInEpg — every channel's <channel> def stays here; only the
+    // per-channel programme *data* fragment of a hidden channel is dropped. Channels 2 and 10 are visible,
+    // channel 3 is hidden. (2 vs 10 also proves ChannelGuide.ToXml orders fragments by DECIMAL, not string.)
+    private const string ChannelsXml =
+        """<channel id="C2.etv"><display-name>2 News</display-name><display-name>2</display-name><display-name>News</display-name><category lang="en">General</category><icon src="{RequestBase}/iptv/logos/news.jpg{AccessTokenUri}" /></channel><channel id="C10.etv"><display-name>10 Movies</display-name><display-name>10</display-name><display-name>Movies</display-name><icon src="{RequestBase}/iptv/logos/gen{AccessTokenUri}&text=Movies" /></channel><channel id="C3.etv"><display-name>3 Hidden</display-name><display-name>3</display-name><display-name>Hidden</display-name><icon src="{RequestBase}/iptv/logos/hidden.jpg{AccessTokenUri}" /></channel>""";
+
+    // Visible (channel 2) — exercises {RequestBase}/{AccessTokenUri} substitution on the programme artwork
+    // <icon> (which must SURVIVE) AND etv:-tag stripping. etv: nodes are the documented optional graphics-
+    // engine feature (paired like <etv:episode_number_key>…</etv:episode_number_key>); a trailing self-
+    // closing <etv:…/> exercises the regex's second alternative. Both must be gone from client output.
+    private const string Channel2Xml =
+        """<programme start="20260101080000 +0000" stop="20260101090000 +0000" channel="C2.etv"><title lang="en">Morning News</title><desc lang="en">Today's headlines.</desc><category lang="en">News</category><icon src="{RequestBase}/iptv/artwork/posters/abc.jpg{AccessTokenUri}" /><etv:episode_number_key>5</etv:episode_number_key><etv:marker /><previously-shown /></programme>""";
+
+    // Visible (channel 10) — uses an EXTERNAL icon URL with no placeholder, proving external URLs pass
+    // through verbatim. Its decimal key (10) must sort AFTER channel 2 despite string order putting "10" first.
+    private const string Channel10Xml =
+        """<programme start="20260101090000 +0000" stop="20260101110000 +0000" channel="C10.etv"><title lang="en">Matinee</title><desc lang="en">A film.</desc><category lang="en">Movie</category><icon src="https://cdn.example.com/movie.jpg" /></programme>""";
+
+    // Hidden (channel 3, ShowInEpg=false) — its programme data must NOT appear in the output.
+    private const string Channel3Xml =
+        """<programme start="20260101080000 +0000" stop="20260101090000 +0000" channel="C3.etv"><title lang="en">Hidden Show</title></programme>""";
+
+    private SqliteConnection _connection;
+    private IDbContextFactory<TvContext> _dbContextFactory;
+
+    [OneTimeSetUp]
+    public async Task SetUpDatabase()
+    {
+        // Shared in-memory SQLite: the connection must stay open for the DB to live across contexts.
+        // Foreign keys are disabled — we only read Channel.Number/ShowInEpg, so referential integrity
+        // (e.g. the FFmpegProfile FK) is irrelevant and would only complicate seeding.
+        _connection = new SqliteConnection("Data Source=:memory:;Foreign Keys=False");
+        await _connection.OpenAsync();
+
+        DbContextOptions<TvContext> options = new DbContextOptionsBuilder<TvContext>()
+            .UseSqlite(_connection)
+            .Options;
+
+        _dbContextFactory = new TestTvContextFactory(options);
+
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+
+        // EnsureCreated builds the schema from the model directly — sufficient here and far cheaper than
+        // replaying every migration just to read two Channel columns.
+        await context.Database.EnsureCreatedAsync();
+        await context.Database.ExecuteSqlRawAsync("PRAGMA foreign_keys = OFF;");
+
+        context.Channels.Add(NewChannel("2", "News", showInEpg: true));
+        context.Channels.Add(NewChannel("10", "Movies", showInEpg: true));
+        context.Channels.Add(NewChannel("3", "Hidden", showInEpg: false));
+        await context.SaveChangesAsync();
+    }
+
+    [OneTimeTearDown]
+    public void TearDownDatabase() => _connection?.Dispose();
+
+    [Test]
+    public Task Guide_without_access_token() =>
+        Verify("guide-no-token.xml", new GetChannelGuide(Scheme, Host, BaseUrl: "", AccessToken: null));
+
+    [Test]
+    public Task Guide_with_access_token() =>
+        Verify("guide-with-token.xml", new GetChannelGuide(Scheme, Host, BaseUrl: "", AccessToken: "SECRET-TOKEN"));
+
+    [Test]
+    public Task Guide_with_base_url() =>
+        Verify("guide-base-url.xml", new GetChannelGuide(Scheme, Host, BaseUrl: "/etv", AccessToken: null));
+
+    // --- harness ---
+
+    private async Task Verify(string goldenName, GetChannelGuide request)
+    {
+        MockFileSystem fileSystem = BuildCacheFileSystem();
+
+        // ListFiles returns channels.xml too (the handler skips it via Contains("channels")) and in a
+        // deliberately non-decimal order, so the test proves ChannelGuide.ToXml re-sorts by decimal key.
+        var localFileSystem = Substitute.For<ILocalFileSystem>();
+        localFileSystem
+            .ListFiles(FileSystemLayout.ChannelGuideCacheFolder)
+            .Returns(new[]
+            {
+                FragmentPath(fileSystem, "channels.xml"),
+                FragmentPath(fileSystem, "10.xml"),
+                FragmentPath(fileSystem, "3.xml"),
+                FragmentPath(fileSystem, "2.xml")
+            });
+
+        var handler = new GetChannelGuideHandler(
+            _dbContextFactory,
+            new RecyclableMemoryStreamManager(),
+            fileSystem,
+            localFileSystem);
+
+        Either<BaseError, ChannelGuide> result = await handler.Handle(request, CancellationToken.None);
+
+        string actual = Normalize(
+            result.Match(
+                Right: guide => guide.ToXml(),
+                Left: error => throw new AssertionException($"Handler returned error: {error.Value}")));
+
+        string path = Path.Combine(GoldenDir(), goldenName);
+
+        if (Environment.GetEnvironmentVariable("ETV_UPDATE_GOLDENS") == "1")
+        {
+            Directory.CreateDirectory(GoldenDir());
+            await File.WriteAllTextAsync(path, actual);
+            Assert.Inconclusive($"Wrote golden '{goldenName}'. Review it and re-run to verify.");
+            return;
+        }
+
+        // A missing golden is a hard failure (not a silent skip) so an un-committed baseline can't pass CI.
+        File.Exists(path).ShouldBeTrue(
+            $"Missing golden '{goldenName}'. Run Regenerate_goldens (or ETV_UPDATE_GOLDENS=1) and commit it.");
+
+        string expected = Canonicalize(await File.ReadAllTextAsync(path));
+        actual.ShouldBe(expected);
+    }
+
+    [Test]
+    [Explicit("Regenerates all XMLTV goldens from current output; review the diff before committing.")]
+    public async Task Regenerate_goldens()
+    {
+        Environment.SetEnvironmentVariable("ETV_UPDATE_GOLDENS", "1");
+        try
+        {
+            foreach (Func<Task> regen in new Func<Task>[]
+                     {
+                         Guide_without_access_token, Guide_with_access_token, Guide_with_base_url
+                     })
+            {
+                try
+                {
+                    await regen();
+                }
+                catch (InconclusiveException)
+                {
+                    // expected — each Verify writes its golden then reports inconclusive
+                }
+            }
+        }
+        finally
+        {
+            Environment.SetEnvironmentVariable("ETV_UPDATE_GOLDENS", null);
+        }
+    }
+
+    private static MockFileSystem BuildCacheFileSystem()
+    {
+        var fileSystem = new MockFileSystem();
+        fileSystem.Directory.CreateDirectory(FileSystemLayout.ChannelGuideCacheFolder);
+        fileSystem.File.WriteAllText(FragmentPath(fileSystem, "channels.xml"), ChannelsXml);
+        fileSystem.File.WriteAllText(FragmentPath(fileSystem, "2.xml"), Channel2Xml);
+        fileSystem.File.WriteAllText(FragmentPath(fileSystem, "10.xml"), Channel10Xml);
+        fileSystem.File.WriteAllText(FragmentPath(fileSystem, "3.xml"), Channel3Xml);
+        return fileSystem;
+    }
+
+    private static string FragmentPath(MockFileSystem fileSystem, string name) =>
+        fileSystem.Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, name);
+
+    // The XMLTV cache-buster (?v={channels.xml last-write ticks}) is the only volatile token; pin it so
+    // the golden is deterministic. Then canonicalize to a single trailing newline (Canonicalize) so the
+    // golden satisfies .editorconfig insert_final_newline and a formatting pass can't break the test.
+    private static string Normalize(string xml) =>
+        Canonicalize(Regex.Replace(xml, @"\?v=\d+", "?v=MTIME"));
+
+    // Strip the UTF-8 BOM that XmlWriter emits as a preamble (the load-bearing strip — the golden files
+    // themselves have no BOM), normalize line endings, and force exactly one trailing newline.
+    private static string Canonicalize(string xml) =>
+        xml.TrimStart('').ReplaceLineEndings("\n").TrimEnd('\n') + "\n";
+
+    private static Channel NewChannel(string number, string name, bool showInEpg) =>
+        new(Guid.NewGuid())
+        {
+            Number = number,
+            Name = name,
+            Group = "ErsatzTV",
+            Categories = string.Empty,
+            StreamSelector = string.Empty,
+            PreferredAudioLanguageCode = string.Empty,
+            PreferredAudioTitle = string.Empty,
+            PreferredSubtitleLanguageCode = string.Empty,
+            MusicVideoCreditsTemplate = string.Empty,
+            ShowInEpg = showInEpg
+        };
+
+    private static string GoldenDir([CallerFilePath] string thisFile = "") =>
+        Path.Combine(Path.GetDirectoryName(thisFile) ?? ".", "Goldens");
+
+    private sealed class TestTvContextFactory(DbContextOptions<TvContext> options) : IDbContextFactory<TvContext>
+    {
+        public TvContext CreateDbContext() =>
+            new(options, NullLoggerFactory.Instance, new SlowQueryInterceptor(NullLogger<SlowQueryInterceptor>.Instance));
+    }
+}

ErsatzTV.Core.Tests/Iptv/ChannelPlaylistGoldenTests.cs

@@ -0,0 +1,180 @@
+using System.Runtime.CompilerServices;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Iptv;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Core.Tests.Iptv;
+
+// Golden-file tests that lock the M3U output shape Jellyfin/Kodi consume (ChannelPlaylist.ToM3U).
+// Baselines capture TODAY's behaviour so a regression — e.g. while implementing the paused #1
+// (tvg-logo base URL) — fails CI instead of only surfacing as Jellyfin misbehaving in prod.
+//
+// Goldens live next to this file under Goldens/ and are located via [CallerFilePath], so they
+// resolve from the checked-out source in CI and locally without embedded-resource plumbing.
+// To regenerate after an INTENTIONAL output change, run the (explicit) Regenerate_goldens test
+// or set ETV_UPDATE_GOLDENS=1, then review and commit the diff.
+[TestFixture]
+public class ChannelPlaylistGoldenTests
+{
+    private const string Scheme = "https";
+    private const string Host = "tv.example.com";
+    private const string BaseUrl = "";
+
+    [SetUp]
+    public void GuardVolatileEnvironment() =>
+        // tvg-id (ChannelIdentifier.FromNumber) appends SystemEnvironment.InstanceId when set;
+        // the goldens assume it is unset (the CI/default case). Skip rather than falsely fail.
+        Assume.That(
+            string.IsNullOrEmpty(SystemEnvironment.InstanceId),
+            "ETV_INSTANCE_ID is set; M3U goldens assume it is unset.");
+
+    [Test]
+    public void Simple_channel_generated_logo() =>
+        Verify(
+            "simple-generated-logo.m3u",
+            new ChannelPlaylist(
+                Scheme,
+                Host,
+                BaseUrl,
+                [BuildChannel(1, "1", "News", StreamingMode.HttpLiveStreamingDirect)],
+                userAgent: "VLC/3.0",
+                accessToken: null));
+
+    [Test]
+    public void Channel_with_internal_logo() =>
+        Verify(
+            "internal-logo.m3u",
+            new ChannelPlaylist(
+                Scheme,
+                Host,
+                BaseUrl,
+                [WithLogo(BuildChannel(2, "2", "Movies", StreamingMode.HttpLiveStreamingSegmenter), "abc123def")],
+                userAgent: "VLC/3.0",
+                accessToken: null));
+
+    [Test]
+    public void Channel_with_external_logo() =>
+        Verify(
+            "external-logo.m3u",
+            new ChannelPlaylist(
+                Scheme,
+                Host,
+                BaseUrl,
+                [WithLogo(BuildChannel(3, "3", "Music", StreamingMode.TransportStream), "https://cdn.example.com/music.png")],
+                userAgent: "VLC/3.0",
+                accessToken: null));
+
+    [Test]
+    public void Multi_channel_sorted_by_number() =>
+        Verify(
+            "multi-channel.m3u",
+            new ChannelPlaylist(
+                Scheme,
+                Host,
+                BaseUrl,
+                [
+                    BuildChannel(10, "10", "Ten", StreamingMode.HttpLiveStreamingDirect),
+                    BuildChannel(2, "2", "Two", StreamingMode.TransportStreamHybrid),
+                    BuildChannel(1, "1.5", "OnePointFive", StreamingMode.HttpLiveStreamingSegmenter)
+                ],
+                userAgent: "VLC/3.0",
+                accessToken: null));
+
+    [Test]
+    public void Kodi_user_agent_adds_kodiprops() =>
+        Verify(
+            "kodi-user-agent.m3u",
+            new ChannelPlaylist(
+                Scheme,
+                Host,
+                BaseUrl,
+                [BuildChannel(4, "4", "Kids", StreamingMode.TransportStream)],
+                userAgent: "Kodi/21.0",
+                accessToken: null));
+
+    [Test]
+    public void With_access_token_and_base_url() =>
+        Verify(
+            "access-token-base-url.m3u",
+            new ChannelPlaylist(
+                Scheme,
+                Host,
+                baseUrl: "/etv",
+                [WithLogo(BuildChannel(5, "5", "Docs", StreamingMode.HttpLiveStreamingDirect), "logo5")],
+                userAgent: "VLC/3.0",
+                accessToken: "SECRET-TOKEN"));
+
+    // --- helpers ---
+
+    private static Channel BuildChannel(int seed, string number, string name, StreamingMode mode) =>
+        new(new Guid($"00000000-0000-0000-0000-{seed:D12}"))
+        {
+            Number = number,
+            Name = name,
+            Group = "ErsatzTV",
+            StreamingMode = mode,
+            Artwork = [],
+            FFmpegProfile = new FFmpegProfile
+            {
+                VideoFormat = FFmpegProfileVideoFormat.H264,
+                AudioFormat = FFmpegProfileAudioFormat.Aac
+            }
+        };
+
+    private static Channel WithLogo(Channel channel, string path)
+    {
+        channel.Artwork = [new Artwork { ArtworkKind = ArtworkKind.Logo, Path = path }];
+        return channel;
+    }
+
+    private static void Verify(string goldenName, ChannelPlaylist playlist)
+    {
+        string actual = playlist.ToM3U().ReplaceLineEndings("\n");
+        string path = Path.Combine(GoldenDir(), goldenName);
+
+        if (Environment.GetEnvironmentVariable("ETV_UPDATE_GOLDENS") == "1")
+        {
+            Directory.CreateDirectory(GoldenDir());
+            File.WriteAllText(path, actual);
+            Assert.Inconclusive($"Wrote golden '{goldenName}'. Review it and re-run to verify.");
+            return;
+        }
+
+        // A missing golden is a hard failure (not a silent skip) so an un-committed baseline
+        // can't pass CI. Create it with the Regenerate_goldens test or ETV_UPDATE_GOLDENS=1.
+        File.Exists(path).ShouldBeTrue(
+            $"Missing golden '{goldenName}'. Run Regenerate_goldens (or ETV_UPDATE_GOLDENS=1) and commit it.");
+
+        string expected = File.ReadAllText(path).ReplaceLineEndings("\n");
+        actual.ShouldBe(expected);
+    }
+
+    [Test]
+    [Explicit("Regenerates all M3U goldens from current output; review the diff before committing.")]
+    public void Regenerate_goldens()
+    {
+        Environment.SetEnvironmentVariable("ETV_UPDATE_GOLDENS", "1");
+        try
+        {
+            Simple_channel_generated_logo();
+            Channel_with_internal_logo();
+            Channel_with_external_logo();
+            Multi_channel_sorted_by_number();
+            Kodi_user_agent_adds_kodiprops();
+            With_access_token_and_base_url();
+        }
+        catch (InconclusiveException)
+        {
+            // expected — each Verify writes its golden then reports inconclusive
+        }
+        finally
+        {
+            Environment.SetEnvironmentVariable("ETV_UPDATE_GOLDENS", null);
+        }
+    }
+
+    private static string GoldenDir([CallerFilePath] string thisFile = "") =>
+        Path.Combine(Path.GetDirectoryName(thisFile) ?? ".", "Goldens");
+}

ErsatzTV.Core.Tests/Iptv/Goldens/access-token-base-url.m3u

@@ -0,0 +1,3 @@
+#EXTM3U url-tvg="https://tv.example.com/etv/iptv/xmltv.xml?access_token=SECRET-TOKEN" x-tvg-url="https://tv.example.com/etv/iptv/xmltv.xml?access_token=SECRET-TOKEN"
+#EXTINF:0 tvg-id="C5.149.ersatztv.org" channel-id="AAAAAAAAAAAAAAAAAAAABQ" channel-number="5" CUID="AAAAAAAAAAAAAAAAAAAABQ" tvg-chno="5" tvg-name="Docs" tvg-logo="https://tv.example.com/etv/iptv/logos/logo5.jpg?access_token=SECRET-TOKEN" group-title="ErsatzTV" tvc-stream-vcodec="h264" tvc-stream-acodec="aac", Docs
+https://tv.example.com/etv/iptv/channel/5.m3u8?mode=hls-direct&access_token=SECRET-TOKEN

ErsatzTV.Core.Tests/Iptv/Goldens/external-logo.m3u

@@ -0,0 +1,3 @@
+#EXTM3U url-tvg="https://tv.example.com/iptv/xmltv.xml" x-tvg-url="https://tv.example.com/iptv/xmltv.xml"
+#EXTINF:0 tvg-id="C3.147.ersatztv.org" channel-id="AAAAAAAAAAAAAAAAAAAAAw" channel-number="3" CUID="AAAAAAAAAAAAAAAAAAAAAw" tvg-chno="3" tvg-name="Music" tvg-logo="https://cdn.example.com/music.png" group-title="ErsatzTV" tvc-stream-vcodec="h264" tvc-stream-acodec="aac", Music
+https://tv.example.com/iptv/channel/3.ts?mode=ts-legacy

ErsatzTV.Core.Tests/Iptv/Goldens/guide-base-url.xml

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="utf-8"?><tv generator-info-name="ersatztv"><channel id="C2.etv"><display-name>2 News</display-name><display-name>2</display-name><display-name>News</display-name><category lang="en">General</category><icon src="https://tv.example.com/etv/iptv/logos/news.jpg?v=MTIME" /></channel><channel id="C10.etv"><display-name>10 Movies</display-name><display-name>10</display-name><display-name>Movies</display-name><icon src="https://tv.example.com/etv/iptv/logos/gen?v=MTIME&text=Movies" /></channel><channel id="C3.etv"><display-name>3 Hidden</display-name><display-name>3</display-name><display-name>Hidden</display-name><icon src="https://tv.example.com/etv/iptv/logos/hidden.jpg?v=MTIME" /></channel><programme start="20260101080000 +0000" stop="20260101090000 +0000" channel="C2.etv"><title lang="en">Morning News</title><desc lang="en">Today's headlines.</desc><category lang="en">News</category><icon src="https://tv.example.com/etv/iptv/artwork/posters/abc.jpg?v=MTIME" /><previously-shown /></programme><programme start="20260101090000 +0000" stop="20260101110000 +0000" channel="C10.etv"><title lang="en">Matinee</title><desc lang="en">A film.</desc><category lang="en">Movie</category><icon src="https://cdn.example.com/movie.jpg" /></programme></tv>

ErsatzTV.Core.Tests/Iptv/Goldens/guide-no-token.xml

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="utf-8"?><tv generator-info-name="ersatztv"><channel id="C2.etv"><display-name>2 News</display-name><display-name>2</display-name><display-name>News</display-name><category lang="en">General</category><icon src="https://tv.example.com/iptv/logos/news.jpg?v=MTIME" /></channel><channel id="C10.etv"><display-name>10 Movies</display-name><display-name>10</display-name><display-name>Movies</display-name><icon src="https://tv.example.com/iptv/logos/gen?v=MTIME&text=Movies" /></channel><channel id="C3.etv"><display-name>3 Hidden</display-name><display-name>3</display-name><display-name>Hidden</display-name><icon src="https://tv.example.com/iptv/logos/hidden.jpg?v=MTIME" /></channel><programme start="20260101080000 +0000" stop="20260101090000 +0000" channel="C2.etv"><title lang="en">Morning News</title><desc lang="en">Today's headlines.</desc><category lang="en">News</category><icon src="https://tv.example.com/iptv/artwork/posters/abc.jpg?v=MTIME" /><previously-shown /></programme><programme start="20260101090000 +0000" stop="20260101110000 +0000" channel="C10.etv"><title lang="en">Matinee</title><desc lang="en">A film.</desc><category lang="en">Movie</category><icon src="https://cdn.example.com/movie.jpg" /></programme></tv>

ErsatzTV.Core.Tests/Iptv/Goldens/guide-with-token.xml

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="utf-8"?><tv generator-info-name="ersatztv"><channel id="C2.etv"><display-name>2 News</display-name><display-name>2</display-name><display-name>News</display-name><category lang="en">General</category><icon src="https://tv.example.com/iptv/logos/news.jpg?v=MTIME&amp;access_token=SECRET-TOKEN" /></channel><channel id="C10.etv"><display-name>10 Movies</display-name><display-name>10</display-name><display-name>Movies</display-name><icon src="https://tv.example.com/iptv/logos/gen?v=MTIME&amp;access_token=SECRET-TOKEN&text=Movies" /></channel><channel id="C3.etv"><display-name>3 Hidden</display-name><display-name>3</display-name><display-name>Hidden</display-name><icon src="https://tv.example.com/iptv/logos/hidden.jpg?v=MTIME&amp;access_token=SECRET-TOKEN" /></channel><programme start="20260101080000 +0000" stop="20260101090000 +0000" channel="C2.etv"><title lang="en">Morning News</title><desc lang="en">Today's headlines.</desc><category lang="en">News</category><icon src="https://tv.example.com/iptv/artwork/posters/abc.jpg?v=MTIME&amp;access_token=SECRET-TOKEN" /><previously-shown /></programme><programme start="20260101090000 +0000" stop="20260101110000 +0000" channel="C10.etv"><title lang="en">Matinee</title><desc lang="en">A film.</desc><category lang="en">Movie</category><icon src="https://cdn.example.com/movie.jpg" /></programme></tv>

ErsatzTV.Core.Tests/Iptv/Goldens/internal-logo.m3u

@@ -0,0 +1,3 @@
+#EXTM3U url-tvg="https://tv.example.com/iptv/xmltv.xml" x-tvg-url="https://tv.example.com/iptv/xmltv.xml"
+#EXTINF:0 tvg-id="C2.146.ersatztv.org" channel-id="AAAAAAAAAAAAAAAAAAAAAg" channel-number="2" CUID="AAAAAAAAAAAAAAAAAAAAAg" tvg-chno="2" tvg-name="Movies" tvg-logo="https://tv.example.com/iptv/logos/abc123def.jpg" group-title="ErsatzTV" tvc-stream-vcodec="h264" tvc-stream-acodec="aac", Movies
+https://tv.example.com/iptv/channel/2.m3u8?mode=segmenter

ErsatzTV.Core.Tests/Iptv/Goldens/kodi-user-agent.m3u

@@ -0,0 +1,6 @@
+#EXTM3U url-tvg="https://tv.example.com/iptv/xmltv.xml" x-tvg-url="https://tv.example.com/iptv/xmltv.xml"
+#KODIPROP:inputstream=inputstream.ffmpegdirect
+#KODIPROP:mimetype=video/mp2t
+#KODIPROP:inputstream.ffmpegdirect.open_mode=ffmpeg
+#EXTINF:0 tvg-id="C4.148.ersatztv.org" channel-id="AAAAAAAAAAAAAAAAAAAABA" channel-number="4" CUID="AAAAAAAAAAAAAAAAAAAABA" tvg-chno="4" tvg-name="Kids" tvg-logo="https://tv.example.com/iptv/logos/gen?text=Kids" group-title="ErsatzTV" tvc-stream-vcodec="h264" tvc-stream-acodec="aac", Kids
+https://tv.example.com/iptv/channel/4.ts?mode=ts-legacy

ErsatzTV.Core.Tests/Iptv/Goldens/multi-channel.m3u

@@ -0,0 +1,7 @@
+#EXTM3U url-tvg="https://tv.example.com/iptv/xmltv.xml" x-tvg-url="https://tv.example.com/iptv/xmltv.xml"
+#EXTINF:0 tvg-id="C1.5.150.ersatztv.org" channel-id="AAAAAAAAAAAAAAAAAAAAAQ" channel-number="1.5" CUID="AAAAAAAAAAAAAAAAAAAAAQ" tvg-chno="1.5" tvg-name="OnePointFive" tvg-logo="https://tv.example.com/iptv/logos/gen?text=OnePointFive" group-title="ErsatzTV" tvc-stream-vcodec="h264" tvc-stream-acodec="aac", OnePointFive
+https://tv.example.com/iptv/channel/1.5.m3u8?mode=segmenter
+#EXTINF:0 tvg-id="C2.146.ersatztv.org" channel-id="AAAAAAAAAAAAAAAAAAAAAg" channel-number="2" CUID="AAAAAAAAAAAAAAAAAAAAAg" tvg-chno="2" tvg-name="Two" tvg-logo="https://tv.example.com/iptv/logos/gen?text=Two" group-title="ErsatzTV" tvc-stream-vcodec="h264" tvc-stream-acodec="aac", Two
+https://tv.example.com/iptv/channel/2.ts
+#EXTINF:0 tvg-id="C10.193.ersatztv.org" channel-id="AAAAAAAAAAAAAAAAAAAAEA" channel-number="10" CUID="AAAAAAAAAAAAAAAAAAAAEA" tvg-chno="10" tvg-name="Ten" tvg-logo="https://tv.example.com/iptv/logos/gen?text=Ten" group-title="ErsatzTV" tvc-stream-vcodec="h264" tvc-stream-acodec="aac", Ten
+https://tv.example.com/iptv/channel/10.m3u8?mode=hls-direct

ErsatzTV.Core.Tests/Iptv/Goldens/simple-generated-logo.m3u

@@ -0,0 +1,3 @@
+#EXTM3U url-tvg="https://tv.example.com/iptv/xmltv.xml" x-tvg-url="https://tv.example.com/iptv/xmltv.xml"
+#EXTINF:0 tvg-id="C1.145.ersatztv.org" channel-id="AAAAAAAAAAAAAAAAAAAAAQ" channel-number="1" CUID="AAAAAAAAAAAAAAAAAAAAAQ" tvg-chno="1" tvg-name="News" tvg-logo="https://tv.example.com/iptv/logos/gen?text=News" group-title="ErsatzTV" tvc-stream-vcodec="h264" tvc-stream-acodec="aac", News
+https://tv.example.com/iptv/channel/1.m3u8?mode=hls-direct

ErsatzTV.Core.Tests/Metadata/FallbackMetadataProviderTests.cs

@@ -1,7 +1,5 @@
-using Bugsnag;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;
-using NSubstitute;
 using NUnit.Framework;
 using Shouldly;
 
@@ -11,7 +9,7 @@ namespace ErsatzTV.Core.Tests.Metadata;
 public class FallbackMetadataProviderTests
 {
     [SetUp]
-    public void SetUp() => _fallbackMetadataProvider = new FallbackMetadataProvider(Substitute.For<IClient>());
+    public void SetUp() => _fallbackMetadataProvider = new FallbackMetadataProvider();
 
     private FallbackMetadataProvider _fallbackMetadataProvider;
 

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerBaseTests.cs

@@ -1,4 +1,4 @@
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.Scheduling;
 using ErsatzTV.Core.Scheduling;
@@ -57,7 +57,13 @@ public class PlayoutModeSchedulerBaseTests : SchedulerTestBase
                     startState,
                     CollectionEnumerators(scheduleItem, enumerator),
                     scheduleItem,
-                    new PlayoutItem(),
+                    // real start time, not default MinValue: the mid-roll Pad math subtracts minutes,
+                    // which underflows DateTimeOffset.MinValue under a non-UTC local offset (#24)
+                    new PlayoutItem
+                    {
+                        Start = startState.CurrentTime.UtcDateTime,
+                        Finish = startState.CurrentTime.UtcDateTime
+                    },
                     new List<MediaChapter>(),
                     new PlayoutBuildWarnings(),
                     _cancellationToken);
@@ -110,7 +116,13 @@ public class PlayoutModeSchedulerBaseTests : SchedulerTestBase
                     startState,
                     enumerators,
                     scheduleItem,
-                    new PlayoutItem(),
+                    // real start time, not default MinValue: the mid-roll Pad math subtracts minutes,
+                    // which underflows DateTimeOffset.MinValue under a non-UTC local offset (#24)
+                    new PlayoutItem
+                    {
+                        Start = startState.CurrentTime.UtcDateTime,
+                        Finish = startState.CurrentTime.UtcDateTime
+                    },
                     new List<MediaChapter> { new() },
                     new PlayoutBuildWarnings(),
                     _cancellationToken);

ErsatzTV.Core.Tests/Scheduling/ScheduleIntegrationTests.cs

@@ -1,4 +1,3 @@
-using Bugsnag;
 using Dapper;
 using Destructurama;
 using ErsatzTV.Core.Domain;
@@ -93,8 +92,6 @@ public class ScheduleIntegrationTests
         services.AddSingleton<ISearchIndex, LuceneSearchIndex>();
         services.AddSingleton<ILanguageCodeCache, LanguageCodeCache>();
 
-        services.AddSingleton(_ => Substitute.For<IClient>());
-
         ServiceProvider provider = services.BuildServiceProvider();
 
         IDbContextFactory<TvContext> factory = provider.GetRequiredService<IDbContextFactory<TvContext>>();
@@ -110,7 +107,6 @@ public class ScheduleIntegrationTests
         await searchIndex.Initialize(
             new LocalFileSystem(
                 new MockFileSystem(),
-                provider.GetRequiredService<IClient>(),
                 provider.GetRequiredService<ILogger<LocalFileSystem>>()),
             provider.GetRequiredService<IConfigElementRepository>(),
             _cancellationToken);
@@ -123,7 +119,7 @@ public class ScheduleIntegrationTests
 
         var builder = new PlayoutBuilder(
             new ConfigElementRepository(factory),
-            new MediaCollectionRepository(Substitute.For<IClient>(), searchIndex, factory),
+            new MediaCollectionRepository(searchIndex, factory),
             new TelevisionRepository(factory, provider.GetRequiredService<ILogger<TelevisionRepository>>()),
             new ArtistRepository(factory),
             Substitute.For<IMultiEpisodeShuffleCollectionEnumeratorFactory>(),
@@ -319,7 +315,7 @@ public class ScheduleIntegrationTests
 
         var builder = new PlayoutBuilder(
             new ConfigElementRepository(factory),
-            new MediaCollectionRepository(Substitute.For<IClient>(), Substitute.For<ISearchIndex>(), factory),
+            new MediaCollectionRepository(Substitute.For<ISearchIndex>(), factory),
             new TelevisionRepository(factory, provider.GetRequiredService<ILogger<TelevisionRepository>>()),
             new ArtistRepository(factory),
             Substitute.For<IMultiEpisodeShuffleCollectionEnumeratorFactory>(),

ErsatzTV.Core/Errors/NotFoundError.cs

@@ -0,0 +1,12 @@
+namespace ErsatzTV.Core.Errors;
+
+/// <summary>
+///     A <see cref="BaseError" /> that indicates the addressed resource does not exist.
+///     REST endpoints map this to HTTP 404; other <see cref="BaseError" /> values map to 422.
+/// </summary>
+public class NotFoundError : BaseError
+{
+    public NotFoundError(string value) : base(value)
+    {
+    }
+}

ErsatzTV.Core/ErsatzTV.Core.csproj

@@ -10,28 +10,27 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Bugsnag" Version="4.1.0" />
-        <PackageReference Include="Destructurama.Attributed" Version="5.2.0" />
-        <PackageReference Include="Flurl" Version="4.0.0" />
-        <PackageReference Include="Humanizer.Core" Version="3.0.1" />
-        <PackageReference Include="LanguageExt.Core" Version="4.4.9" />
-        <PackageReference Include="LanguageExt.Transformers" Version="4.4.8" />
-        <PackageReference Include="MediatR" Version="[12.5.0]" />
-        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.1" />
-        <PackageReference Include="NCalcSync" Version="5.11.0" />
-        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
-        <PackageReference Include="Serilog" Version="4.3.0" />
-        <PackageReference Include="Serilog.Sinks.Console" Version="6.1.1" />
-        <PackageReference Include="SkiaSharp" Version="3.119.1" />
-        <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="3.119.1" />
-        <PackageReference Include="System.CommandLine" Version="2.0.2" />
-        <PackageReference Include="Testably.Abstractions" Version="10.0.0" />
-        <PackageReference Include="TimeSpanParserUtil" Version="1.2.0" />
-        <PackageReference Include="YamlDotNet" Version="16.3.0" />
+        <PackageReference Include="Destructurama.Attributed" />
+        <PackageReference Include="Flurl" />
+        <PackageReference Include="Humanizer.Core" />
+        <PackageReference Include="LanguageExt.Core" />
+        <PackageReference Include="LanguageExt.Transformers" />
+        <PackageReference Include="MediatR" />
+        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" />
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
+        <PackageReference Include="Microsoft.Extensions.Http" />
+        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
+        <PackageReference Include="Microsoft.IO.RecyclableMemoryStream" />
+        <PackageReference Include="NCalcSync" />
+        <PackageReference Include="Newtonsoft.Json" />
+        <PackageReference Include="Serilog" />
+        <PackageReference Include="Serilog.Sinks.Console" />
+        <PackageReference Include="SkiaSharp" />
+        <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" />
+        <PackageReference Include="System.CommandLine" />
+        <PackageReference Include="Testably.Abstractions" />
+        <PackageReference Include="TimeSpanParserUtil" />
+        <PackageReference Include="YamlDotNet" />
     </ItemGroup>
 
     <ItemGroup>

ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics;
-using Bugsnag;
 using CliWrap;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
@@ -12,7 +11,6 @@ namespace ErsatzTV.Core.FFmpeg;
 
 public class FFmpegProcessService
 {
-    private readonly IClient _client;
     private readonly IFFmpegStreamSelector _ffmpegStreamSelector;
     private readonly ILogger<FFmpegProcessService> _logger;
     private readonly ITempFilePool _tempFilePool;
@@ -20,12 +18,10 @@ public class FFmpegProcessService
     public FFmpegProcessService(
         IFFmpegStreamSelector ffmpegStreamSelector,
         ITempFilePool tempFilePool,
-        IClient client,
         ILogger<FFmpegProcessService> logger)
     {
         _ffmpegStreamSelector = ffmpegStreamSelector;
         _tempFilePool = tempFilePool;
-        _client = client;
         _logger = logger;
     }
 
@@ -131,7 +127,6 @@ public class FFmpegProcessService
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "Error generating song image");
-            _client.Notify(ex);
             return Left(BaseError.New(ex.Message));
         }
     }

ErsatzTV.Core/Health/Checks/IErrorReportsHealthCheck.cs

@@ -1,5 +0,0 @@
-namespace ErsatzTV.Core.Health.Checks;
-
-public interface IErrorReportsHealthCheck : IHealthCheck
-{
-}

ErsatzTV.Core/Interfaces/Search/ISearchIndex.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Search;
@@ -38,7 +37,6 @@ public interface ISearchIndex : IDisposable
     Task<bool> RemoveItems(IEnumerable<int> ids);
 
     Task<SearchResult> Search(
-        IClient client,
         string query,
         string smartCollectionName,
         int skip,
@@ -46,7 +44,6 @@ public interface ISearchIndex : IDisposable
         CancellationToken cancellationToken);
 
     Task<SearchResult> Search(
-        IClient client,
         string query,
         string smartCollectionName,
         int skip,

ErsatzTV.Core/Metadata/FallbackMetadataProvider.cs

@@ -1,12 +1,11 @@
 using System.Globalization;
 using System.Text.RegularExpressions;
-using Bugsnag;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 
 namespace ErsatzTV.Core.Metadata;
 
-public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadataProvider
+public partial class FallbackMetadataProvider : IFallbackMetadataProvider
 {
     private static readonly Regex SeasonPattern = SeasonNumber();
 
@@ -203,7 +202,7 @@ public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadat
     [GeneratedRegex(@"s(?:eason)?\s?(\d+)(?![e\d])", RegexOptions.IgnoreCase)]
     private static partial Regex SeasonNumber();
 
-    private List<EpisodeMetadata> GetEpisodeMetadata(string fileName, EpisodeMetadata baseMetadata)
+    private static List<EpisodeMetadata> GetEpisodeMetadata(string fileName, EpisodeMetadata baseMetadata)
     {
         var result = new List<EpisodeMetadata> { baseMetadata };
 
@@ -260,15 +259,15 @@ public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadat
                 }
             }
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            client.Notify(ex);
+            // do nothing
         }
 
         return result;
     }
 
-    private MovieMetadata GetMovieMetadata(string fileName, MovieMetadata metadata)
+    private static MovieMetadata GetMovieMetadata(string fileName, MovieMetadata metadata)
     {
         try
         {
@@ -283,15 +282,15 @@ public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadat
                 metadata.DateUpdated = DateTime.UtcNow;
             }
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            client.Notify(ex);
+            // do nothing
         }
 
         return metadata;
     }
 
-    private Option<MusicVideoMetadata> GetMusicVideoMetadata(string fileName, MusicVideoMetadata metadata)
+    private static Option<MusicVideoMetadata> GetMusicVideoMetadata(string fileName, MusicVideoMetadata metadata)
     {
         try
         {
@@ -310,14 +309,13 @@ public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadat
 
             return metadata;
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            client.Notify(ex);
             return None;
         }
     }
 
-    private Option<OtherVideoMetadata> GetOtherVideoMetadata(string path, OtherVideoMetadata metadata)
+    private static Option<OtherVideoMetadata> GetOtherVideoMetadata(string path, OtherVideoMetadata metadata)
     {
         try
         {
@@ -348,14 +346,13 @@ public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadat
 
             return metadata;
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            client.Notify(ex);
             return None;
         }
     }
 
-    private Option<ImageMetadata> GetImageMetadata(string path, ImageMetadata metadata)
+    private static Option<ImageMetadata> GetImageMetadata(string path, ImageMetadata metadata)
     {
         try
         {
@@ -386,14 +383,13 @@ public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadat
 
             return metadata;
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            client.Notify(ex);
             return None;
         }
     }
 
-    private Option<RemoteStreamMetadata> GetRemoteStreamMetadata(string path, RemoteStreamMetadata metadata)
+    private static Option<RemoteStreamMetadata> GetRemoteStreamMetadata(string path, RemoteStreamMetadata metadata)
     {
         try
         {
@@ -424,14 +420,13 @@ public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadat
 
             return metadata;
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            client.Notify(ex);
             return None;
         }
     }
 
-    private Option<SongMetadata> GetSongMetadata(string path, SongMetadata metadata)
+    private static Option<SongMetadata> GetSongMetadata(string path, SongMetadata metadata)
     {
         try
         {
@@ -462,14 +457,13 @@ public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadat
 
             return metadata;
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            client.Notify(ex);
             return None;
         }
     }
 
-    private ShowMetadata GetTelevisionShowMetadata(string fileName, ShowMetadata metadata)
+    private static ShowMetadata GetTelevisionShowMetadata(string fileName, ShowMetadata metadata)
     {
         try
         {
@@ -484,9 +478,9 @@ public partial class FallbackMetadataProvider(IClient client) : IFallbackMetadat
                 metadata.DateUpdated = DateTime.UtcNow;
             }
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            client.Notify(ex);
+            // do nothing
         }
 
         return metadata;

ErsatzTV.Core/Metadata/LocalFileSystem.cs

@@ -1,13 +1,12 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO.Abstractions;
 using System.Security.Cryptography;
-using Bugsnag;
 using ErsatzTV.Core.Interfaces.Metadata;
 using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Core.Metadata;
 
-public class LocalFileSystem(IFileSystem fileSystem, IClient client, ILogger<LocalFileSystem> logger) : ILocalFileSystem
+public class LocalFileSystem(IFileSystem fileSystem, ILogger<LocalFileSystem> logger) : ILocalFileSystem
 {
     public Unit EnsureFolderExists(string folder)
     {
@@ -50,10 +49,9 @@ public class LocalFileSystem(IFileSystem fileSystem, IClient client, ILogger<Loc
             {
                 logger.LogWarning("Unauthorized access exception listing subdirectories of folder {Folder}", folder);
             }
-            catch (Exception ex)
+            catch (Exception)
             {
                 // do nothing
-                client.Notify(ex);
             }
         }
 
@@ -73,10 +71,9 @@ public class LocalFileSystem(IFileSystem fileSystem, IClient client, ILogger<Loc
             {
                 logger.LogWarning("Unauthorized access exception listing files in folder {Folder}", folder);
             }
-            catch (Exception ex)
+            catch (Exception)
             {
                 // do nothing
-                client.Notify(ex);
             }
         }
 
@@ -96,10 +93,9 @@ public class LocalFileSystem(IFileSystem fileSystem, IClient client, ILogger<Loc
             {
                 logger.LogWarning("Unauthorized access exception listing files in folder {Folder}", folder);
             }
-            catch (Exception ex)
+            catch (Exception)
             {
                 // do nothing
-                client.Notify(ex);
             }
         }
 
@@ -123,10 +119,9 @@ public class LocalFileSystem(IFileSystem fileSystem, IClient client, ILogger<Loc
             {
                 logger.LogWarning("Unauthorized access exception listing files in folder {Folder}", folder);
             }
-            catch (Exception ex)
+            catch (Exception)
             {
                 // do nothing
-                client.Notify(ex);
             }
         }
 
@@ -151,7 +146,6 @@ public class LocalFileSystem(IFileSystem fileSystem, IClient client, ILogger<Loc
         }
         catch (Exception ex)
         {
-            client.Notify(ex);
             return BaseError.New(ex.ToString());
         }
     }

ErsatzTV.FFmpeg.Tests/ErsatzTV.FFmpeg.Tests.csproj

@@ -8,14 +8,14 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.Extensions.DependencyModel" Version="[8.0.2]" />
-        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
-        <PackageReference Include="NSubstitute" Version="5.3.0" />
-        <PackageReference Include="NUnit" Version="4.4.0" />
-        <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
-        <PackageReference Include="Shouldly" Version="4.3.0" />
-        <PackageReference Include="coverlet.collector" Version="6.0.4">
+        <PackageReference Include="Microsoft.Extensions.DependencyModel" />
+        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" />
+        <PackageReference Include="NSubstitute" />
+        <PackageReference Include="NUnit" />
+        <PackageReference Include="NUnit3TestAdapter" />
+        <PackageReference Include="Shouldly" />
+        <PackageReference Include="coverlet.collector">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>

ErsatzTV.FFmpeg/ErsatzTV.FFmpeg.csproj

@@ -11,12 +11,12 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="CliWrap" Version="3.10.0" />
-        <PackageReference Include="Hardware.Info" Version="101.1.1.1" />
-        <PackageReference Include="LanguageExt.Core" Version="4.4.9" />
-        <PackageReference Include="Lennox.NvEncSharp" Version="2.0.0" />
-        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.2" />
+        <PackageReference Include="CliWrap" />
+        <PackageReference Include="Hardware.Info" />
+        <PackageReference Include="LanguageExt.Core" />
+        <PackageReference Include="Lennox.NvEncSharp" />
+        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" />
+        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
     </ItemGroup>
 
 

ErsatzTV.Infrastructure.MySql/ErsatzTV.Infrastructure.MySql.csproj

@@ -16,9 +16,9 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="EFCore.BulkExtensions.MySql" Version="[9.0.2,10)" />
-        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="[9.0.12,10)" />
-        <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="9.0.0" />
+        <PackageReference Include="EFCore.BulkExtensions.MySql" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
+        <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" />
     </ItemGroup>
 
 </Project>

ErsatzTV.Infrastructure.Sqlite/ErsatzTV.Infrastructure.Sqlite.csproj

@@ -12,10 +12,13 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="Dapper" Version="2.1.66" />
-        <PackageReference Include="EFCore.BulkExtensions.Sqlite" Version="[9.0.2,10)" />
-        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="[9.0.12,10)" />
-        <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="[9.0.12,10)" />
+        <PackageReference Include="Dapper" />
+        <PackageReference Include="EFCore.BulkExtensions.Sqlite" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" />
+        <!-- Override EF Core's transitive SQLitePCLRaw 2.1.10 (vulnerable SQLite,
+             GHSA-2m69-gcr7-jv3q) with the patched 3.x bundle. Version is central (#8). -->
+        <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" />
     </ItemGroup>
 
 

ErsatzTV.Infrastructure.Tests/ErsatzTV.Infrastructure.Tests.csproj

@@ -9,20 +9,20 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
-        <PackageReference Include="NSubstitute" Version="5.3.0" />
-        <PackageReference Include="NUnit" Version="4.4.0" />
-        <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
-        <PackageReference Include="NUnit.Analyzers" Version="4.11.2">
+        <PackageReference Include="Microsoft.NET.Test.Sdk" />
+        <PackageReference Include="NSubstitute" />
+        <PackageReference Include="NUnit" />
+        <PackageReference Include="NUnit3TestAdapter" />
+        <PackageReference Include="NUnit.Analyzers">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
         </PackageReference>
-        <PackageReference Include="coverlet.collector" Version="6.0.4">
+        <PackageReference Include="coverlet.collector">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
         </PackageReference>
-        <PackageReference Include="Shouldly" Version="4.3.0" />
-        <PackageReference Include="Testably.Abstractions.Testing" Version="5.1.0" />
+        <PackageReference Include="Shouldly" />
+        <PackageReference Include="Testably.Abstractions.Testing" />
     </ItemGroup>
 
     <ItemGroup>

ErsatzTV.Infrastructure.Tests/Metadata/LocalStatisticsProviderTests.cs

@@ -1,5 +1,4 @@
-using Bugsnag;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.FFmpeg.Capabilities;
@@ -24,7 +23,6 @@ public class LocalStatisticsProviderTests
             Substitute.For<IMetadataRepository>(),
             new MockFileSystem(),
             Substitute.For<ILocalFileSystem>(),
-            Substitute.For<IClient>(),
             Substitute.For<IHardwareCapabilitiesFactory>(),
             Substitute.For<ILogger<LocalStatisticsProvider>>());
 

ErsatzTV.Infrastructure.Tests/Streaming/Graphics/OpacityExpressionHelperTests.cs

@@ -0,0 +1,52 @@
+using ErsatzTV.Infrastructure.Streaming.Graphics;
+using NCalc;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Infrastructure.Tests.Streaming.Graphics;
+
+[TestFixture]
+public class OpacityExpressionHelperTests
+{
+    // Exercises the NCalc custom-function wiring (FunctionEventArgs / FunctionData under NCalc 6.x)
+    // exactly the way the graphics elements do: build an Expression, hook EvaluateFunction, evaluate.
+    private static float Evaluate(string expressionString, TimeSpan timeOfDay)
+    {
+        var expression = new Expression(expressionString);
+        expression.EvaluateFunction += OpacityExpressionHelper.EvaluateFunction;
+        return OpacityExpressionHelper.GetOpacity(
+            expression,
+            timeOfDay,
+            TimeSpan.Zero,
+            TimeSpan.Zero,
+            TimeSpan.Zero);
+    }
+
+    // LinearFadePoints(time, start=0, peakStart=10, peakEnd=20, end=30)
+    [TestCase(5, 0.5)]   // fade in:  (5-0)/(10-0)
+    [TestCase(15, 1.0)]  // solid
+    [TestCase(25, 0.5)]  // fade out: (30-25)/(30-20)
+    [TestCase(35, 0.0)]  // past end
+    public void LinearFadePoints_ReturnsExpectedOpacity(int timeOfDaySeconds, double expected)
+    {
+        float opacity = Evaluate(
+            "LinearFadePoints(time_of_day_seconds, 0, 10, 20, 30)",
+            TimeSpan.FromSeconds(timeOfDaySeconds));
+
+        opacity.ShouldBe((float)expected, 0.0001);
+    }
+
+    // LinearFadeDuration(time, start=0, fadeSeconds=10, peakSeconds=10)
+    // -> peakStart=10, peakEnd=20, end=30 (same curve as the LinearFadePoints case above)
+    [TestCase(5, 0.5)]   // mid fade in
+    [TestCase(15, 1.0)]  // solid
+    [TestCase(25, 0.5)]  // mid fade out
+    public void LinearFadeDuration_ReturnsExpectedOpacity(int timeOfDaySeconds, double expected)
+    {
+        float opacity = Evaluate(
+            "LinearFadeDuration(time_of_day_seconds, 0, 10, 10)",
+            TimeSpan.FromSeconds(timeOfDaySeconds));
+
+        opacity.ShouldBe((float)expected, 0.0001);
+    }
+}

ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics.CodeAnalysis;
-using Bugsnag;
 using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
@@ -14,16 +13,13 @@ namespace ErsatzTV.Infrastructure.Data.Repositories;
 
 public class MediaCollectionRepository : IMediaCollectionRepository
 {
-    private readonly IClient _client;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
     private readonly ISearchIndex _searchIndex;
 
     public MediaCollectionRepository(
-        IClient client,
         ISearchIndex searchIndex,
         IDbContextFactory<TvContext> dbContextFactory)
     {
-        _client = client;
         _searchIndex = searchIndex;
         _dbContextFactory = dbContextFactory;
     }
@@ -463,7 +459,6 @@ public class MediaCollectionRepository : IMediaCollectionRepository
 
         // elasticsearch doesn't like when we ask for a limit of zero, so use 10,000
         SearchResult searchResults = await _searchIndex.Search(
-            _client,
             query,
             smartCollectionName,
             0,

ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj

@@ -12,33 +12,33 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Blurhash.SkiaSharp" Version="2.0.0" />
-        <PackageReference Include="CliWrap" Version="3.10.0" />
-        <PackageReference Include="Dapper" Version="2.1.66" />
-        <PackageReference Include="EFCore.BulkExtensions" Version="[9.0.2,10)" />
-        <PackageReference Include="Elastic.Clients.Elasticsearch" Version="9.3.0" />
-        <PackageReference Include="Humanizer.Core" Version="3.0.1" />
-        <PackageReference Include="Jint" Version="4.5.0" />
-        <PackageReference Include="JsonSchema.Net" Version="9.0.0" />
-        <PackageReference Include="Lucene.Net" Version="4.8.0-beta00017" />
-        <PackageReference Include="Lucene.Net.Analysis.Common" Version="4.8.0-beta00017" />
-        <PackageReference Include="Lucene.Net.QueryParser" Version="4.8.0-beta00017" />
-        <PackageReference Include="Microsoft.EntityFrameworkCore" Version="[9.0.12,10)" />
-        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="[9.0.12,10)">
+        <PackageReference Include="Blurhash.SkiaSharp" />
+        <PackageReference Include="CliWrap" />
+        <PackageReference Include="Dapper" />
+        <PackageReference Include="EFCore.BulkExtensions" />
+        <PackageReference Include="Elastic.Clients.Elasticsearch" />
+        <PackageReference Include="Humanizer.Core" />
+        <PackageReference Include="Jint" />
+        <PackageReference Include="JsonSchema.Net" />
+        <PackageReference Include="Lucene.Net" />
+        <PackageReference Include="Lucene.Net.Analysis.Common" />
+        <PackageReference Include="Lucene.Net.QueryParser" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Design">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
-        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="[9.0.12,10)" />
-        <PackageReference Include="Newtonsoft.Json.Schema" Version="4.0.1" />
-        <PackageReference Include="Refit" Version="9.0.2" />
-        <PackageReference Include="Refit.Newtonsoft.Json" Version="9.0.2" />
-        <PackageReference Include="Refit.Xml" Version="9.0.2" />
-        <PackageReference Include="RichTextKit.Stbear" Version="0.4.167.3" />
-        <PackageReference Include="Scriban.Signed" Version="6.5.2" />
-        <PackageReference Include="SixLabors.ImageSharp" Version="3.1.12" />
-        <PackageReference Include="SkiaSharp" Version="3.119.1" />
-        <PackageReference Include="TagLibSharp" Version="2.3.0" />
-        <PackageReference Include="TimeZoneConverter" Version="7.2.0" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
+        <PackageReference Include="Newtonsoft.Json.Schema" />
+        <PackageReference Include="Refit" />
+        <PackageReference Include="Refit.Newtonsoft.Json" />
+        <PackageReference Include="Refit.Xml" />
+        <PackageReference Include="RichTextKit.Stbear" />
+        <PackageReference Include="Scriban.Signed" />
+        <PackageReference Include="SixLabors.ImageSharp" />
+        <PackageReference Include="SkiaSharp" />
+        <PackageReference Include="TagLibSharp" />
+        <PackageReference Include="TimeZoneConverter" />
     </ItemGroup>
 
     <ItemGroup>

ErsatzTV.Infrastructure/Health/Checks/ErrorReportsHealthCheck.cs

@@ -1,33 +0,0 @@
-using ErsatzTV.Core.Errors;
-using ErsatzTV.Core.Health;
-using ErsatzTV.Core.Health.Checks;
-using Microsoft.Extensions.Options;
-
-namespace ErsatzTV.Infrastructure.Health.Checks;
-
-public class ErrorReportsHealthCheck : BaseHealthCheck, IErrorReportsHealthCheck
-{
-    private readonly IOptions<BugsnagConfiguration> _bugsnagConfiguration;
-
-    public ErrorReportsHealthCheck(IOptions<BugsnagConfiguration> bugsnagConfiguration) =>
-        _bugsnagConfiguration = bugsnagConfiguration;
-
-    public override string Title => "Error Reports";
-
-    public Task<HealthCheckResult> Check(CancellationToken cancellationToken)
-    {
-        if (_bugsnagConfiguration.Value.Enable)
-        {
-            return Result(
-                    HealthCheckStatus.Pass,
-                    "Automated error reporting is enabled, thank you! To disable, edit the file appsettings.json or set the Bugsnag:Enable environment variable to false",
-                    "Automated error reporting is enabled, thank you!")
-                .AsTask();
-        }
-
-        return InfoResult(
-                "Automated error reporting is disabled. Please enable to support bug fixing efforts!",
-                "Automated error reporting is disabled")
-            .AsTask();
-    }
-}

ErsatzTV.Infrastructure/Health/HealthCheckService.cs

@@ -27,7 +27,6 @@ public class HealthCheckService : IHealthCheckService
         IFileNotFoundHealthCheck fileNotFoundHealthCheck,
         IUnavailableHealthCheck unavailableHealthCheck,
         IVaapiDriverHealthCheck vaapiDriverHealthCheck,
-        IErrorReportsHealthCheck errorReportsHealthCheck,
         IUnifiedDockerHealthCheck unifiedDockerHealthCheck,
         IDowngradeHealthCheck downgradeHealthCheck,
         IEmptyScheduleHealthCheck emptyScheduleHealthCheck,
@@ -53,8 +52,7 @@ public class HealthCheckService : IHealthCheckService
             fileNotFoundHealthCheck,
             unavailableHealthCheck,
             emptyScheduleHealthCheck,
-            vaapiDriverHealthCheck,
-            errorReportsHealthCheck
+            vaapiDriverHealthCheck
         ];
     }
 

ErsatzTV.Infrastructure/Metadata/LocalStatisticsProvider.cs

@@ -4,7 +4,6 @@ using System.Globalization;
 using System.IO.Abstractions;
 using System.Text;
 using System.Text.RegularExpressions;
-using Bugsnag;
 using CliWrap;
 using CliWrap.Buffered;
 using ErsatzTV.Core;
@@ -21,7 +20,6 @@ namespace ErsatzTV.Infrastructure.Metadata;
 
 public partial class LocalStatisticsProvider : ILocalStatisticsProvider
 {
-    private readonly IClient _client;
     private readonly IHardwareCapabilitiesFactory _hardwareCapabilitiesFactory;
     private readonly ILocalFileSystem _localFileSystem;
     private readonly ILogger<LocalStatisticsProvider> _logger;
@@ -32,14 +30,12 @@ public partial class LocalStatisticsProvider : ILocalStatisticsProvider
         IMetadataRepository metadataRepository,
         IFileSystem fileSystem,
         ILocalFileSystem localFileSystem,
-        IClient client,
         IHardwareCapabilitiesFactory hardwareCapabilitiesFactory,
         ILogger<LocalStatisticsProvider> logger)
     {
         _metadataRepository = metadataRepository;
         _fileSystem = fileSystem;
         _localFileSystem = localFileSystem;
-        _client = client;
         _hardwareCapabilitiesFactory = hardwareCapabilitiesFactory;
         _logger = logger;
     }
@@ -71,7 +67,6 @@ public partial class LocalStatisticsProvider : ILocalStatisticsProvider
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "Failed to refresh statistics for media item {Id}", mediaItem.Id);
-            _client.Notify(ex);
             return BaseError.New(ex.Message);
         }
     }
@@ -130,7 +125,6 @@ public partial class LocalStatisticsProvider : ILocalStatisticsProvider
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "Failed to get format tags for media item {Id}", mediaItem.Id);
-            _client.Notify(ex);
             return BaseError.New(ex.Message);
         }
     }
@@ -225,7 +219,6 @@ public partial class LocalStatisticsProvider : ILocalStatisticsProvider
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "Failed to refresh statistics for media item {Id}", mediaItem.Id);
-            _client.Notify(ex);
             return BaseError.New(ex.Message);
         }
     }
@@ -466,9 +459,8 @@ public partial class LocalStatisticsProvider : ILocalStatisticsProvider
                 _logger.LogError("Duration analysis failed for media item at {Path}", path);
             }
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            _client.Notify(ex);
             _logger.LogError("Duration analysis failed for media item at {Path}", path);
         }
     }

ErsatzTV.Infrastructure/Search/ElasticSearchIndex.cs

@@ -1,5 +1,4 @@
 using System.Globalization;
-using Bugsnag;
 using Elastic.Clients.Elasticsearch.Aggregations;
 using Elastic.Clients.Elasticsearch.Core.Bulk;
 using Elastic.Clients.Elasticsearch.IndexManagement;
@@ -168,13 +167,11 @@ public class ElasticSearchIndex : ISearchIndex
     }
 
     public Task<SearchResult> Search(
-        IClient client,
         string query,
         string smartCollectionName,
         int skip,
         int limit,
         CancellationToken cancellationToken) => Search(
-        client,
         query,
         smartCollectionName,
         skip,
@@ -183,7 +180,6 @@ public class ElasticSearchIndex : ISearchIndex
         cancellationToken);
 
     public async Task<SearchResult> Search(
-        IClient client,
         string query,
         string smartCollectionName,
         int skip,

ErsatzTV.Infrastructure/Search/LuceneSearchIndex.cs

@@ -1,5 +1,4 @@
 using System.Globalization;
-using Bugsnag;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
@@ -212,13 +211,11 @@ public sealed class LuceneSearchIndex : ISearchIndex
 
     // default to title field only
     public Task<SearchResult> Search(
-        IClient client,
         string query,
         string smartCollectionName,
         int skip,
         int limit,
         CancellationToken cancellationToken) => Search(
-        client,
         query,
         smartCollectionName,
         skip,
@@ -227,7 +224,6 @@ public sealed class LuceneSearchIndex : ISearchIndex
         cancellationToken);
 
     public async Task<SearchResult> Search(
-        IClient client,
         string query,
         string smartCollectionName,
         int skip,
@@ -235,15 +231,6 @@ public sealed class LuceneSearchIndex : ISearchIndex
         List<string> defaultFields,
         CancellationToken cancellationToken)
     {
-        var metadata = new Dictionary<string, string>
-        {
-            { "searchQuery", query },
-            { "skip", skip.ToString(CultureInfo.InvariantCulture) },
-            { "limit", limit.ToString(CultureInfo.InvariantCulture) }
-        };
-
-        client?.Breadcrumbs?.Leave("SearchIndex.Search", BreadcrumbType.State, metadata);
-
         query ??= string.Empty;
 
         if (string.IsNullOrWhiteSpace(query.Replace("*", string.Empty).Replace("?", string.Empty)) ||

ErsatzTV.Infrastructure/Streaming/Graphics/OpacityExpressionHelper.cs

@@ -6,37 +6,37 @@ namespace ErsatzTV.Infrastructure.Streaming.Graphics;
 
 public static class OpacityExpressionHelper
 {
-    public static void EvaluateFunction(string name, FunctionArgs args)
+    public static void EvaluateFunction(string name, FunctionEventArgs args)
     {
         switch (name)
         {
             case "LinearFadePoints":
             {
-                if (args.Parameters.Length != 5)
+                if (args.Parameters.Count != 5)
                 {
                     throw new ArgumentException("LinearFadePoints() requires 5 arguments.");
                 }
 
-                var time = Convert.ToDouble(args.Parameters[0].Evaluate(), CultureInfo.CurrentCulture);
-                var start = Convert.ToDouble(args.Parameters[1].Evaluate(), CultureInfo.CurrentCulture);
-                var peakStart = Convert.ToDouble(args.Parameters[2].Evaluate(), CultureInfo.CurrentCulture);
-                var peakEnd = Convert.ToDouble(args.Parameters[3].Evaluate(), CultureInfo.CurrentCulture);
-                var end = Convert.ToDouble(args.Parameters[4].Evaluate(), CultureInfo.CurrentCulture);
+                var time = Convert.ToDouble(args.Parameters.Evaluate(0), CultureInfo.CurrentCulture);
+                var start = Convert.ToDouble(args.Parameters.Evaluate(1), CultureInfo.CurrentCulture);
+                var peakStart = Convert.ToDouble(args.Parameters.Evaluate(2), CultureInfo.CurrentCulture);
+                var peakEnd = Convert.ToDouble(args.Parameters.Evaluate(3), CultureInfo.CurrentCulture);
+                var end = Convert.ToDouble(args.Parameters.Evaluate(4), CultureInfo.CurrentCulture);
 
                 args.Result = LinearFadePoints(time, start, peakStart, peakEnd, end);
                 break;
             }
             case "LinearFadeDuration":
             {
-                if (args.Parameters.Length != 4)
+                if (args.Parameters.Count != 4)
                 {
                     throw new ArgumentException("LinearFadeDuration() requires 4 arguments.");
                 }
 
-                var time = Convert.ToDouble(args.Parameters[0].Evaluate(), CultureInfo.CurrentCulture);
-                var start = Convert.ToDouble(args.Parameters[1].Evaluate(), CultureInfo.CurrentCulture);
-                var fadeSeconds = Convert.ToDouble(args.Parameters[2].Evaluate(), CultureInfo.CurrentCulture);
-                var peakSeconds = Convert.ToDouble(args.Parameters[3].Evaluate(), CultureInfo.CurrentCulture);
+                var time = Convert.ToDouble(args.Parameters.Evaluate(0), CultureInfo.CurrentCulture);
+                var start = Convert.ToDouble(args.Parameters.Evaluate(1), CultureInfo.CurrentCulture);
+                var fadeSeconds = Convert.ToDouble(args.Parameters.Evaluate(2), CultureInfo.CurrentCulture);
+                var peakSeconds = Convert.ToDouble(args.Parameters.Evaluate(3), CultureInfo.CurrentCulture);
 
                 args.Result = LinearFadeDuration(time, start, fadeSeconds, peakSeconds);
                 break;

ErsatzTV.Scanner.Tests/Core/FFmpeg/TranscodingTests.cs

@@ -2,7 +2,6 @@
 using System.Diagnostics;
 using System.Security.Cryptography;
 using System.Text;
-using Bugsnag;
 using CliWrap;
 using CliWrap.Buffered;
 using ErsatzTV.Core;
@@ -246,7 +245,6 @@ public class TranscodingTests
     {
         var localFileSystem = new LocalFileSystem(
             new RealFileSystem(),
-            Substitute.For<IClient>(),
             LoggerFactory.CreateLogger<LocalFileSystem>());
         var fileSystem = new MockFileSystem();
         var tempFilePool = new TempFilePool();
@@ -276,7 +274,6 @@ public class TranscodingTests
         var oldService = new FFmpegProcessService(
             new FakeStreamSelector(),
             tempFilePool,
-            Substitute.For<IClient>(),
             LoggerFactory.CreateLogger<FFmpegProcessService>());
 
         var service = new FFmpegLibraryProcessService(
@@ -368,7 +365,6 @@ public class TranscodingTests
             metadataRepository,
             fileSystem,
             localFileSystem,
-            Substitute.For<IClient>(),
             Substitute.For<IHardwareCapabilitiesFactory>(),
             LoggerFactory.CreateLogger<LocalStatisticsProvider>());
 
@@ -484,7 +480,6 @@ public class TranscodingTests
 
         var localFileSystem = new LocalFileSystem(
             new MockFileSystem(),
-            Substitute.For<IClient>(),
             LoggerFactory.CreateLogger<LocalFileSystem>());
         var fileSystem = new MockFileSystem();
 
@@ -533,7 +528,6 @@ public class TranscodingTests
             metadataRepository,
             fileSystem,
             localFileSystem,
-            Substitute.For<IClient>(),
             Substitute.For<IHardwareCapabilitiesFactory>(),
             LoggerFactory.CreateLogger<LocalStatisticsProvider>());
 
@@ -1007,7 +1001,6 @@ public class TranscodingTests
         var oldService = new FFmpegProcessService(
             new FakeStreamSelector(),
             Substitute.For<ITempFilePool>(),
-            Substitute.For<IClient>(),
             LoggerFactory.CreateLogger<FFmpegProcessService>());
 
         var service = new FFmpegLibraryProcessService(

ErsatzTV.Scanner.Tests/Core/Metadata/LocalSubtitlesProviderTests.cs

@@ -1,5 +1,4 @@
 using System.Globalization;
-using Bugsnag;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
@@ -61,7 +60,7 @@ public class LocalSubtitlesProviderTests
             Substitute.For<IMediaItemRepository>(),
             Substitute.For<IMetadataRepository>(),
             fileSystem,
-            new LocalFileSystem(fileSystem, Substitute.For<IClient>(), Substitute.For<ILogger<LocalFileSystem>>()),
+            new LocalFileSystem(fileSystem, Substitute.For<ILogger<LocalFileSystem>>()),
             Substitute.For<ILogger<LocalSubtitlesProvider>>());
 
         List<Subtitle> result = provider.LocateExternalSubtitles(
@@ -115,7 +114,7 @@ public class LocalSubtitlesProviderTests
             Substitute.For<IMediaItemRepository>(),
             Substitute.For<IMetadataRepository>(),
             fileSystem,
-            new LocalFileSystem(fileSystem, Substitute.For<IClient>(), Substitute.For<ILogger<LocalFileSystem>>()),
+            new LocalFileSystem(fileSystem, Substitute.For<ILogger<LocalFileSystem>>()),
             Substitute.For<ILogger<LocalSubtitlesProvider>>());
 
         List<Subtitle> result = provider.LocateExternalSubtitles(

ErsatzTV.Scanner.Tests/Core/Metadata/MovieFolderScannerTests.cs

@@ -1,5 +1,4 @@
 using System.Runtime.InteropServices;
-using Bugsnag;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
@@ -1032,7 +1031,7 @@ public class MovieFolderScannerTests
             return new MovieFolderScanner(
                 _scannerProxy,
                 fileSystem,
-                new LocalFileSystem(fileSystem, Substitute.For<IClient>(), Substitute.For<ILogger<LocalFileSystem>>()),
+                new LocalFileSystem(fileSystem, Substitute.For<ILogger<LocalFileSystem>>()),
                 _movieRepository,
                 _localStatisticsProvider,
                 Substitute.For<ILocalSubtitlesProvider>(),
@@ -1044,7 +1043,6 @@ public class MovieFolderScannerTests
                 _mediaItemRepository,
                 Substitute.For<IFFmpegPngService>(),
                 Substitute.For<ITempFilePool>(),
-                Substitute.For<IClient>(),
                 Logger);
         }
 
@@ -1060,7 +1058,7 @@ public class MovieFolderScannerTests
             return new MovieFolderScanner(
                 _scannerProxy,
                 fileSystem,
-                new LocalFileSystem(fileSystem, Substitute.For<IClient>(), Substitute.For<ILogger<LocalFileSystem>>()),
+                new LocalFileSystem(fileSystem, Substitute.For<ILogger<LocalFileSystem>>()),
                 _movieRepository,
                 _localStatisticsProvider,
                 Substitute.For<ILocalSubtitlesProvider>(),
@@ -1072,7 +1070,6 @@ public class MovieFolderScannerTests
                 _mediaItemRepository,
                 Substitute.For<IFFmpegPngService>(),
                 Substitute.For<ITempFilePool>(),
-                Substitute.For<IClient>(),
                 Logger);
         }
     }

ErsatzTV.Scanner.Tests/Core/Metadata/Nfo/ArtistNfoReaderTests.cs

@@ -1,10 +1,8 @@
 using System.Text;
-using Bugsnag;
 using ErsatzTV.Core;
 using ErsatzTV.Scanner.Core.Metadata.Nfo;
 using Microsoft.Extensions.Logging;
 using Microsoft.IO;
-using NSubstitute;
 using NUnit.Framework;
 using Serilog;
 using Shouldly;
@@ -17,7 +15,6 @@ public class ArtistNfoReaderTests
     [SetUp]
     public void SetUp() => _artistNfoReader = new ArtistNfoReader(
         new RecyclableMemoryStreamManager(),
-        Substitute.For<IClient>(),
         _logger);
 
     private readonly ILogger<ArtistNfoReader> _logger;

ErsatzTV.Scanner.Tests/Core/Metadata/Nfo/EpisodeNfoReaderTests.cs

@@ -1,10 +1,8 @@
 using System.Text;
-using Bugsnag;
 using ErsatzTV.Core;
 using ErsatzTV.Scanner.Core.Metadata.Nfo;
 using Microsoft.Extensions.Logging;
 using Microsoft.IO;
-using NSubstitute;
 using NUnit.Framework;
 using Serilog;
 using Shouldly;
@@ -17,7 +15,6 @@ public class EpisodeNfoReaderTests
     [SetUp]
     public void SetUp() => _episodeNfoReader = new EpisodeNfoReader(
         new RecyclableMemoryStreamManager(),
-        Substitute.For<IClient>(),
         _logger);
 
     private readonly ILogger<EpisodeNfoReader> _logger;

ErsatzTV.Scanner.Tests/Core/Metadata/Nfo/MovieNfoReaderTests.cs

@@ -1,10 +1,8 @@
 using System.Text;
-using Bugsnag;
 using ErsatzTV.Core;
 using ErsatzTV.Scanner.Core.Metadata.Nfo;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.IO;
-using NSubstitute;
 using NUnit.Framework;
 using Shouldly;
 
@@ -16,7 +14,6 @@ public class MovieNfoReaderTests
     [SetUp]
     public void SetUp() => _movieNfoReader = new MovieNfoReader(
         new RecyclableMemoryStreamManager(),
-        Substitute.For<IClient>(),
         new NullLogger<MovieNfoReader>());
 
     private MovieNfoReader _movieNfoReader;

ErsatzTV.Scanner.Tests/Core/Metadata/Nfo/MusicVideoNfoReaderTests.cs

@@ -1,10 +1,8 @@
 using System.Text;
-using Bugsnag;
 using ErsatzTV.Core;
 using ErsatzTV.Scanner.Core.Metadata.Nfo;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.IO;
-using NSubstitute;
 using NUnit.Framework;
 using Shouldly;
 
@@ -16,7 +14,6 @@ public class MusicVideoNfoReaderTests
     [SetUp]
     public void SetUp() => _musicVideoNfoReader = new MusicVideoNfoReader(
         new RecyclableMemoryStreamManager(),
-        Substitute.For<IClient>(),
         new NullLogger<MusicVideoNfoReader>());
 
     private MusicVideoNfoReader _musicVideoNfoReader;