test(#289 ): pin BoundedLineReader cap/CRLF boundaries + document per-segment path assumption

Non-blocking polish from the fix-commit re-review (verdict MERGEABLE): - BuildPath: comment the assumption that each {param} is its own path segment (revalidate the whole path if a template ever concatenates adjacent params). - Two additive BoundedLineReader tests: exactly-at-cap line returned intact (inclusive max), and \r\n carriage-return stripping. No logic change. 36 tests (was 34). Refs #289 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
security(#289 ): review fixes — body-read timeout, transport-error response, bounded stdin, env clamps
2026-07-12 01:24:35 +02:00 · 2026-07-12 01:20:10 +02:00 · 2026-07-12 01:08:07 +02:00 · 2026-07-07 11:58:29 +02:00 · 2026-07-07 11:44:44 +02:00 · 2026-07-07 11:39:02 +02:00
491 changed files with 85209 additions and 1038 deletions
@@ -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
@@ -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."
@@ -50,6 +50,37 @@ jobs:
      - name: Restore
        run: dotnet restore

+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22.x'
+          cache: npm
+          cache-dependency-path: web/package-lock.json
+
+      - name: Install SPA dependencies
+        working-directory: web
+        run: npm ci
+
+      - name: Check generated SPA API client
+        working-directory: web
+        run: npm run check:api
+
+      - name: Lint SPA
+        working-directory: web
+        run: npm run lint
+
+      - name: Typecheck SPA
+        working-directory: web
+        run: npm run typecheck
+
+      - name: Test SPA
+        working-directory: web
+        run: npm test -- --run
+
+      - name: Build SPA
+        working-directory: web
+        run: npm run build
+
      - name: Strip Scanner project ref (matches Docker build)
        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj

@@ -59,10 +90,79 @@ jobs:
      - 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
+    needs: [test, migrations]
    if: github.event_name != 'pull_request'
    steps:
      - name: Checkout
@@ -122,7 +222,7 @@ jobs:
          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 test (HTTP readiness)
+      - 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 }}"
@@ -154,11 +254,29 @@ jobs:
            fi
            sleep 2
          done
-          echo "===== container logs (tail) ====="
-          docker logs "$NAME" 2>&1 | tail -n 40 || true
-          echo "================================="
          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 "Smoke test passed: ErsatzTV served HTTP on :8409"
+          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" && check "/app/" "ChicoryTV"; then
+            echo "Smoke + IPTV E2E passed: channels.m3u + xmltv.xml serve a valid playlist + guide; /app/ serves the ChicoryTV SPA"
+          else
+            echo "===== container logs (tail) ====="; docker logs "$NAME" 2>&1 | tail -n 40 || true
+            exit 1
+          fi
@@ -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
@@ -3,9 +3,13 @@
 project.lock.json
 .DS_Store
 *.pyc
+.worktrees/

 # Claude Code
 .mcp/
+.mcp.json
+.agents/
+plugins/
 nupkg/

 # Visual Studio Code
@@ -48,3 +52,6 @@ scripts/download-test-content.sh
 docker-compose.override.yml

 ErsatzTV/wwwroot/v2/
+ErsatzTV/wwwroot/app/
+web/dist/
+web/node_modules/
@@ -1,56 +0,0 @@
-{
-  "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"
-      }
-    }
-  }
-}
@@ -0,0 +1,15 @@
+# Codex Instructions
+
+## Verification Commands
+
+Run .NET restore, build, and test commands outside the sandbox by default in this repo. Sandboxed .NET commands can stall on NuGet/package/compiler cache access, while the same commands complete normally with approved unsandboxed execution.
+
+Preferred verification commands:
+
+```bash
+TZ=UTC dotnet restore ErsatzTV.sln -v minimal
+TZ=UTC dotnet build ErsatzTV.sln --no-restore -v minimal
+TZ=UTC dotnet test ErsatzTV.sln --no-build -v minimal
+```
+
+Use scoped escalated execution for these commands rather than first trying a sandboxed run.
@@ -4,7 +4,8 @@ Custom IPTV channel server for Jellyfin. Forked from [ErsatzTV/ErsatzTV](https:/

 ## Architecture

- **Language**: C# / .NET 10, Blazor Server UI (MudBlazor)
+- **Language**: C# / .NET 10
+- **UI**: ChicoryTV React SPA (`web/`, Vite, served at `/app`) over the REST API — the default UI; root `/` and migrated legacy routes 302 there (`ErsatzTV/LegacyUiRedirects.cs`). The legacy Blazor Server UI (MudBlazor) still serves un-migrated admin screens (collections, media browse, trakt, filler, watermarks, ffmpeg profiles, blocks/decos/templates, playout editors, logs, troubleshooting; Blazor home = `/system/health`); its removal is #91 phase (b), gated on parity issues #140–#147
 - **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
@@ -14,7 +15,8 @@ Custom IPTV channel server for Jellyfin. Forked from [ErsatzTV/ErsatzTV](https:/

 | Project | Role |
 |---------|------|
-| `ErsatzTV/` | ASP.NET Core host, Blazor pages, API controllers, DI setup |
+| `ErsatzTV/` | ASP.NET Core host, API controllers, SPA static hosting, legacy Blazor pages, DI setup |
+| `web/` | ChicoryTV React SPA (Vite + TypeScript; builds into `ErsatzTV/wwwroot/app`) |
 | `ErsatzTV.Application/` | MediatR handlers (business logic) |
 | `ErsatzTV.Core/` | Domain entities, interfaces, no infrastructure deps |
 | `ErsatzTV.Infrastructure/` | EF Core repos, data access |
@@ -36,7 +38,7 @@ Custom IPTV channel server for Jellyfin. Forked from [ErsatzTV/ErsatzTV](https:/
 - **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`.
+- **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 deploys via **Komodo GitOps**: the `media-servers` compose in `timothy/server-management` (`docker/bumblebee/stacks/media-servers/compose.yaml`) pins the version tag (currently `26.5.0`, deployed 2026-07-07); releasing = tag here, wait for the image build, bump that pin and push (the Komodo pre-deploy hook backs up before recreating). Test container tracks `:latest`. Pipeline details: `docs/ci-cd.md`.

 ## Development

@@ -53,10 +55,14 @@ 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 xUnit (existing test projects)
+- Keep UI thin: the SPA talks to `/api/*` only; legacy Blazor pages delegate to MediatR handlers. New screens go in the SPA (`web/`), never in Blazor
+- 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)

@@ -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>
@@ -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="7.2.5" />
+    <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>
@@ -0,0 +1,13 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artworks;
+
+/// <summary>
+///     Validates and stores an uploaded image as channel logo or watermark artwork,
+///     landing it in the same on-disk cache the Blazor UI uses (via <c>IImageCache</c>),
+///     so the returned path is equivalent to a Blazor-uploaded image.
+/// </summary>
+public record UploadArtwork(Stream Stream, string ContentType, ArtworkKind ArtworkKind)
+    : IRequest<Either<BaseError, ArtworkUploadResponseModel>>;
@@ -0,0 +1,53 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Images;
+
+namespace ErsatzTV.Application.Artworks;
+
+public class UploadArtworkHandler : IRequestHandler<UploadArtwork, Either<BaseError, ArtworkUploadResponseModel>>
+{
+    // png/jpeg/gif/webp are all decoded by SkiaSharp and read by FFmpeg, matching the
+    // formats the Blazor logo/watermark upload already accepts. Format expansion is ersatztv#66.
+    private static readonly System.Collections.Generic.HashSet<string> AcceptedContentTypes = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "image/png",
+        "image/jpeg",
+        "image/gif",
+        "image/webp"
+    };
+
+    private readonly IImageCache _imageCache;
+
+    public UploadArtworkHandler(IImageCache imageCache) => _imageCache = imageCache;
+
+    public async Task<Either<BaseError, ArtworkUploadResponseModel>> Handle(
+        UploadArtwork request,
+        CancellationToken cancellationToken)
+    {
+        string contentType = (request.ContentType ?? string.Empty).Trim();
+        if (!AcceptedContentTypes.Contains(contentType))
+        {
+            return BaseError.New(
+                $"Unsupported image content type '{contentType}'; supported types are: {string.Join(", ", AcceptedContentTypes)}");
+        }
+
+        Either<BaseError, string> maybeFileName = await _imageCache.SaveArtworkToCache(
+            request.Stream,
+            request.ArtworkKind);
+
+        return maybeFileName.Map(fileName => new ArtworkUploadResponseModel(
+            BuildPath(request.ArtworkKind, fileName),
+            contentType));
+    }
+
+    // Mirror the on-disk conventions the Blazor editors use so the returned path is a drop-in
+    // for ArtworkContentTypeModel.Path: channel logos are addressed as "iptv/logos/{file}"
+    // (see ChannelEditor.UploadLogo), watermarks by the bare cache file name (see WatermarkEditor).
+    private static string BuildPath(ArtworkKind artworkKind, string fileName) =>
+        artworkKind switch
+        {
+            ArtworkKind.Logo => $"iptv/logos/{fileName}",
+            _ => fileName
+        };
+}
@@ -0,0 +1,24 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+internal static class ChannelTemplateDefault
+{
+    public static async Task<int?> GetDefaultTemplateId(
+        IConfigElementRepository configElementRepository,
+        CancellationToken cancellationToken)
+    {
+        Option<int> maybeDefault =
+            await configElementRepository.GetValue<int>(
+                ConfigElementKey.ChannelTemplatesDefaultTemplateId,
+                cancellationToken);
+        int? result = null;
+        foreach (int id in maybeDefault)
+        {
+            result = id;
+        }
+
+        return result;
+    }
+}
@@ -0,0 +1,38 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public static class ChannelTemplateMapper
+{
+    public static ChannelTemplateResponseModel ProjectToResponseModel(ChannelTemplate template, int? defaultTemplateId) =>
+        new(
+            template.Id,
+            template.Name,
+            template.Description,
+            template.IsSystem,
+            defaultTemplateId == template.Id,
+            template.FFmpegProfileId,
+            template.WatermarkId,
+            template.FallbackFillerId,
+            template.PreRollFillerId,
+            template.MidRollFillerId,
+            template.PostRollFillerId,
+            template.StreamSelectorMode,
+            template.StreamSelector,
+            template.PreferredAudioLanguageCode,
+            template.PreferredAudioTitle,
+            template.PlayoutSource,
+            template.PlayoutMode,
+            template.StreamingMode,
+            template.PreferredSubtitleLanguageCode,
+            template.SubtitleMode,
+            template.MusicVideoCreditsMode,
+            template.MusicVideoCreditsTemplate,
+            template.SongVideoMode,
+            template.TranscodeMode,
+            template.IdleBehavior,
+            template.ShuffleScheduleItems,
+            template.RandomStartPoint,
+            template.FixedStartTimeBehavior);
+}
@@ -0,0 +1,155 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Scheduling;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public abstract record ChannelTemplateCommandBase(
+    string Name,
+    string Description,
+    int FFmpegProfileId,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    int? PreRollFillerId,
+    int? MidRollFillerId,
+    int? PostRollFillerId,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
+    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
+    ChannelPlayoutSource PlayoutSource,
+    ChannelPlayoutMode PlayoutMode,
+    StreamingMode StreamingMode,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelTranscodeMode TranscodeMode,
+    ChannelIdleBehavior IdleBehavior,
+    bool ShuffleScheduleItems,
+    bool RandomStartPoint,
+    FixedStartTimeBehavior FixedStartTimeBehavior)
+{
+    internal static async Task<Option<BaseError>> ValidateCommon(
+        TvContext dbContext,
+        ChannelTemplateCommandBase request,
+        int? existingTemplateId,
+        CancellationToken cancellationToken)
+    {
+        string name = NormalizeName(request.Name);
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            return BaseError.New("Name is required.");
+        }
+
+        if (name.Length > 50)
+        {
+            return BaseError.New("Name must be 50 characters or less.");
+        }
+
+        if (request.Description?.Length > 500)
+        {
+            return BaseError.New("Description must be 500 characters or less.");
+        }
+
+        bool duplicateName = await dbContext.ChannelTemplates
+            .AnyAsync(t => t.Id != existingTemplateId && t.Name == name, cancellationToken);
+        if (duplicateName)
+        {
+            return BaseError.New("Channel template name must be unique.");
+        }
+
+        bool ffmpegProfileExists = await dbContext.FFmpegProfiles
+            .AnyAsync(p => p.Id == request.FFmpegProfileId, cancellationToken);
+        if (!ffmpegProfileExists)
+        {
+            return new NotFoundError($"FFmpegProfile {request.FFmpegProfileId} does not exist.");
+        }
+
+        foreach (int watermarkId in Optional(request.WatermarkId))
+        {
+            bool watermarkExists = await dbContext.ChannelWatermarks
+                .AnyAsync(w => w.Id == watermarkId, cancellationToken);
+            if (!watermarkExists)
+            {
+                return new NotFoundError($"Watermark {watermarkId} does not exist.");
+            }
+        }
+
+        Option<BaseError> maybeFillerError =
+            await FillerMustExist(dbContext, request.FallbackFillerId, FillerKind.Fallback, cancellationToken);
+        if (maybeFillerError.IsSome)
+        {
+            return maybeFillerError;
+        }
+
+        maybeFillerError = await FillerMustExist(dbContext, request.PreRollFillerId, FillerKind.PreRoll, cancellationToken);
+        if (maybeFillerError.IsSome)
+        {
+            return maybeFillerError;
+        }
+
+        maybeFillerError = await FillerMustExist(dbContext, request.MidRollFillerId, FillerKind.MidRoll, cancellationToken);
+        if (maybeFillerError.IsSome)
+        {
+            return maybeFillerError;
+        }
+
+        return await FillerMustExist(dbContext, request.PostRollFillerId, FillerKind.PostRoll, cancellationToken);
+    }
+
+    internal void ApplyTo(ChannelTemplate template)
+    {
+        template.Name = NormalizeName(Name);
+        template.Description = Description ?? string.Empty;
+        template.FFmpegProfileId = FFmpegProfileId;
+        template.WatermarkId = WatermarkId;
+        template.FallbackFillerId = FallbackFillerId;
+        template.PreRollFillerId = PreRollFillerId;
+        template.MidRollFillerId = MidRollFillerId;
+        template.PostRollFillerId = PostRollFillerId;
+        template.StreamSelectorMode = StreamSelectorMode;
+        template.StreamSelector = StreamSelector ?? string.Empty;
+        template.PreferredAudioLanguageCode = PreferredAudioLanguageCode ?? string.Empty;
+        template.PreferredAudioTitle = PreferredAudioTitle ?? string.Empty;
+        template.PlayoutSource = PlayoutSource;
+        template.PlayoutMode = PlayoutMode;
+        template.StreamingMode = StreamingMode;
+        template.PreferredSubtitleLanguageCode = PreferredSubtitleLanguageCode ?? string.Empty;
+        template.SubtitleMode = SubtitleMode;
+        template.MusicVideoCreditsMode = MusicVideoCreditsMode;
+        template.MusicVideoCreditsTemplate = MusicVideoCreditsTemplate ?? string.Empty;
+        template.SongVideoMode = SongVideoMode;
+        template.TranscodeMode = TranscodeMode;
+        template.IdleBehavior = IdleBehavior;
+        template.ShuffleScheduleItems = ShuffleScheduleItems;
+        template.RandomStartPoint = RandomStartPoint;
+        template.FixedStartTimeBehavior = FixedStartTimeBehavior;
+    }
+
+    internal static string NormalizeName(string name) => (name ?? string.Empty).Trim();
+
+    private static async Task<Option<BaseError>> FillerMustExist(
+        TvContext dbContext,
+        int? fillerPresetId,
+        FillerKind fillerKind,
+        CancellationToken cancellationToken)
+    {
+        foreach (int id in Optional(fillerPresetId))
+        {
+            bool exists = await dbContext.FillerPresets
+                .AnyAsync(f => f.Id == id && f.FillerKind == fillerKind, cancellationToken);
+            if (!exists)
+            {
+                return new NotFoundError($"{fillerKind} filler {id} does not exist.");
+            }
+        }
+
+        return Option<BaseError>.None;
+    }
+}
@@ -0,0 +1,60 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record CreateChannelTemplate(
+    string Name,
+    string Description,
+    int FFmpegProfileId,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    int? PreRollFillerId,
+    int? MidRollFillerId,
+    int? PostRollFillerId,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
+    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
+    ChannelPlayoutSource PlayoutSource,
+    ChannelPlayoutMode PlayoutMode,
+    StreamingMode StreamingMode,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelTranscodeMode TranscodeMode,
+    ChannelIdleBehavior IdleBehavior,
+    bool ShuffleScheduleItems,
+    bool RandomStartPoint,
+    FixedStartTimeBehavior FixedStartTimeBehavior)
+    : ChannelTemplateCommandBase(
+        Name,
+        Description,
+        FFmpegProfileId,
+        WatermarkId,
+        FallbackFillerId,
+        PreRollFillerId,
+        MidRollFillerId,
+        PostRollFillerId,
+        StreamSelectorMode,
+        StreamSelector,
+        PreferredAudioLanguageCode,
+        PreferredAudioTitle,
+        PlayoutSource,
+        PlayoutMode,
+        StreamingMode,
+        PreferredSubtitleLanguageCode,
+        SubtitleMode,
+        MusicVideoCreditsMode,
+        MusicVideoCreditsTemplate,
+        SongVideoMode,
+        TranscodeMode,
+        IdleBehavior,
+        ShuffleScheduleItems,
+        RandomStartPoint,
+        FixedStartTimeBehavior),
+        IRequest<Either<BaseError, ChannelTemplateResponseModel>>;
@@ -0,0 +1,36 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public class CreateChannelTemplateHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository)
+    : IRequestHandler<CreateChannelTemplate, Either<BaseError, ChannelTemplateResponseModel>>
+{
+    public async Task<Either<BaseError, ChannelTemplateResponseModel>> Handle(
+        CreateChannelTemplate request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Option<BaseError> maybeError =
+            await ChannelTemplateCommandBase.ValidateCommon(dbContext, request, null, cancellationToken);
+        foreach (BaseError error in maybeError)
+        {
+            return error;
+        }
+
+        var template = new ChannelTemplate();
+        request.ApplyTo(template);
+        await dbContext.ChannelTemplates.AddAsync(template, cancellationToken);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        int? defaultTemplateId =
+            await ChannelTemplateDefault.GetDefaultTemplateId(configElementRepository, cancellationToken);
+        return ChannelTemplateMapper.ProjectToResponseModel(template, defaultTemplateId);
+    }
+}
@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record DeleteChannelTemplate(int ChannelTemplateId) : IRequest<Either<BaseError, Unit>>;
@@ -0,0 +1,42 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public class DeleteChannelTemplateHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository)
+    : IRequestHandler<DeleteChannelTemplate, Either<BaseError, Unit>>
+{
+    public async Task<Either<BaseError, Unit>> Handle(DeleteChannelTemplate request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Option<ChannelTemplate> maybeTemplate = await dbContext.ChannelTemplates
+            .SelectOneAsync(t => t.Id, t => t.Id == request.ChannelTemplateId, cancellationToken);
+        foreach (ChannelTemplate template in maybeTemplate)
+        {
+            if (template.IsSystem)
+            {
+                return BaseError.New("System templates cannot be deleted.");
+            }
+
+            int? defaultTemplateId =
+                await ChannelTemplateDefault.GetDefaultTemplateId(configElementRepository, cancellationToken);
+            if (defaultTemplateId == template.Id)
+            {
+                return BaseError.New("Default channel template cannot be deleted.");
+            }
+
+            dbContext.ChannelTemplates.Remove(template);
+            await dbContext.SaveChangesAsync(cancellationToken);
+            return Unit.Default;
+        }
+
+        return new NotFoundError($"ChannelTemplate {request.ChannelTemplateId} does not exist.");
+    }
+}
@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.ChannelTemplates;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record SetDefaultChannelTemplate(int ChannelTemplateId) : IRequest<Either<BaseError, ChannelTemplateResponseModel>>;
@@ -0,0 +1,36 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public class SetDefaultChannelTemplateHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository)
+    : IRequestHandler<SetDefaultChannelTemplate, Either<BaseError, ChannelTemplateResponseModel>>
+{
+    public async Task<Either<BaseError, ChannelTemplateResponseModel>> Handle(
+        SetDefaultChannelTemplate request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Option<ChannelTemplate> maybeTemplate = await dbContext.ChannelTemplates
+            .AsNoTracking()
+            .SelectOneAsync(t => t.Id, t => t.Id == request.ChannelTemplateId, cancellationToken);
+        foreach (ChannelTemplate template in maybeTemplate)
+        {
+            await configElementRepository.Upsert(
+                ConfigElementKey.ChannelTemplatesDefaultTemplateId,
+                template.Id,
+                cancellationToken);
+            return ChannelTemplateMapper.ProjectToResponseModel(template, template.Id);
+        }
+
+        return new NotFoundError($"ChannelTemplate {request.ChannelTemplateId} does not exist.");
+    }
+}
@@ -0,0 +1,61 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record UpdateChannelTemplate(
+    int ChannelTemplateId,
+    string Name,
+    string Description,
+    int FFmpegProfileId,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    int? PreRollFillerId,
+    int? MidRollFillerId,
+    int? PostRollFillerId,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
+    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
+    ChannelPlayoutSource PlayoutSource,
+    ChannelPlayoutMode PlayoutMode,
+    StreamingMode StreamingMode,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelTranscodeMode TranscodeMode,
+    ChannelIdleBehavior IdleBehavior,
+    bool ShuffleScheduleItems,
+    bool RandomStartPoint,
+    FixedStartTimeBehavior FixedStartTimeBehavior)
+    : ChannelTemplateCommandBase(
+        Name,
+        Description,
+        FFmpegProfileId,
+        WatermarkId,
+        FallbackFillerId,
+        PreRollFillerId,
+        MidRollFillerId,
+        PostRollFillerId,
+        StreamSelectorMode,
+        StreamSelector,
+        PreferredAudioLanguageCode,
+        PreferredAudioTitle,
+        PlayoutSource,
+        PlayoutMode,
+        StreamingMode,
+        PreferredSubtitleLanguageCode,
+        SubtitleMode,
+        MusicVideoCreditsMode,
+        MusicVideoCreditsTemplate,
+        SongVideoMode,
+        TranscodeMode,
+        IdleBehavior,
+        ShuffleScheduleItems,
+        RandomStartPoint,
+        FixedStartTimeBehavior),
+        IRequest<Either<BaseError, ChannelTemplateResponseModel>>;
@@ -0,0 +1,51 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public class UpdateChannelTemplateHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository)
+    : IRequestHandler<UpdateChannelTemplate, Either<BaseError, ChannelTemplateResponseModel>>
+{
+    public async Task<Either<BaseError, ChannelTemplateResponseModel>> Handle(
+        UpdateChannelTemplate request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Option<ChannelTemplate> maybeTemplate = await dbContext.ChannelTemplates
+            .SelectOneAsync(t => t.Id, t => t.Id == request.ChannelTemplateId, cancellationToken);
+        foreach (ChannelTemplate template in maybeTemplate)
+        {
+            if (template.IsSystem)
+            {
+                return BaseError.New("System templates cannot be updated.");
+            }
+
+            Option<BaseError> maybeError =
+                await ChannelTemplateCommandBase.ValidateCommon(
+                    dbContext,
+                    request,
+                    request.ChannelTemplateId,
+                    cancellationToken);
+            foreach (BaseError error in maybeError)
+            {
+                return error;
+            }
+
+            request.ApplyTo(template);
+            await dbContext.SaveChangesAsync(cancellationToken);
+            int? defaultTemplateId =
+                await ChannelTemplateDefault.GetDefaultTemplateId(configElementRepository, cancellationToken);
+            return ChannelTemplateMapper.ProjectToResponseModel(template, defaultTemplateId);
+        }
+
+        return new NotFoundError($"ChannelTemplate {request.ChannelTemplateId} does not exist.");
+    }
+}
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record GetAllChannelTemplates : IRequest<List<ChannelTemplateResponseModel>>;
@@ -0,0 +1,28 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public class GetAllChannelTemplatesHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository)
+    : IRequestHandler<GetAllChannelTemplates, List<ChannelTemplateResponseModel>>
+{
+    public async Task<List<ChannelTemplateResponseModel>> Handle(
+        GetAllChannelTemplates request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        int? defaultTemplateId =
+            await ChannelTemplateDefault.GetDefaultTemplateId(configElementRepository, cancellationToken);
+        return await dbContext.ChannelTemplates
+            .AsNoTracking()
+            .OrderBy(t => t.IsSystem ? 0 : 1)
+            .ThenBy(t => t.Name)
+            .Select(t => ChannelTemplateMapper.ProjectToResponseModel(t, defaultTemplateId))
+            .ToListAsync(cancellationToken);
+    }
+}
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record GetChannelTemplateById(int ChannelTemplateId) : IRequest<Option<ChannelTemplateResponseModel>>;
@@ -0,0 +1,27 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public class GetChannelTemplateByIdHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository)
+    : IRequestHandler<GetChannelTemplateById, Option<ChannelTemplateResponseModel>>
+{
+    public async Task<Option<ChannelTemplateResponseModel>> Handle(
+        GetChannelTemplateById request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        int? defaultTemplateId =
+            await ChannelTemplateDefault.GetDefaultTemplateId(configElementRepository, cancellationToken);
+        Option<ChannelTemplate> maybeTemplate = await dbContext.ChannelTemplates
+            .AsNoTracking()
+            .SelectOneAsync(t => t.Id, t => t.Id == request.ChannelTemplateId, cancellationToken);
+        return maybeTemplate.Map(t => ChannelTemplateMapper.ProjectToResponseModel(t, defaultTemplateId));
+    }
+}
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record GetDefaultChannelTemplate : IRequest<Option<ChannelTemplateResponseModel>>;
@@ -0,0 +1,40 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public class GetDefaultChannelTemplateHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository)
+    : IRequestHandler<GetDefaultChannelTemplate, Option<ChannelTemplateResponseModel>>
+{
+    public async Task<Option<ChannelTemplateResponseModel>> Handle(
+        GetDefaultChannelTemplate request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        int? defaultTemplateId =
+            await ChannelTemplateDefault.GetDefaultTemplateId(configElementRepository, cancellationToken);
+        foreach (int id in Optional(defaultTemplateId))
+        {
+            Option<ChannelTemplate> maybeConfigured = await dbContext.ChannelTemplates
+                .AsNoTracking()
+                .SelectOneAsync(t => t.Id, t => t.Id == id, cancellationToken);
+            foreach (ChannelTemplate template in maybeConfigured)
+            {
+                return ChannelTemplateMapper.ProjectToResponseModel(template, id);
+            }
+        }
+
+        ChannelTemplate fallback = await dbContext.ChannelTemplates
+            .AsNoTracking()
+            .Where(t => t.IsSystem)
+            .OrderBy(t => t.Name)
+            .FirstOrDefaultAsync(cancellationToken);
+        return Optional(fallback).Map(t => ChannelTemplateMapper.ProjectToResponseModel(t, t.Id));
+    }
+}
@@ -0,0 +1,71 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Channels;
+
+/// <summary>
+///     Shared programme-metadata projection for guide output. Both the XMLTV cache builder
+///     (<see cref="RefreshChannelDataHandler" />) and the JSON guide query
+///     (<see cref="GetChannelGuideDataHandler" />) resolve the display title/subtitle/category from a
+///     <see cref="PlayoutItem" /> here so the two representations stay consistent.
+/// </summary>
+public static class ChannelGuideMetadata
+{
+    public static string GetTitle(PlayoutItem playoutItem)
+    {
+        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+        {
+            return playoutItem.CustomTitle;
+        }
+
+        return playoutItem.MediaItem switch
+        {
+            Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title ?? string.Empty)
+                .IfNone("[unknown movie]"),
+            Episode e => e.Season.Show.ShowMetadata.HeadOrNone().Map(em => em.Title ?? string.Empty)
+                .IfNone("[unknown show]"),
+            MusicVideo mv => mv.Artist.ArtistMetadata.HeadOrNone().Map(am => am.Title ?? string.Empty)
+                .IfNone("[unknown artist]"),
+            OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
+                .IfNone("[unknown video]"),
+            RemoteStream rs => rs.RemoteStreamMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
+                .IfNone("[unknown remote stream]"),
+            _ => "[unknown]"
+        };
+    }
+
+    public static string GetSubtitle(PlayoutItem playoutItem)
+    {
+        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+        {
+            return string.Empty;
+        }
+
+        return playoutItem.MediaItem switch
+        {
+            Episode e => e.EpisodeMetadata.HeadOrNone().Match(
+                em => em.Title ?? string.Empty,
+                () => string.Empty),
+            MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                mvm => mvm.Title ?? string.Empty,
+                () => string.Empty),
+            Song s => s.SongMetadata.HeadOrNone().Match(
+                mvm => mvm.Title ?? string.Empty,
+                () => string.Empty),
+            _ => string.Empty
+        };
+    }
+
+    /// <summary>
+    ///     The primary guide category, mirroring the fixed <c>&lt;category&gt;</c> the XMLTV templates
+    ///     emit per media kind (Movie / Series / Music). Media kinds without a fixed category return null.
+    /// </summary>
+    public static string GetCategory(PlayoutItem playoutItem) =>
+        playoutItem.MediaItem switch
+        {
+            Movie => "Movie",
+            Episode => "Series",
+            MusicVideo => "Music",
+            Song => "Music",
+            _ => null
+        };
+}
@@ -0,0 +1,164 @@
+using ErsatzTV.Application.Configuration;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+
+namespace ErsatzTV.Application.Channels;
+
+/// <summary>
+///     A single guide programme resolved from one or more <see cref="PlayoutItem" />s: the
+///     <see cref="DisplayItem" /> whose metadata is shown, plus the coalesced <see cref="Start" />/
+///     <see cref="Stop" /> window and whether the originating item carried a custom title.
+/// </summary>
+public readonly record struct ChannelGuideEntry(
+    PlayoutItem DisplayItem,
+    DateTimeOffset Start,
+    DateTimeOffset Stop,
+    bool HasCustomTitle);
+
+/// <summary>
+///     Shared guide-group / filler-merge projection. This is the single source of truth for turning a
+///     channel's sorted <see cref="PlayoutItem" />s into guide programmes; both the XMLTV cache builder
+///     (<see cref="RefreshChannelDataHandler" />) and the JSON guide query
+///     (<see cref="GetChannelGuideDataHandler" />) consume it so the two representations cannot drift.
+///     The XMLTV path formats <see cref="ChannelGuideEntry.Start" />/<see cref="ChannelGuideEntry.Stop" />
+///     into the XMLTV timestamp strings; the JSON path returns them (and the display item's
+///     <see cref="FillerKind" />) directly and lets the UI decide how to render filler.
+/// </summary>
+public static class ChannelGuideProjector
+{
+    public static IEnumerable<ChannelGuideEntry> Project(
+        PlayoutScheduleKind scheduleKind,
+        IReadOnlyList<PlayoutItem> sorted,
+        XmltvTimeZone timeZone,
+        XmltvBlockBehavior blockBehavior) =>
+        scheduleKind switch
+        {
+            PlayoutScheduleKind.Block => ProjectBlock(sorted, timeZone, blockBehavior),
+            _ => ProjectFlood(sorted, timeZone)
+        };
+
+    // Classic / Sequential / Scripted / ExternalJson: skip leading non-preroll filler, then coalesce
+    // each guide group (following filler) into a single programme using the display item's GuideFinish
+    // override when present.
+    private static IEnumerable<ChannelGuideEntry> ProjectFlood(
+        IReadOnlyList<PlayoutItem> sorted,
+        XmltvTimeZone timeZone)
+    {
+        // skip all filler that isn't pre-roll
+        var i = 0;
+        while (i < sorted.Count && sorted[i].FillerKind != FillerKind.None &&
+               sorted[i].FillerKind != FillerKind.PreRoll)
+        {
+            i++;
+        }
+
+        while (i < sorted.Count)
+        {
+            PlayoutItem startItem = sorted[i];
+            int j = i;
+            while (sorted[j].FillerKind != FillerKind.None && j + 1 < sorted.Count)
+            {
+                j++;
+            }
+
+            PlayoutItem displayItem = sorted[j];
+            bool hasCustomTitle = !string.IsNullOrWhiteSpace(startItem.CustomTitle);
+
+            int finishIndex = j;
+            while (finishIndex + 1 < sorted.Count && (sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup
+                                                      || sorted[finishIndex + 1].FillerKind is FillerKind.GuideMode
+                                                          or FillerKind.PostRoll or FillerKind.Tail
+                                                          or FillerKind.Fallback or FillerKind.DecoDefault))
+            {
+                finishIndex++;
+            }
+
+            PlayoutItem finishItem = sorted[finishIndex];
+            i = finishIndex;
+
+            DateTimeOffset startTime = timeZone switch
+            {
+                XmltvTimeZone.Utc => new DateTimeOffset(startItem.Start, TimeSpan.Zero),
+                _ => startItem.StartOffset
+            };
+
+            DateTimeOffset stopTime = (timeZone, displayItem.GuideFinishOffset.HasValue) switch
+            {
+                (XmltvTimeZone.Utc, true) => new DateTimeOffset(displayItem.GuideFinish!.Value, TimeSpan.Zero),
+                (XmltvTimeZone.Utc, false) => new DateTimeOffset(finishItem.Finish, TimeSpan.Zero),
+                (_, true) => displayItem.GuideFinishOffset!.Value,
+                (_, false) => finishItem.FinishOffset
+            };
+
+            yield return new ChannelGuideEntry(displayItem, startTime, stopTime, hasCustomTitle);
+
+            i++;
+        }
+    }
+
+    // Block: group by guide window, drop filler entirely, then either use the items' actual times or
+    // split the group window evenly across the non-filler items.
+    private static IEnumerable<ChannelGuideEntry> ProjectBlock(
+        IReadOnlyList<PlayoutItem> sorted,
+        XmltvTimeZone timeZone,
+        XmltvBlockBehavior blockBehavior)
+    {
+        var groups = sorted.GroupBy(s => new { s.GuideStart, s.GuideFinish, s.GuideGroup });
+        foreach (var group in groups)
+        {
+            var itemsToInclude = group.Filter(g => g.FillerKind is FillerKind.None).ToList();
+            if (itemsToInclude.Count == 0)
+            {
+                continue;
+            }
+
+            switch (blockBehavior)
+            {
+                case XmltvBlockBehavior.UseActualTimes:
+                    foreach (PlayoutItem item in itemsToInclude)
+                    {
+                        DateTimeOffset actualStart = timeZone switch
+                        {
+                            XmltvTimeZone.Utc => new DateTimeOffset(item.Start, TimeSpan.Zero),
+                            _ => new DateTimeOffset(item.Start, TimeSpan.Zero).ToLocalTime()
+                        };
+
+                        DateTimeOffset actualFinish = timeZone switch
+                        {
+                            XmltvTimeZone.Utc => new DateTimeOffset(item.Finish, TimeSpan.Zero),
+                            _ => new DateTimeOffset(item.Finish, TimeSpan.Zero).ToLocalTime()
+                        };
+
+                        yield return new ChannelGuideEntry(item, actualStart, actualFinish, false);
+                    }
+
+                    break;
+                case XmltvBlockBehavior.SplitTimeEvenly:
+                default:
+                    DateTime groupStart = group.Key.GuideStart!.Value;
+                    DateTime groupFinish = group.Key.GuideFinish!.Value;
+                    TimeSpan groupDuration = groupFinish - groupStart;
+
+                    TimeSpan perItem = groupDuration / itemsToInclude.Count;
+
+                    DateTimeOffset currentStart = timeZone switch
+                    {
+                        XmltvTimeZone.Utc => new DateTimeOffset(groupStart, TimeSpan.Zero),
+                        _ => new DateTimeOffset(groupStart, TimeSpan.Zero).ToLocalTime()
+                    };
+
+                    DateTimeOffset currentFinish = currentStart + perItem;
+
+                    foreach (PlayoutItem item in itemsToInclude)
+                    {
+                        yield return new ChannelGuideEntry(item, currentStart, currentFinish, false);
+
+                        currentStart = currentFinish;
+                        currentFinish += perItem;
+                    }
+
+                    break;
+            }
+        }
+    }
+}
@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Channels;
+
+public record BulkDeleteChannels(IReadOnlyList<int> ChannelIds) : IRequest<Either<BaseError, Unit>>;
@@ -0,0 +1,62 @@
+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 Microsoft.EntityFrameworkCore;
+using Channel = ErsatzTV.Core.Domain.Channel;
+
+namespace ErsatzTV.Application.Channels;
+
+public class BulkDeleteChannelsHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    ChannelWriter<IBackgroundServiceRequest> workerChannel,
+    IFileSystem fileSystem,
+    ISearchTargets searchTargets)
+    : IRequestHandler<BulkDeleteChannels, Either<BaseError, Unit>>
+{
+    public async Task<Either<BaseError, Unit>> Handle(
+        BulkDeleteChannels request,
+        CancellationToken cancellationToken)
+    {
+        if (request.ChannelIds.Count == 0)
+        {
+            return Left<BaseError, Unit>(BaseError.New("At least one channel id is required"));
+        }
+
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken);
+
+        List<int> channelIds = request.ChannelIds.Distinct().ToList();
+        List<Channel> channels = await dbContext.Channels
+            .Where(c => channelIds.Contains(c.Id))
+            .ToListAsync(cancellationToken);
+
+        if (channels.Count != channelIds.Count)
+        {
+            var found = channels.Select(c => c.Id).ToHashSet();
+            int missingId = channelIds.First(id => !found.Contains(id));
+            return Left<BaseError, Unit>(new NotFoundError($"Channel {missingId} does not exist."));
+        }
+
+        dbContext.Channels.RemoveRange(channels);
+        await dbContext.SaveChangesAsync(cancellationToken);
+        await transaction.CommitAsync(cancellationToken);
+
+        searchTargets.SearchTargetsChanged();
+
+        foreach (Channel channel in channels)
+        {
+            string cacheFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{channel.Number}.xml");
+            if (fileSystem.File.Exists(cacheFile))
+            {
+                fileSystem.File.Delete(cacheFile);
+            }
+        }
+
+        await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
+
+        return Right<BaseError, Unit>(Unit.Default);
+    }
+}
@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Channels;
+
+public record BulkMoveChannelsToGroup(IReadOnlyList<int> ChannelIds, string Group)
+    : IRequest<Either<BaseError, Unit>>;
@@ -0,0 +1,61 @@
+using System.Threading.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Channels.ChannelValidations;
+using Channel = ErsatzTV.Core.Domain.Channel;
+
+namespace ErsatzTV.Application.Channels;
+
+public class BulkMoveChannelsToGroupHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    ChannelWriter<IBackgroundServiceRequest> workerChannel,
+    ISearchTargets searchTargets)
+    : IRequestHandler<BulkMoveChannelsToGroup, Either<BaseError, Unit>>
+{
+    public async Task<Either<BaseError, Unit>> Handle(
+        BulkMoveChannelsToGroup request,
+        CancellationToken cancellationToken)
+    {
+        if (request.ChannelIds.Count == 0)
+        {
+            return Left<BaseError, Unit>(BaseError.New("At least one channel id is required"));
+        }
+
+        Validation<BaseError, string> groupValidation = ValidateGroup(request.Group);
+        if (groupValidation.IsFail)
+        {
+            return Left<BaseError, Unit>(groupValidation.FailToSeq().Head());
+        }
+
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken);
+
+        List<int> channelIds = request.ChannelIds.Distinct().ToList();
+        List<Channel> channels = await dbContext.Channels
+            .Where(c => channelIds.Contains(c.Id))
+            .ToListAsync(cancellationToken);
+
+        if (channels.Count != channelIds.Count)
+        {
+            var found = channels.Select(c => c.Id).ToHashSet();
+            int missingId = channelIds.First(id => !found.Contains(id));
+            return Left<BaseError, Unit>(new NotFoundError($"Channel {missingId} does not exist."));
+        }
+
+        foreach (Channel channel in channels)
+        {
+            channel.Group = request.Group;
+        }
+
+        await dbContext.SaveChangesAsync(cancellationToken);
+        await transaction.CommitAsync(cancellationToken);
+
+        searchTargets.SearchTargetsChanged();
+        await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
+
+        return Right<BaseError, Unit>(Unit.Default);
+    }
+}
@@ -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;
+    }
+}
@@ -0,0 +1,56 @@
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Api.LibraryBrowse;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+
+namespace ErsatzTV.Application.Channels;
+
+public record CreateChannelFromLineup(
+    string Name,
+    string Number,
+    string Group,
+    string Categories,
+    ArtworkContentTypeModel Logo,
+    bool IsEnabled,
+    bool ShowInEpg,
+    int TemplateId,
+    CreateChannelFromLineupAdvancedOptions Advanced,
+    List<CreateChannelFromLineupItem> Lineup) : IRequest<Either<BaseError, CreateChannelFromLineupResponseModel>>;
+
+public record CreateChannelFromLineupAdvancedOptions(
+    PlaybackOrder? PlaybackOrder = null,
+    int? FFmpegProfileId = null,
+    int? WatermarkId = null,
+    int? FallbackFillerId = null,
+    int? PreRollFillerId = null,
+    int? MidRollFillerId = null,
+    int? PostRollFillerId = null,
+    ChannelStreamSelectorMode? StreamSelectorMode = null,
+    string StreamSelector = null,
+    string PreferredAudioLanguageCode = null,
+    string PreferredAudioTitle = null,
+    ChannelPlayoutSource? PlayoutSource = null,
+    ChannelPlayoutMode? PlayoutMode = null,
+    StreamingMode? StreamingMode = null,
+    string PreferredSubtitleLanguageCode = null,
+    ChannelSubtitleMode? SubtitleMode = null,
+    ChannelMusicVideoCreditsMode? MusicVideoCreditsMode = null,
+    string MusicVideoCreditsTemplate = null,
+    ChannelSongVideoMode? SongVideoMode = null,
+    ChannelTranscodeMode? TranscodeMode = null,
+    ChannelIdleBehavior? IdleBehavior = null,
+    bool? ShuffleScheduleItems = null,
+    bool? RandomStartPoint = null,
+    FixedStartTimeBehavior? FixedStartTimeBehavior = null);
+
+public record CreateChannelFromLineupItem(
+    LibraryBrowseMediaType MediaType,
+    CollectionType CollectionType,
+    int? CollectionId,
+    int? MultiCollectionId,
+    int? SmartCollectionId,
+    int? RerunCollectionId,
+    int? MediaItemId,
+    int? PlaylistId);
@@ -0,0 +1,754 @@
+using System.Globalization;
+using System.Text.RegularExpressions;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Api.LibraryBrowse;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Scheduling;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Channel = ErsatzTV.Core.Domain.Channel;
+
+namespace ErsatzTV.Application.Channels;
+
+public class CreateChannelFromLineupHandler(
+    ChannelWriter<IBackgroundServiceRequest> workerChannel,
+    IDbContextFactory<TvContext> dbContextFactory,
+    ISearchTargets searchTargets,
+    ILogger<CreateChannelFromLineupHandler> logger)
+    : IRequestHandler<CreateChannelFromLineup, Either<BaseError, CreateChannelFromLineupResponseModel>>
+{
+    // The single system playlist group that holds every generated channel-lineup playlist.
+    // Matches the Trakt "Trakt Lists" precedent (DbInitializer + delete guards on IsSystem).
+    private const string SystemPlaylistGroupName = "Channel Lineups";
+
+    public async Task<Either<BaseError, CreateChannelFromLineupResponseModel>> Handle(
+        CreateChannelFromLineup request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        Either<BaseError, PreparedCreate> validation = await Validate(dbContext, request, cancellationToken);
+        return await validation.Match(
+            Left: error => Task.FromResult<Either<BaseError, CreateChannelFromLineupResponseModel>>(error),
+            Right: prepared => PersistAndDispatch(dbContext, prepared, cancellationToken));
+    }
+
+    private async Task<Either<BaseError, CreateChannelFromLineupResponseModel>> PersistAndDispatch(
+        TvContext dbContext,
+        PreparedCreate prepared,
+        CancellationToken cancellationToken)
+    {
+        await using var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken);
+        try
+        {
+            dbContext.Channels.Add(prepared.Channel);
+            if (prepared.Playlist is not null)
+            {
+                dbContext.Playlists.Add(prepared.Playlist);
+            }
+
+            dbContext.ProgramSchedules.Add(prepared.ProgramSchedule);
+            dbContext.Playouts.Add(prepared.Playout);
+
+            await dbContext.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+        }
+        catch (DbUpdateException ex)
+        {
+            await transaction.RollbackAsync(cancellationToken);
+            logger.LogError(ex, "Failed to persist channel created from lineup");
+            return BaseError.New("Unable to create channel from lineup");
+        }
+
+        searchTargets.SearchTargetsChanged();
+        await workerChannel.WriteAsync(
+            new BuildPlayout(prepared.Playout.Id, PlayoutBuildMode.Reset),
+            cancellationToken);
+
+        // Mirror CreateClassicPlayoutHandler: on-demand playouts must be time-shifted to "now" after build.
+        if (prepared.Channel.PlayoutMode is ChannelPlayoutMode.OnDemand)
+        {
+            await workerChannel.WriteAsync(
+                new TimeShiftOnDemandPlayout(prepared.Playout.Id, DateTimeOffset.Now, false),
+                cancellationToken);
+        }
+
+        await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
+
+        return new CreateChannelFromLineupResponseModel(
+            prepared.Channel.Id,
+            prepared.Playlist?.Id,
+            prepared.ProgramSchedule.Id,
+            prepared.Playout.Id);
+    }
+
+    private static async Task<Either<BaseError, PreparedCreate>> Validate(
+        TvContext dbContext,
+        CreateChannelFromLineup request,
+        CancellationToken cancellationToken)
+    {
+        string name = (request.Name ?? string.Empty).Trim();
+        string number = (request.Number ?? string.Empty).Trim();
+        string group = (request.Group ?? string.Empty).Trim();
+        string categories = (request.Categories ?? string.Empty).Trim();
+        CreateChannelFromLineupAdvancedOptions advanced = request.Advanced ?? new CreateChannelFromLineupAdvancedOptions();
+
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            return BaseError.New("Channel name is required");
+        }
+
+        if (name.Length > 50)
+        {
+            return BaseError.New("Channel name must be 50 characters or fewer");
+        }
+
+        if (string.IsNullOrWhiteSpace(group))
+        {
+            return BaseError.New("Channel group is required");
+        }
+
+        if (!Regex.IsMatch(number, Channel.NumberValidator))
+        {
+            return BaseError.New("Invalid channel number; two decimals are allowed for subchannels");
+        }
+
+        if (await dbContext.Channels.AnyAsync(c => c.Number == number, cancellationToken))
+        {
+            return BaseError.New("Channel number must be unique");
+        }
+
+        if (!request.IsEnabled && request.ShowInEpg)
+        {
+            return BaseError.New("Disabled channels cannot be shown in EPG");
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.Logo?.Path) &&
+            Uri.TryCreate(request.Logo.Path, UriKind.Absolute, out _) &&
+            !Artwork.IsExternalUrl(request.Logo.Path))
+        {
+            return BaseError.New("External logo url is invalid");
+        }
+
+        if (request.Lineup is null || request.Lineup.Count == 0)
+        {
+            return BaseError.New("Lineup must contain at least one item");
+        }
+
+        ChannelTemplate template = await dbContext.ChannelTemplates
+            .AsNoTracking()
+            .SingleOrDefaultAsync(t => t.Id == request.TemplateId, cancellationToken);
+        if (template is null)
+        {
+            return new NotFoundError($"Channel template {request.TemplateId} does not exist.");
+        }
+
+        int ffmpegProfileId = advanced.FFmpegProfileId ?? template.FFmpegProfileId;
+        int? fallbackFillerId = advanced.FallbackFillerId ?? template.FallbackFillerId;
+        int? preRollFillerId = advanced.PreRollFillerId ?? template.PreRollFillerId;
+        int? midRollFillerId = advanced.MidRollFillerId ?? template.MidRollFillerId;
+        int? postRollFillerId = advanced.PostRollFillerId ?? template.PostRollFillerId;
+        PlaybackOrder playbackOrder = advanced.PlaybackOrder ?? PlaybackOrder.Chronological;
+        ChannelPlayoutSource playoutSource = advanced.PlayoutSource ?? template.PlayoutSource;
+
+        // Mirror channels need special MirrorSourceChannelId plumbing (see CreateChannelHandler);
+        // this endpoint only builds generated playouts.
+        if (playoutSource is ChannelPlayoutSource.Mirror)
+        {
+            return BaseError.New("Mirror playout source is not supported by this endpoint");
+        }
+
+        Either<BaseError, Unit> referenceValidation = await ValidateReferences(
+            dbContext,
+            advanced,
+            template,
+            cancellationToken);
+        foreach (BaseError error in referenceValidation.LeftToSeq())
+        {
+            return error;
+        }
+
+        // Normalize + validate every lineup entry once, so validation and build see the same data.
+        var normalized = new List<NormalizedLineupItem>();
+        for (int i = 0; i < request.Lineup.Count; i++)
+        {
+            Either<BaseError, NormalizedLineupItem> itemValidation =
+                await NormalizeLineupItem(dbContext, request.Lineup[i], i, cancellationToken);
+            foreach (BaseError error in itemValidation.LeftToSeq())
+            {
+                return error;
+            }
+
+            foreach (NormalizedLineupItem item in itemValidation.RightToSeq())
+            {
+                normalized.Add(item);
+            }
+        }
+
+        bool multiItem = normalized.Count >= 2;
+
+        // MultiCollection entries only support Shuffle / ShuffleInOrder (mirrors PlayoutModeMustBeValid).
+        if (normalized.Any(i => i.CollectionType is CollectionType.MultiCollection) &&
+            playbackOrder is not (PlaybackOrder.Shuffle or PlaybackOrder.ShuffleInOrder))
+        {
+            return BaseError.New($"Invalid playback order for multi collection: '{playbackOrder}'");
+        }
+
+        if (multiItem)
+        {
+            // The generated playlist cannot express rerun collections or nested playlists
+            // (PlaylistItem + CollectionKey.ForPlaylistItem lack those fields).
+            for (int i = 0; i < normalized.Count; i++)
+            {
+                if (normalized[i].CollectionType is CollectionType.RerunFirstRun or CollectionType.Playlist)
+                {
+                    return BaseError.New(
+                        $"lineup[{normalized[i].Index}]: rerun collections and playlists are only " +
+                        "supported as a single-item lineup");
+                }
+            }
+        }
+
+        Channel channel = BuildChannel(
+            request,
+            template,
+            advanced,
+            name,
+            number,
+            group,
+            categories,
+            ffmpegProfileId,
+            fallbackFillerId);
+
+        string scheduleName = await DeCollideName(
+            GeneratedName(number, name, "Schedule"),
+            (candidate, ct) => dbContext.ProgramSchedules.AnyAsync(ps => ps.Name == candidate, ct),
+            cancellationToken);
+
+        ProgramSchedule schedule = BuildProgramSchedule(scheduleName, template, advanced);
+
+        Playlist playlist = null;
+        ProgramScheduleItemFlood floodItem = BuildFloodBase(
+            playbackOrder,
+            advanced,
+            template,
+            fallbackFillerId,
+            preRollFillerId,
+            midRollFillerId,
+            postRollFillerId);
+
+        if (multiItem)
+        {
+            playlist = await BuildPlaylist(dbContext, number, name, normalized, playbackOrder, cancellationToken);
+            floodItem.CollectionType = CollectionType.Playlist;
+            floodItem.Playlist = playlist;
+        }
+        else
+        {
+            NormalizedLineupItem only = normalized[0];
+            floodItem.CollectionType = only.CollectionType;
+            floodItem.CollectionId = only.CollectionId;
+            floodItem.MultiCollectionId = only.MultiCollectionId;
+            floodItem.SmartCollectionId = only.SmartCollectionId;
+            floodItem.RerunCollectionId = only.RerunCollectionId;
+            floodItem.MediaItemId = only.MediaItemId;
+            floodItem.PlaylistId = only.PlaylistId;
+        }
+
+        schedule.Items = [floodItem];
+
+        var playout = new Playout
+        {
+            Channel = channel,
+            ProgramSchedule = schedule,
+            ScheduleKind = PlayoutScheduleKind.Classic
+        };
+
+        return new PreparedCreate(channel, playlist, schedule, playout);
+    }
+
+    private static async Task<Playlist> BuildPlaylist(
+        TvContext dbContext,
+        string channelNumber,
+        string channelName,
+        List<NormalizedLineupItem> lineup,
+        PlaybackOrder playbackOrder,
+        CancellationToken cancellationToken)
+    {
+        // Reuse the single system playlist group, creating it on first use.
+        PlaylistGroup playlistGroup = await dbContext.PlaylistGroups
+            .FirstOrDefaultAsync(pg => pg.IsSystem && pg.Name == SystemPlaylistGroupName, cancellationToken);
+        playlistGroup ??= new PlaylistGroup { Name = SystemPlaylistGroupName, IsSystem = true };
+
+        string playlistName = await DeCollideName(
+            GeneratedName(channelNumber, channelName, "Lineup"),
+            (candidate, ct) => dbContext.Playlists.AnyAsync(
+                p => p.PlaylistGroupId == playlistGroup.Id && p.Name == candidate,
+                ct),
+            cancellationToken);
+
+        var playlist = new Playlist
+        {
+            Name = playlistName,
+            IsSystem = true,
+            PlaylistGroup = playlistGroup,
+            PlaylistGroupId = playlistGroup.Id,
+            Items = []
+        };
+
+        int index = 1;
+        foreach (NormalizedLineupItem item in lineup)
+        {
+            playlist.Items.Add(new PlaylistItem
+            {
+                Playlist = playlist,
+                Index = index++,
+                CollectionType = item.CollectionType,
+                CollectionId = item.CollectionId,
+                MultiCollectionId = item.MultiCollectionId,
+                SmartCollectionId = item.SmartCollectionId,
+                MediaItemId = item.MediaItemId,
+                PlaybackOrder = playbackOrder,
+
+                // Play every item in each entry before advancing so lineup order is honored
+                // (PlaylistEnumerator round-robins one-per-entry unless PlayAll/Count).
+                PlayAll = true,
+                IncludeInProgramGuide = true
+            });
+        }
+
+        return playlist;
+    }
+
+    private static Channel BuildChannel(
+        CreateChannelFromLineup request,
+        ChannelTemplate template,
+        CreateChannelFromLineupAdvancedOptions advanced,
+        string name,
+        string number,
+        string group,
+        string categories,
+        int ffmpegProfileId,
+        int? fallbackFillerId)
+    {
+        var artwork = new List<Artwork>();
+        if (!string.IsNullOrWhiteSpace(request.Logo?.Path))
+        {
+            string logo = request.Logo.Path;
+            if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
+            {
+                logo = logo.Replace("iptv/logos/", string.Empty);
+            }
+
+            artwork.Add(new Artwork
+            {
+                Path = logo,
+                ArtworkKind = ArtworkKind.Logo,
+                OriginalContentType = !string.IsNullOrEmpty(request.Logo.ContentType) ? request.Logo.ContentType : null,
+                DateAdded = DateTime.UtcNow,
+                DateUpdated = DateTime.UtcNow
+            });
+        }
+
+        return new Channel(Guid.NewGuid())
+        {
+            Name = name,
+            Number = number,
+            SortNumber = double.Parse(number, CultureInfo.InvariantCulture),
+            Group = group,
+            Categories = categories,
+            FFmpegProfileId = ffmpegProfileId,
+            SlugSeconds = null,
+            PlayoutSource = advanced.PlayoutSource ?? template.PlayoutSource,
+            PlayoutMode = advanced.PlayoutMode ?? template.PlayoutMode,
+            StreamingMode = advanced.StreamingMode ?? template.StreamingMode,
+            WatermarkId = advanced.WatermarkId ?? template.WatermarkId,
+            FallbackFillerId = fallbackFillerId,
+            Artwork = artwork,
+            StreamSelectorMode = advanced.StreamSelectorMode ?? template.StreamSelectorMode,
+            StreamSelector = advanced.StreamSelector ?? template.StreamSelector ?? string.Empty,
+            PreferredAudioLanguageCode =
+                advanced.PreferredAudioLanguageCode ?? template.PreferredAudioLanguageCode ?? string.Empty,
+            PreferredAudioTitle = advanced.PreferredAudioTitle ?? template.PreferredAudioTitle ?? string.Empty,
+            PreferredSubtitleLanguageCode =
+                advanced.PreferredSubtitleLanguageCode ?? template.PreferredSubtitleLanguageCode ?? string.Empty,
+            SubtitleMode = advanced.SubtitleMode ?? template.SubtitleMode,
+            MusicVideoCreditsMode = advanced.MusicVideoCreditsMode ?? template.MusicVideoCreditsMode,
+            MusicVideoCreditsTemplate =
+                advanced.MusicVideoCreditsTemplate ?? template.MusicVideoCreditsTemplate ?? string.Empty,
+            SongVideoMode = advanced.SongVideoMode ?? template.SongVideoMode,
+            TranscodeMode = advanced.TranscodeMode ?? template.TranscodeMode,
+            IdleBehavior = advanced.IdleBehavior ?? template.IdleBehavior,
+            IsEnabled = request.IsEnabled,
+            ShowInEpg = request.IsEnabled && request.ShowInEpg
+        };
+    }
+
+    private static ProgramSchedule BuildProgramSchedule(
+        string scheduleName,
+        ChannelTemplate template,
+        CreateChannelFromLineupAdvancedOptions advanced) =>
+        new()
+        {
+            Name = scheduleName,
+            KeepMultiPartEpisodesTogether = true,
+            TreatCollectionsAsShows = true,
+            ShuffleScheduleItems = advanced.ShuffleScheduleItems ?? template.ShuffleScheduleItems,
+            RandomStartPoint = advanced.RandomStartPoint ?? template.RandomStartPoint,
+            FixedStartTimeBehavior = advanced.FixedStartTimeBehavior ?? template.FixedStartTimeBehavior,
+            Items = []
+        };
+
+    private static ProgramScheduleItemFlood BuildFloodBase(
+        PlaybackOrder playbackOrder,
+        CreateChannelFromLineupAdvancedOptions advanced,
+        ChannelTemplate template,
+        int? fallbackFillerId,
+        int? preRollFillerId,
+        int? midRollFillerId,
+        int? postRollFillerId) =>
+        new()
+        {
+            Index = 1,
+            PlaybackOrder = playbackOrder,
+            GuideMode = GuideMode.Normal,
+            CustomTitle = string.Empty,
+            SearchTitle = string.Empty,
+            SearchQuery = string.Empty,
+            PreRollFillerId = preRollFillerId,
+            MidRollFillerId = midRollFillerId,
+            PostRollFillerId = postRollFillerId,
+            FallbackFillerId = fallbackFillerId,
+            PreferredAudioLanguageCode =
+                advanced.PreferredAudioLanguageCode ?? template.PreferredAudioLanguageCode ?? string.Empty,
+            PreferredAudioTitle = advanced.PreferredAudioTitle ?? template.PreferredAudioTitle ?? string.Empty,
+            PreferredSubtitleLanguageCode =
+                advanced.PreferredSubtitleLanguageCode ?? template.PreferredSubtitleLanguageCode ?? string.Empty,
+            SubtitleMode = advanced.SubtitleMode ?? template.SubtitleMode
+        };
+
+    private static string GeneratedName(string channelNumber, string channelName, string suffix)
+    {
+        string prefix = $"{channelNumber} {channelName}".Trim();
+        int maxPrefixLength = Math.Max(0, 50 - suffix.Length - 1);
+        if (prefix.Length > maxPrefixLength)
+        {
+            prefix = prefix[..maxPrefixLength].TrimEnd();
+        }
+
+        return $"{prefix} {suffix}".Trim();
+    }
+
+    // De-collide a generated (already <= 50 char) name against a unique index by appending " 2", " 3", ...
+    // rather than leaking a raw UNIQUE-constraint failure.
+    private static async Task<string> DeCollideName(
+        string baseName,
+        Func<string, CancellationToken, Task<bool>> exists,
+        CancellationToken cancellationToken)
+    {
+        if (!await exists(baseName, cancellationToken))
+        {
+            return baseName;
+        }
+
+        for (int n = 2; ; n++)
+        {
+            string suffix = $" {n}";
+            string candidate = baseName.Length + suffix.Length > 50
+                ? baseName[..(50 - suffix.Length)].TrimEnd() + suffix
+                : baseName + suffix;
+
+            if (!await exists(candidate, cancellationToken))
+            {
+                return candidate;
+            }
+        }
+    }
+
+    private static async Task<Either<BaseError, Unit>> ValidateReferences(
+        TvContext dbContext,
+        CreateChannelFromLineupAdvancedOptions advanced,
+        ChannelTemplate template,
+        CancellationToken cancellationToken)
+    {
+        int ffmpegProfileId = advanced.FFmpegProfileId ?? template.FFmpegProfileId;
+        if (!await dbContext.FFmpegProfiles.AnyAsync(p => p.Id == ffmpegProfileId, cancellationToken))
+        {
+            return new NotFoundError($"FFmpegProfile {ffmpegProfileId} does not exist.");
+        }
+
+        Either<BaseError, Unit> channelReferences = await ValidateChannelReferences(
+            dbContext,
+            advanced.WatermarkId ?? template.WatermarkId,
+            advanced.FallbackFillerId ?? template.FallbackFillerId,
+            cancellationToken);
+        foreach (BaseError error in channelReferences.LeftToSeq())
+        {
+            return error;
+        }
+
+        Either<BaseError, Unit> itemFillers = await ValidateItemFillers(
+            dbContext,
+            advanced.PreRollFillerId ?? template.PreRollFillerId,
+            advanced.MidRollFillerId ?? template.MidRollFillerId,
+            advanced.PostRollFillerId ?? template.PostRollFillerId,
+            cancellationToken);
+        foreach (BaseError error in itemFillers.LeftToSeq())
+        {
+            return error;
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Either<BaseError, Unit>> ValidateChannelReferences(
+        TvContext dbContext,
+        int? watermarkId,
+        int? fallbackFillerId,
+        CancellationToken cancellationToken)
+    {
+        if (watermarkId.HasValue &&
+            !await dbContext.ChannelWatermarks.AnyAsync(w => w.Id == watermarkId.Value, cancellationToken))
+        {
+            return new NotFoundError($"Watermark {watermarkId.Value} does not exist.");
+        }
+
+        if (fallbackFillerId.HasValue && !await dbContext.FillerPresets.AnyAsync(
+                fp => fp.Id == fallbackFillerId.Value && fp.FillerKind == FillerKind.Fallback,
+                cancellationToken))
+        {
+            return new NotFoundError($"Fallback filler {fallbackFillerId.Value} does not exist.");
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Either<BaseError, Unit>> ValidateItemFillers(
+        TvContext dbContext,
+        int? preRollFillerId,
+        int? midRollFillerId,
+        int? postRollFillerId,
+        CancellationToken cancellationToken)
+    {
+        if (preRollFillerId.HasValue && !await FillerExists(dbContext, preRollFillerId.Value, FillerKind.PreRoll, cancellationToken))
+        {
+            return new NotFoundError($"Pre-roll filler {preRollFillerId.Value} does not exist.");
+        }
+
+        if (midRollFillerId.HasValue && !await FillerExists(dbContext, midRollFillerId.Value, FillerKind.MidRoll, cancellationToken))
+        {
+            return new NotFoundError($"Mid-roll filler {midRollFillerId.Value} does not exist.");
+        }
+
+        if (postRollFillerId.HasValue && !await FillerExists(dbContext, postRollFillerId.Value, FillerKind.PostRoll, cancellationToken))
+        {
+            return new NotFoundError($"Post-roll filler {postRollFillerId.Value} does not exist.");
+        }
+
+        return Unit.Default;
+    }
+
+    private static Task<bool> FillerExists(
+        TvContext dbContext,
+        int id,
+        FillerKind fillerKind,
+        CancellationToken cancellationToken) =>
+        dbContext.FillerPresets.AnyAsync(fp => fp.Id == id && fp.FillerKind == fillerKind, cancellationToken);
+
+    private static async Task<Either<BaseError, NormalizedLineupItem>> NormalizeLineupItem(
+        TvContext dbContext,
+        CreateChannelFromLineupItem item,
+        int index,
+        CancellationToken cancellationToken)
+    {
+        int providedIds = new int?[]
+        {
+            item.CollectionId,
+            item.MultiCollectionId,
+            item.SmartCollectionId,
+            item.RerunCollectionId,
+            item.MediaItemId,
+            item.PlaylistId
+        }.Count(id => id.HasValue);
+
+        if (providedIds != 1)
+        {
+            return BaseError.New($"lineup[{index}] must provide exactly one typed id.");
+        }
+
+        switch (item.MediaType)
+        {
+            case LibraryBrowseMediaType.Movie:
+                return await NormalizeMediaItem(
+                    dbContext.Movies, item, CollectionType.Movie, index, "Movie", cancellationToken);
+            case LibraryBrowseMediaType.TelevisionShow:
+                return await NormalizeMediaItem(
+                    dbContext.Shows, item, CollectionType.TelevisionShow, index, "TelevisionShow", cancellationToken);
+            case LibraryBrowseMediaType.TelevisionSeason:
+                return await NormalizeMediaItem(
+                    dbContext.Seasons, item, CollectionType.TelevisionSeason, index, "TelevisionSeason", cancellationToken);
+            case LibraryBrowseMediaType.Artist:
+                return await NormalizeMediaItem(
+                    dbContext.Artists, item, CollectionType.Artist, index, "Artist", cancellationToken);
+            case LibraryBrowseMediaType.Collection:
+                if (item.CollectionType != CollectionType.Collection)
+                {
+                    return Mismatch(index, item);
+                }
+
+                if (!item.CollectionId.HasValue)
+                {
+                    return WrongId(index, item.MediaType, "collectionId");
+                }
+
+                return await ExistsThen(
+                    dbContext.Collections,
+                    item.CollectionId.Value,
+                    $"lineup[{index}] Collection",
+                    new NormalizedLineupItem(index, CollectionType.Collection, CollectionId: item.CollectionId),
+                    cancellationToken);
+            case LibraryBrowseMediaType.SmartCollection:
+                if (item.CollectionType != CollectionType.SmartCollection)
+                {
+                    return Mismatch(index, item);
+                }
+
+                if (!item.SmartCollectionId.HasValue)
+                {
+                    return WrongId(index, item.MediaType, "smartCollectionId");
+                }
+
+                return await ExistsThen(
+                    dbContext.SmartCollections,
+                    item.SmartCollectionId.Value,
+                    $"lineup[{index}] SmartCollection",
+                    new NormalizedLineupItem(index, CollectionType.SmartCollection, SmartCollectionId: item.SmartCollectionId),
+                    cancellationToken);
+            case LibraryBrowseMediaType.MultiCollection:
+                if (item.CollectionType != CollectionType.MultiCollection)
+                {
+                    return Mismatch(index, item);
+                }
+
+                if (!item.MultiCollectionId.HasValue)
+                {
+                    return WrongId(index, item.MediaType, "multiCollectionId");
+                }
+
+                return await ExistsThen(
+                    dbContext.MultiCollections,
+                    item.MultiCollectionId.Value,
+                    $"lineup[{index}] MultiCollection",
+                    new NormalizedLineupItem(index, CollectionType.MultiCollection, MultiCollectionId: item.MultiCollectionId),
+                    cancellationToken);
+            case LibraryBrowseMediaType.RerunCollection:
+                if (item.CollectionType != CollectionType.RerunFirstRun)
+                {
+                    return Mismatch(index, item);
+                }
+
+                if (!item.RerunCollectionId.HasValue)
+                {
+                    return WrongId(index, item.MediaType, "rerunCollectionId");
+                }
+
+                return await ExistsThen(
+                    dbContext.RerunCollections,
+                    item.RerunCollectionId.Value,
+                    $"lineup[{index}] RerunCollection",
+                    new NormalizedLineupItem(index, CollectionType.RerunFirstRun, RerunCollectionId: item.RerunCollectionId),
+                    cancellationToken);
+            case LibraryBrowseMediaType.Playlist:
+                if (item.CollectionType != CollectionType.Playlist)
+                {
+                    return Mismatch(index, item);
+                }
+
+                if (!item.PlaylistId.HasValue)
+                {
+                    return WrongId(index, item.MediaType, "playlistId");
+                }
+
+                return await ExistsThen(
+                    dbContext.Playlists,
+                    item.PlaylistId.Value,
+                    $"lineup[{index}] Playlist",
+                    new NormalizedLineupItem(index, CollectionType.Playlist, PlaylistId: item.PlaylistId),
+                    cancellationToken);
+            default:
+                return BaseError.New($"lineup[{index}] has an unsupported media type '{item.MediaType}'.");
+        }
+    }
+
+    private static async Task<Either<BaseError, NormalizedLineupItem>> NormalizeMediaItem<TEntity>(
+        DbSet<TEntity> set,
+        CreateChannelFromLineupItem item,
+        CollectionType expectedType,
+        int index,
+        string label,
+        CancellationToken cancellationToken)
+        where TEntity : class
+    {
+        if (item.CollectionType != expectedType)
+        {
+            return Mismatch(index, item);
+        }
+
+        if (!item.MediaItemId.HasValue)
+        {
+            return WrongId(index, item.MediaType, "mediaItemId");
+        }
+
+        return await ExistsThen(
+            set,
+            item.MediaItemId.Value,
+            $"lineup[{index}] {label}",
+            new NormalizedLineupItem(index, expectedType, MediaItemId: item.MediaItemId),
+            cancellationToken);
+    }
+
+    private static BaseError Mismatch(int index, CreateChannelFromLineupItem item) =>
+        BaseError.New(
+            $"lineup[{index}]: media type '{item.MediaType}' does not match collection type '{item.CollectionType}'.");
+
+    private static BaseError WrongId(int index, LibraryBrowseMediaType mediaType, string expectedField) =>
+        BaseError.New($"lineup[{index}]: media type '{mediaType}' requires a {expectedField}.");
+
+    private static async Task<Either<BaseError, NormalizedLineupItem>> ExistsThen<TEntity>(
+        DbSet<TEntity> set,
+        int id,
+        string label,
+        NormalizedLineupItem normalized,
+        CancellationToken cancellationToken)
+        where TEntity : class
+    {
+        bool exists = await set.AsNoTracking()
+            .AnyAsync(e => EF.Property<int>(e, "Id") == id, cancellationToken);
+        return exists
+            ? normalized
+            : new NotFoundError($"{label} {id} does not exist.");
+    }
+
+    private sealed record NormalizedLineupItem(
+        int Index,
+        CollectionType CollectionType,
+        int? CollectionId = null,
+        int? MultiCollectionId = null,
+        int? SmartCollectionId = null,
+        int? RerunCollectionId = null,
+        int? MediaItemId = null,
+        int? PlaylistId = null);
+
+    private sealed record PreparedCreate(
+        Channel Channel,
+        Playlist Playlist,
+        ProgramSchedule ProgramSchedule,
+        Playout Playout);
+}
@@ -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(
@@ -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.");
-    }
 }
@@ -129,89 +129,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
            List<Playout> playouts = await dbContext.Playouts
                .AsNoTracking()
                .Filter(pi => pi.Channel.Number == (mirrorChannelNumber ?? request.ChannelNumber))
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Studios)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Directors)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Artists)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .ThenInclude(am => am.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as RemoteStream).RemoteStreamMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(sm => sm.Studios)
+                .IncludeGuideMetadata()
                .AsSplitQuery()
                .ToListAsync(cancellationToken);

@@ -244,8 +162,9 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                            item.Finish += playoutOffset;
                        }

-                        await WritePlayoutXml(
+                        await WriteScheduleXml(
                            request,
+                            playout.ScheduleKind,
                            floodSorted,
                            templateContext,
                            movieTemplate,
@@ -270,8 +189,9 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                            item.Finish += playoutOffset;
                        }

-                        await WriteBlockPlayoutXml(
+                        await WriteScheduleXml(
                            request,
+                            playout.ScheduleKind,
                            blockSorted,
                            templateContext,
                            movieTemplate,
@@ -294,8 +214,9 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                            item.Finish += playoutOffset;
                        }

-                        await WritePlayoutXml(
+                        await WriteScheduleXml(
                            request,
+                            playout.ScheduleKind,
                            externalJsonSorted,
                            templateContext,
                            movieTemplate,
@@ -324,100 +245,9 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
        }
    }

-    private async Task WritePlayoutXml(
-        RefreshChannelData request,
-        List<PlayoutItem> sorted,
-        XmlTemplateContext templateContext,
-        Template movieTemplate,
-        Template episodeTemplate,
-        Template musicVideoTemplate,
-        Template songTemplate,
-        Template otherVideoTemplate,
-        Template remoteStreamTemplate,
-        XmlMinifier minifier,
-        XmlWriter xml,
-        CancellationToken cancellationToken)
-    {
-        XmltvTimeZone xmltvTimeZone = await _configElementRepository
-            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken)
-            .IfNoneAsync(XmltvTimeZone.Local);
-
-        // skip all filler that isn't pre-roll
-        var i = 0;
-        while (i < sorted.Count && sorted[i].FillerKind != FillerKind.None &&
-               sorted[i].FillerKind != FillerKind.PreRoll)
-        {
-            i++;
-        }
-
-        while (i < sorted.Count)
-        {
-            PlayoutItem startItem = sorted[i];
-            int j = i;
-            while (sorted[j].FillerKind != FillerKind.None && j + 1 < sorted.Count)
-            {
-                j++;
-            }
-
-            PlayoutItem displayItem = sorted[j];
-            bool hasCustomTitle = !string.IsNullOrWhiteSpace(startItem.CustomTitle);
-
-            int finishIndex = j;
-            while (finishIndex + 1 < sorted.Count && (sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup
-                                                      || sorted[finishIndex + 1].FillerKind is FillerKind.GuideMode
-                                                          or FillerKind.PostRoll or FillerKind.Tail
-                                                          or FillerKind.Fallback or FillerKind.DecoDefault))
-            {
-                finishIndex++;
-            }
-
-            PlayoutItem finishItem = sorted[finishIndex];
-            i = finishIndex;
-
-            DateTimeOffset startTime = xmltvTimeZone switch
-            {
-                XmltvTimeZone.Utc => new DateTimeOffset(startItem.Start, TimeSpan.Zero),
-                _ => startItem.StartOffset
-            };
-
-            DateTimeOffset stopTime = (xmltvTimeZone, displayItem.GuideFinishOffset.HasValue) switch
-            {
-                (XmltvTimeZone.Utc, true) => new DateTimeOffset(displayItem.GuideFinish!.Value, TimeSpan.Zero),
-                (XmltvTimeZone.Utc, false) => new DateTimeOffset(finishItem.Finish, TimeSpan.Zero),
-                (_, true) => displayItem.GuideFinishOffset!.Value,
-                (_, false) => finishItem.FinishOffset
-            };
-
-            string start = startTime
-                .ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                .Replace(":", string.Empty);
-
-            string stop = stopTime
-                .ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                .Replace(":", string.Empty);
-
-            await WriteItemToXml(
-                request,
-                displayItem,
-                start,
-                stop,
-                hasCustomTitle,
-                templateContext,
-                movieTemplate,
-                episodeTemplate,
-                musicVideoTemplate,
-                songTemplate,
-                otherVideoTemplate,
-                remoteStreamTemplate,
-                minifier,
-                xml);
-
-            i++;
-        }
-    }
-
-    private async Task WriteBlockPlayoutXml(
+    private async Task WriteScheduleXml(
        RefreshChannelData request,
+        PlayoutScheduleKind scheduleKind,
        List<PlayoutItem> sorted,
        XmlTemplateContext templateContext,
        Template movieTemplate,
@@ -438,98 +268,36 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
            .GetValue<XmltvBlockBehavior>(ConfigElementKey.XmltvBlockBehavior, cancellationToken)
            .IfNoneAsync(XmltvBlockBehavior.SplitTimeEvenly);

-        var groups = sorted.GroupBy(s => new { s.GuideStart, s.GuideFinish, s.GuideGroup });
-        foreach (var group in groups)
+        // guide-group / filler-merge logic is shared with the JSON guide query so the two cannot drift
+        foreach (ChannelGuideEntry entry in ChannelGuideProjector.Project(
+                     scheduleKind,
+                     sorted,
+                     xmltvTimeZone,
+                     xmltvBlockBehavior))
        {
-            var itemsToInclude = group.Filter(g => g.FillerKind is FillerKind.None).ToList();
-            if (itemsToInclude.Count == 0)
-            {
-                continue;
-            }
+            string start = entry.Start
+                .ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                .Replace(":", string.Empty);

-            switch (xmltvBlockBehavior)
-            {
-                case XmltvBlockBehavior.UseActualTimes:
-                    foreach (PlayoutItem item in itemsToInclude)
-                    {
-                        DateTimeOffset actualStart = xmltvTimeZone switch
-                        {
-                            XmltvTimeZone.Utc => new DateTimeOffset(item.Start, TimeSpan.Zero),
-                            _ => new DateTimeOffset(item.Start, TimeSpan.Zero).ToLocalTime()
-                        };
+            string stop = entry.Stop
+                .ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                .Replace(":", string.Empty);

-                        DateTimeOffset actualFinish = xmltvTimeZone switch
-                        {
-                            XmltvTimeZone.Utc => new DateTimeOffset(item.Finish, TimeSpan.Zero),
-                            _ => new DateTimeOffset(item.Finish, TimeSpan.Zero).ToLocalTime()
-                        };
-
-                        string start = actualStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-                        string stop = actualFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-
-                        await WriteItemToXml(
-                            request,
-                            item,
-                            start,
-                            stop,
-                            false,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml);
-                    }
-                    break;
-                case XmltvBlockBehavior.SplitTimeEvenly:
-                default:
-                    DateTime groupStart = group.Key.GuideStart!.Value;
-                    DateTime groupFinish = group.Key.GuideFinish!.Value;
-                    TimeSpan groupDuration = groupFinish - groupStart;
-
-                    TimeSpan perItem = groupDuration / itemsToInclude.Count;
-
-                    DateTimeOffset currentStart = xmltvTimeZone switch
-                    {
-                        XmltvTimeZone.Utc => new DateTimeOffset(groupStart, TimeSpan.Zero),
-                        _ => new DateTimeOffset(groupStart, TimeSpan.Zero).ToLocalTime()
-                    };
-
-                    DateTimeOffset currentFinish = currentStart + perItem;
-
-                    foreach (PlayoutItem item in itemsToInclude)
-                    {
-                        string start = currentStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-                        string stop = currentFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-
-                        await WriteItemToXml(
-                            request,
-                            item,
-                            start,
-                            stop,
-                            false,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml);
-
-                        currentStart = currentFinish;
-                        currentFinish += perItem;
-                    }
-                    break;
-            }
+            await WriteItemToXml(
+                request,
+                entry.DisplayItem,
+                start,
+                stop,
+                entry.HasCustomTitle,
+                templateContext,
+                movieTemplate,
+                episodeTemplate,
+                musicVideoTemplate,
+                songTemplate,
+                otherVideoTemplate,
+                remoteStreamTemplate,
+                minifier,
+                xml);
        }
    }

@@ -549,8 +317,8 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
        XmlMinifier minifier,
        XmlWriter xml)
    {
-        string title = GetTitle(displayItem);
-        string subtitle = GetSubtitle(displayItem);
+        string title = ChannelGuideMetadata.GetTitle(displayItem);
+        string subtitle = ChannelGuideMetadata.GetSubtitle(displayItem);

        Option<string> maybeTemplateOutput = displayItem.MediaItem switch
        {
@@ -1117,51 +885,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
        return artworkPath;
    }

-    private static string GetTitle(PlayoutItem playoutItem)
-    {
-        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
-        {
-            return playoutItem.CustomTitle;
-        }
-
-        return playoutItem.MediaItem switch
-        {
-            Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title ?? string.Empty)
-                .IfNone("[unknown movie]"),
-            Episode e => e.Season.Show.ShowMetadata.HeadOrNone().Map(em => em.Title ?? string.Empty)
-                .IfNone("[unknown show]"),
-            MusicVideo mv => mv.Artist.ArtistMetadata.HeadOrNone().Map(am => am.Title ?? string.Empty)
-                .IfNone("[unknown artist]"),
-            OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
-                .IfNone("[unknown video]"),
-            RemoteStream rs => rs.RemoteStreamMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
-                .IfNone("[unknown remote stream]"),
-            _ => "[unknown]"
-        };
-    }
-
-    private static string GetSubtitle(PlayoutItem playoutItem)
-    {
-        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
-        {
-            return string.Empty;
-        }
-
-        return playoutItem.MediaItem switch
-        {
-            Episode e => e.EpisodeMetadata.HeadOrNone().Match(
-                em => em.Title ?? string.Empty,
-                () => string.Empty),
-            MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
-                mvm => mvm.Title ?? string.Empty,
-                () => string.Empty),
-            Song s => s.SongMetadata.HeadOrNone().Match(
-                mvm => mvm.Title ?? string.Empty,
-                () => string.Empty),
-            _ => string.Empty
-        };
-    }
-
    private static string GetPrioritizedArtworkPath(Metadata metadata)
    {
        Option<string> maybeArtwork = Optional(metadata.Artwork).Flatten()
@@ -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,
@@ -1,6 +1,8 @@
 using System.Globalization;
+using System.Text.RegularExpressions;
 using System.Threading.Channels;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using Channel = ErsatzTV.Core.Domain.Channel;
@@ -14,18 +16,41 @@ public class UpdateChannelNumbersHandler(
 {
    public async Task<Option<BaseError>> Handle(UpdateChannelNumbers request, CancellationToken cancellationToken)
    {
+        Option<BaseError> validationError = ValidateRequest(request);
+        if (validationError.IsSome)
+        {
+            return validationError;
+        }
+
        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
        await using var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken);

        try
        {
            var numberUpdates = request.Channels.ToDictionary(c => c.Id, c => c.Number);
-            var channelIds = numberUpdates.Keys;
+            List<int> channelIds = numberUpdates.Keys.ToList();

            List<Channel> channelsToUpdate = await dbContext.Channels
                .Where(c => channelIds.Contains(c.Id))
                .ToListAsync(cancellationToken);

+            if (channelsToUpdate.Count != channelIds.Count)
+            {
+                var found = channelsToUpdate.Select(c => c.Id).ToHashSet();
+                int missingId = channelIds.First(id => !found.Contains(id));
+                return new NotFoundError($"Channel {missingId} does not exist.");
+            }
+
+            List<string> requestedNumbers = numberUpdates.Values.ToList();
+            bool numberConflict = await dbContext.Channels
+                .AnyAsync(
+                    c => requestedNumbers.Contains(c.Number) && !channelIds.Contains(c.Id),
+                    cancellationToken);
+            if (numberConflict)
+            {
+                return BaseError.New("Channel number must be unique");
+            }
+
            // give every channel a non-conflicting number
            foreach (var channel in channelsToUpdate)
            {
@@ -69,4 +94,32 @@ public class UpdateChannelNumbersHandler(
            return BaseError.New("Failed to update channel numbers: " + ex.Message);
        }
    }
+
+    private static Option<BaseError> ValidateRequest(UpdateChannelNumbers request)
+    {
+        if (request.Channels.Count == 0)
+        {
+            return BaseError.New("At least one channel is required");
+        }
+
+        if (request.Channels.Select(c => c.Id).Distinct().Count() != request.Channels.Count)
+        {
+            return BaseError.New("Channel ids must be unique");
+        }
+
+        if (request.Channels.Select(c => c.Number).Distinct(StringComparer.Ordinal).Count() != request.Channels.Count)
+        {
+            return BaseError.New("Channel number must be unique");
+        }
+
+        foreach (ChannelSortViewModel channel in request.Channels)
+        {
+            if (!Regex.IsMatch(channel.Number, Channel.NumberValidator))
+            {
+                return BaseError.New("Invalid channel number; two decimals are allowed for subchannels");
+            }
+        }
+
+        return Option<BaseError>.None;
+    }
 }
@@ -42,10 +42,15 @@ internal static class Mapper
        new(
            channel.Id,
            channel.Number,
+            channel.SortNumber,
            channel.Name,
+            channel.Group,
+            channel.Categories,
            channel.FFmpegProfile.Name,
            channel.PreferredAudioLanguageCode,
-            GetStreamingMode(channel));
+            GetStreamingMode(channel),
+            channel.IsEnabled,
+            channel.ShowInEpg);

    internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
        new(resolution.Height, resolution.Width);
@@ -0,0 +1,10 @@
+using ErsatzTV.Core.Api.Channels;
+
+namespace ErsatzTV.Application.Channels;
+
+/// <summary>
+///     JSON channel-guide query for the EPG grid. <paramref name="Start" /> defaults to now and
+///     <paramref name="End" /> defaults to now + the configured XmltvDaysToBuild window.
+/// </summary>
+public record GetChannelGuideData(DateTimeOffset? Start, DateTimeOffset? End)
+    : IRequest<ChannelGuideResponseModel>;
@@ -0,0 +1,145 @@
+using System.Globalization;
+using ErsatzTV.Application.Configuration;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+/// <summary>
+///     Builds the JSON channel guide directly from <see cref="Playout" /> items, using the shared
+///     <see cref="ChannelGuideProjector" /> guide-group/filler-merge logic (the same logic the XMLTV
+///     cache builder uses) so the two representations cannot drift. Only channels with
+///     <see cref="Channel.ShowInEpg" /> are included, mirroring <c>GetChannelGuideHandler</c>.
+///     Unlike XMLTV, filler programmes are returned (with their <see cref="Core.Domain.Filler.FillerKind" />)
+///     so the UI can decide how to render them.
+/// </summary>
+public class GetChannelGuideDataHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository)
+    : IRequestHandler<GetChannelGuideData, ChannelGuideResponseModel>
+{
+    public async Task<ChannelGuideResponseModel> Handle(
+        GetChannelGuideData request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        int daysToBuild = await configElementRepository
+            .GetValue<int>(ConfigElementKey.XmltvDaysToBuild, cancellationToken)
+            .IfNoneAsync(2);
+
+        XmltvTimeZone xmltvTimeZone = await configElementRepository
+            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken)
+            .IfNoneAsync(XmltvTimeZone.Local);
+
+        XmltvBlockBehavior xmltvBlockBehavior = await configElementRepository
+            .GetValue<XmltvBlockBehavior>(ConfigElementKey.XmltvBlockBehavior, cancellationToken)
+            .IfNoneAsync(XmltvBlockBehavior.SplitTimeEvenly);
+
+        DateTimeOffset start = request.Start ?? DateTimeOffset.UtcNow;
+        DateTimeOffset end = request.End ?? start.AddDays(daysToBuild);
+
+        // Visible channels only (mirror GetChannelGuideHandler's ShowInEpg == false skip).
+        List<Channel> channels = await dbContext.Channels
+            .AsNoTracking()
+            .Where(c => c.ShowInEpg)
+            .Include(c => c.MirrorSourceChannel)
+            .ToListAsync(cancellationToken);
+
+        // Order channels by their decimal channel number so "2" precedes "10", matching
+        // ChannelGuide.ToXml (which orders XMLTV channels by decimal.Parse of the number).
+        channels = channels
+            .OrderBy(c => decimal.Parse(c.Number, CultureInfo.InvariantCulture))
+            .ToList();
+
+        var responseChannels = new List<ChannelGuideChannelResponseModel>();
+
+        foreach (Channel channel in channels)
+        {
+            bool isMirror = channel.PlayoutSource == ChannelPlayoutSource.Mirror
+                && channel.MirrorSourceChannel is not null;
+
+            string sourceChannelNumber = isMirror ? channel.MirrorSourceChannel.Number : channel.Number;
+            TimeSpan playoutOffset = isMirror ? channel.PlayoutOffset ?? TimeSpan.Zero : TimeSpan.Zero;
+
+            List<Playout> playouts = await dbContext.Playouts
+                .AsNoTracking()
+                .Filter(p => p.Channel.Number == sourceChannelNumber)
+                .IncludeGuideMetadata()
+                .AsSplitQuery()
+                .ToListAsync(cancellationToken);
+
+            var programmes = new List<ChannelGuideProgrammeResponseModel>();
+
+            foreach (Playout playout in playouts)
+            {
+                // ExternalJson playouts materialize items from a file rather than Playout.Items; they are
+                // out of scope for the JSON guide (see issue #102 notes).
+                if (playout.ScheduleKind is PlayoutScheduleKind.ExternalJson)
+                {
+                    continue;
+                }
+
+                // Filter to the window (on the pre-offset time, mirroring the XMLTV builder) then apply the
+                // mirror playout offset without mutating the loaded (shared, AsNoTracking) entities.
+                List<PlayoutItem> sorted = playout.Items
+                    .OrderBy(pi => pi.Start)
+                    .Filter(pi => pi.StartOffset <= end)
+                    .Select(pi => playoutOffset == TimeSpan.Zero ? pi : WithPlayoutOffset(pi, playoutOffset))
+                    .ToList();
+
+                foreach (ChannelGuideEntry entry in ChannelGuideProjector.Project(
+                             playout.ScheduleKind,
+                             sorted,
+                             xmltvTimeZone,
+                             xmltvBlockBehavior))
+                {
+                    // drop programmes that finish before the requested window starts
+                    if (entry.Stop <= start)
+                    {
+                        continue;
+                    }
+
+                    string subtitle = ChannelGuideMetadata.GetSubtitle(entry.DisplayItem);
+
+                    programmes.Add(
+                        new ChannelGuideProgrammeResponseModel(
+                            entry.Start,
+                            entry.Stop,
+                            ChannelGuideMetadata.GetTitle(entry.DisplayItem),
+                            string.IsNullOrWhiteSpace(subtitle) ? null : subtitle,
+                            ChannelGuideMetadata.GetCategory(entry.DisplayItem),
+                            entry.DisplayItem.FillerKind));
+                }
+            }
+
+            responseChannels.Add(
+                new ChannelGuideChannelResponseModel(
+                    channel.Number,
+                    channel.Name,
+                    programmes.OrderBy(p => p.Start).ToList()));
+        }
+
+        return new ChannelGuideResponseModel(start, end, responseChannels);
+    }
+
+    // Copy (don't mutate) the loaded PlayoutItem when shifting by the mirror playout offset. The loaded
+    // entities are AsNoTracking and shared; mutating them in place would corrupt the guide projection.
+    // Mirrors the XMLTV builder, which shifts only Start/Finish (not the Guide* window).
+    private static PlayoutItem WithPlayoutOffset(PlayoutItem item, TimeSpan offset) =>
+        new()
+        {
+            MediaItem = item.MediaItem,
+            Start = item.Start + offset,
+            Finish = item.Finish + offset,
+            GuideStart = item.GuideStart,
+            GuideFinish = item.GuideFinish,
+            GuideGroup = item.GuideGroup,
+            FillerKind = item.FillerKind,
+            CustomTitle = item.CustomTitle
+        };
+}
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Channels;
+
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelStatesForApi(DateTime Now) : IRequest<List<ChannelStateResponseModel>>;
@@ -0,0 +1,151 @@
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using PlayoutMapper = ErsatzTV.Application.Playouts.Mapper;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelStatesForApiHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IFFmpegSegmenterService ffmpegSegmenterService)
+    : IRequestHandler<GetChannelStatesForApi, List<ChannelStateResponseModel>>
+{
+    // a guide entry (program + surrounding filler) never spans anywhere near a day; the time
+    // bound also protects against GuideGroup values recycling (mod 10000) elsewhere in a playout
+    private static readonly TimeSpan GuideEntryBound = TimeSpan.FromDays(1);
+
+    public async Task<List<ChannelStateResponseModel>> Handle(
+        GetChannelStatesForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<Channel> channels = await dbContext.Channels
+            .AsNoTracking()
+            .OrderBy(c => c.SortNumber)
+            .ThenBy(c => c.Number)
+            .ToListAsync(cancellationToken);
+
+        if (channels.Count == 0)
+        {
+            return [];
+        }
+
+        Dictionary<int, (int SourceChannelId, TimeSpan Offset, DateTime LookupTime)> channelLookup = channels
+            .ToDictionary(
+                c => c.Id,
+                c =>
+                {
+                    TimeSpan offset = c.PlayoutOffset ?? TimeSpan.Zero;
+                    return (c.MirrorSourceChannelId ?? c.Id, offset, request.Now - offset);
+                });
+
+        // one covering-item query per distinct lookup time (i.e. per distinct playout offset,
+        // typically just one) with a cheap projection; metadata is hydrated in a second query
+        // for only the covering items' guide groups
+        var coveringBySourceAndTime = new Dictionary<(int SourceChannelId, DateTime LookupTime), CoveringItem>();
+        foreach (IGrouping<DateTime, (int SourceChannelId, TimeSpan Offset, DateTime LookupTime)> timeGroup in
+                 channelLookup.Values.GroupBy(v => v.LookupTime))
+        {
+            DateTime lookupTime = timeGroup.Key;
+            int[] sourceChannelIds = timeGroup.Map(v => v.SourceChannelId).Distinct().ToArray();
+
+            List<CoveringItem> covering = await dbContext.PlayoutItems
+                .AsNoTracking()
+                .Where(pi => sourceChannelIds.Contains(pi.Playout.ChannelId))
+                .Where(pi => pi.Start <= lookupTime && pi.Finish > lookupTime)
+                .Select(pi => new CoveringItem(pi.Id, pi.PlayoutId, pi.Playout.ChannelId, pi.GuideGroup, pi.Start))
+                .ToListAsync(cancellationToken);
+
+            foreach (CoveringItem item in covering.OrderBy(ci => ci.Start))
+            {
+                coveringBySourceAndTime.TryAdd((item.ChannelId, lookupTime), item);
+            }
+        }
+
+        Dictionary<(int PlayoutId, int GuideGroup), List<PlayoutItem>> itemsByGuideEntry = [];
+        if (coveringBySourceAndTime.Count > 0)
+        {
+            int[] playoutIds = coveringBySourceAndTime.Values.Map(ci => ci.PlayoutId).Distinct().ToArray();
+            int[] guideGroups = coveringBySourceAndTime.Values.Map(ci => ci.GuideGroup).Distinct().ToArray();
+            DateTime windowStart = channelLookup.Values.Min(v => v.LookupTime) - GuideEntryBound;
+            DateTime windowFinish = channelLookup.Values.Max(v => v.LookupTime) + GuideEntryBound;
+
+            List<PlayoutItem> guideEntryItems = await dbContext.PlayoutItems
+                .AsNoTracking()
+                .Include(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Episode).EpisodeMetadata)
+                .Include(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Episode).Season)
+                .ThenInclude(s => s.Show)
+                .ThenInclude(s => s.ShowMetadata)
+                .Include(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Movie).MovieMetadata)
+                .Include(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as MusicVideo).MusicVideoMetadata)
+                .Include(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as MusicVideo).Artist)
+                .ThenInclude(a => a.ArtistMetadata)
+                .Include(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
+                .Include(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Song).SongMetadata)
+                .Include(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Image).ImageMetadata)
+                .Include(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as RemoteStream).RemoteStreamMetadata)
+                .Where(pi => playoutIds.Contains(pi.PlayoutId) && guideGroups.Contains(pi.GuideGroup))
+                .Where(pi => pi.Start <= windowFinish && pi.Finish > windowStart)
+                .ToListAsync(cancellationToken);
+
+            itemsByGuideEntry = guideEntryItems
+                .GroupBy(pi => (pi.PlayoutId, pi.GuideGroup))
+                .ToDictionary(g => g.Key, g => g.OrderBy(pi => pi.Start).ToList());
+        }
+
+        return channels
+            .Map(channel =>
+            {
+                (int sourceChannelId, TimeSpan offset, DateTime lookupTime) = channelLookup[channel.Id];
+                ChannelNowPlayingResponseModel nowPlaying = null;
+
+                if (coveringBySourceAndTime.TryGetValue((sourceChannelId, lookupTime), out CoveringItem covering) &&
+                    itemsByGuideEntry.TryGetValue(
+                        (covering.PlayoutId, covering.GuideGroup),
+                        out List<PlayoutItem> guideEntry))
+                {
+                    // like the XMLTV guide, surface the program rather than its filler: use the
+                    // covering item itself when it is a program part, otherwise the guide entry's
+                    // first program item; an entry with no program item (e.g. offline fallback
+                    // filler) stays null
+                    PlayoutItem coveringItem = guideEntry.Find(pi => pi.Id == covering.Id);
+                    PlayoutItem displayItem = coveringItem?.FillerKind == FillerKind.None
+                        ? coveringItem
+                        : guideEntry.Find(pi => pi.FillerKind == FillerKind.None);
+
+                    if (displayItem is not null)
+                    {
+                        DateTime start = guideEntry[0].Start;
+                        DateTime finish = displayItem.GuideFinish ?? guideEntry.Max(pi => pi.Finish);
+
+                        nowPlaying = new ChannelNowPlayingResponseModel(
+                            PlayoutMapper.GetDisplayTitle(displayItem.MediaItem, Optional(displayItem.ChapterTitle)),
+                            new DateTimeOffset(start + offset, TimeSpan.Zero),
+                            new DateTimeOffset(finish + offset, TimeSpan.Zero));
+                    }
+                }
+
+                return new ChannelStateResponseModel(
+                    channel.Id,
+                    channel.Number,
+                    ffmpegSegmenterService.IsActive(channel.Number),
+                    nowPlaying);
+            })
+            .ToList();
+    }
+
+    private sealed record CoveringItem(int Id, int PlayoutId, int ChannelId, int GuideGroup, DateTime Start);
+}
@@ -10,15 +10,15 @@
    </PropertyGroup>

    <ItemGroup>
-        <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>
@@ -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;
@@ -24,8 +25,15 @@ public class CreateFFmpegProfileHandler :
        CancellationToken cancellationToken)
    {
        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(profile => PersistFFmpegProfile(dbContext, profile));
+        Option<int> maybeResolutionId = await ResolutionMustExist(dbContext, request, cancellationToken);
+        return await maybeResolutionId.Match(
+            Some: async resolutionId =>
+            {
+                Validation<BaseError, FFmpegProfile> validation = Validate(request, resolutionId);
+                return await validation.Apply(profile => PersistFFmpegProfile(dbContext, profile));
+            },
+            None: () => Task.FromResult<Either<BaseError, CreateFFmpegProfileResult>>(
+                new NotFoundError($"[Resolution] {request.ResolutionId} does not exist")));
    }

    private async Task<CreateFFmpegProfileResult> PersistFFmpegProfile(
@@ -38,13 +46,11 @@ public class CreateFFmpegProfileHandler :
        return new CreateFFmpegProfileResult(ffmpegProfile.Id);
    }

-    private static async Task<Validation<BaseError, FFmpegProfile>> Validate(
-        TvContext dbContext,
+    private static Validation<BaseError, FFmpegProfile> Validate(
        CreateFFmpegProfile request,
-        CancellationToken cancellationToken) =>
-        (ValidateName(request), ValidateThreadCount(request),
-            await ResolutionMustExist(dbContext, request, cancellationToken))
-        .Apply((name, threadCount, resolutionId) =>
+        int resolutionId) =>
+        (ValidateName(request), ValidateThreadCount(request))
+        .Apply((name, threadCount) =>
        {
            var hwAccel = request.NormalizeVideo
                ? request.HardwareAcceleration
@@ -110,12 +116,11 @@ public class CreateFFmpegProfileHandler :
    private static Validation<BaseError, int> ValidateThreadCount(CreateFFmpegProfile createFFmpegProfile) =>
        createFFmpegProfile.AtLeast(0)(p => p.ThreadCount);

-    private static Task<Validation<BaseError, int>> ResolutionMustExist(
+    private static Task<Option<int>> ResolutionMustExist(
        TvContext dbContext,
        CreateFFmpegProfile createFFmpegProfile,
        CancellationToken cancellationToken) =>
        dbContext.Resolutions
            .SelectOneAsync(r => r.Id, r => r.Id == createFFmpegProfile.ResolutionId, cancellationToken)
-            .MapT(r => r.Id)
-            .Map(o => o.ToValidation<BaseError>($"[Resolution] {createFFmpegProfile.ResolutionId} does not exist"));
+            .MapT(r => r.Id);
 }
@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
@@ -19,8 +20,19 @@ public class DeleteFFmpegProfileHandler(
        CancellationToken cancellationToken)
    {
        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(p => DoDeletion(dbContext, p));
+        Option<FFmpegProfile> maybeProfile = await FFmpegProfileMustExist(dbContext, request, cancellationToken);
+        return await maybeProfile.Match(
+            Some: async profile =>
+            {
+                Validation<BaseError, FFmpegProfile> validation = await Validate(
+                    dbContext,
+                    request,
+                    profile,
+                    cancellationToken);
+                return await validation.Apply(p => DoDeletion(dbContext, p));
+            },
+            None: () => Task.FromResult<Either<BaseError, Unit>>(
+                new NotFoundError($"FFmpegProfile {request.FFmpegProfileId} does not exist")));
    }

    private async Task<Unit> DoDeletion(TvContext dbContext, FFmpegProfile ffmpegProfile)
@@ -34,19 +46,18 @@ public class DeleteFFmpegProfileHandler(
    private async Task<Validation<BaseError, FFmpegProfile>> Validate(
        TvContext dbContext,
        DeleteFFmpegProfile request,
+        FFmpegProfile profile,
        CancellationToken cancellationToken) =>
        (await FFmpegProfileMustNotBeUsed(dbContext, request, cancellationToken),
-            await FFmpegProfileMustNotBeDefault(request, cancellationToken),
-            await FFmpegProfileMustExist(dbContext, request, cancellationToken))
-        .Apply((_, _, ffmpegProfile) => ffmpegProfile);
+            await FFmpegProfileMustNotBeDefault(request, cancellationToken))
+        .Apply((_, _) => profile);

-    private static Task<Validation<BaseError, FFmpegProfile>> FFmpegProfileMustExist(
+    private static Task<Option<FFmpegProfile>> FFmpegProfileMustExist(
        TvContext dbContext,
        DeleteFFmpegProfile request,
        CancellationToken cancellationToken) =>
        dbContext.FFmpegProfiles
-            .SelectOneAsync(p => p.Id, p => p.Id == request.FFmpegProfileId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {request.FFmpegProfileId} does not exist"));
+            .SelectOneAsync(p => p.Id, p => p.Id == request.FFmpegProfileId, cancellationToken);

    private static async Task<Validation<BaseError, Unit>> FFmpegProfileMustNotBeUsed(
        TvContext dbContext,
@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.FFmpeg.Preset;
@@ -17,8 +18,22 @@ public class UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFa
        CancellationToken cancellationToken)
    {
        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request, cancellationToken));
+        Option<FFmpegProfile> maybeProfile = await FFmpegProfileMustExist(dbContext, request, cancellationToken);
+        return await maybeProfile.Match(
+            Some: async profile =>
+            {
+                Option<int> maybeResolutionId = await ResolutionMustExist(dbContext, request, cancellationToken);
+                return await maybeResolutionId.Match(
+                    Some: async _ =>
+                    {
+                        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request, profile);
+                        return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request, cancellationToken));
+                    },
+                    None: () => Task.FromResult<Either<BaseError, UpdateFFmpegProfileResult>>(
+                        new NotFoundError($"[Resolution] {request.ResolutionId} does not exist")));
+            },
+            None: () => Task.FromResult<Either<BaseError, UpdateFFmpegProfileResult>>(
+                new NotFoundError("FFmpegProfile does not exist.")));
    }

    private async Task<UpdateFFmpegProfileResult> ApplyUpdateRequest(
@@ -109,20 +124,16 @@ public class UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFa
    private static async Task<Validation<BaseError, FFmpegProfile>> Validate(
        TvContext dbContext,
        UpdateFFmpegProfile request,
-        CancellationToken cancellationToken) =>
-        (await FFmpegProfileMustExist(dbContext, request, cancellationToken),
-            await ValidateName(dbContext, request),
-            ValidateThreadCount(request),
-            await ResolutionMustExist(dbContext, request, cancellationToken))
-        .Apply((ffmpegProfileToUpdate, _, _, _) => ffmpegProfileToUpdate);
+        FFmpegProfile profile) =>
+        (await ValidateName(dbContext, request), ValidateThreadCount(request))
+        .Apply((_, _) => profile);

-    private static Task<Validation<BaseError, FFmpegProfile>> FFmpegProfileMustExist(
+    private static Task<Option<FFmpegProfile>> FFmpegProfileMustExist(
        TvContext dbContext,
        UpdateFFmpegProfile updateFFmpegProfile,
        CancellationToken cancellationToken) =>
        dbContext.FFmpegProfiles
-            .SelectOneAsync(p => p.Id, p => p.Id == updateFFmpegProfile.FFmpegProfileId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("FFmpegProfile does not exist."));
+            .SelectOneAsync(p => p.Id, p => p.Id == updateFFmpegProfile.FFmpegProfileId, cancellationToken);

    private static async Task<Validation<BaseError, string>> ValidateName(
        TvContext dbContext,
@@ -147,12 +158,11 @@ public class UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFa
    private static Validation<BaseError, int> ValidateThreadCount(UpdateFFmpegProfile updateFFmpegProfile) =>
        updateFFmpegProfile.AtLeast(0)(p => p.ThreadCount);

-    private static Task<Validation<BaseError, int>> ResolutionMustExist(
+    private static Task<Option<int>> ResolutionMustExist(
        TvContext dbContext,
        UpdateFFmpegProfile updateFFmpegProfile,
        CancellationToken cancellationToken) =>
        dbContext.Resolutions
            .SelectOneAsync(r => r.Id, r => r.Id == updateFFmpegProfile.ResolutionId, cancellationToken)
-            .MapT(r => r.Id)
-            .Map(o => o.ToValidation<BaseError>($"[Resolution] {updateFFmpegProfile.ResolutionId} does not exist"));
+            .MapT(r => r.Id);
 }
@@ -1,9 +1,13 @@
-using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Api.Filler;
+using ErsatzTV.Core.Domain.Filler;

 namespace ErsatzTV.Application.Filler;

 internal static class Mapper
 {
+    internal static FillerPresetResponseModel ProjectToResponseModel(FillerPreset fillerPreset) =>
+        new(fillerPreset.Id, fillerPreset.Name);
+
    internal static FillerPresetViewModel ProjectToViewModel(FillerPreset fillerPreset) =>
        new(
            fillerPreset.Id,
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Filler;
+
+namespace ErsatzTV.Application.Filler;
+
+public record GetAllFillerPresetsForApi : IRequest<List<FillerPresetResponseModel>>;
@@ -0,0 +1,22 @@
+using ErsatzTV.Core.Api.Filler;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Filler.Mapper;
+
+namespace ErsatzTV.Application.Filler;
+
+public class GetAllFillerPresetsForApiHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllFillerPresetsForApi, List<FillerPresetResponseModel>>
+{
+    public async Task<List<FillerPresetResponseModel>> Handle(
+        GetAllFillerPresetsForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        List<FillerPreset> fillerPresets = await dbContext.FillerPresets
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+        return fillerPresets.Map(ProjectToResponseModel).ToList();
+    }
+}
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Graphics;
+
+namespace ErsatzTV.Application.Graphics;
+
+public record GetAllGraphicsElementsForApi : IRequest<List<GraphicsElementResponseModel>>;
@@ -0,0 +1,27 @@
+using ErsatzTV.Core.Api.Graphics;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Graphics.Mapper;
+
+namespace ErsatzTV.Application.Graphics;
+
+public class GetAllGraphicsElementsForApiHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllGraphicsElementsForApi, List<GraphicsElementResponseModel>>
+{
+    public async Task<List<GraphicsElementResponseModel>> Handle(
+        GetAllGraphicsElementsForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        List<GraphicsElement> graphicsElements = await dbContext.GraphicsElements
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+        return graphicsElements
+            .Map(ProjectToViewModel)
+            .OrderBy(e => e.Name == e.FileName)
+            .ThenBy(e => e.Name)
+            .Select(vm => new GraphicsElementResponseModel(vm.Id, vm.Name))
+            .ToList();
+    }
+}
@@ -0,0 +1,24 @@
+using ErsatzTV.Core.Api.Health;
+using ErsatzTV.Core.Health;
+
+namespace ErsatzTV.Application.Health;
+
+internal static class Mapper
+{
+    internal static HealthCheckResponseModel ProjectToResponseModel(HealthCheckResult result) =>
+        new(
+            result.Title,
+            GetStatus(result.Status),
+            result.Message,
+            result.Link.MatchUnsafe(l => l.Link, () => null));
+
+    private static string GetStatus(HealthCheckStatus status) =>
+        status switch
+        {
+            HealthCheckStatus.Pass => "pass",
+            HealthCheckStatus.Fail => "fail",
+            HealthCheckStatus.Warning => "warn",
+            HealthCheckStatus.Info => "info",
+            _ => throw new ArgumentOutOfRangeException(nameof(status), status, null)
+        };
+}
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Health;
+
+namespace ErsatzTV.Application.Health;
+
+public record GetAllHealthCheckResultsForApi : IRequest<List<HealthCheckResponseModel>>;
@@ -0,0 +1,32 @@
+using ErsatzTV.Core.Api.Health;
+using ErsatzTV.Core.Health;
+using static ErsatzTV.Application.Health.Mapper;
+
+namespace ErsatzTV.Application.Health;
+
+public class GetAllHealthCheckResultsForApiHandler
+    : IRequestHandler<GetAllHealthCheckResultsForApi, List<HealthCheckResponseModel>>
+{
+    private readonly IHealthCheckService _healthCheckService;
+
+    public GetAllHealthCheckResultsForApiHandler(IHealthCheckService healthCheckService) =>
+        _healthCheckService = healthCheckService;
+
+    public async Task<List<HealthCheckResponseModel>> Handle(
+        GetAllHealthCheckResultsForApi request,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            List<HealthCheckResult> results = await _healthCheckService.PerformHealthChecks(cancellationToken);
+            return results
+                .Filter(r => r.Status != HealthCheckStatus.NotApplicable)
+                .Map(ProjectToResponseModel)
+                .ToList();
+        }
+        catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
+        {
+            return [];
+        }
+    }
+}
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Libraries;
+
+namespace ErsatzTV.Application.Libraries;
+
+public record GetLibraryScanStatus : IRequest<List<LibraryScanStatusResponseModel>>;
@@ -0,0 +1,20 @@
+using ErsatzTV.Core.Api.Libraries;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Metadata;
+
+namespace ErsatzTV.Application.Libraries;
+
+public class GetLibraryScanStatusHandler(IScannerProxyService scannerProxyService)
+    : IRequestHandler<GetLibraryScanStatus, List<LibraryScanStatusResponseModel>>
+{
+    public Task<List<LibraryScanStatusResponseModel>> Handle(
+        GetLibraryScanStatus request,
+        CancellationToken cancellationToken)
+    {
+        List<LibraryScanStatusResponseModel> result = scannerProxyService.GetActiveScans()
+            .Select(scan => new LibraryScanStatusResponseModel(scan.LibraryId, scan.Progress))
+            .ToList();
+
+        return Task.FromResult(result);
+    }
+}
@@ -0,0 +1,10 @@
+using ErsatzTV.Core.Api.LibraryBrowse;
+
+namespace ErsatzTV.Application.LibraryBrowse;
+
+public record GetLibraryBrowseItems(
+    string Query,
+    int? LibraryId,
+    LibraryBrowseMediaType? MediaType,
+    int PageNum,
+    int PageSize) : IRequest<PagedLibraryBrowseItemsResponseModel>;
@@ -0,0 +1,953 @@
+using ErsatzTV.Core.Api.LibraryBrowse;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Jellyfin;
+using ErsatzTV.Core.Search;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Search;
+using Flurl;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.LibraryBrowse;
+
+public class GetLibraryBrowseItemsHandler(
+    ISearchIndex searchIndex,
+    IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetLibraryBrowseItems, PagedLibraryBrowseItemsResponseModel>
+{
+    private const string LibraryIdField = "library_id";
+
+    public async Task<PagedLibraryBrowseItemsResponseModel> Handle(
+        GetLibraryBrowseItems request,
+        CancellationToken cancellationToken)
+    {
+        int offset = request.PageNum * request.PageSize;
+        SearchResult mediaResult = await SearchMedia(request, offset, request.PageSize, cancellationToken);
+
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<LibraryBrowseItemResponseModel> mediaItems = await HydrateMediaItems(
+            dbContext,
+            mediaResult.Items,
+            cancellationToken);
+
+        int collectionTotal = await CountCollections(dbContext, request, cancellationToken);
+        // Lucene total count can briefly include stale media ids until the async rescan catches up; collection
+        // paging may drift in that window, matching the staleness behavior accepted by the existing search UI.
+        int collectionSkip = Math.Max(0, offset - mediaResult.TotalCount);
+        int collectionTake = request.PageSize - mediaItems.Count;
+        List<LibraryBrowseItemResponseModel> collectionItems = collectionTake > 0
+            ? await GetCollectionItems(dbContext, request, collectionSkip, collectionTake, cancellationToken)
+            : [];
+
+        return new PagedLibraryBrowseItemsResponseModel(
+            mediaResult.TotalCount + collectionTotal,
+            mediaItems.Concat(collectionItems).ToList());
+    }
+
+    private async Task<SearchResult> SearchMedia(
+        GetLibraryBrowseItems request,
+        int offset,
+        int pageSize,
+        CancellationToken cancellationToken)
+    {
+        List<string> typeFilters = MediaTypesFor(request.MediaType).ToList();
+        if (typeFilters.Count == 0)
+        {
+            return new SearchResult([], 0);
+        }
+
+        var clauses = new List<string>
+        {
+            typeFilters.Count == 1
+                ? $"type:{typeFilters[0]}"
+                : $"({string.Join(" OR ", typeFilters.Map(t => $"type:{t}"))})"
+        };
+
+        if (request.LibraryId.HasValue)
+        {
+            clauses.Add($"{LibraryIdField}:{request.LibraryId.Value}");
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.Query))
+        {
+            clauses.Add($"({request.Query})");
+        }
+
+        return await searchIndex.Search(
+            string.Join(" AND ", clauses),
+            string.Empty,
+            offset,
+            pageSize,
+            [LuceneSearchIndex.TitleAndYearSearchField],
+            cancellationToken);
+    }
+
+    private static IEnumerable<string> MediaTypesFor(LibraryBrowseMediaType? mediaType) =>
+        mediaType switch
+        {
+            LibraryBrowseMediaType.Movie => [LuceneSearchIndex.MovieType],
+            LibraryBrowseMediaType.TelevisionShow => [LuceneSearchIndex.ShowType],
+            LibraryBrowseMediaType.TelevisionSeason => [LuceneSearchIndex.SeasonType],
+            LibraryBrowseMediaType.Artist => [LuceneSearchIndex.ArtistType],
+            null =>
+            [
+                LuceneSearchIndex.MovieType,
+                LuceneSearchIndex.ShowType,
+                LuceneSearchIndex.SeasonType,
+                LuceneSearchIndex.ArtistType
+            ],
+            _ => []
+        };
+
+    private static async Task<List<LibraryBrowseItemResponseModel>> HydrateMediaItems(
+        TvContext dbContext,
+        List<SearchItem> searchItems,
+        CancellationToken cancellationToken)
+    {
+        if (searchItems.Count == 0)
+        {
+            return [];
+        }
+
+        List<int> movieIds = searchItems.Where(i => i.Type == LuceneSearchIndex.MovieType).Select(i => i.Id).ToList();
+        List<int> showIds = searchItems.Where(i => i.Type == LuceneSearchIndex.ShowType).Select(i => i.Id).ToList();
+        List<int> seasonIds = searchItems.Where(i => i.Type == LuceneSearchIndex.SeasonType).Select(i => i.Id).ToList();
+        List<int> artistIds = searchItems.Where(i => i.Type == LuceneSearchIndex.ArtistType).Select(i => i.Id).ToList();
+
+        Dictionary<(string Type, int Id), LibraryBrowseItemResponseModel> hydrated = [];
+
+        foreach (LibraryBrowseItemResponseModel item in await GetMovies(dbContext, movieIds, cancellationToken))
+        {
+            hydrated[(LuceneSearchIndex.MovieType, item.Id)] = item;
+        }
+
+        foreach (LibraryBrowseItemResponseModel item in await GetShows(dbContext, showIds, cancellationToken))
+        {
+            hydrated[(LuceneSearchIndex.ShowType, item.Id)] = item;
+        }
+
+        foreach (LibraryBrowseItemResponseModel item in await GetSeasons(dbContext, seasonIds, cancellationToken))
+        {
+            hydrated[(LuceneSearchIndex.SeasonType, item.Id)] = item;
+        }
+
+        foreach (LibraryBrowseItemResponseModel item in await GetArtists(dbContext, artistIds, cancellationToken))
+        {
+            hydrated[(LuceneSearchIndex.ArtistType, item.Id)] = item;
+        }
+
+        return searchItems
+            .Where(i => hydrated.ContainsKey((i.Type, i.Id)))
+            .Select(i => hydrated[(i.Type, i.Id)])
+            .ToList();
+    }
+
+    private static async Task<List<LibraryBrowseItemResponseModel>> GetMovies(
+        TvContext dbContext,
+        List<int> ids,
+        CancellationToken cancellationToken)
+    {
+        if (ids.Count == 0)
+        {
+            return [];
+        }
+
+        return await dbContext.MovieMetadata
+            .AsNoTracking()
+            .Where(mm => ids.Contains(mm.MovieId))
+            .Include(mm => mm.Artwork)
+            .Include(mm => mm.Movie)
+            .ThenInclude(m => m.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(mm => mm.Movie)
+            .ThenInclude(m => m.MediaVersions)
+            .ToListAsync(cancellationToken)
+            .Map(list => list
+                .GroupBy(mm => mm.MovieId)
+                .Select(g => g.OrderBy(mm => mm.Id).First())
+                .Map(mm => new LibraryBrowseItemResponseModel(
+                mm.MovieId,
+                LibraryBrowseMediaType.Movie,
+                mm.Title ?? string.Empty,
+                mm.Movie.LibraryPath.LibraryId,
+                mm.Movie.LibraryPath.Library.Name,
+                Artwork(mm, ArtworkKind.Poster),
+                BestDuration(mm.Movie.MediaVersions),
+                1,
+                null,
+                CollectionType.Movie,
+                null,
+                null,
+                null,
+                null,
+                mm.MovieId,
+                null)).ToList());
+    }
+
+    private static async Task<List<LibraryBrowseItemResponseModel>> GetShows(
+        TvContext dbContext,
+        List<int> ids,
+        CancellationToken cancellationToken)
+    {
+        if (ids.Count == 0)
+        {
+            return [];
+        }
+
+        Dictionary<int, int> counts = await dbContext.Episodes
+            .AsNoTracking()
+            .Where(e => ids.Contains(e.Season.ShowId))
+            .GroupBy(e => e.Season.ShowId)
+            .Select(g => new { ShowId = g.Key, Count = g.Count() })
+            .ToDictionaryAsync(g => g.ShowId, g => g.Count, cancellationToken);
+
+        return await dbContext.ShowMetadata
+            .AsNoTracking()
+            .Where(sm => ids.Contains(sm.ShowId))
+            .Include(sm => sm.Artwork)
+            .Include(sm => sm.Show)
+            .ThenInclude(s => s.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .ToListAsync(cancellationToken)
+            .Map(list => list
+                .GroupBy(sm => sm.ShowId)
+                .Select(g => g.OrderBy(sm => sm.Id).First())
+                .Map(sm => new LibraryBrowseItemResponseModel(
+                sm.ShowId,
+                LibraryBrowseMediaType.TelevisionShow,
+                sm.Title ?? string.Empty,
+                sm.Show.LibraryPath.LibraryId,
+                sm.Show.LibraryPath.Library.Name,
+                Artwork(sm, ArtworkKind.Poster),
+                null,
+                counts.TryGetValue(sm.ShowId, out int count) ? count : 0,
+                null,
+                CollectionType.TelevisionShow,
+                null,
+                null,
+                null,
+                null,
+                sm.ShowId,
+                null)).ToList());
+    }
+
+    private static async Task<List<LibraryBrowseItemResponseModel>> GetSeasons(
+        TvContext dbContext,
+        List<int> ids,
+        CancellationToken cancellationToken)
+    {
+        if (ids.Count == 0)
+        {
+            return [];
+        }
+
+        Dictionary<int, int> counts = await dbContext.Episodes
+            .AsNoTracking()
+            .Where(e => ids.Contains(e.SeasonId))
+            .GroupBy(e => e.SeasonId)
+            .Select(g => new { SeasonId = g.Key, Count = g.Count() })
+            .ToDictionaryAsync(g => g.SeasonId, g => g.Count, cancellationToken);
+
+        return await dbContext.SeasonMetadata
+            .AsNoTracking()
+            .Where(sm => ids.Contains(sm.SeasonId))
+            .Include(sm => sm.Artwork)
+            .Include(sm => sm.Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Include(sm => sm.Season)
+            .ThenInclude(s => s.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .ToListAsync(cancellationToken)
+            .Map(list => list
+                .GroupBy(sm => sm.SeasonId)
+                .Select(g => g.OrderBy(sm => sm.Id).First())
+                .Map(sm => new LibraryBrowseItemResponseModel(
+                sm.SeasonId,
+                LibraryBrowseMediaType.TelevisionSeason,
+                SeasonTitle(sm),
+                sm.Season.LibraryPath.LibraryId,
+                sm.Season.LibraryPath.Library.Name,
+                Artwork(sm, ArtworkKind.Poster),
+                null,
+                counts.TryGetValue(sm.SeasonId, out int count) ? count : 0,
+                null,
+                CollectionType.TelevisionSeason,
+                null,
+                null,
+                null,
+                null,
+                sm.SeasonId,
+                null)).ToList());
+    }
+
+    private static async Task<List<LibraryBrowseItemResponseModel>> GetArtists(
+        TvContext dbContext,
+        List<int> ids,
+        CancellationToken cancellationToken)
+    {
+        if (ids.Count == 0)
+        {
+            return [];
+        }
+
+        Dictionary<int, int> counts = await dbContext.MusicVideos
+            .AsNoTracking()
+            .Where(mv => ids.Contains(mv.ArtistId))
+            .GroupBy(mv => mv.ArtistId)
+            .Select(g => new { ArtistId = g.Key, Count = g.Count() })
+            .ToDictionaryAsync(g => g.ArtistId, g => g.Count, cancellationToken);
+
+        return await dbContext.ArtistMetadata
+            .AsNoTracking()
+            .Where(am => ids.Contains(am.ArtistId))
+            .Include(am => am.Artwork)
+            .Include(am => am.Artist)
+            .ThenInclude(a => a.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .ToListAsync(cancellationToken)
+            .Map(list => list
+                .GroupBy(am => am.ArtistId)
+                .Select(g => g.OrderBy(am => am.Id).First())
+                .Map(am => new LibraryBrowseItemResponseModel(
+                am.ArtistId,
+                LibraryBrowseMediaType.Artist,
+                am.Title ?? string.Empty,
+                am.Artist.LibraryPath.LibraryId,
+                am.Artist.LibraryPath.Library.Name,
+                Artwork(am, ArtworkKind.Thumbnail),
+                null,
+                counts.TryGetValue(am.ArtistId, out int count) ? count : 0,
+                null,
+                CollectionType.Artist,
+                null,
+                null,
+                null,
+                null,
+                am.ArtistId,
+                null)).ToList());
+    }
+
+    private static async Task<int> CountCollections(
+        TvContext dbContext,
+        GetLibraryBrowseItems request,
+        CancellationToken cancellationToken)
+    {
+        int count = 0;
+        if (ShouldInclude(request.MediaType, LibraryBrowseMediaType.Collection))
+        {
+            count += await FilterCollections(dbContext.Collections.AsNoTracking(), request)
+                .CountAsync(cancellationToken);
+        }
+
+        if (!request.LibraryId.HasValue && ShouldInclude(request.MediaType, LibraryBrowseMediaType.SmartCollection))
+        {
+            count += await FilterByName(dbContext.SmartCollections.AsNoTracking(), request.Query)
+                .CountAsync(cancellationToken);
+        }
+
+        if (!request.LibraryId.HasValue && ShouldInclude(request.MediaType, LibraryBrowseMediaType.MultiCollection))
+        {
+            count += await FilterByName(dbContext.MultiCollections.AsNoTracking(), request.Query)
+                .CountAsync(cancellationToken);
+        }
+
+        if (!request.LibraryId.HasValue && ShouldInclude(request.MediaType, LibraryBrowseMediaType.RerunCollection))
+        {
+            count += await FilterByName(dbContext.RerunCollections.AsNoTracking(), request.Query)
+                .CountAsync(cancellationToken);
+        }
+
+        if (!request.LibraryId.HasValue && ShouldInclude(request.MediaType, LibraryBrowseMediaType.Playlist))
+        {
+            count += await FilterByName(dbContext.Playlists.AsNoTracking(), request.Query)
+                .CountAsync(cancellationToken);
+        }
+
+        return count;
+    }
+
+    private static async Task<List<LibraryBrowseItemResponseModel>> GetCollectionItems(
+        TvContext dbContext,
+        GetLibraryBrowseItems request,
+        int skip,
+        int take,
+        CancellationToken cancellationToken)
+    {
+        var results = new List<LibraryBrowseItemResponseModel>();
+
+        int remainingSkip = skip;
+
+        if (ShouldInclude(request.MediaType, LibraryBrowseMediaType.Collection))
+        {
+            IQueryable<Collection> collectionQuery = FilterCollections(dbContext.Collections.AsNoTracking(), request);
+            int count = await collectionQuery.CountAsync(cancellationToken);
+            int pageSkip = Math.Min(remainingSkip, count);
+            remainingSkip -= pageSkip;
+
+            List<Collection> collections = await collectionQuery
+                .OrderBy(c => c.Name)
+                .Skip(pageSkip)
+                .Take(take)
+                .ToListAsync(cancellationToken);
+            List<int> collectionIds = collections.Map(c => c.Id).ToList();
+            Dictionary<int, int> itemCounts = await dbContext.CollectionItems
+                .AsNoTracking()
+                .Where(ci => collectionIds.Contains(ci.CollectionId))
+                .GroupBy(ci => ci.CollectionId)
+                .Select(g => new { CollectionId = g.Key, Count = g.Count() })
+                .ToDictionaryAsync(g => g.CollectionId, g => g.Count, cancellationToken);
+            Dictionary<int, TimeSpan?> durations = await GetManualCollectionDurations(
+                dbContext,
+                collectionIds,
+                cancellationToken);
+            Dictionary<int, string> artwork = await GetManualCollectionArtwork(dbContext, collectionIds, cancellationToken);
+
+            results.AddRange(collections.Map(c => new LibraryBrowseItemResponseModel(
+                c.Id,
+                LibraryBrowseMediaType.Collection,
+                c.Name,
+                null,
+                null,
+                artwork.TryGetValue(c.Id, out string poster) ? poster : string.Empty,
+                durations.TryGetValue(c.Id, out TimeSpan? duration) ? duration : null,
+                itemCounts.TryGetValue(c.Id, out int itemCount) ? itemCount : 0,
+                "Manual",
+                CollectionType.Collection,
+                c.Id,
+                null,
+                null,
+                null,
+                null,
+                null)));
+        }
+
+        if (results.Count >= take || request.LibraryId.HasValue)
+        {
+            return results.Take(take).ToList();
+        }
+
+        remainingSkip = await AppendSmartCollections(dbContext, request, results, remainingSkip, take, cancellationToken);
+        remainingSkip = await AppendMultiCollections(dbContext, request, results, remainingSkip, take, cancellationToken);
+        remainingSkip = await AppendRerunCollections(dbContext, request, results, remainingSkip, take, cancellationToken);
+        await AppendPlaylists(dbContext, request, results, remainingSkip, take, cancellationToken);
+        return results.Take(take).ToList();
+    }
+
+    private static async Task<int> AppendSmartCollections(
+        TvContext dbContext,
+        GetLibraryBrowseItems request,
+        List<LibraryBrowseItemResponseModel> results,
+        int skip,
+        int take,
+        CancellationToken cancellationToken)
+    {
+        if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.SmartCollection) || results.Count >= take)
+        {
+            return skip;
+        }
+
+        IQueryable<SmartCollection> query = FilterByName(dbContext.SmartCollections.AsNoTracking(), request.Query);
+        int count = await query.CountAsync(cancellationToken);
+        int pageSkip = Math.Min(skip, count);
+
+        List<SmartCollection> page = await query
+            .OrderBy(c => c.Name)
+            .Skip(pageSkip)
+            .Take(take - results.Count)
+            .ToListAsync(cancellationToken);
+
+        results.AddRange(page.Map(c => new LibraryBrowseItemResponseModel(
+            c.Id,
+            LibraryBrowseMediaType.SmartCollection,
+            c.Name,
+            null,
+            null,
+            string.Empty,
+            null,
+            null,
+            "Smart",
+            CollectionType.SmartCollection,
+            null,
+            null,
+            c.Id,
+            null,
+            null,
+            null)));
+
+        return skip - pageSkip;
+    }
+
+    private static async Task<int> AppendMultiCollections(
+        TvContext dbContext,
+        GetLibraryBrowseItems request,
+        List<LibraryBrowseItemResponseModel> results,
+        int skip,
+        int take,
+        CancellationToken cancellationToken)
+    {
+        if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.MultiCollection) || results.Count >= take)
+        {
+            return skip;
+        }
+
+        IQueryable<MultiCollection> query = FilterByName(dbContext.MultiCollections.AsNoTracking(), request.Query);
+        int count = await query.CountAsync(cancellationToken);
+        int pageSkip = Math.Min(skip, count);
+
+        List<MultiCollection> page = await query
+            .OrderBy(c => c.Name)
+            .Skip(pageSkip)
+            .Take(take - results.Count)
+            .ToListAsync(cancellationToken);
+        List<int> ids = page.Map(c => c.Id).ToList();
+        Dictionary<int, int> collectionCounts = await dbContext.Set<MultiCollectionItem>()
+            .AsNoTracking()
+            .Where(i => ids.Contains(i.MultiCollectionId))
+            .GroupBy(i => i.MultiCollectionId)
+            .Select(g => new { MultiCollectionId = g.Key, Count = g.Count() })
+            .ToDictionaryAsync(g => g.MultiCollectionId, g => g.Count, cancellationToken);
+        Dictionary<int, int> smartCollectionCounts = await dbContext.Set<MultiCollectionSmartItem>()
+            .AsNoTracking()
+            .Where(i => ids.Contains(i.MultiCollectionId))
+            .GroupBy(i => i.MultiCollectionId)
+            .Select(g => new { MultiCollectionId = g.Key, Count = g.Count() })
+            .ToDictionaryAsync(g => g.MultiCollectionId, g => g.Count, cancellationToken);
+
+        results.AddRange(page.Map(c => new LibraryBrowseItemResponseModel(
+            c.Id,
+            LibraryBrowseMediaType.MultiCollection,
+            c.Name,
+            null,
+            null,
+            string.Empty,
+            null,
+            (collectionCounts.TryGetValue(c.Id, out int collectionCount) ? collectionCount : 0) +
+            (smartCollectionCounts.TryGetValue(c.Id, out int smartCollectionCount) ? smartCollectionCount : 0),
+            "Multi",
+            CollectionType.MultiCollection,
+            null,
+            c.Id,
+            null,
+            null,
+            null,
+            null)));
+
+        return skip - pageSkip;
+    }
+
+    private static async Task<int> AppendRerunCollections(
+        TvContext dbContext,
+        GetLibraryBrowseItems request,
+        List<LibraryBrowseItemResponseModel> results,
+        int skip,
+        int take,
+        CancellationToken cancellationToken)
+    {
+        if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.RerunCollection) || results.Count >= take)
+        {
+            return skip;
+        }
+
+        IQueryable<RerunCollection> query = FilterByName(dbContext.RerunCollections.AsNoTracking(), request.Query);
+        int count = await query.CountAsync(cancellationToken);
+        int pageSkip = Math.Min(skip, count);
+
+        List<RerunCollection> page = await query
+            .OrderBy(c => c.Name)
+            .Skip(pageSkip)
+            .Take(take - results.Count)
+            .ToListAsync(cancellationToken);
+
+        results.AddRange(page.Map(c => new LibraryBrowseItemResponseModel(
+            c.Id,
+            LibraryBrowseMediaType.RerunCollection,
+            c.Name,
+            null,
+            null,
+            string.Empty,
+            null,
+            null,
+            "Rerun",
+            // RerunFirstRun addresses the first-run side; the SPA can substitute RerunRerun for rerun schedule items.
+            CollectionType.RerunFirstRun,
+            null,
+            null,
+            null,
+            c.Id,
+            null,
+            null)));
+
+        return skip - pageSkip;
+    }
+
+    private static async Task AppendPlaylists(
+        TvContext dbContext,
+        GetLibraryBrowseItems request,
+        List<LibraryBrowseItemResponseModel> results,
+        int skip,
+        int take,
+        CancellationToken cancellationToken)
+    {
+        if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.Playlist) || results.Count >= take)
+        {
+            return;
+        }
+
+        IQueryable<Playlist> query = FilterByName(dbContext.Playlists.AsNoTracking(), request.Query);
+        int count = await query.CountAsync(cancellationToken);
+        int pageSkip = Math.Min(skip, count);
+
+        List<Playlist> page = await query
+            .OrderBy(c => c.Name)
+            .Skip(pageSkip)
+            .Take(take - results.Count)
+            .ToListAsync(cancellationToken);
+        List<int> ids = page.Map(c => c.Id).ToList();
+        Dictionary<int, int> itemCounts = await dbContext.PlaylistItems
+            .AsNoTracking()
+            .Where(i => ids.Contains(i.PlaylistId))
+            .GroupBy(i => i.PlaylistId)
+            .Select(g => new { PlaylistId = g.Key, Count = g.Count() })
+            .ToDictionaryAsync(g => g.PlaylistId, g => g.Count, cancellationToken);
+
+        results.AddRange(page.Map(c => new LibraryBrowseItemResponseModel(
+            c.Id,
+            LibraryBrowseMediaType.Playlist,
+            c.Name,
+            null,
+            null,
+            string.Empty,
+            null,
+            itemCounts.TryGetValue(c.Id, out int itemCount) ? itemCount : 0,
+            null,
+            CollectionType.Playlist,
+            null,
+            null,
+            null,
+            null,
+            null,
+            c.Id)));
+    }
+
+    private static IQueryable<Collection> FilterCollections(
+        IQueryable<Collection> query,
+        GetLibraryBrowseItems request)
+    {
+        query = FilterByName(query, request.Query);
+        if (request.LibraryId.HasValue)
+        {
+            query = query.Where(c => c.MediaItems.Any(mi => mi.LibraryPath.LibraryId == request.LibraryId.Value));
+        }
+
+        return query;
+    }
+
+    private static IQueryable<T> FilterByName<T>(IQueryable<T> query, string searchQuery)
+        where T : class
+    {
+        if (string.IsNullOrWhiteSpace(searchQuery))
+        {
+            return query;
+        }
+
+        return query.Where(c => EF.Functions.Like(EF.Property<string>(c, "Name"), $"%{EscapeLike(searchQuery)}%", "\\"));
+    }
+
+    private static bool ShouldInclude(LibraryBrowseMediaType? requestType, LibraryBrowseMediaType itemType) =>
+        requestType is null || requestType == itemType;
+
+    private static TimeSpan? BestDuration(IEnumerable<MediaVersion> versions)
+    {
+        TimeSpan duration = versions
+            .Select(v => v.Duration)
+            .Where(d => d > TimeSpan.Zero)
+            .DefaultIfEmpty()
+            .Max();
+        return duration > TimeSpan.Zero ? duration : null;
+    }
+
+    private static async Task<Dictionary<int, TimeSpan?>> GetManualCollectionDurations(
+        TvContext dbContext,
+        List<int> collectionIds,
+        CancellationToken cancellationToken)
+    {
+        List<CollectionMediaItem> items = await GetCollectionMediaItems(dbContext, collectionIds, cancellationToken);
+        List<int> mediaItemIds = items.Map(i => i.MediaItemId).Distinct().ToList();
+        Dictionary<int, TimeSpan> mediaItemDurations = [];
+
+        foreach (Movie movie in await dbContext.Movies
+                     .AsNoTracking()
+                     .Where(m => mediaItemIds.Contains(m.Id))
+                     .Include(m => m.MediaVersions)
+                     .ToListAsync(cancellationToken))
+        {
+            TimeSpan? duration = BestDuration(movie.MediaVersions);
+            if (duration.HasValue)
+            {
+                mediaItemDurations[movie.Id] = duration.Value;
+            }
+        }
+
+        foreach (Episode episode in await dbContext.Episodes
+                     .AsNoTracking()
+                     .Where(e => mediaItemIds.Contains(e.Id))
+                     .Include(e => e.MediaVersions)
+                     .ToListAsync(cancellationToken))
+        {
+            TimeSpan? duration = BestDuration(episode.MediaVersions);
+            if (duration.HasValue)
+            {
+                mediaItemDurations[episode.Id] = duration.Value;
+            }
+        }
+
+        foreach (MusicVideo musicVideo in await dbContext.MusicVideos
+                     .AsNoTracking()
+                     .Where(mv => mediaItemIds.Contains(mv.Id))
+                     .Include(mv => mv.MediaVersions)
+                     .ToListAsync(cancellationToken))
+        {
+            TimeSpan? duration = BestDuration(musicVideo.MediaVersions);
+            if (duration.HasValue)
+            {
+                mediaItemDurations[musicVideo.Id] = duration.Value;
+            }
+        }
+
+        foreach (OtherVideo otherVideo in await dbContext.OtherVideos
+                     .AsNoTracking()
+                     .Where(ov => mediaItemIds.Contains(ov.Id))
+                     .Include(ov => ov.MediaVersions)
+                     .ToListAsync(cancellationToken))
+        {
+            TimeSpan? duration = BestDuration(otherVideo.MediaVersions);
+            if (duration.HasValue)
+            {
+                mediaItemDurations[otherVideo.Id] = duration.Value;
+            }
+        }
+
+        foreach (Song song in await dbContext.Songs
+                     .AsNoTracking()
+                     .Where(s => mediaItemIds.Contains(s.Id))
+                     .Include(s => s.MediaVersions)
+                     .ToListAsync(cancellationToken))
+        {
+            TimeSpan? duration = BestDuration(song.MediaVersions);
+            if (duration.HasValue)
+            {
+                mediaItemDurations[song.Id] = duration.Value;
+            }
+        }
+
+        foreach (Image image in await dbContext.Images
+                     .AsNoTracking()
+                     .Where(i => mediaItemIds.Contains(i.Id))
+                     .Include(i => i.MediaVersions)
+                     .ToListAsync(cancellationToken))
+        {
+            TimeSpan? duration = BestDuration(image.MediaVersions);
+            if (duration.HasValue)
+            {
+                mediaItemDurations[image.Id] = duration.Value;
+            }
+        }
+
+        foreach (RemoteStream remoteStream in await dbContext.RemoteStreams
+                     .AsNoTracking()
+                     .Where(rs => mediaItemIds.Contains(rs.Id))
+                     .Include(rs => rs.MediaVersions)
+                     .ToListAsync(cancellationToken))
+        {
+            TimeSpan? duration = BestDuration(remoteStream.MediaVersions);
+            if (duration.HasValue)
+            {
+                mediaItemDurations[remoteStream.Id] = duration.Value;
+            }
+        }
+
+        return items
+            .Where(i => mediaItemDurations.ContainsKey(i.MediaItemId))
+            .GroupBy(i => i.CollectionId)
+            .ToDictionary(
+                g => g.Key,
+                g => (TimeSpan?)g.Aggregate(TimeSpan.Zero, (sum, item) => sum + mediaItemDurations[item.MediaItemId]));
+    }
+
+    private static async Task<Dictionary<int, string>> GetManualCollectionArtwork(
+        TvContext dbContext,
+        List<int> collectionIds,
+        CancellationToken cancellationToken)
+    {
+        List<CollectionMediaItem> items = await GetCollectionMediaItems(dbContext, collectionIds, cancellationToken);
+        List<int> mediaItemIds = items.Map(i => i.MediaItemId).Distinct().ToList();
+        Dictionary<int, string> mediaItemArtwork = [];
+
+        foreach (MovieMetadata metadata in await dbContext.MovieMetadata
+                     .AsNoTracking()
+                     .Where(mm => mediaItemIds.Contains(mm.MovieId))
+                     .Include(mm => mm.Artwork)
+                     .OrderBy(mm => mm.Id)
+                     .ToListAsync(cancellationToken))
+        {
+            string poster = Artwork(metadata, ArtworkKind.Poster);
+            if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.MovieId))
+            {
+                mediaItemArtwork[metadata.MovieId] = poster;
+            }
+        }
+
+        foreach (ShowMetadata metadata in await dbContext.ShowMetadata
+                     .AsNoTracking()
+                     .Where(sm => mediaItemIds.Contains(sm.ShowId))
+                     .Include(sm => sm.Artwork)
+                     .OrderBy(sm => sm.Id)
+                     .ToListAsync(cancellationToken))
+        {
+            string poster = Artwork(metadata, ArtworkKind.Poster);
+            if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.ShowId))
+            {
+                mediaItemArtwork[metadata.ShowId] = poster;
+            }
+        }
+
+        foreach (SeasonMetadata metadata in await dbContext.SeasonMetadata
+                     .AsNoTracking()
+                     .Where(sm => mediaItemIds.Contains(sm.SeasonId))
+                     .Include(sm => sm.Artwork)
+                     .OrderBy(sm => sm.Id)
+                     .ToListAsync(cancellationToken))
+        {
+            string poster = Artwork(metadata, ArtworkKind.Poster);
+            if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.SeasonId))
+            {
+                mediaItemArtwork[metadata.SeasonId] = poster;
+            }
+        }
+
+        foreach (OtherVideoMetadata metadata in await dbContext.OtherVideoMetadata
+                     .AsNoTracking()
+                     .Where(ovm => mediaItemIds.Contains(ovm.OtherVideoId))
+                     .Include(ovm => ovm.Artwork)
+                     .OrderBy(ovm => ovm.Id)
+                     .ToListAsync(cancellationToken))
+        {
+            string poster = Artwork(metadata, ArtworkKind.Poster);
+            if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.OtherVideoId))
+            {
+                mediaItemArtwork[metadata.OtherVideoId] = poster;
+            }
+        }
+
+        foreach (SongMetadata metadata in await dbContext.SongMetadata
+                     .AsNoTracking()
+                     .Where(sm => mediaItemIds.Contains(sm.SongId))
+                     .Include(sm => sm.Artwork)
+                     .OrderBy(sm => sm.Id)
+                     .ToListAsync(cancellationToken))
+        {
+            string poster = Artwork(metadata, ArtworkKind.Poster);
+            if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.SongId))
+            {
+                mediaItemArtwork[metadata.SongId] = poster;
+            }
+        }
+
+        foreach (ImageMetadata metadata in await dbContext.ImageMetadata
+                     .AsNoTracking()
+                     .Where(im => mediaItemIds.Contains(im.ImageId))
+                     .Include(im => im.Artwork)
+                     .OrderBy(im => im.Id)
+                     .ToListAsync(cancellationToken))
+        {
+            string poster = Artwork(metadata, ArtworkKind.Poster);
+            if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.ImageId))
+            {
+                mediaItemArtwork[metadata.ImageId] = poster;
+            }
+        }
+
+        foreach (RemoteStreamMetadata metadata in await dbContext.RemoteStreamMetadata
+                     .AsNoTracking()
+                     .Where(rsm => mediaItemIds.Contains(rsm.RemoteStreamId))
+                     .Include(rsm => rsm.Artwork)
+                     .OrderBy(rsm => rsm.Id)
+                     .ToListAsync(cancellationToken))
+        {
+            string poster = Artwork(metadata, ArtworkKind.Poster);
+            if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.RemoteStreamId))
+            {
+                mediaItemArtwork[metadata.RemoteStreamId] = poster;
+            }
+        }
+
+        return items
+            .Where(i => mediaItemArtwork.ContainsKey(i.MediaItemId))
+            .GroupBy(i => i.CollectionId)
+            .ToDictionary(
+                g => g.Key,
+                g => mediaItemArtwork[g.OrderBy(i => i.CustomIndex ?? int.MaxValue).ThenBy(i => i.MediaItemId).First().MediaItemId]);
+    }
+
+    private static async Task<List<CollectionMediaItem>> GetCollectionMediaItems(
+        TvContext dbContext,
+        List<int> collectionIds,
+        CancellationToken cancellationToken) =>
+        await dbContext.CollectionItems
+            .AsNoTracking()
+            .Where(ci => collectionIds.Contains(ci.CollectionId))
+            .Select(ci => new CollectionMediaItem(ci.CollectionId, ci.MediaItemId, ci.CustomIndex))
+            .ToListAsync(cancellationToken);
+
+    private static string SeasonTitle(SeasonMetadata metadata)
+    {
+        string showTitle = metadata.Season.Show.ShowMetadata.HeadOrNone()
+            .Map(sm => sm.Title ?? string.Empty)
+            .IfNone(string.Empty);
+        string seasonTitle = metadata.Season.SeasonNumber == 0
+            ? "Specials"
+            : $"Season {metadata.Season.SeasonNumber}";
+        return string.IsNullOrWhiteSpace(showTitle) ? seasonTitle : $"{showTitle} - {seasonTitle}";
+    }
+
+    private static string Artwork(Metadata metadata, ArtworkKind artworkKind)
+    {
+        string artwork = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
+            .Match(a => a.Path, string.Empty);
+
+        if (artwork.StartsWith("jellyfin://", StringComparison.OrdinalIgnoreCase))
+        {
+            Url url = JellyfinUrl.RelativeProxyForArtwork(artwork);
+            if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
+            {
+                url.SetQueryParam("fillHeight", 440);
+            }
+
+            return url;
+        }
+
+        if (artwork.StartsWith("emby://", StringComparison.OrdinalIgnoreCase))
+        {
+            Url url = EmbyUrl.RelativeProxyForArtwork(artwork);
+            if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
+            {
+                url.SetQueryParam("maxHeight", 440);
+            }
+
+            return url;
+        }
+
+        return artwork;
+    }
+
+    private static string EscapeLike(string searchQuery) =>
+        searchQuery
+            .Replace("\\", "\\\\", StringComparison.Ordinal)
+            .Replace("%", "\\%", StringComparison.Ordinal)
+            .Replace("_", "\\_", StringComparison.Ordinal);
+
+    private sealed record CollectionMediaItem(int CollectionId, int MediaItemId, int? CustomIndex);
+}
@@ -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);
 }
@@ -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);
 }
@@ -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);
 }
@@ -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);
 }
@@ -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,
@@ -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,
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.MediaSources;
+
+namespace ErsatzTV.Application.MediaSources;
+
+public record GetAllMediaSourcesForApi : IRequest<List<MediaSourceResponseModel>>;
@@ -0,0 +1,146 @@
+#nullable enable
+using ErsatzTV.Core.Api.MediaSources;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaSources;
+
+public class GetAllMediaSourcesForApiHandler(
+    IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllMediaSourcesForApi, List<MediaSourceResponseModel>>
+{
+    public async Task<List<MediaSourceResponseModel>> Handle(
+        GetAllMediaSourcesForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<MediaSource> mediaSources = await dbContext.MediaSources
+                .AsNoTracking()
+                .Include(s => s.Libraries)
+                .ThenInclude(l => l.Paths)
+                .ToListAsync(cancellationToken);
+
+        Dictionary<int, int> itemCountsByLibrary = await GetItemCountsByLibrary(dbContext, cancellationToken);
+        Dictionary<int, string> addressByMediaSourceId = await GetConnectionAddresses(dbContext, cancellationToken);
+
+        var result = new List<MediaSourceResponseModel>();
+        foreach (MediaSource mediaSource in mediaSources)
+        {
+            List<MediaSourceLibraryResponseModel> libraryModels = mediaSource.Libraries
+                .Filter(ShouldIncludeLibrary)
+                .OrderBy(l => l.MediaKind)
+                .ThenBy(l => l.Name)
+                .Map(l => new MediaSourceLibraryResponseModel(
+                    l.Id,
+                    l.Name,
+                    l.MediaKind,
+                    l.LastScan,
+                    itemCountsByLibrary.TryGetValue(l.Id, out int count) ? count : 0))
+                .ToList();
+
+            string? address = addressByMediaSourceId.TryGetValue(mediaSource.Id, out string? a) ? a : null;
+
+            result.Add(
+                new MediaSourceResponseModel(
+                    mediaSource.Id,
+                    GetKind(mediaSource),
+                    GetName(mediaSource),
+                    address,
+                    libraryModels));
+        }
+
+        return result
+            .OrderBy(s => s.Kind == "Local" ? 0 : 1)
+            .ThenBy(s => s.Kind)
+            .ThenBy(s => s.Name)
+            .ToList();
+    }
+
+    private static async Task<Dictionary<int, int>> GetItemCountsByLibrary(
+        TvContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        // EF instead of Dapper: with zero rows, Microsoft.Data.Sqlite reports the
+        // COUNT(*) column as BLOB, so Dapper builds an incompatible deserializer
+        // and every fresh (empty) database returned 500 from this endpoint.
+        var counts = await dbContext.MediaItems
+            .AsNoTracking()
+            .GroupBy(mi => mi.LibraryPath.LibraryId)
+            .Select(g => new { LibraryId = g.Key, Count = g.Count() })
+            .ToListAsync(cancellationToken);
+
+        return counts.ToDictionary(c => c.LibraryId, c => c.Count);
+    }
+
+    private static async Task<Dictionary<int, string>> GetConnectionAddresses(
+        TvContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        var addresses = new Dictionary<int, string>();
+
+        foreach (PlexMediaSource plex in await dbContext.PlexMediaSources
+                     .AsNoTracking()
+                     .Include(s => s.Connections)
+                     .ToListAsync(cancellationToken))
+        {
+            foreach (PlexConnection connection in Optional(plex.Connections.SingleOrDefault(c => c.IsActive)))
+            {
+                addresses[plex.Id] = connection.Uri;
+            }
+        }
+
+        foreach (JellyfinMediaSource jellyfin in await dbContext.JellyfinMediaSources
+                     .AsNoTracking()
+                     .Include(s => s.Connections)
+                     .ToListAsync(cancellationToken))
+        {
+            foreach (JellyfinConnection connection in jellyfin.Connections.HeadOrNone())
+            {
+                addresses[jellyfin.Id] = connection.Address;
+            }
+        }
+
+        foreach (EmbyMediaSource emby in await dbContext.EmbyMediaSources
+                     .AsNoTracking()
+                     .Include(s => s.Connections)
+                     .ToListAsync(cancellationToken))
+        {
+            foreach (EmbyConnection connection in emby.Connections.HeadOrNone())
+            {
+                addresses[emby.Id] = connection.Address;
+            }
+        }
+
+        return addresses;
+    }
+
+    private static bool ShouldIncludeLibrary(Library library) =>
+        library switch
+        {
+            LocalLibrary => library.Paths.Count > 0,
+            PlexLibrary plex => plex.ShouldSyncItems,
+            JellyfinLibrary jellyfin => jellyfin.ShouldSyncItems,
+            EmbyLibrary emby => emby.ShouldSyncItems,
+            _ => false
+        };
+
+    private static string GetKind(MediaSource mediaSource) =>
+        mediaSource switch
+        {
+            PlexMediaSource => "Plex",
+            JellyfinMediaSource => "Jellyfin",
+            EmbyMediaSource => "Emby",
+            _ => "Local"
+        };
+
+    private static string GetName(MediaSource mediaSource) =>
+        mediaSource switch
+        {
+            PlexMediaSource plex => plex.ServerName,
+            JellyfinMediaSource jellyfin => jellyfin.ServerName,
+            EmbyMediaSource emby => emby.ServerName,
+            _ => "Local"
+        };
+}
@@ -2,6 +2,7 @@
 using ErsatzTV.Application.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -28,8 +29,23 @@ public class CreateClassicPlayoutHandler : IRequestHandler<CreateClassicPlayout,
        CancellationToken cancellationToken)
    {
        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Playout> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(playout => PersistPlayout(dbContext, playout));
+        Option<Channel> maybeChannel = await GetChannel(dbContext, request, cancellationToken);
+        return await maybeChannel.Match(
+            Some: async channel =>
+            {
+                Option<ProgramSchedule> maybeProgramSchedule =
+                    await GetProgramSchedule(dbContext, request, cancellationToken);
+                return await maybeProgramSchedule.Match(
+                    Some: async programSchedule =>
+                    {
+                        Validation<BaseError, Playout> validation = Validate(request, channel, programSchedule);
+                        return await validation.Apply(playout => PersistPlayout(dbContext, playout));
+                    },
+                    None: () => Task.FromResult<Either<BaseError, CreatePlayoutResponse>>(
+                        new NotFoundError("Program schedule does not exist")));
+            },
+            None: () => Task.FromResult<Either<BaseError, CreatePlayoutResponse>>(
+                new NotFoundError("Channel does not exist")));
    }

    private async Task<CreatePlayoutResponse> PersistPlayout(TvContext dbContext, Playout playout)
@@ -46,12 +62,12 @@ public class CreateClassicPlayoutHandler : IRequestHandler<CreateClassicPlayout,
        return new CreatePlayoutResponse(playout.Id);
    }

-    private static async Task<Validation<BaseError, Playout>> Validate(
-        TvContext dbContext,
+    private static Validation<BaseError, Playout> Validate(
        CreateClassicPlayout request,
-        CancellationToken cancellationToken) =>
-        (await ValidateChannel(dbContext, request, cancellationToken),
-            await ValidateProgramSchedule(dbContext, request, cancellationToken),
+        Channel channel,
+        ProgramSchedule programSchedule) =>
+        (ChannelMustNotHavePlayouts(channel),
+            ProgramScheduleMustHaveItems(programSchedule),
            ValidateScheduleKind(request))
        .Apply((channel, programSchedule, scheduleKind) => new Playout
        {
@@ -60,15 +76,13 @@ public class CreateClassicPlayoutHandler : IRequestHandler<CreateClassicPlayout,
            ScheduleKind = scheduleKind
        });

-    private static Task<Validation<BaseError, Channel>> ValidateChannel(
+    private static Task<Option<Channel>> GetChannel(
        TvContext dbContext,
        CreateClassicPlayout createClassicPlayout,
        CancellationToken cancellationToken) =>
        dbContext.Channels
            .Include(c => c.Playouts)
-            .SelectOneAsync(c => c.Id, c => c.Id == createClassicPlayout.ChannelId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("Channel does not exist"))
-            .BindT(ChannelMustNotHavePlayouts);
+            .SelectOneAsync(c => c.Id, c => c.Id == createClassicPlayout.ChannelId, cancellationToken);

    private static Validation<BaseError, Channel> ChannelMustNotHavePlayouts(Channel channel) =>
        Optional(channel.Playouts.Count)
@@ -76,15 +90,13 @@ public class CreateClassicPlayoutHandler : IRequestHandler<CreateClassicPlayout,
            .Map(_ => channel)
            .ToValidation<BaseError>("Channel already has one playout");

-    private static Task<Validation<BaseError, ProgramSchedule>> ValidateProgramSchedule(
+    private static Task<Option<ProgramSchedule>> GetProgramSchedule(
        TvContext dbContext,
        CreateClassicPlayout createClassicPlayout,
        CancellationToken cancellationToken) =>
        dbContext.ProgramSchedules
            .Include(ps => ps.Items)
-            .SelectOneAsync(ps => ps.Id, ps => ps.Id == createClassicPlayout.ProgramScheduleId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("Program schedule does not exist"))
-            .BindT(ProgramScheduleMustHaveItems);
+            .SelectOneAsync(ps => ps.Id, ps => ps.Id == createClassicPlayout.ProgramScheduleId, cancellationToken);

    private static Validation<BaseError, ProgramSchedule> ProgramScheduleMustHaveItems(
        ProgramSchedule programSchedule) =>
@@ -3,6 +3,7 @@ using System.Threading.Channels;
 using ErsatzTV.Application.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Notifications;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -45,6 +46,6 @@ public class DeletePlayoutHandler(

        return maybePlayout
            .Map(_ => Unit.Default)
-            .ToEither(BaseError.New($"Playout {request.PlayoutId} does not exist."));
+            .ToEither<BaseError>(new NotFoundError($"Playout {request.PlayoutId} does not exist."));
    }
 }
@@ -16,6 +16,7 @@ public class GetPlayoutByIdHandler(IDbContextFactory<TvContext> dbContextFactory
            .AsNoTracking()
            .Include(p => p.ProgramSchedule)
            .Include(p => p.Channel)
+            .Include(p => p.BuildStatus)
            .SelectOneAsync(p => p.Id, p => p.Id == request.PlayoutId, cancellationToken)
            .MapT(p => new PlayoutNameViewModel(
                p.Id,
@@ -2,6 +2,7 @@
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
@@ -28,8 +29,16 @@ public class AddProgramScheduleItemHandler : ProgramScheduleItemCommandBase,
        CancellationToken cancellationToken)
    {
        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(ps => PersistItem(dbContext, request, ps, cancellationToken));
+        Option<ProgramSchedule> maybeProgramSchedule =
+            await ProgramScheduleMustExist(dbContext, request.ProgramScheduleId, cancellationToken);
+        return await maybeProgramSchedule.Match(
+            Some: async programSchedule =>
+            {
+                Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request, programSchedule);
+                return await validation.Apply(ps => PersistItem(dbContext, request, ps, cancellationToken));
+            },
+            None: () => Task.FromResult<Either<BaseError, ProgramScheduleItemViewModel>>(
+                new NotFoundError("[ProgramScheduleId] does not exist.")));
    }

    private async Task<ProgramScheduleItemViewModel> PersistItem(
@@ -54,10 +63,25 @@ public class AddProgramScheduleItemHandler : ProgramScheduleItemCommandBase,
        return ProjectToViewModel(item);
    }

-    private static Task<Validation<BaseError, ProgramSchedule>> Validate(
+    private static async Task<Validation<BaseError, ProgramSchedule>> Validate(
        TvContext dbContext,
        AddProgramScheduleItem request,
-        CancellationToken cancellationToken) =>
-        ProgramScheduleMustExist(dbContext, request.ProgramScheduleId, cancellationToken)
-            .BindT(programSchedule => PlayoutModeMustBeValid(request, programSchedule));
+        ProgramSchedule programSchedule)
+    {
+        Validation<BaseError, ProgramSchedule> validation =
+            PlayoutModeMustBeValid(request, programSchedule)
+                .Bind(programSchedule => CollectionTypeMustBeValid(request, programSchedule));
+
+        return await validation.ToEither().Match(
+            Left: error => Task.FromResult<Validation<BaseError, ProgramSchedule>>(
+                Fail<BaseError, ProgramSchedule>(error)),
+            Right: async validProgramSchedule =>
+            {
+                Either<BaseError, ProgramSchedule> fillerResult = await FillerConfigurationMustBeValid(
+                    dbContext,
+                    request,
+                    validProgramSchedule);
+                return fillerResult.ToValidation();
+            });
+    }
 }
@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -18,11 +19,14 @@ public class DeleteProgramScheduleHandler : IRequestHandler<DeleteProgramSchedul
        CancellationToken cancellationToken)
    {
        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, ProgramSchedule> validation = await ProgramScheduleMustExist(
+        Option<ProgramSchedule> maybeProgramSchedule = await ProgramScheduleMustExist(
            dbContext,
            request,
            cancellationToken);
-        return await validation.Apply(ps => DoDeletion(dbContext, ps));
+        return await maybeProgramSchedule.Match(
+            Some: programSchedule => DoDeletion(dbContext, programSchedule).Map(Right<BaseError, Unit>),
+            None: () => Task.FromResult<Either<BaseError, Unit>>(
+                new NotFoundError($"ProgramSchedule {request.ProgramScheduleId} does not exist.")));
    }

    private static Task<Unit> DoDeletion(TvContext dbContext, ProgramSchedule programSchedule)
@@ -31,11 +35,11 @@ public class DeleteProgramScheduleHandler : IRequestHandler<DeleteProgramSchedul
        return dbContext.SaveChangesAsync().ToUnit();
    }

-    private static Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
+    private static Task<Option<ProgramSchedule>> ProgramScheduleMustExist(
        TvContext dbContext,
        DeleteProgramSchedule request,
        CancellationToken cancellationToken) =>
        dbContext.ProgramSchedules
            .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.ProgramScheduleId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>($"ProgramSchedule {request.ProgramScheduleId} does not exist."));
+            .Map(identity);
 }
@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record DeleteProgramScheduleItem(int ProgramScheduleId, int ProgramScheduleItemId)
+    : IRequest<Either<BaseError, Unit>>;
@@ -0,0 +1,46 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Scheduling;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class DeleteProgramScheduleItemHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    ChannelWriter<IBackgroundServiceRequest> channel) : IRequestHandler<DeleteProgramScheduleItem, Either<BaseError, Unit>>
+{
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteProgramScheduleItem request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        ProgramScheduleItem item = await dbContext.ProgramScheduleItems
+            .Include(i => i.ProgramSchedule)
+            .ThenInclude(ps => ps.Playouts)
+            .SingleOrDefaultAsync(
+                i => i.Id == request.ProgramScheduleItemId && i.ProgramScheduleId == request.ProgramScheduleId,
+                cancellationToken);
+
+        if (item is null)
+        {
+            return new NotFoundError(
+                $"ProgramScheduleItem {request.ProgramScheduleItemId} does not exist on schedule {request.ProgramScheduleId}.");
+        }
+
+        List<Playout> playouts = item.ProgramSchedule.Playouts;
+        dbContext.ProgramScheduleItems.Remove(item);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        foreach (Playout playout in playouts)
+        {
+            await channel.WriteAsync(new BuildPlayout(playout.Id, PlayoutBuildMode.Refresh), cancellationToken);
+        }
+
+        return Unit.Default;
+    }
+}
@@ -1,6 +1,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -9,7 +10,7 @@ namespace ErsatzTV.Application.ProgramSchedules;

 public abstract class ProgramScheduleItemCommandBase
 {
-    protected static Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
+    protected static Task<Option<ProgramSchedule>> ProgramScheduleMustExist(
        TvContext dbContext,
        int programScheduleId,
        CancellationToken cancellationToken) =>
@@ -17,7 +18,7 @@ public abstract class ProgramScheduleItemCommandBase
            .Include(ps => ps.Items)
            .Include(ps => ps.Playouts)
            .SelectOneAsync(ps => ps.Id, ps => ps.Id == programScheduleId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("[ProgramScheduleId] does not exist."));
+            .Map(identity);

    protected static async Task<Either<BaseError, ProgramSchedule>> FillerConfigurationMustBeValid(
        TvContext dbContext,
@@ -352,9 +353,11 @@ public abstract class ProgramScheduleItemCommandBase
            _ => throw new NotSupportedException($"Unsupported playout mode {item.PlayoutMode}")
        };

+        result.ProgramScheduleItemWatermarks = [];
+        result.ProgramScheduleItemGraphicsElements = [];
+
        foreach (int watermarkId in item.WatermarkIds)
        {
-            result.ProgramScheduleItemWatermarks ??= [];
            result.ProgramScheduleItemWatermarks.Add(
                new ProgramScheduleItemWatermark
                {
@@ -365,7 +368,6 @@ public abstract class ProgramScheduleItemCommandBase

        foreach (int graphicsElementId in item.GraphicsElementIds)
        {
-            result.ProgramScheduleItemGraphicsElements ??= [];
            result.ProgramScheduleItemGraphicsElements.Add(
                new ProgramScheduleItemGraphicsElement
                {
@@ -2,6 +2,7 @@
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
@@ -19,8 +20,16 @@ public class ReplaceProgramScheduleItemsHandler(
        CancellationToken cancellationToken)
    {
        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(ps => PersistItems(dbContext, request, ps, cancellationToken));
+        Option<ProgramSchedule> maybeProgramSchedule =
+            await ProgramScheduleMustExist(dbContext, request.ProgramScheduleId, cancellationToken);
+        return await maybeProgramSchedule.Match(
+            Some: async programSchedule =>
+            {
+                Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request, programSchedule);
+                return await validation.Apply(ps => PersistItems(dbContext, request, ps, cancellationToken));
+            },
+            None: () => Task.FromResult<Either<BaseError, IEnumerable<ProgramScheduleItemViewModel>>>(
+                new NotFoundError("[ProgramScheduleId] does not exist.")));
    }

    private async Task<IEnumerable<ProgramScheduleItemViewModel>> PersistItems(
@@ -50,15 +59,20 @@ public class ReplaceProgramScheduleItemsHandler(
        return programSchedule.Items.Map(ProjectToViewModel);
    }

-    private static Task<Validation<BaseError, ProgramSchedule>> Validate(
+    private static async Task<Validation<BaseError, ProgramSchedule>> Validate(
        TvContext dbContext,
        ReplaceProgramScheduleItems request,
-        CancellationToken cancellationToken) =>
-        ProgramScheduleMustExist(dbContext, request.ProgramScheduleId, cancellationToken)
-            .BindT(programSchedule => PlayoutModesMustBeValid(request, programSchedule))
-            .BindT(programSchedule => CollectionTypesMustBeValid(request, programSchedule))
-            .BindT(programSchedule => PlaybackOrdersMustBeValid(request, programSchedule))
-            .BindT(programSchedule => FillerConfigurationsMustBeValid(dbContext, request, programSchedule));
+        ProgramSchedule programSchedule)
+    {
+        Validation<BaseError, ProgramSchedule> validation = PlayoutModesMustBeValid(request, programSchedule)
+            .Bind(programSchedule => CollectionTypesMustBeValid(request, programSchedule))
+            .Bind(programSchedule => PlaybackOrdersMustBeValid(request, programSchedule));
+
+        return await validation.ToEither().Match(
+            Left: error => Task.FromResult<Validation<BaseError, ProgramSchedule>>(
+                Fail<BaseError, ProgramSchedule>(error)),
+            Right: validProgramSchedule => FillerConfigurationsMustBeValid(dbContext, request, validProgramSchedule));
+    }

    private static Validation<BaseError, ProgramSchedule> PlayoutModesMustBeValid(
        ReplaceProgramScheduleItems request,
@@ -2,6 +2,7 @@
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -20,8 +21,16 @@ public class UpdateProgramScheduleHandler(
        CancellationToken cancellationToken)
    {
        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
+        Option<ProgramSchedule> maybeProgramSchedule =
+            await ProgramScheduleMustExist(dbContext, request, cancellationToken);
+        return await maybeProgramSchedule.Match(
+            Some: async programSchedule =>
+            {
+                Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request, programSchedule, cancellationToken);
+                return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
+            },
+            None: () => Task.FromResult<Either<BaseError, UpdateProgramScheduleResult>>(
+                new NotFoundError("Schedule does not exist")));
    }

    private async Task<UpdateProgramScheduleResult> ApplyUpdateRequest(
@@ -66,17 +75,17 @@ public class UpdateProgramScheduleHandler(
    private static async Task<Validation<BaseError, ProgramSchedule>> Validate(
        TvContext dbContext,
        UpdateProgramSchedule request,
+        ProgramSchedule programSchedule,
        CancellationToken cancellationToken) =>
-        (await ProgramScheduleMustExist(dbContext, request, cancellationToken), await ValidateName(dbContext, request, cancellationToken))
-        .Apply((programSchedule, _) => programSchedule);
+        (await ValidateName(dbContext, request, cancellationToken)).Map(_ => programSchedule);

-    private static Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
+    private static Task<Option<ProgramSchedule>> ProgramScheduleMustExist(
        TvContext dbContext,
        UpdateProgramSchedule request,
        CancellationToken cancellationToken) =>
        dbContext.ProgramSchedules
            .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.ProgramScheduleId, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("Schedule does not exist"));
+            .Map(identity);

    private static async Task<Validation<BaseError, string>> ValidateName(
        TvContext dbContext,
@@ -44,6 +44,33 @@ public abstract record ProgramScheduleItemViewModel(
    string PreferredSubtitleLanguageCode,
    ChannelSubtitleMode? SubtitleMode)
 {
+    /// <summary>
+    ///     A rough estimate, in wall-clock time, of how long a single pass of this schedule item will play,
+    ///     derived from the aggregated playout runtimes of the referenced content.
+    ///     <para>
+    ///         Semantics by <see cref="PlayoutMode" />:
+    ///         <list type="bullet">
+    ///             <item><b>One</b> — the average runtime of one item in the referenced collection.</item>
+    ///             <item>
+    ///                 <b>Multiple</b> — the average item runtime multiplied by the configured count
+    ///                 (<see cref="MultipleMode.Count" />), or the whole collection runtime for
+    ///                 <see cref="MultipleMode.CollectionSize" />. An expression-based (non-integer)
+    ///                 count cannot be evaluated here and yields <c>null</c>.
+    ///             </item>
+    ///             <item><b>Flood</b> — always <c>null</c>: a flood item fills the remaining time and is unbounded.</item>
+    ///             <item><b>Duration</b> — the explicit <c>playoutDuration</c> setting on the item.</item>
+    ///         </list>
+    ///     </para>
+    ///     <para>
+    ///         <c>null</c> whenever a bounded estimate cannot be produced — an unbounded mode (Flood),
+    ///         a referenced collection with no items that have a known positive duration, a Multiple mode other
+    ///         than Count/CollectionSize, or a collection type other than <see cref="CollectionType.Collection" />
+    ///         (smart/multi/playlist/search/rerun/show/season/artist references are not aggregated in this pass).
+    ///         Callers should treat a <c>null</c> as "unknown", never as zero.
+    ///     </para>
+    /// </summary>
+    public TimeSpan? DurationEstimate { get; init; }
+
    public string Name => CollectionType switch
    {
        CollectionType.Collection => Collection?.Name,
@@ -0,0 +1,18 @@
+namespace ErsatzTV.Application.ProgramSchedules;
+
+/// <summary>
+///     The items of a schedule together with computed runtime estimates. Each item carries its own
+///     <see cref="ProgramScheduleItemViewModel.DurationEstimate" /> (nullable — see that property for
+///     the per-mode semantics), and <see cref="TotalDurationEstimate" /> is the sum of the items that
+///     could be estimated.
+/// </summary>
+/// <param name="Items">The schedule items, each with a nullable <c>DurationEstimate</c>.</param>
+/// <param name="TotalDurationEstimate">
+///     The sum of every non-null per-item estimate, i.e. a rough runtime for a single pass through the
+///     estimable items. <c>null</c> when no item in the schedule could be estimated (for example a
+///     schedule made up entirely of Flood items, or of collection types that are not aggregated).
+///     Because unbounded items contribute nothing, this is a lower bound, never an exact schedule length.
+/// </param>
+public record ProgramScheduleItemsWithDurationViewModel(
+    List<ProgramScheduleItemViewModel> Items,
+    TimeSpan? TotalDurationEstimate);
@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record GetProgramScheduleItemsWithDurations(int Id)
+    : IRequest<ProgramScheduleItemsWithDurationViewModel>;
@@ -0,0 +1,70 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Extensions;
+using ErsatzTV.Core.Interfaces.Repositories;
+using static ErsatzTV.Application.ProgramSchedules.ScheduleItemDurationEstimator;
+
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class GetProgramScheduleItemsWithDurationsHandler(
+    IMediator mediator,
+    IMediaCollectionRepository mediaCollectionRepository)
+    : IRequestHandler<GetProgramScheduleItemsWithDurations, ProgramScheduleItemsWithDurationViewModel>
+{
+    public async Task<ProgramScheduleItemsWithDurationViewModel> Handle(
+        GetProgramScheduleItemsWithDurations request,
+        CancellationToken cancellationToken)
+    {
+        List<ProgramScheduleItemViewModel> items =
+            await mediator.Send(new GetProgramScheduleItems(request.Id), cancellationToken);
+
+        Dictionary<int, CollectionDuration> durationsByCollectionId =
+            await AggregateReferencedCollections(items);
+
+        var itemsWithEstimates = items
+            .Map(item => item with { DurationEstimate = Estimate(item, durationsByCollectionId) })
+            .ToList();
+
+        List<TimeSpan> estimates = itemsWithEstimates
+            .Map(item => Optional(item.DurationEstimate))
+            .Somes()
+            .ToList();
+
+        TimeSpan? total = estimates.Count > 0
+            ? TimeSpan.FromTicks(estimates.Sum(estimate => estimate.Ticks))
+            : null;
+
+        return new ProgramScheduleItemsWithDurationViewModel(itemsWithEstimates, total);
+    }
+
+    // Aggregate MediaVersion.Duration once per distinct referenced collection (not per item). Only plain
+    // collections are resolved here; other reference types are estimated as null (see DurationEstimate docs).
+    private async Task<Dictionary<int, CollectionDuration>> AggregateReferencedCollections(
+        IReadOnlyList<ProgramScheduleItemViewModel> items)
+    {
+        List<int> collectionIds = items
+            .Filter(item => item.CollectionType is CollectionType.Collection && item.Collection is not null)
+            .Filter(item => item.PlayoutMode is PlayoutMode.One or PlayoutMode.Multiple)
+            .Map(item => item.Collection.Id)
+            .Distinct()
+            .ToList();
+
+        var result = new Dictionary<int, CollectionDuration>();
+        foreach (int collectionId in collectionIds)
+        {
+            List<MediaItem> mediaItems = await mediaCollectionRepository.GetItems(collectionId);
+
+            List<TimeSpan> durations = mediaItems
+                .Map(mediaItem => mediaItem.GetDurationForPlayout())
+                .Filter(duration => duration > TimeSpan.Zero)
+                .ToList();
+
+            if (durations.Count > 0)
+            {
+                var total = TimeSpan.FromTicks(durations.Sum(duration => duration.Ticks));
+                result[collectionId] = new CollectionDuration(total, durations.Count);
+            }
+        }
+
+        return result;
+    }
+}
@@ -0,0 +1,73 @@
+using System.Globalization;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.ProgramSchedules;
+
+/// <summary>
+///     Pure computation of per-item runtime estimates from pre-aggregated collection durations.
+///     Kept separate from the query handler so the (non-trivial) per-mode math can be unit-tested
+///     without a database. See <see cref="ProgramScheduleItemViewModel.DurationEstimate" /> for the
+///     documented semantics this implements.
+/// </summary>
+internal static class ScheduleItemDurationEstimator
+{
+    /// <summary>
+    ///     Aggregate runtime of a single referenced collection: the total runtime of every item with a
+    ///     known non-zero duration, and how many such items there are.
+    /// </summary>
+    public sealed record CollectionDuration(TimeSpan Total, int ItemCount)
+    {
+        public TimeSpan? Average => ItemCount > 0 ? Total / ItemCount : null;
+    }
+
+    /// <summary>
+    ///     Estimate the runtime of one pass of <paramref name="item" />, or <c>null</c> when no bounded
+    ///     estimate is possible. <paramref name="durationsByCollectionId" /> holds aggregates only for the
+    ///     plain collections that were resolved; a missing entry yields <c>null</c>.
+    /// </summary>
+    public static TimeSpan? Estimate(
+        ProgramScheduleItemViewModel item,
+        IReadOnlyDictionary<int, CollectionDuration> durationsByCollectionId)
+    {
+        if (item is ProgramScheduleItemDurationViewModel durationItem)
+        {
+            return durationItem.PlayoutDuration;
+        }
+
+        // only plain collections are aggregated in this pass
+        if (item.CollectionType is not CollectionType.Collection || item.Collection is null)
+        {
+            return null;
+        }
+
+        if (!durationsByCollectionId.TryGetValue(item.Collection.Id, out CollectionDuration duration))
+        {
+            return null;
+        }
+
+        return item switch
+        {
+            // one item per pass -> the average item runtime
+            ProgramScheduleItemOneViewModel => duration.Average,
+
+            // a fixed count of items, or the whole collection once
+            ProgramScheduleItemMultipleViewModel multiple => EstimateMultiple(multiple, duration),
+
+            // Flood is an unbounded fill; Duration is handled above from its explicit playoutDuration.
+            _ => null
+        };
+    }
+
+    private static TimeSpan? EstimateMultiple(
+        ProgramScheduleItemMultipleViewModel multiple,
+        CollectionDuration duration) =>
+        multiple.MultipleMode switch
+        {
+            MultipleMode.Count when
+                int.TryParse(multiple.Count, NumberStyles.Integer, CultureInfo.InvariantCulture, out int count)
+                && count > 0
+                && duration.Average is { } average => average * count,
+            MultipleMode.CollectionSize => duration.Total,
+            _ => null
+        };
+}
@@ -1,6 +1,7 @@
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -18,23 +19,28 @@ public class DeleteCustomResolutionHandler : IRequestHandler<DeleteCustomResolut
    {
        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);

-        Option<Resolution> maybeResolution = await dbContext.Resolutions
+        Option<Resolution> maybeAnyResolution = await dbContext.Resolutions
            .AsNoTracking()
-            .SelectOneAsync(p => p.Id, p => p.Id == request.ResolutionId && p.IsCustom == true, cancellationToken);
+            .SelectOneAsync(p => p.Id, p => p.Id == request.ResolutionId, cancellationToken);

-        foreach (Resolution resolution in maybeResolution)
+        foreach (Resolution existingResolution in maybeAnyResolution)
        {
+            if (!existingResolution.IsCustom)
+            {
+                return BaseError.New($"Resolution {request.ResolutionId} is not a custom resolution.");
+            }
+
            // reset any ffmpeg profiles using this resolution to 1920x1080
            await dbContext.Connection.ExecuteAsync(
                @"UPDATE FFmpegProfile SET ResolutionId = 3 WHERE ResolutionId = @ResolutionId",
                new { request.ResolutionId });

-            dbContext.Resolutions.Remove(resolution);
+            dbContext.Resolutions.Remove(existingResolution);
            await dbContext.SaveChangesAsync(cancellationToken);
        }

-        return maybeResolution.IsNone
-            ? BaseError.New($"Resolution {request.ResolutionId} does not exist.")
+        return maybeAnyResolution.IsNone
+            ? new NotFoundError($"Resolution {request.ResolutionId} does not exist.")
            : Option<BaseError>.None;
    }
 }
@@ -1,10 +1,14 @@
 using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core.Api.Watermarks;
 using ErsatzTV.Core.Domain;

 namespace ErsatzTV.Application.Watermarks;

 internal static class Mapper
 {
+    internal static WatermarkResponseModel ProjectToResponseModel(ChannelWatermark watermark) =>
+        new(watermark.Id, watermark.Name);
+
    public static WatermarkViewModel ProjectToViewModel(ChannelWatermark watermark) =>
        new(
            watermark.Id,
@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Watermarks;
+
+namespace ErsatzTV.Application.Watermarks;
+
+public record GetAllWatermarksForApi : IRequest<List<WatermarkResponseModel>>;
@@ -0,0 +1,22 @@
+using ErsatzTV.Core.Api.Watermarks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Watermarks.Mapper;
+
+namespace ErsatzTV.Application.Watermarks;
+
+public class GetAllWatermarksForApiHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllWatermarksForApi, List<WatermarkResponseModel>>
+{
+    public async Task<List<WatermarkResponseModel>> Handle(
+        GetAllWatermarksForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        List<ChannelWatermark> watermarks = await dbContext.ChannelWatermarks
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+        return watermarks.Map(ProjectToResponseModel).ToList();
+    }
+}
@@ -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>
@@ -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);
+    }
+}
@@ -7,28 +7,34 @@
    </PropertyGroup>

    <ItemGroup>
-        <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" />
    </ItemGroup>

+    <ItemGroup>
+        <None Include="..\ErsatzTV\Resources\Fonts\Sen.ttf" Link="Resources\Fonts\Sen.ttf" CopyToOutputDirectory="PreserveNewest" />
+        <None Include="..\ErsatzTV\wwwroot\images\ersatztv-500.png" Link="Resources\Images\ersatztv-500.png" CopyToOutputDirectory="PreserveNewest" />
+    </ItemGroup>
+
 </Project>
@@ -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()
        {
@@ -0,0 +1,41 @@
+using ErsatzTV.Core.Images;
+using Microsoft.Extensions.Logging.Abstractions;
+using NUnit.Framework;
+using Shouldly;
+using SkiaSharp;
+
+namespace ErsatzTV.Core.Tests.Images;
+
+[TestFixture]
+public class ChannelLogoGeneratorTests
+{
+    [TestCase("News", 100, 200)]
+    [TestCase("A Very Long Channel Name That Should Force Font Shrinking", 100, 200)]
+    [TestCase("Tall Logo", 180, 120)]
+    public void GenerateChannelLogo_WithInjectedAssets_ReturnsValidPngWithRequestedDimensions(
+        string text,
+        int logoHeight,
+        int logoWidth)
+    {
+        var generator = new ChannelLogoGenerator(
+            NullLogger<ChannelLogoGenerator>.Instance,
+            TestAssetPath("Resources", "Images", "ersatztv-500.png"),
+            TestAssetPath("Resources", "Fonts", "Sen.ttf"));
+
+        byte[] bytes = generator.GenerateChannelLogo(text, logoHeight, logoWidth, CancellationToken.None)
+            .Match(
+                Left: error => throw new AssertionException(error.Value),
+                Right: identity);
+
+        using var stream = new MemoryStream(bytes);
+        using var codec = SKCodec.Create(stream);
+
+        codec.ShouldNotBeNull();
+        codec.EncodedFormat.ShouldBe(SKEncodedImageFormat.Png);
+        codec.Info.Width.ShouldBe(logoWidth);
+        codec.Info.Height.ShouldBe(logoHeight);
+    }
+
+    private static string TestAssetPath(params string[] segments) =>
+        Path.Combine([TestContext.CurrentContext.TestDirectory, .. segments]);
+}
@@ -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));
+    }
+}
@@ -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");
+}
@@ -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
@@ -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
--- a/Show More
+++ b/Show More