fix(api): rework from-lineup to generated playlist design + review fixes (#63)

Adversarial review found the previous multi-flood design non-viable:
PlayoutModeSchedulerFlood never yields to a following Dynamic-start
schedule item, so only the first item ever played, and grouping
media items into a Collection silently dropped the requested order.

Redesign:
- Single-item lineup: one ProgramScheduleItemFlood referencing the
  target directly (media item / collection / smart / multi / rerun /
  playlist); no generated collection or playlist. Response PlaylistId
  is null.
- Multi-item lineup (>= 2): one generated IsSystem Playlist in a
  get-or-created IsSystem PlaylistGroup ("Channel Lineups"), one
  PlaylistItem per entry in lineup order with PlayAll=true, referenced
  by a single Flood schedule item. Rerun collections and playlists are
  rejected (422) in multi lineups (PlaylistItem/CollectionKey lack the
  fields to enumerate them).

Review fixes:
- Normalize + strict-validate MediaType<->CollectionType pairs once up
  front (422 on mismatch / wrong id / not exactly one id).
- Reject MultiCollection with non-Shuffle order (mirrors
  PlayoutModeMustBeValid), Mirror playout source, all via 422.
- OnDemand parity: queue TimeShiftOnDemandPlayout post-commit.
- De-collide generated ProgramSchedule and Playlist names against their
  unique indexes instead of leaking a UNIQUE-constraint DbUpdateException.
- Generic 422 on save failure + ILogger; AnyAsync existence checks;
  Either/Validation unwrap via Match; XML doc on request DTO + endpoint.
- Response model: ChannelId, PlaylistId (nullable), ProgramScheduleId,
  PlayoutId (CollectionId removed). Regenerated OpenAPI v1.json + v1.d.ts.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.gitea/workflows/docker-build.yml

@@ -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
 

.gitignore

@@ -3,6 +3,7 @@
 project.lock.json
 .DS_Store
 *.pyc
+.worktrees/
 
 # Claude Code
 .mcp/
@@ -51,3 +52,6 @@ scripts/download-test-content.sh
 docker-compose.override.yml
 
 ErsatzTV/wwwroot/v2/
+ErsatzTV/wwwroot/app/
+web/dist/
+web/node_modules/

CLAUDE.md

@@ -36,7 +36,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>`. Cutover done (2026-06-27, server-management#481/#482): prod container runs fork `:prod` (currently v26.3.1), test container tracks `:latest`; prod advances only when a new `v*` tag is pushed (next: `v26.4.0`, first app-change release). Pipeline details: `docs/ci-cd.md`.
 
 ## Development
 

ErsatzTV.Application/ChannelTemplates/ChannelTemplateDefault.cs

@@ -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;
+    }
+}

ErsatzTV.Application/ChannelTemplates/ChannelTemplateMapper.cs

@@ -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);
+}

ErsatzTV.Application/ChannelTemplates/Commands/ChannelTemplateCommandBase.cs

@@ -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;
+    }
+}

ErsatzTV.Application/ChannelTemplates/Commands/CreateChannelTemplate.cs

@@ -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>>;

ErsatzTV.Application/ChannelTemplates/Commands/CreateChannelTemplateHandler.cs

@@ -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);
+    }
+}

ErsatzTV.Application/ChannelTemplates/Commands/DeleteChannelTemplate.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record DeleteChannelTemplate(int ChannelTemplateId) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/ChannelTemplates/Commands/DeleteChannelTemplateHandler.cs

@@ -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.");
+    }
+}

ErsatzTV.Application/ChannelTemplates/Commands/SetDefaultChannelTemplate.cs

@@ -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>>;

ErsatzTV.Application/ChannelTemplates/Commands/SetDefaultChannelTemplateHandler.cs

@@ -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.");
+    }
+}

ErsatzTV.Application/ChannelTemplates/Commands/UpdateChannelTemplate.cs

@@ -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>>;

ErsatzTV.Application/ChannelTemplates/Commands/UpdateChannelTemplateHandler.cs

@@ -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.");
+    }
+}

ErsatzTV.Application/ChannelTemplates/Queries/GetAllChannelTemplates.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record GetAllChannelTemplates : IRequest<List<ChannelTemplateResponseModel>>;

ErsatzTV.Application/ChannelTemplates/Queries/GetAllChannelTemplatesHandler.cs

@@ -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);
+    }
+}

ErsatzTV.Application/ChannelTemplates/Queries/GetChannelTemplateById.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record GetChannelTemplateById(int ChannelTemplateId) : IRequest<Option<ChannelTemplateResponseModel>>;

ErsatzTV.Application/ChannelTemplates/Queries/GetChannelTemplateByIdHandler.cs

@@ -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));
+    }
+}

ErsatzTV.Application/ChannelTemplates/Queries/GetDefaultChannelTemplate.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.ChannelTemplates;
+
+namespace ErsatzTV.Application.ChannelTemplates;
+
+public record GetDefaultChannelTemplate : IRequest<Option<ChannelTemplateResponseModel>>;

ErsatzTV.Application/ChannelTemplates/Queries/GetDefaultChannelTemplateHandler.cs

@@ -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));
+    }
+}

ErsatzTV.Application/Channels/ChannelGuideMetadata.cs

@@ -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
+        };
+}

ErsatzTV.Application/Channels/ChannelGuideProjector.cs

@@ -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;
+            }
+        }
+    }
+}

ErsatzTV.Application/Channels/Commands/BulkDeleteChannels.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Channels;
+
+public record BulkDeleteChannels(IReadOnlyList<int> ChannelIds) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Channels/Commands/BulkDeleteChannelsHandler.cs

@@ -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);
+    }
+}

ErsatzTV.Application/Channels/Commands/BulkMoveChannelsToGroup.cs

@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Channels;
+
+public record BulkMoveChannelsToGroup(IReadOnlyList<int> ChannelIds, string Group)
+    : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Channels/Commands/BulkMoveChannelsToGroupHandler.cs

@@ -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);
+    }
+}

ErsatzTV.Application/Channels/Commands/CreateChannelFromLineup.cs

@@ -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);

ErsatzTV.Application/Channels/Commands/CreateChannelFromLineupHandler.cs

@@ -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);
+}

ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs

@@ -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()

ErsatzTV.Application/Channels/Commands/UpdateChannelNumbersHandler.cs

@@ -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;
+    }
 }

ErsatzTV.Application/Channels/Mapper.cs

@@ -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);

ErsatzTV.Application/Channels/Queries/GetChannelGuideData.cs

@@ -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>;

ErsatzTV.Application/Channels/Queries/GetChannelGuideDataHandler.cs

@@ -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
+        };
+}

ErsatzTV.Application/Channels/Queries/GetChannelStatesForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Channels;
+
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelStatesForApi(DateTime Now) : IRequest<List<ChannelStateResponseModel>>;

ErsatzTV.Application/Channels/Queries/GetChannelStatesForApiHandler.cs

@@ -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);
+}

ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItems.cs

@@ -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>;

ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItemsHandler.cs

@@ -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);
+}

ErsatzTV.Core.Tests/Streaming/DirectStreamSessionTrackerTests.cs

@@ -0,0 +1,98 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Streaming;
+using ErsatzTV.Core.Streaming;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Core.Tests.Streaming;
+
+[TestFixture]
+public class DirectStreamSessionTrackerTests
+{
+    [Test]
+    public void Should_Track_Concurrent_Viewers_Per_Channel()
+    {
+        var tracker = new DirectStreamSessionTracker();
+
+        using IDisposable session1 = tracker.Register("1", StreamingMode.TransportStream);
+        using IDisposable session2 = tracker.Register("1", StreamingMode.HttpLiveStreamingDirect);
+        using IDisposable session3 = tracker.Register("2", StreamingMode.TransportStream);
+
+        tracker.IsActive("1").ShouldBeTrue();
+        tracker.GetViewerCount("1").ShouldBe(2);
+        tracker.GetViewerCount("2").ShouldBe(1);
+        tracker.GetActiveSessions().Count.ShouldBe(3);
+    }
+
+    [Test]
+    public void Should_Remove_Only_Disposed_Session()
+    {
+        var tracker = new DirectStreamSessionTracker();
+
+        IDisposable session1 = tracker.Register("1", StreamingMode.TransportStream);
+        IDisposable session2 = tracker.Register("1", StreamingMode.TransportStream);
+
+        session1.Dispose();
+
+        tracker.IsActive("1").ShouldBeTrue();
+        tracker.GetViewerCount("1").ShouldBe(1);
+
+        session2.Dispose();
+
+        tracker.IsActive("1").ShouldBeFalse();
+        tracker.GetViewerCount("1").ShouldBe(0);
+    }
+
+    [Test]
+    public void Should_Dispose_Registration_Only_Once()
+    {
+        var tracker = new DirectStreamSessionTracker();
+
+        IDisposable session = tracker.Register("1", StreamingMode.TransportStream);
+
+        session.Dispose();
+        session.Dispose();
+
+        tracker.IsActive("1").ShouldBeFalse();
+        tracker.GetViewerCount("1").ShouldBe(0);
+    }
+
+    [Test]
+    public void Should_Filter_Active_Sessions_By_Channel()
+    {
+        var tracker = new DirectStreamSessionTracker();
+
+        using IDisposable session1 = tracker.Register("1", StreamingMode.TransportStream);
+        using IDisposable session2 = tracker.Register("2", StreamingMode.HttpLiveStreamingDirect);
+
+        IReadOnlyCollection<DirectStreamSession> sessions = tracker.GetActiveSessions("2");
+
+        sessions.Count.ShouldBe(1);
+        sessions.Single().ChannelNumber.ShouldBe("2");
+        sessions.Single().StreamingMode.ShouldBe(StreamingMode.HttpLiveStreamingDirect);
+    }
+
+    [Test]
+    public void Should_Not_Orphan_Session_When_Last_Registration_Is_Removed_During_Register()
+    {
+        DirectStreamSessionTracker tracker = null;
+        IDisposable existingSession = null;
+
+        tracker = new TestDirectStreamSessionTracker(() => existingSession?.Dispose());
+        existingSession = tracker.Register("1", StreamingMode.TransportStream);
+
+        using IDisposable newSession = tracker.Register("1", StreamingMode.HttpLiveStreamingDirect);
+
+        tracker.IsActive("1").ShouldBeTrue();
+        tracker.GetViewerCount("1").ShouldBe(1);
+
+        IReadOnlyCollection<DirectStreamSession> sessions = tracker.GetActiveSessions("1");
+        sessions.Count.ShouldBe(1);
+        sessions.Single().StreamingMode.ShouldBe(StreamingMode.HttpLiveStreamingDirect);
+    }
+
+    private sealed class TestDirectStreamSessionTracker(Action onRegisteringSession) : DirectStreamSessionTracker
+    {
+        protected override void OnRegisteringSession() => onRegisteringSession();
+    }
+}

ErsatzTV.Core/Api/ChannelTemplates/ChannelTemplateResponseModel.cs

@@ -0,0 +1,36 @@
+#nullable enable
+
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+
+namespace ErsatzTV.Core.Api.ChannelTemplates;
+
+public record ChannelTemplateResponseModel(
+    int Id,
+    string Name,
+    string Description,
+    bool IsSystem,
+    bool IsDefault,
+    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);

ErsatzTV.Core/Api/Channels/ChannelGuideResponseModel.cs

@@ -0,0 +1,25 @@
+#nullable enable
+using ErsatzTV.Core.Domain.Filler;
+
+namespace ErsatzTV.Core.Api.Channels;
+
+/// <summary>A single guide programme for the JSON EPG grid.</summary>
+public record ChannelGuideProgrammeResponseModel(
+    DateTimeOffset Start,
+    DateTimeOffset Stop,
+    string Title,
+    string? SubTitle,
+    string? Category,
+    FillerKind FillerKind);
+
+/// <summary>One channel's guide programmes for the requested window.</summary>
+public record ChannelGuideChannelResponseModel(
+    string Number,
+    string Name,
+    List<ChannelGuideProgrammeResponseModel> Programmes);
+
+/// <summary>The JSON channel-guide response: the resolved window plus per-channel programme arrays.</summary>
+public record ChannelGuideResponseModel(
+    DateTimeOffset Start,
+    DateTimeOffset End,
+    List<ChannelGuideChannelResponseModel> Channels);

ErsatzTV.Core/Api/Channels/ChannelNowPlayingResponseModel.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Core.Api.Channels;
+
+#nullable enable
+
+public record ChannelNowPlayingResponseModel(
+    string Title,
+    DateTimeOffset StartUtc,
+    DateTimeOffset FinishUtc);

ErsatzTV.Core/Api/Channels/ChannelResponseModel.cs

@@ -1,12 +1,18 @@
-using Newtonsoft.Json;
+#nullable enable
+using Newtonsoft.Json;
 
 namespace ErsatzTV.Core.Api.Channels;
 
 public record ChannelResponseModel(
     int Id,
     string Number,
+    double SortNumber,
     string Name,
+    string Group,
+    string Categories,
     [property: JsonProperty("ffmpegProfile")]
     string FFmpegProfile,
     string Language,
-    string StreamingMode);
+    string StreamingMode,
+    bool IsEnabled,
+    bool ShowInEpg);

ErsatzTV.Core/Api/Channels/ChannelStateResponseModel.cs

@@ -0,0 +1,9 @@
+namespace ErsatzTV.Core.Api.Channels;
+
+#nullable enable
+
+public record ChannelStateResponseModel(
+    int ChannelId,
+    string ChannelNumber,
+    bool OnAir,
+    ChannelNowPlayingResponseModel? NowPlaying);

ErsatzTV.Core/Api/Channels/CreateChannelFromLineupResponseModel.cs

@@ -0,0 +1,9 @@
+#nullable enable
+
+namespace ErsatzTV.Core.Api.Channels;
+
+public record CreateChannelFromLineupResponseModel(
+    int ChannelId,
+    int? PlaylistId,
+    int ProgramScheduleId,
+    int PlayoutId);

ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseItemResponseModel.cs

@@ -0,0 +1,22 @@
+#nullable enable
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Core.Api.LibraryBrowse;
+
+public record LibraryBrowseItemResponseModel(
+    int Id,
+    LibraryBrowseMediaType MediaType,
+    string Title,
+    int? LibraryId,
+    string? LibraryName,
+    string Artwork,
+    TimeSpan? Duration,
+    int? ItemCount,
+    string? CollectionKind,
+    CollectionType CollectionType,
+    int? CollectionId,
+    int? MultiCollectionId,
+    int? SmartCollectionId,
+    int? RerunCollectionId,
+    int? MediaItemId,
+    int? PlaylistId);

ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseMediaType.cs

@@ -0,0 +1,15 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.LibraryBrowse;
+
+public enum LibraryBrowseMediaType
+{
+    Movie = 1,
+    TelevisionShow = 2,
+    TelevisionSeason = 3,
+    Artist = 4,
+    Collection = 5,
+    SmartCollection = 6,
+    MultiCollection = 7,
+    RerunCollection = 8,
+    Playlist = 9
+}

ErsatzTV.Core/Api/LibraryBrowse/PagedLibraryBrowseItemsResponseModel.cs

@@ -0,0 +1,6 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.LibraryBrowse;
+
+public record PagedLibraryBrowseItemsResponseModel(
+    int TotalCount,
+    List<LibraryBrowseItemResponseModel> Page);

ErsatzTV.Core/Domain/ChannelTemplate.cs

@@ -0,0 +1,41 @@
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Scheduling;
+
+namespace ErsatzTV.Core.Domain;
+
+public class ChannelTemplate
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public string Description { get; set; }
+    public bool IsSystem { get; set; }
+    public int FFmpegProfileId { get; set; }
+    public FFmpegProfile FFmpegProfile { get; set; }
+    public int? WatermarkId { get; set; }
+    public ChannelWatermark Watermark { get; set; }
+    public int? FallbackFillerId { get; set; }
+    public FillerPreset FallbackFiller { get; set; }
+    public int? PreRollFillerId { get; set; }
+    public FillerPreset PreRollFiller { get; set; }
+    public int? MidRollFillerId { get; set; }
+    public FillerPreset MidRollFiller { get; set; }
+    public int? PostRollFillerId { get; set; }
+    public FillerPreset PostRollFiller { get; set; }
+    public ChannelStreamSelectorMode StreamSelectorMode { get; set; }
+    public string StreamSelector { get; set; }
+    public string PreferredAudioLanguageCode { get; set; }
+    public string PreferredAudioTitle { get; set; }
+    public ChannelPlayoutSource PlayoutSource { get; set; }
+    public ChannelPlayoutMode PlayoutMode { get; set; }
+    public StreamingMode StreamingMode { get; set; }
+    public string PreferredSubtitleLanguageCode { get; set; }
+    public ChannelSubtitleMode SubtitleMode { get; set; }
+    public ChannelMusicVideoCreditsMode MusicVideoCreditsMode { get; set; }
+    public string MusicVideoCreditsTemplate { get; set; }
+    public ChannelSongVideoMode SongVideoMode { get; set; }
+    public ChannelTranscodeMode TranscodeMode { get; set; }
+    public ChannelIdleBehavior IdleBehavior { get; set; }
+    public bool ShuffleScheduleItems { get; set; }
+    public bool RandomStartPoint { get; set; }
+    public FixedStartTimeBehavior FixedStartTimeBehavior { get; set; }
+}

ErsatzTV.Core/Domain/ConfigElementKey.cs

@@ -23,6 +23,7 @@ public class ConfigElementKey
     public static ConfigElementKey FFmpegPreferredLanguageCode => new("ffmpeg.preferred_language_code");
     public static ConfigElementKey FFmpegGlobalWatermarkId => new("ffmpeg.global_watermark_id");
     public static ConfigElementKey FFmpegGlobalFallbackFillerId => new("ffmpeg.global_fallback_filler_id");
+    public static ConfigElementKey ChannelTemplatesDefaultTemplateId => new("channel_templates.default_template_id");
     public static ConfigElementKey FFmpegSegmenterTimeout => new("ffmpeg.segmenter.timeout_seconds");
     public static ConfigElementKey FFmpegWorkAheadSegmenters => new("ffmpeg.segmenter.work_ahead_limit");
     public static ConfigElementKey FFmpegInitialSegmentCount => new("ffmpeg.segmenter.initial_segment_count");

ErsatzTV.Core/Interfaces/Streaming/IDirectStreamSessionTracker.cs

@@ -0,0 +1,13 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Streaming;
+
+namespace ErsatzTV.Core.Interfaces.Streaming;
+
+public interface IDirectStreamSessionTracker
+{
+    IDisposable Register(string channelNumber, StreamingMode streamingMode);
+    bool IsActive(string channelNumber);
+    int GetViewerCount(string channelNumber);
+    IReadOnlyCollection<DirectStreamSession> GetActiveSessions();
+    IReadOnlyCollection<DirectStreamSession> GetActiveSessions(string channelNumber);
+}

ErsatzTV.Core/Streaming/DirectStreamSession.cs

@@ -0,0 +1,9 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Core.Streaming;
+
+public record DirectStreamSession(
+    Guid Id,
+    string ChannelNumber,
+    StreamingMode StreamingMode,
+    DateTimeOffset StartedAt);

ErsatzTV.Core/Streaming/DirectStreamSessionTracker.cs

@@ -0,0 +1,66 @@
+using System.Collections.Concurrent;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Streaming;
+
+namespace ErsatzTV.Core.Streaming;
+
+public class DirectStreamSessionTracker : IDirectStreamSessionTracker
+{
+    private readonly ConcurrentDictionary<string, ConcurrentDictionary<Guid, DirectStreamSession>> _sessions = new();
+
+    public IDisposable Register(string channelNumber, StreamingMode streamingMode)
+    {
+        var session = new DirectStreamSession(Guid.NewGuid(), channelNumber, streamingMode, DateTimeOffset.Now);
+
+        ConcurrentDictionary<Guid, DirectStreamSession> channelSessions =
+            _sessions.GetOrAdd(channelNumber, _ => new ConcurrentDictionary<Guid, DirectStreamSession>());
+
+        OnRegisteringSession();
+
+        channelSessions.TryAdd(session.Id, session);
+
+        return new Registration(this, session);
+    }
+
+    protected virtual void OnRegisteringSession()
+    {
+    }
+
+    public bool IsActive(string channelNumber) => GetViewerCount(channelNumber) > 0;
+
+    public int GetViewerCount(string channelNumber) =>
+        _sessions.TryGetValue(channelNumber, out ConcurrentDictionary<Guid, DirectStreamSession> channelSessions)
+            ? channelSessions.Count
+            : 0;
+
+    public IReadOnlyCollection<DirectStreamSession> GetActiveSessions() =>
+        _sessions.Values.SelectMany(s => s.Values).ToList();
+
+    public IReadOnlyCollection<DirectStreamSession> GetActiveSessions(string channelNumber) =>
+        _sessions.TryGetValue(channelNumber, out ConcurrentDictionary<Guid, DirectStreamSession> channelSessions)
+            ? channelSessions.Values.ToList()
+            : [];
+
+    private void Remove(DirectStreamSession session)
+    {
+        if (!_sessions.TryGetValue(session.ChannelNumber, out ConcurrentDictionary<Guid, DirectStreamSession> channelSessions))
+        {
+            return;
+        }
+
+        channelSessions.TryRemove(session.Id, out _);
+    }
+
+    private sealed class Registration(DirectStreamSessionTracker tracker, DirectStreamSession session) : IDisposable
+    {
+        private int _disposed;
+
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) == 0)
+            {
+                tracker.Remove(session);
+            }
+        }
+    }
+}

ErsatzTV.Infrastructure.MySql/Migrations/20260706155538_AddChannelTemplates.cs

@@ -0,0 +1,140 @@
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.MySql.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddChannelTemplates : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "ChannelTemplate",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    Name = table.Column<string>(type: "varchar(50)", maxLength: 50, nullable: false, collation: "utf8mb4_general_ci")
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    Description = table.Column<string>(type: "varchar(500)", maxLength: 500, nullable: false, defaultValue: "")
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    IsSystem = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    FFmpegProfileId = table.Column<int>(type: "int", nullable: false),
+                    WatermarkId = table.Column<int>(type: "int", nullable: true),
+                    FallbackFillerId = table.Column<int>(type: "int", nullable: true),
+                    PreRollFillerId = table.Column<int>(type: "int", nullable: true),
+                    MidRollFillerId = table.Column<int>(type: "int", nullable: true),
+                    PostRollFillerId = table.Column<int>(type: "int", nullable: true),
+                    StreamSelectorMode = table.Column<int>(type: "int", nullable: false),
+                    StreamSelector = table.Column<string>(type: "longtext", nullable: true)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    PreferredAudioLanguageCode = table.Column<string>(type: "longtext", nullable: true)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    PreferredAudioTitle = table.Column<string>(type: "longtext", nullable: true)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    PlayoutSource = table.Column<int>(type: "int", nullable: false),
+                    PlayoutMode = table.Column<int>(type: "int", nullable: false),
+                    StreamingMode = table.Column<int>(type: "int", nullable: false),
+                    PreferredSubtitleLanguageCode = table.Column<string>(type: "longtext", nullable: true)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    SubtitleMode = table.Column<int>(type: "int", nullable: false),
+                    MusicVideoCreditsMode = table.Column<int>(type: "int", nullable: false),
+                    MusicVideoCreditsTemplate = table.Column<string>(type: "longtext", nullable: true)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    SongVideoMode = table.Column<int>(type: "int", nullable: false),
+                    TranscodeMode = table.Column<int>(type: "int", nullable: false),
+                    IdleBehavior = table.Column<int>(type: "int", nullable: false),
+                    ShuffleScheduleItems = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    RandomStartPoint = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    FixedStartTimeBehavior = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ChannelTemplate", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_ChannelWatermark_WatermarkId",
+                        column: x => x.WatermarkId,
+                        principalTable: "ChannelWatermark",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FFmpegProfile_FFmpegProfileId",
+                        column: x => x.FFmpegProfileId,
+                        principalTable: "FFmpegProfile",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FillerPreset_FallbackFillerId",
+                        column: x => x.FallbackFillerId,
+                        principalTable: "FillerPreset",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FillerPreset_MidRollFillerId",
+                        column: x => x.MidRollFillerId,
+                        principalTable: "FillerPreset",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FillerPreset_PostRollFillerId",
+                        column: x => x.PostRollFillerId,
+                        principalTable: "FillerPreset",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FillerPreset_PreRollFillerId",
+                        column: x => x.PreRollFillerId,
+                        principalTable: "FillerPreset",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_FallbackFillerId",
+                table: "ChannelTemplate",
+                column: "FallbackFillerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_FFmpegProfileId",
+                table: "ChannelTemplate",
+                column: "FFmpegProfileId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_MidRollFillerId",
+                table: "ChannelTemplate",
+                column: "MidRollFillerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_Name",
+                table: "ChannelTemplate",
+                column: "Name",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_PostRollFillerId",
+                table: "ChannelTemplate",
+                column: "PostRollFillerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_PreRollFillerId",
+                table: "ChannelTemplate",
+                column: "PreRollFillerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_WatermarkId",
+                table: "ChannelTemplate",
+                column: "WatermarkId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "ChannelTemplate");
+        }
+    }
+}

ErsatzTV.Infrastructure.MySql/Migrations/TvContextModelSnapshot.cs

@@ -403,6 +403,119 @@ namespace ErsatzTV.Infrastructure.MySql.Migrations
                     b.ToTable("Channel", (string)null);
                 });
 
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelTemplate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)")
+                        .HasDefaultValue("");
+
+                    b.Property<int>("FFmpegProfileId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FixedStartTimeBehavior")
+                        .HasColumnType("int");
+
+                    b.Property<int>("IdleBehavior")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MidRollFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MusicVideoCreditsMode")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MusicVideoCreditsTemplate")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)")
+                        .UseCollation("utf8mb4_general_ci");
+
+                    b.Property<int>("PlayoutMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlayoutSource")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("PostRollFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("PreRollFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("RandomStartPoint")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("ShuffleScheduleItems")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("SongVideoMode")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StreamSelector")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("StreamSelectorMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StreamingMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubtitleMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TranscodeMode")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FFmpegProfileId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("MidRollFillerId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("PostRollFillerId");
+
+                    b.HasIndex("PreRollFillerId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("ChannelTemplate", (string)null);
+                });
+
             modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelWatermark", b =>
                 {
                     b.Property<int>("Id")
@@ -4559,6 +4672,52 @@ namespace ErsatzTV.Infrastructure.MySql.Migrations
                     b.Navigation("Watermark");
                 });
 
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelTemplate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.FFmpegProfile", "FFmpegProfile")
+                        .WithMany()
+                        .HasForeignKey("FFmpegProfileId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "MidRollFiller")
+                        .WithMany()
+                        .HasForeignKey("MidRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PostRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PostRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PreRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PreRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FFmpegProfile");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("MidRollFiller");
+
+                    b.Navigation("PostRollFiller");
+
+                    b.Navigation("PreRollFiller");
+
+                    b.Navigation("Watermark");
+                });
+
             modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
                 {
                     b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")

ErsatzTV.Infrastructure.Sqlite/Migrations/20260706155532_AddChannelTemplates.cs

@@ -0,0 +1,131 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.Sqlite.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddChannelTemplates : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "ChannelTemplate",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Name = table.Column<string>(type: "varchar(50)", maxLength: 50, nullable: false, collation: "NOCASE"),
+                    Description = table.Column<string>(type: "varchar(500)", maxLength: 500, nullable: false, defaultValue: ""),
+                    IsSystem = table.Column<bool>(type: "INTEGER", nullable: false),
+                    FFmpegProfileId = table.Column<int>(type: "INTEGER", nullable: false),
+                    WatermarkId = table.Column<int>(type: "INTEGER", nullable: true),
+                    FallbackFillerId = table.Column<int>(type: "INTEGER", nullable: true),
+                    PreRollFillerId = table.Column<int>(type: "INTEGER", nullable: true),
+                    MidRollFillerId = table.Column<int>(type: "INTEGER", nullable: true),
+                    PostRollFillerId = table.Column<int>(type: "INTEGER", nullable: true),
+                    StreamSelectorMode = table.Column<int>(type: "INTEGER", nullable: false),
+                    StreamSelector = table.Column<string>(type: "TEXT", nullable: true),
+                    PreferredAudioLanguageCode = table.Column<string>(type: "TEXT", nullable: true),
+                    PreferredAudioTitle = table.Column<string>(type: "TEXT", nullable: true),
+                    PlayoutSource = table.Column<int>(type: "INTEGER", nullable: false),
+                    PlayoutMode = table.Column<int>(type: "INTEGER", nullable: false),
+                    StreamingMode = table.Column<int>(type: "INTEGER", nullable: false),
+                    PreferredSubtitleLanguageCode = table.Column<string>(type: "TEXT", nullable: true),
+                    SubtitleMode = table.Column<int>(type: "INTEGER", nullable: false),
+                    MusicVideoCreditsMode = table.Column<int>(type: "INTEGER", nullable: false),
+                    MusicVideoCreditsTemplate = table.Column<string>(type: "TEXT", nullable: true),
+                    SongVideoMode = table.Column<int>(type: "INTEGER", nullable: false),
+                    TranscodeMode = table.Column<int>(type: "INTEGER", nullable: false),
+                    IdleBehavior = table.Column<int>(type: "INTEGER", nullable: false),
+                    ShuffleScheduleItems = table.Column<bool>(type: "INTEGER", nullable: false),
+                    RandomStartPoint = table.Column<bool>(type: "INTEGER", nullable: false),
+                    FixedStartTimeBehavior = table.Column<int>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ChannelTemplate", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_ChannelWatermark_WatermarkId",
+                        column: x => x.WatermarkId,
+                        principalTable: "ChannelWatermark",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FFmpegProfile_FFmpegProfileId",
+                        column: x => x.FFmpegProfileId,
+                        principalTable: "FFmpegProfile",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FillerPreset_FallbackFillerId",
+                        column: x => x.FallbackFillerId,
+                        principalTable: "FillerPreset",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FillerPreset_MidRollFillerId",
+                        column: x => x.MidRollFillerId,
+                        principalTable: "FillerPreset",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FillerPreset_PostRollFillerId",
+                        column: x => x.PostRollFillerId,
+                        principalTable: "FillerPreset",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                    table.ForeignKey(
+                        name: "FK_ChannelTemplate_FillerPreset_PreRollFillerId",
+                        column: x => x.PreRollFillerId,
+                        principalTable: "FillerPreset",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.SetNull);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_FallbackFillerId",
+                table: "ChannelTemplate",
+                column: "FallbackFillerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_FFmpegProfileId",
+                table: "ChannelTemplate",
+                column: "FFmpegProfileId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_MidRollFillerId",
+                table: "ChannelTemplate",
+                column: "MidRollFillerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_Name",
+                table: "ChannelTemplate",
+                column: "Name",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_PostRollFillerId",
+                table: "ChannelTemplate",
+                column: "PostRollFillerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_PreRollFillerId",
+                table: "ChannelTemplate",
+                column: "PreRollFillerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChannelTemplate_WatermarkId",
+                table: "ChannelTemplate",
+                column: "WatermarkId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "ChannelTemplate");
+        }
+    }
+}

ErsatzTV.Infrastructure.Sqlite/Migrations/TvContextModelSnapshot.cs

@@ -390,6 +390,117 @@ namespace ErsatzTV.Infrastructure.Sqlite.Migrations
                     b.ToTable("Channel", (string)null);
                 });
 
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelTemplate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)")
+                        .HasDefaultValue("");
+
+                    b.Property<int>("FFmpegProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FixedStartTimeBehavior")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("IdleBehavior")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MidRollFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MusicVideoCreditsMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MusicVideoCreditsTemplate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)")
+                        .UseCollation("NOCASE");
+
+                    b.Property<int>("PlayoutMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayoutSource")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("PostRollFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("PreRollFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("RandomStartPoint")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShuffleScheduleItems")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SongVideoMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("StreamSelector")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("StreamSelectorMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StreamingMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TranscodeMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FFmpegProfileId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("MidRollFillerId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("PostRollFillerId");
+
+                    b.HasIndex("PreRollFillerId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("ChannelTemplate", (string)null);
+                });
+
             modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelWatermark", b =>
                 {
                     b.Property<int>("Id")
@@ -4386,6 +4497,52 @@ namespace ErsatzTV.Infrastructure.Sqlite.Migrations
                     b.Navigation("Watermark");
                 });
 
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelTemplate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.FFmpegProfile", "FFmpegProfile")
+                        .WithMany()
+                        .HasForeignKey("FFmpegProfileId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "MidRollFiller")
+                        .WithMany()
+                        .HasForeignKey("MidRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PostRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PostRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PreRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PreRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FFmpegProfile");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("MidRollFiller");
+
+                    b.Navigation("PostRollFiller");
+
+                    b.Navigation("PreRollFiller");
+
+                    b.Navigation("Watermark");
+                });
+
             modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
                 {
                     b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")

ErsatzTV.Infrastructure/Data/Configurations/ChannelTemplateConfiguration.cs

@@ -0,0 +1,62 @@
+using ErsatzTV.Core.Domain;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ChannelTemplateConfiguration : IEntityTypeConfiguration<ChannelTemplate>
+{
+    public void Configure(EntityTypeBuilder<ChannelTemplate> builder)
+    {
+        builder.ToTable("ChannelTemplate");
+
+        builder.HasIndex(t => t.Name)
+            .IsUnique();
+
+        builder.Property(t => t.Name)
+            .HasMaxLength(50)
+            .HasColumnType("varchar(50)")
+            .IsRequired();
+
+        builder.Property(t => t.Description)
+            .HasMaxLength(500)
+            .HasColumnType("varchar(500)")
+            .HasDefaultValue(string.Empty)
+            .IsRequired();
+
+        builder.HasOne(t => t.FFmpegProfile)
+            .WithMany()
+            .HasForeignKey(t => t.FFmpegProfileId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasOne(t => t.Watermark)
+            .WithMany()
+            .HasForeignKey(t => t.WatermarkId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
+
+        builder.HasOne(t => t.FallbackFiller)
+            .WithMany()
+            .HasForeignKey(t => t.FallbackFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
+
+        builder.HasOne(t => t.PreRollFiller)
+            .WithMany()
+            .HasForeignKey(t => t.PreRollFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
+
+        builder.HasOne(t => t.MidRollFiller)
+            .WithMany()
+            .HasForeignKey(t => t.MidRollFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
+
+        builder.HasOne(t => t.PostRollFiller)
+            .WithMany()
+            .HasForeignKey(t => t.PostRollFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
+    }
+}

ErsatzTV.Infrastructure/Data/DbInitializer.cs

@@ -2,6 +2,8 @@
 using System.Reflection;
 using Dapper;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Infrastructure.Data;
 
@@ -84,54 +86,180 @@ public static class DbInitializer
             await context.SaveChangesAsync(cancellationToken);
         }
 
-        if (context.Resolutions.Any(x => x.Width == 1920))
+        if (!context.Resolutions.Any(x => x.Width == 1920))
         {
-            return Unit.Default;
+            var resolutions = new List<Resolution>
+            {
+                new() { Id = 1, Name = "720x480", Width = 720, Height = 480 },
+                new() { Id = 2, Name = "1280x720", Width = 1280, Height = 720 },
+                new() { Id = 3, Name = "1920x1080", Width = 1920, Height = 1080 },
+                new() { Id = 4, Name = "3840x2160", Width = 3840, Height = 2160 }
+            };
+            await context.Resolutions.AddRangeAsync(resolutions, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
+
+            var resolutionConfig = new ConfigElement
+            {
+                Key = ConfigElementKey.FFmpegDefaultResolutionId.Key,
+                Value = "3" // 1920x1080
+            };
+            await context.ConfigElements.AddAsync(resolutionConfig, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
+
+            var defaultProfile = FFmpegProfile.New("1920x1080 x264 aac", resolutions[2]);
+            await context.FFmpegProfiles.AddAsync(defaultProfile, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
+
+            var profileConfig = new ConfigElement
+            {
+                Key = ConfigElementKey.FFmpegDefaultProfileId.Key,
+                Value = defaultProfile.Id.ToString(CultureInfo.InvariantCulture)
+            };
+            await context.ConfigElements.AddAsync(profileConfig, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
+
+            var defaultChannel = new Channel(Guid.NewGuid())
+            {
+                Number = "1",
+                Name = "ErsatzTV",
+                FFmpegProfile = defaultProfile,
+                StreamingMode = StreamingMode.TransportStreamHybrid,
+                IsEnabled = true,
+                ShowInEpg = true
+            };
+            await context.Channels.AddAsync(defaultChannel, cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
         }
 
-        var resolutions = new List<Resolution>
-        {
-            new() { Id = 1, Name = "720x480", Width = 720, Height = 480 },
-            new() { Id = 2, Name = "1280x720", Width = 1280, Height = 720 },
-            new() { Id = 3, Name = "1920x1080", Width = 1920, Height = 1080 },
-            new() { Id = 4, Name = "3840x2160", Width = 3840, Height = 2160 }
-        };
-        await context.Resolutions.AddRangeAsync(resolutions, cancellationToken);
-        await context.SaveChangesAsync(cancellationToken);
-
-        var resolutionConfig = new ConfigElement
-        {
-            Key = ConfigElementKey.FFmpegDefaultResolutionId.Key,
-            Value = "3" // 1920x1080
-        };
-        await context.ConfigElements.AddAsync(resolutionConfig, cancellationToken);
-        await context.SaveChangesAsync(cancellationToken);
-
-        var defaultProfile = FFmpegProfile.New("1920x1080 x264 aac", resolutions[2]);
-        await context.FFmpegProfiles.AddAsync(defaultProfile, cancellationToken);
-        await context.SaveChangesAsync(cancellationToken);
-
-        var profileConfig = new ConfigElement
-        {
-            Key = ConfigElementKey.FFmpegDefaultProfileId.Key,
-            Value = defaultProfile.Id.ToString(CultureInfo.InvariantCulture)
-        };
-        await context.ConfigElements.AddAsync(profileConfig, cancellationToken);
-        await context.SaveChangesAsync(cancellationToken);
-
-        var defaultChannel = new Channel(Guid.NewGuid())
-        {
-            Number = "1",
-            Name = "ErsatzTV",
-            FFmpegProfile = defaultProfile,
-            StreamingMode = StreamingMode.TransportStreamHybrid,
-            IsEnabled = true,
-            ShowInEpg = true
-        };
-        await context.Channels.AddAsync(defaultChannel, cancellationToken);
-        await context.SaveChangesAsync(cancellationToken);
+        await SeedChannelTemplates(context, cancellationToken);
 
         // TODO: create looping static image that mentions configuring via web
         return Unit.Default;
     }
+
+    private static async Task SeedChannelTemplates(TvContext context, CancellationToken cancellationToken)
+    {
+        if (await context.ChannelTemplates.AnyAsync(t => t.Name == "Standard", cancellationToken) &&
+            await context.ChannelTemplates.AnyAsync(t => t.Name == "Music videos", cancellationToken))
+        {
+            await EnsureDefaultChannelTemplateConfig(context, cancellationToken);
+            return;
+        }
+
+        FFmpegProfile defaultProfile = await GetDefaultFFmpegProfile(context, cancellationToken);
+        if (defaultProfile is null)
+        {
+            return;
+        }
+
+        if (!await context.ChannelTemplates.AnyAsync(t => t.Name == "Standard", cancellationToken))
+        {
+            await context.ChannelTemplates.AddAsync(
+                NewSystemTemplate(
+                    "Standard",
+                    "Balanced defaults for generated channels.",
+                    defaultProfile.Id,
+                    ChannelMusicVideoCreditsMode.None,
+                    ChannelSongVideoMode.Default,
+                    shuffleScheduleItems: false,
+                    randomStartPoint: false),
+                cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
+        }
+
+        if (!await context.ChannelTemplates.AnyAsync(t => t.Name == "Music videos", cancellationToken))
+        {
+            await context.ChannelTemplates.AddAsync(
+                NewSystemTemplate(
+                    "Music videos",
+                    "Defaults for shuffled music-video channels with generated credit subtitles.",
+                    defaultProfile.Id,
+                    ChannelMusicVideoCreditsMode.GenerateSubtitles,
+                    ChannelSongVideoMode.WithProgress,
+                    shuffleScheduleItems: true,
+                    randomStartPoint: true),
+                cancellationToken);
+            await context.SaveChangesAsync(cancellationToken);
+        }
+
+        await EnsureDefaultChannelTemplateConfig(context, cancellationToken);
+    }
+
+    private static async Task<FFmpegProfile> GetDefaultFFmpegProfile(
+        TvContext context,
+        CancellationToken cancellationToken)
+    {
+        string defaultProfileConfigKey = ConfigElementKey.FFmpegDefaultProfileId.Key;
+        ConfigElement profileConfig = await context.ConfigElements
+            .AsNoTracking()
+            .FirstOrDefaultAsync(c => c.Key == defaultProfileConfigKey, cancellationToken);
+        if (profileConfig is not null &&
+            int.TryParse(profileConfig.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out int profileId))
+        {
+            FFmpegProfile configuredProfile = await context.FFmpegProfiles
+                .FirstOrDefaultAsync(p => p.Id == profileId, cancellationToken);
+            if (configuredProfile is not null)
+            {
+                return configuredProfile;
+            }
+        }
+
+        return await context.FFmpegProfiles.OrderBy(p => p.Id).FirstOrDefaultAsync(cancellationToken);
+    }
+
+    private static async Task EnsureDefaultChannelTemplateConfig(TvContext context, CancellationToken cancellationToken)
+    {
+        string defaultTemplateConfigKey = ConfigElementKey.ChannelTemplatesDefaultTemplateId.Key;
+        bool configExists = await context.ConfigElements
+            .AnyAsync(c => c.Key == defaultTemplateConfigKey, cancellationToken);
+        if (configExists)
+        {
+            return;
+        }
+
+        ChannelTemplate standard = await context.ChannelTemplates
+            .AsNoTracking()
+            .FirstAsync(t => t.Name == "Standard", cancellationToken);
+        await context.ConfigElements.AddAsync(
+            new ConfigElement
+            {
+                Key = defaultTemplateConfigKey,
+                Value = standard.Id.ToString(CultureInfo.InvariantCulture)
+            },
+            cancellationToken);
+        await context.SaveChangesAsync(cancellationToken);
+    }
+
+    private static ChannelTemplate NewSystemTemplate(
+        string name,
+        string description,
+        int ffmpegProfileId,
+        ChannelMusicVideoCreditsMode musicVideoCreditsMode,
+        ChannelSongVideoMode songVideoMode,
+        bool shuffleScheduleItems,
+        bool randomStartPoint) =>
+        new()
+        {
+            Name = name,
+            Description = description,
+            IsSystem = true,
+            FFmpegProfileId = ffmpegProfileId,
+            StreamSelectorMode = ChannelStreamSelectorMode.Default,
+            StreamSelector = string.Empty,
+            PreferredAudioLanguageCode = string.Empty,
+            PreferredAudioTitle = string.Empty,
+            PlayoutSource = ChannelPlayoutSource.Generated,
+            PlayoutMode = ChannelPlayoutMode.Continuous,
+            StreamingMode = StreamingMode.TransportStreamHybrid,
+            PreferredSubtitleLanguageCode = string.Empty,
+            SubtitleMode = ChannelSubtitleMode.None,
+            MusicVideoCreditsMode = musicVideoCreditsMode,
+            MusicVideoCreditsTemplate = string.Empty,
+            SongVideoMode = songVideoMode,
+            TranscodeMode = ChannelTranscodeMode.OnDemand,
+            IdleBehavior = ChannelIdleBehavior.StopOnDisconnect,
+            ShuffleScheduleItems = shuffleScheduleItems,
+            RandomStartPoint = randomStartPoint,
+            FixedStartTimeBehavior = FixedStartTimeBehavior.Flexible
+        };
 }

ErsatzTV.Infrastructure/Data/TvContext.cs

@@ -30,6 +30,7 @@ public class TvContext : DbContext
 
     public DbSet<ConfigElement> ConfigElements { get; set; }
     public DbSet<Channel> Channels { get; set; }
+    public DbSet<ChannelTemplate> ChannelTemplates { get; set; }
     public DbSet<ChannelWatermark> ChannelWatermarks { get; set; }
     public DbSet<MediaSource> MediaSources { get; set; }
     public DbSet<LocalMediaSource> LocalMediaSources { get; set; }
@@ -160,6 +161,7 @@ public class TvContext : DbContext
             modelBuilder.Entity<Block>().Property(b => b.Name).UseCollation(collation);
             modelBuilder.Entity<BlockGroup>().Property(b => b.Name).UseCollation(collation);
             modelBuilder.Entity<Channel>().Property(c => c.Name).UseCollation(collation);
+            modelBuilder.Entity<ChannelTemplate>().Property(c => c.Name).UseCollation(collation);
             modelBuilder.Entity<ChannelWatermark>().Property(c => c.Name).UseCollation(collation);
             modelBuilder.Entity<Collection>().Property(c => c.Name).UseCollation(collation);
             modelBuilder.Entity<Deco>().Property(d => d.Name).UseCollation(collation);

ErsatzTV.Infrastructure/Extensions/PlayoutGuideQueryableExtensions.cs

@@ -0,0 +1,98 @@
+using ErsatzTV.Core.Domain;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Infrastructure.Extensions;
+
+public static class PlayoutGuideQueryableExtensions
+{
+    /// <summary>
+    ///     Eager-loads the full playout-item metadata graph needed to render guide programme
+    ///     titles/subtitles/categories/artwork. Shared by the XMLTV cache builder and the JSON guide
+    ///     query so both surfaces see identical data. Callers should apply <c>AsSplitQuery()</c>.
+    /// </summary>
+    public static IQueryable<Playout> IncludeGuideMetadata(this IQueryable<Playout> playouts) =>
+        playouts
+            .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);
+}

ErsatzTV.Tests/Application/ChannelTemplates/ChannelTemplateHandlerTests.cs

@@ -0,0 +1,288 @@
+using ErsatzTV.Application.ChannelTemplates;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Data.Repositories;
+using ErsatzTV.Tests.Support;
+using LanguageExt;
+using NUnit.Framework;
+using Shouldly;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Tests.Application.ChannelTemplates;
+
+[TestFixture]
+public class ChannelTemplateHandlerTests
+{
+    private InMemoryTvContext _db = null!;
+    private IConfigElementRepository _config = null!;
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        _db = await InMemoryTvContext.CreateAsync();
+        _config = new ConfigElementRepository(_db.Factory);
+    }
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task Create_Should_Persist_Template_With_Reference_Ids()
+    {
+        await SeedProfile(1);
+        await SeedFiller(2, FillerKind.PreRoll);
+        await SeedFiller(3, FillerKind.MidRoll);
+        await SeedFiller(4, FillerKind.PostRoll);
+        var handler = new CreateChannelTemplateHandler(_db.Factory, _config);
+
+        Either<BaseError, ChannelTemplateResponseModel> result =
+            await handler.Handle(MakeCreate("Custom"), CancellationToken.None);
+
+        ChannelTemplateResponseModel vm = RightOf(result);
+        vm.Id.ShouldBeGreaterThan(0);
+        vm.Name.ShouldBe("Custom");
+        vm.IsSystem.ShouldBeFalse();
+        vm.PreRollFillerId.ShouldBe(2);
+        vm.MidRollFillerId.ShouldBe(3);
+        vm.PostRollFillerId.ShouldBe(4);
+
+        await using TvContext context = _db.CreateContext();
+        context.ChannelTemplates.Single().Name.ShouldBe("Custom");
+    }
+
+    [Test]
+    public async Task Create_Should_Return_NotFoundError_When_Profile_Missing()
+    {
+        var handler = new CreateChannelTemplateHandler(_db.Factory, _config);
+
+        Either<BaseError, ChannelTemplateResponseModel> result =
+            await handler.Handle(MakeCreate("Missing", ffmpegProfileId: 99), CancellationToken.None);
+
+        LeftOf(result).ShouldBeOfType<NotFoundError>();
+    }
+
+    [Test]
+    public async Task Create_Should_Return_Error_When_Trimmed_Name_Already_Exists()
+    {
+        await SeedProfile(1);
+        await SeedTemplate(7, "Standard");
+        var handler = new CreateChannelTemplateHandler(_db.Factory, _config);
+
+        Either<BaseError, ChannelTemplateResponseModel> result =
+            await handler.Handle(MakeCreate("Standard "), CancellationToken.None);
+
+        LeftOf(result).Value.ShouldBe("Channel template name must be unique.");
+    }
+
+    [Test]
+    public async Task Create_Should_Validate_Filler_Kind()
+    {
+        await SeedProfile(1);
+        await SeedFiller(2, FillerKind.PostRoll);
+        var handler = new CreateChannelTemplateHandler(_db.Factory, _config);
+
+        Either<BaseError, ChannelTemplateResponseModel> result =
+            await handler.Handle(MakeCreate("Bad", preRollFillerId: 2), CancellationToken.None);
+
+        LeftOf(result).ShouldBeOfType<NotFoundError>();
+    }
+
+    [Test]
+    public async Task Update_Should_Reject_System_Template()
+    {
+        await SeedProfile(1);
+        await SeedTemplate(7, "Standard", isSystem: true);
+        var handler = new UpdateChannelTemplateHandler(_db.Factory, _config);
+
+        Either<BaseError, ChannelTemplateResponseModel> result =
+            await handler.Handle(MakeUpdate(7, "Changed"), CancellationToken.None);
+
+        LeftOf(result).Value.ShouldBe("System templates cannot be updated.");
+    }
+
+    [Test]
+    public async Task Delete_Should_Reject_Default_Template()
+    {
+        await SeedProfile(1);
+        await SeedTemplate(7, "Default");
+        await _config.Upsert(ConfigElementKey.ChannelTemplatesDefaultTemplateId, 7, CancellationToken.None);
+        var handler = new DeleteChannelTemplateHandler(_db.Factory, _config);
+
+        Either<BaseError, Unit> result = await handler.Handle(new DeleteChannelTemplate(7), CancellationToken.None);
+
+        LeftOf(result).Value.ShouldBe("Default channel template cannot be deleted.");
+    }
+
+    [Test]
+    public async Task SetDefault_Should_Update_Config_And_Return_Template()
+    {
+        await SeedProfile(1);
+        await SeedTemplate(7, "Default");
+        var handler = new SetDefaultChannelTemplateHandler(_db.Factory, _config);
+
+        Either<BaseError, ChannelTemplateResponseModel> result =
+            await handler.Handle(new SetDefaultChannelTemplate(7), CancellationToken.None);
+
+        ChannelTemplateResponseModel vm = RightOf(result);
+        vm.IsDefault.ShouldBeTrue();
+        Option<int> defaultId =
+            await _config.GetValue<int>(ConfigElementKey.ChannelTemplatesDefaultTemplateId, CancellationToken.None);
+        defaultId.IfNone(0).ShouldBe(7);
+    }
+
+    [Test]
+    public async Task GetAll_Should_Flag_Configured_Default()
+    {
+        await SeedProfile(1);
+        await SeedTemplate(7, "Standard");
+        await SeedTemplate(8, "Music videos");
+        await _config.Upsert(ConfigElementKey.ChannelTemplatesDefaultTemplateId, 8, CancellationToken.None);
+        var handler = new GetAllChannelTemplatesHandler(_db.Factory, _config);
+
+        List<ChannelTemplateResponseModel> result =
+            await handler.Handle(new GetAllChannelTemplates(), CancellationToken.None);
+
+        result.Single(t => t.Id == 7).IsDefault.ShouldBeFalse();
+        result.Single(t => t.Id == 8).IsDefault.ShouldBeTrue();
+    }
+
+    [Test]
+    public async Task GetDefault_Should_Fall_Back_To_First_System_Template_By_Name()
+    {
+        await SeedProfile(1);
+        await SeedTemplate(1, "Zulu", isSystem: true);
+        await SeedTemplate(99, "Alpha", isSystem: true);
+        var handler = new GetDefaultChannelTemplateHandler(_db.Factory, _config);
+
+        Option<ChannelTemplateResponseModel> result =
+            await handler.Handle(new GetDefaultChannelTemplate(), CancellationToken.None);
+
+        ChannelTemplateResponseModel vm = result.IfNone(() => throw new AssertionException("Expected a template"));
+        vm.Id.ShouldBe(99);
+        vm.Name.ShouldBe("Alpha");
+        vm.IsDefault.ShouldBeTrue();
+    }
+
+    private async Task SeedProfile(int id)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.FFmpegProfiles.Add(new FFmpegProfile { Id = id, Name = $"profile-{id}" });
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedFiller(int id, FillerKind fillerKind)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.FillerPresets.Add(new FillerPreset
+        {
+            Id = id,
+            Name = $"filler-{id}",
+            FillerKind = fillerKind,
+            FillerMode = FillerMode.Count,
+            Count = 1,
+            CollectionType = CollectionType.Collection
+        });
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedTemplate(int id, string name, bool isSystem = false)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.ChannelTemplates.Add(new ChannelTemplate
+        {
+            Id = id,
+            Name = name,
+            Description = string.Empty,
+            IsSystem = isSystem,
+            FFmpegProfileId = 1,
+            StreamSelectorMode = ChannelStreamSelectorMode.Default,
+            StreamSelector = string.Empty,
+            PreferredAudioLanguageCode = string.Empty,
+            PreferredAudioTitle = string.Empty,
+            PlayoutSource = ChannelPlayoutSource.Generated,
+            PlayoutMode = ChannelPlayoutMode.Continuous,
+            StreamingMode = StreamingMode.TransportStreamHybrid,
+            PreferredSubtitleLanguageCode = string.Empty,
+            SubtitleMode = ChannelSubtitleMode.None,
+            MusicVideoCreditsMode = ChannelMusicVideoCreditsMode.None,
+            MusicVideoCreditsTemplate = string.Empty,
+            SongVideoMode = ChannelSongVideoMode.Default,
+            TranscodeMode = ChannelTranscodeMode.OnDemand,
+            IdleBehavior = ChannelIdleBehavior.StopOnDisconnect,
+            FixedStartTimeBehavior = FixedStartTimeBehavior.Flexible
+        });
+        await context.SaveChangesAsync();
+    }
+
+    private static CreateChannelTemplate MakeCreate(
+        string name,
+        int ffmpegProfileId = 1,
+        int? preRollFillerId = 2) =>
+        new(
+            name,
+            "Description",
+            ffmpegProfileId,
+            null,
+            null,
+            preRollFillerId,
+            3,
+            4,
+            ChannelStreamSelectorMode.Default,
+            string.Empty,
+            string.Empty,
+            string.Empty,
+            ChannelPlayoutSource.Generated,
+            ChannelPlayoutMode.Continuous,
+            StreamingMode.TransportStreamHybrid,
+            string.Empty,
+            ChannelSubtitleMode.None,
+            ChannelMusicVideoCreditsMode.None,
+            string.Empty,
+            ChannelSongVideoMode.Default,
+            ChannelTranscodeMode.OnDemand,
+            ChannelIdleBehavior.StopOnDisconnect,
+            true,
+            false,
+            FixedStartTimeBehavior.Flexible);
+
+    private static UpdateChannelTemplate MakeUpdate(int id, string name) =>
+        new(
+            id,
+            name,
+            "Description",
+            1,
+            null,
+            null,
+            null,
+            null,
+            null,
+            ChannelStreamSelectorMode.Default,
+            string.Empty,
+            string.Empty,
+            string.Empty,
+            ChannelPlayoutSource.Generated,
+            ChannelPlayoutMode.Continuous,
+            StreamingMode.TransportStreamHybrid,
+            string.Empty,
+            ChannelSubtitleMode.None,
+            ChannelMusicVideoCreditsMode.None,
+            string.Empty,
+            ChannelSongVideoMode.Default,
+            ChannelTranscodeMode.OnDemand,
+            ChannelIdleBehavior.StopOnDisconnect,
+            false,
+            false,
+            FixedStartTimeBehavior.Flexible);
+
+    private static BaseError LeftOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Left: e => e, Right: _ => throw new AssertionException("Expected a Left result"));
+
+    private static TR RightOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Left: e => throw new AssertionException($"Expected a Right result but got {e.Value}"), Right: r => r);
+}

ErsatzTV.Tests/Application/Channels/BulkDeleteChannelsHandlerTests.cs

@@ -0,0 +1,57 @@
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using Testably.Abstractions.Testing;
+
+namespace ErsatzTV.Tests.Application.Channels;
+
+[TestFixture]
+public class BulkDeleteChannelsHandlerTests : ChannelHandlerTestBase
+{
+    private readonly MockFileSystem _fileSystem = new();
+
+    private BulkDeleteChannelsHandler MakeHandler() => new(Db.Factory, Worker, _fileSystem, SearchTargets);
+
+    [Test]
+    public async Task Should_Delete_All_Channels()
+    {
+        await SeedChannel(1, "5");
+        await SeedChannel(2, "6");
+
+        Either<BaseError, Unit> result =
+            await MakeHandler().Handle(new BulkDeleteChannels([1, 2]), CancellationToken.None);
+
+        result.IsRight.ShouldBeTrue();
+
+        await using TvContext context = Db.CreateContext();
+        int count = await context.Channels.CountAsync();
+        count.ShouldBe(0);
+        SearchTargets.Received(1).SearchTargetsChanged();
+    }
+
+    [Test]
+    public async Task Should_Return_NotFound_And_Not_Delete_When_Any_Channel_Is_Missing()
+    {
+        await SeedChannel(1, "5");
+
+        Either<BaseError, Unit> result =
+            await MakeHandler().Handle(new BulkDeleteChannels([1, 99]), CancellationToken.None);
+
+        BaseError error = LeftOf(result);
+        error.ShouldBeOfType<NotFoundError>();
+
+        await using TvContext context = Db.CreateContext();
+        bool exists = await context.Channels.AnyAsync(c => c.Id == 1);
+        exists.ShouldBeTrue();
+    }
+
+    private static BaseError LeftOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Left: e => e, Right: _ => throw new AssertionException("Expected a Left result"));
+}

ErsatzTV.Tests/Application/Channels/BulkMoveChannelsToGroupHandlerTests.cs

@@ -0,0 +1,74 @@
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Channels;
+
+[TestFixture]
+public class BulkMoveChannelsToGroupHandlerTests : ChannelHandlerTestBase
+{
+    private BulkMoveChannelsToGroupHandler MakeHandler() => new(Db.Factory, Worker, SearchTargets);
+
+    [Test]
+    public async Task Should_Move_All_Channels_To_Group()
+    {
+        await SeedChannel(1, "5");
+        await SeedChannel(2, "6");
+
+        Either<BaseError, Unit> result =
+            await MakeHandler().Handle(new BulkMoveChannelsToGroup([1, 2], "Movies"), CancellationToken.None);
+
+        result.IsRight.ShouldBeTrue();
+
+        await using TvContext context = Db.CreateContext();
+        List<string> groups = await context.Channels
+            .OrderBy(c => c.Id)
+            .Select(c => c.Group)
+            .ToListAsync();
+        groups.ShouldBe(["Movies", "Movies"]);
+        SearchTargets.Received(1).SearchTargetsChanged();
+    }
+
+    [Test]
+    public async Task Should_Return_NotFound_And_Not_Move_When_Any_Channel_Is_Missing()
+    {
+        await SeedChannel(1, "5", group: "Original");
+
+        Either<BaseError, Unit> result =
+            await MakeHandler().Handle(new BulkMoveChannelsToGroup([1, 99], "Movies"), CancellationToken.None);
+
+        BaseError error = LeftOf(result);
+        error.ShouldBeOfType<NotFoundError>();
+
+        await using TvContext context = Db.CreateContext();
+        string group = await context.Channels.Where(c => c.Id == 1).Select(c => c.Group).SingleAsync();
+        group.ShouldBe("Original");
+    }
+
+    [Test]
+    public async Task Should_Reject_Empty_Group()
+    {
+        await SeedChannel(1, "5", group: "Original");
+
+        Either<BaseError, Unit> result =
+            await MakeHandler().Handle(new BulkMoveChannelsToGroup([1], ""), CancellationToken.None);
+
+        BaseError error = LeftOf(result);
+        error.ShouldNotBeOfType<NotFoundError>();
+        error.Value.ShouldContain("group");
+
+        await using TvContext context = Db.CreateContext();
+        string group = await context.Channels.Where(c => c.Id == 1).Select(c => c.Group).SingleAsync();
+        group.ShouldBe("Original");
+    }
+
+    private static BaseError LeftOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Left: e => e, Right: _ => throw new AssertionException("Expected a Left result"));
+}

ErsatzTV.Tests/Application/Channels/CreateChannelFromLineupHandlerTests.cs

@@ -0,0 +1,751 @@
+using System.Threading.Channels;
+using ErsatzTV.Application;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Application.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 ErsatzTV.Tests.Support;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging.Abstractions;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using DomainChannel = ErsatzTV.Core.Domain.Channel;
+using DomainPlaylistItem = ErsatzTV.Core.Domain.PlaylistItem;
+
+namespace ErsatzTV.Tests.Application.Channels;
+
+[TestFixture]
+public class CreateChannelFromLineupHandlerTests
+{
+    private Channel<IBackgroundServiceRequest> _background = null!;
+    private InMemoryTvContext _db = null!;
+    private ISearchTargets _searchTargets = null!;
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        _background = System.Threading.Channels.Channel.CreateUnbounded<IBackgroundServiceRequest>();
+        _db = await InMemoryTvContext.CreateAsync();
+        _searchTargets = Substitute.For<ISearchTargets>();
+    }
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task Should_Create_Single_Media_Item_Directly_Without_Playlist()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(), CancellationToken.None);
+
+        CreateChannelFromLineupResponseModel response = RightOf(result);
+        response.ChannelId.ShouldBeGreaterThan(0);
+        response.PlaylistId.ShouldBeNull();
+        response.ProgramScheduleId.ShouldBeGreaterThan(0);
+        response.PlayoutId.ShouldBeGreaterThan(0);
+
+        await using TvContext context = _db.CreateContext();
+
+        // No generated playlist or collection for a single-item lineup.
+        (await context.Playlists.CountAsync()).ShouldBe(0);
+        (await context.Collections.CountAsync()).ShouldBe(0);
+
+        DomainChannel channel = await context.Channels.SingleAsync();
+        channel.Name.ShouldBe("Movies");
+        channel.Number.ShouldBe("12");
+        channel.Group.ShouldBe("Kids");
+        channel.FFmpegProfileId.ShouldBe(1);
+        channel.FallbackFillerId.ShouldBe(5);
+        channel.StreamingMode.ShouldBe(StreamingMode.HttpLiveStreamingSegmenter);
+        channel.ShowInEpg.ShouldBeTrue();
+
+        ProgramSchedule schedule = await context.ProgramSchedules.Include(ps => ps.Items).SingleAsync();
+        schedule.Name.ShouldBe("12 Movies Schedule");
+        schedule.ShuffleScheduleItems.ShouldBeTrue();
+        schedule.RandomStartPoint.ShouldBeTrue();
+        schedule.FixedStartTimeBehavior.ShouldBe(FixedStartTimeBehavior.Strict);
+
+        ProgramScheduleItem item = schedule.Items.Single();
+        item.ShouldBeOfType<ProgramScheduleItemFlood>();
+        item.CollectionType.ShouldBe(CollectionType.Movie);
+        item.MediaItemId.ShouldBe(42);
+        item.CollectionId.ShouldBeNull();
+        item.PlaylistId.ShouldBeNull();
+        item.PlaybackOrder.ShouldBe(PlaybackOrder.Shuffle);
+        item.PreRollFillerId.ShouldBe(2);
+        item.MidRollFillerId.ShouldBe(3);
+        item.PostRollFillerId.ShouldBe(4);
+        item.FallbackFillerId.ShouldBe(5);
+
+        Playout playout = await context.Playouts.SingleAsync();
+        playout.ChannelId.ShouldBe(channel.Id);
+        playout.ProgramScheduleId.ShouldBe(schedule.Id);
+        playout.ScheduleKind.ShouldBe(PlayoutScheduleKind.Classic);
+
+        _background.Reader.TryRead(out IBackgroundServiceRequest? buildRequest).ShouldBeTrue();
+        BuildPlayout buildPlayout = buildRequest.ShouldBeOfType<BuildPlayout>();
+        buildPlayout.PlayoutId.ShouldBe(playout.Id);
+        buildPlayout.Mode.ShouldBe(PlayoutBuildMode.Reset);
+
+        _background.Reader.TryRead(out IBackgroundServiceRequest? refreshRequest).ShouldBeTrue();
+        refreshRequest.ShouldBeOfType<RefreshChannelList>();
+        _searchTargets.Received(1).SearchTargetsChanged();
+    }
+
+    [Test]
+    public async Task Should_Create_Single_Collection_Item_Directly()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedCollection(7);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(lineup: [CollectionItem(7)]), CancellationToken.None);
+
+        RightOf(result).PlaylistId.ShouldBeNull();
+
+        await using TvContext context = _db.CreateContext();
+        (await context.Playlists.CountAsync()).ShouldBe(0);
+        ProgramScheduleItem item = await context.ProgramScheduleItems.SingleAsync();
+        item.CollectionType.ShouldBe(CollectionType.Collection);
+        item.CollectionId.ShouldBe(7);
+    }
+
+    [Test]
+    public async Task Should_Create_Single_Playlist_Item_Directly()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedExistingPlaylist(9);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(lineup: [PlaylistEntry(9)]), CancellationToken.None);
+
+        // The generated-playlist id is null for a single-item lineup, even when it references a playlist.
+        RightOf(result).PlaylistId.ShouldBeNull();
+
+        await using TvContext context = _db.CreateContext();
+        ProgramScheduleItem item = await context.ProgramScheduleItems.SingleAsync();
+        item.CollectionType.ShouldBe(CollectionType.Playlist);
+        item.PlaylistId.ShouldBe(9);
+    }
+
+    [Test]
+    public async Task Should_Create_Single_Rerun_Collection_As_First_Run()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedRerunCollection(11);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(lineup: [RerunItem(11)]), CancellationToken.None);
+
+        RightOf(result).PlaylistId.ShouldBeNull();
+
+        await using TvContext context = _db.CreateContext();
+        ProgramScheduleItem item = await context.ProgramScheduleItems.SingleAsync();
+        item.CollectionType.ShouldBe(CollectionType.RerunFirstRun);
+        item.RerunCollectionId.ShouldBe(11);
+    }
+
+    [Test]
+    public async Task Should_Create_Multi_Item_Lineup_As_Generated_System_Playlist()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+        await SeedShow(43);
+        await SeedCollection(7);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(
+                MakeRequest(lineup: [MovieItem(42), ShowItem(43), CollectionItem(7)]),
+                CancellationToken.None);
+
+        CreateChannelFromLineupResponseModel response = RightOf(result);
+        response.PlaylistId.ShouldNotBeNull();
+
+        await using TvContext context = _db.CreateContext();
+
+        PlaylistGroup group = await context.PlaylistGroups.SingleAsync();
+        group.Name.ShouldBe("Channel Lineups");
+        group.IsSystem.ShouldBeTrue();
+
+        Playlist playlist = await context.Playlists.Include(p => p.Items).SingleAsync();
+        playlist.Id.ShouldBe(response.PlaylistId!.Value);
+        playlist.Name.ShouldBe("12 Movies Lineup");
+        playlist.IsSystem.ShouldBeTrue();
+        playlist.PlaylistGroupId.ShouldBe(group.Id);
+
+        List<DomainPlaylistItem> items = playlist.Items.OrderBy(i => i.Index).ToList();
+        items.Count.ShouldBe(3);
+        items.ShouldAllBe(i => i.PlayAll);
+        items.ShouldAllBe(i => i.IncludeInProgramGuide);
+        items.ShouldAllBe(i => i.PlaybackOrder == PlaybackOrder.Shuffle);
+
+        items[0].Index.ShouldBe(1);
+        items[0].CollectionType.ShouldBe(CollectionType.Movie);
+        items[0].MediaItemId.ShouldBe(42);
+
+        items[1].Index.ShouldBe(2);
+        items[1].CollectionType.ShouldBe(CollectionType.TelevisionShow);
+        items[1].MediaItemId.ShouldBe(43);
+
+        items[2].Index.ShouldBe(3);
+        items[2].CollectionType.ShouldBe(CollectionType.Collection);
+        items[2].CollectionId.ShouldBe(7);
+
+        // Exactly one flood schedule item, referencing the generated playlist.
+        ProgramScheduleItem scheduleItem = await context.ProgramScheduleItems.SingleAsync();
+        scheduleItem.ShouldBeOfType<ProgramScheduleItemFlood>();
+        scheduleItem.CollectionType.ShouldBe(CollectionType.Playlist);
+        scheduleItem.PlaylistId.ShouldBe(playlist.Id);
+    }
+
+    [Test]
+    public async Task Should_Reject_Rerun_Collection_In_Multi_Item_Lineup()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+        await SeedRerunCollection(11);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(
+                MakeRequest(lineup: [MovieItem(42), RerunItem(11)]),
+                CancellationToken.None);
+
+        BaseError error = LeftOf(result);
+        error.ShouldNotBeOfType<NotFoundError>();
+        error.Value.ShouldContain("single-item");
+    }
+
+    [Test]
+    public async Task Should_Reject_Playlist_In_Multi_Item_Lineup()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+        await SeedExistingPlaylist(9);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(
+                MakeRequest(lineup: [MovieItem(42), PlaylistEntry(9)]),
+                CancellationToken.None);
+
+        BaseError error = LeftOf(result);
+        error.ShouldNotBeOfType<NotFoundError>();
+        error.Value.ShouldContain("single-item");
+    }
+
+    [Test]
+    public async Task Advanced_Overrides_Should_Beat_Template_Defaults()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+
+        await using (TvContext context = _db.CreateContext())
+        {
+            context.FFmpegProfiles.Add(new FFmpegProfile { Id = 2, Name = "advanced-profile" });
+            context.ChannelWatermarks.Add(new ChannelWatermark { Id = 21, Name = "wm", Image = "wm.png" });
+            context.FillerPresets.AddRange(
+                MakeFiller(6, FillerKind.Fallback),
+                MakeFiller(7, FillerKind.PreRoll));
+            await context.SaveChangesAsync();
+        }
+
+        var advanced = new CreateChannelFromLineupAdvancedOptions(
+            PlaybackOrder: PlaybackOrder.Shuffle,
+            FFmpegProfileId: 2,
+            WatermarkId: 21,
+            FallbackFillerId: 6,
+            PreRollFillerId: 7,
+            StreamingMode: StreamingMode.TransportStream);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(advanced: advanced), CancellationToken.None);
+
+        RightOf(result);
+
+        await using TvContext assert = _db.CreateContext();
+        DomainChannel channel = await assert.Channels.SingleAsync();
+
+        // Advanced wins over the template's values (template = profile 1, no watermark, HLS, fallback 5).
+        channel.FFmpegProfileId.ShouldBe(2);
+        channel.WatermarkId.ShouldBe(21);
+        channel.StreamingMode.ShouldBe(StreamingMode.TransportStream);
+        channel.FallbackFillerId.ShouldBe(6);
+
+        ProgramScheduleItem item = await assert.ProgramScheduleItems.SingleAsync();
+        item.PlaybackOrder.ShouldBe(PlaybackOrder.Shuffle);
+        item.PreRollFillerId.ShouldBe(7);
+        item.FallbackFillerId.ShouldBe(6);
+
+        // Not overridden in Advanced -> falls through to the template value.
+        item.MidRollFillerId.ShouldBe(3);
+    }
+
+    [Test]
+    public async Task Should_Return_Validation_Error_When_Not_Exactly_One_Id_Provided()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+
+        var item = new CreateChannelFromLineupItem(
+            LibraryBrowseMediaType.Movie, CollectionType.Movie, null, null, null, null, null, null);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(lineup: [item]), CancellationToken.None);
+
+        LeftOf(result).Value.ShouldContain("exactly one typed id");
+    }
+
+    [Test]
+    public async Task Should_Return_Validation_Error_When_Media_Type_Does_Not_Match_Collection_Type()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+
+        var item = new CreateChannelFromLineupItem(
+            LibraryBrowseMediaType.Movie, CollectionType.Playlist, null, null, null, null, 42, null);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(lineup: [item]), CancellationToken.None);
+
+        BaseError error = LeftOf(result);
+        error.ShouldNotBeOfType<NotFoundError>();
+        error.Value.ShouldContain("does not match");
+    }
+
+    [Test]
+    public async Task Should_Reject_MultiCollection_With_Non_Shuffle_Playback_Order()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMultiCollection(15);
+
+        var advanced = new CreateChannelFromLineupAdvancedOptions(PlaybackOrder: PlaybackOrder.Chronological);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(
+                MakeRequest(advanced: advanced, lineup: [MultiCollectionItem(15)]),
+                CancellationToken.None);
+
+        LeftOf(result).Value.ShouldContain("Invalid playback order for multi collection");
+    }
+
+    [Test]
+    public async Task Should_Reject_Mirror_Playout_Source()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+
+        var advanced = new CreateChannelFromLineupAdvancedOptions(
+            PlaybackOrder: PlaybackOrder.Shuffle,
+            PlayoutSource: ChannelPlayoutSource.Mirror);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(advanced: advanced), CancellationToken.None);
+
+        LeftOf(result).Value.ShouldContain("Mirror playout source");
+    }
+
+    [Test]
+    public async Task OnDemand_Playout_Mode_Should_Queue_TimeShift_After_Build()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+
+        var advanced = new CreateChannelFromLineupAdvancedOptions(
+            PlaybackOrder: PlaybackOrder.Shuffle,
+            PlayoutMode: ChannelPlayoutMode.OnDemand);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(advanced: advanced), CancellationToken.None);
+
+        CreateChannelFromLineupResponseModel response = RightOf(result);
+
+        _background.Reader.TryRead(out IBackgroundServiceRequest? first).ShouldBeTrue();
+        first.ShouldBeOfType<BuildPlayout>();
+
+        _background.Reader.TryRead(out IBackgroundServiceRequest? second).ShouldBeTrue();
+        TimeShiftOnDemandPlayout timeShift = second.ShouldBeOfType<TimeShiftOnDemandPlayout>();
+        timeShift.PlayoutId.ShouldBe(response.PlayoutId);
+        timeShift.Force.ShouldBeFalse();
+
+        _background.Reader.TryRead(out IBackgroundServiceRequest? third).ShouldBeTrue();
+        third.ShouldBeOfType<RefreshChannelList>();
+    }
+
+    [Test]
+    public async Task Should_Recreate_With_De_Collided_Names_After_Channel_Delete()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+        await SeedShow(43);
+
+        // First create builds "12 Movies Schedule" + "12 Movies Lineup".
+        RightOf(await MakeHandler().Handle(
+            MakeRequest(lineup: [MovieItem(42), ShowItem(43)]),
+            CancellationToken.None));
+
+        // Delete the channel + playout but leave the generated schedule/playlist rows behind.
+        await using (TvContext context = _db.CreateContext())
+        {
+            context.Playouts.RemoveRange(await context.Playouts.ToListAsync());
+            context.Channels.RemoveRange(await context.Channels.ToListAsync());
+            await context.SaveChangesAsync();
+        }
+
+        // Second create with the same name must succeed via de-collided names.
+        CreateChannelFromLineupResponseModel response = RightOf(await MakeHandler().Handle(
+            MakeRequest(lineup: [MovieItem(42), ShowItem(43)]),
+            CancellationToken.None));
+
+        await using TvContext assert = _db.CreateContext();
+
+        bool scheduleExists = await assert.ProgramSchedules.AnyAsync(ps => ps.Name == "12 Movies Schedule 2");
+        scheduleExists.ShouldBeTrue();
+
+        Playlist newPlaylist = await assert.Playlists.SingleAsync(p => p.Id == response.PlaylistId!.Value);
+        newPlaylist.Name.ShouldBe("12 Movies Lineup 2");
+
+        // Only one system playlist group is ever created.
+        (await assert.PlaylistGroups.CountAsync(pg => pg.Name == "Channel Lineups")).ShouldBe(1);
+    }
+
+    [Test]
+    public async Task Should_Return_NotFound_For_Missing_Advanced_References()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+
+        await AssertNotFound(
+            new CreateChannelFromLineupAdvancedOptions(FFmpegProfileId: 999),
+            "FFmpegProfile 999");
+        await AssertNotFound(
+            new CreateChannelFromLineupAdvancedOptions(WatermarkId: 999),
+            "Watermark 999");
+        await AssertNotFound(
+            new CreateChannelFromLineupAdvancedOptions(FallbackFillerId: 999),
+            "Fallback filler 999");
+        await AssertNotFound(
+            new CreateChannelFromLineupAdvancedOptions(PreRollFillerId: 999),
+            "Pre-roll filler 999");
+        await AssertNotFound(
+            new CreateChannelFromLineupAdvancedOptions(MidRollFillerId: 999),
+            "Mid-roll filler 999");
+        await AssertNotFound(
+            new CreateChannelFromLineupAdvancedOptions(PostRollFillerId: 999),
+            "Post-roll filler 999");
+    }
+
+    [Test]
+    public async Task Should_Roll_Back_When_Save_Fails()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+        await SeedShow(43);
+
+        // A non-system group with the reserved name forces the handler's new system group insert
+        // to violate the unique Name index at save time (multi-item lineup path).
+        await using (TvContext context = _db.CreateContext())
+        {
+            context.PlaylistGroups.Add(new PlaylistGroup { Id = 99, Name = "Channel Lineups", IsSystem = false });
+            await context.SaveChangesAsync();
+        }
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(
+                MakeRequest(lineup: [MovieItem(42), ShowItem(43)]),
+                CancellationToken.None);
+
+        BaseError error = LeftOf(result);
+        error.ShouldNotBeOfType<NotFoundError>();
+        error.Value.ShouldBe("Unable to create channel from lineup");
+
+        await using TvContext assertContext = _db.CreateContext();
+        (await assertContext.Channels.CountAsync()).ShouldBe(0);
+        (await assertContext.Playlists.CountAsync()).ShouldBe(0);
+        (await assertContext.ProgramSchedules.CountAsync()).ShouldBe(0);
+        (await assertContext.Playouts.CountAsync()).ShouldBe(0);
+        _background.Reader.TryRead(out _).ShouldBeFalse();
+    }
+
+    [Test]
+    public async Task Should_Return_NotFound_When_Template_Is_Missing()
+    {
+        await SeedTemplateDependencies();
+        await SeedMovie(42);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(templateId: 999), CancellationToken.None);
+
+        LeftOf(result).ShouldBeOfType<NotFoundError>();
+    }
+
+    [Test]
+    public async Task Should_Return_Validation_Error_When_Channel_Number_Already_Exists_After_Trim()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+        await using (TvContext context = _db.CreateContext())
+        {
+            context.Channels.Add(new DomainChannel(Guid.NewGuid())
+            {
+                Number = "12",
+                Name = "Existing",
+                Group = "Kids",
+                Categories = string.Empty,
+                FFmpegProfileId = 1,
+                StreamSelector = string.Empty,
+                PreferredAudioLanguageCode = string.Empty,
+                PreferredAudioTitle = string.Empty,
+                PreferredSubtitleLanguageCode = string.Empty,
+                MusicVideoCreditsTemplate = string.Empty
+            });
+            await context.SaveChangesAsync();
+        }
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(number: " 12 "), CancellationToken.None);
+
+        BaseError error = LeftOf(result);
+        error.ShouldNotBeOfType<NotFoundError>();
+        error.Value.ShouldContain("Channel number must be unique");
+    }
+
+    [Test]
+    public async Task Should_Return_Validation_Error_When_Disabled_But_Shown_In_Epg()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(
+                MakeRequest(isEnabled: false, showInEpg: true),
+                CancellationToken.None);
+
+        BaseError error = LeftOf(result);
+        error.ShouldNotBeOfType<NotFoundError>();
+        error.Value.ShouldContain("Disabled channels cannot be shown in EPG");
+    }
+
+    [Test]
+    public async Task Should_Return_Validation_Error_For_Invalid_External_Logo()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+        await SeedMovie(42);
+
+        var logo = new ArtworkContentTypeModel("ftp://example.com/logo.png", string.Empty);
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(logo: logo), CancellationToken.None);
+
+        LeftOf(result).Value.ShouldContain("External logo url is invalid");
+    }
+
+    [Test]
+    public async Task Should_Return_NotFound_When_Lineup_Target_Is_Missing()
+    {
+        await SeedTemplateDependencies();
+        await SeedTemplate();
+
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(), CancellationToken.None);
+
+        NotFoundError error = LeftOf(result).ShouldBeOfType<NotFoundError>();
+        error.Value.ShouldContain("lineup[0]");
+        error.Value.ShouldContain("Movie 42");
+    }
+
+    private async Task AssertNotFound(CreateChannelFromLineupAdvancedOptions advanced, string expectedFragment)
+    {
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await MakeHandler().Handle(MakeRequest(advanced: advanced), CancellationToken.None);
+
+        NotFoundError error = LeftOf(result).ShouldBeOfType<NotFoundError>();
+        error.Value.ShouldContain(expectedFragment);
+    }
+
+    private CreateChannelFromLineupHandler MakeHandler() =>
+        new(
+            _background.Writer,
+            _db.Factory,
+            _searchTargets,
+            NullLogger<CreateChannelFromLineupHandler>.Instance);
+
+    private async Task SeedTemplateDependencies()
+    {
+        await using TvContext context = _db.CreateContext();
+        context.FFmpegProfiles.Add(new FFmpegProfile { Id = 1, Name = "profile" });
+        context.FillerPresets.AddRange(
+            MakeFiller(2, FillerKind.PreRoll),
+            MakeFiller(3, FillerKind.MidRoll),
+            MakeFiller(4, FillerKind.PostRoll),
+            MakeFiller(5, FillerKind.Fallback));
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedTemplate()
+    {
+        await using TvContext context = _db.CreateContext();
+        context.ChannelTemplates.Add(new ChannelTemplate
+        {
+            Id = 10,
+            Name = "Template",
+            Description = string.Empty,
+            FFmpegProfileId = 1,
+            FallbackFillerId = 5,
+            PreRollFillerId = 2,
+            MidRollFillerId = 3,
+            PostRollFillerId = 4,
+            StreamSelectorMode = ChannelStreamSelectorMode.Default,
+            StreamSelector = string.Empty,
+            PreferredAudioLanguageCode = string.Empty,
+            PreferredAudioTitle = string.Empty,
+            PlayoutSource = ChannelPlayoutSource.Generated,
+            PlayoutMode = ChannelPlayoutMode.Continuous,
+            StreamingMode = StreamingMode.HttpLiveStreamingSegmenter,
+            PreferredSubtitleLanguageCode = string.Empty,
+            SubtitleMode = ChannelSubtitleMode.None,
+            MusicVideoCreditsMode = ChannelMusicVideoCreditsMode.None,
+            MusicVideoCreditsTemplate = string.Empty,
+            SongVideoMode = ChannelSongVideoMode.Default,
+            TranscodeMode = ChannelTranscodeMode.OnDemand,
+            IdleBehavior = ChannelIdleBehavior.StopOnDisconnect,
+            ShuffleScheduleItems = true,
+            RandomStartPoint = true,
+            FixedStartTimeBehavior = FixedStartTimeBehavior.Strict
+        });
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedMovie(int id)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.Movies.Add(new Movie { Id = id });
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedShow(int id)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.Shows.Add(new Show { Id = id });
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedCollection(int id)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.Collections.Add(new Collection { Id = id, Name = $"Collection {id}" });
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedMultiCollection(int id)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.MultiCollections.Add(new MultiCollection { Id = id, Name = $"Multi {id}" });
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedRerunCollection(int id)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.RerunCollections.Add(new RerunCollection
+        {
+            Id = id,
+            Name = $"Rerun {id}",
+            CollectionType = CollectionType.Collection
+        });
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedExistingPlaylist(int id)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.PlaylistGroups.Add(new PlaylistGroup { Id = 500, Name = "User Group", IsSystem = false });
+        context.Playlists.Add(new Playlist { Id = id, Name = $"Playlist {id}", PlaylistGroupId = 500, IsSystem = false });
+        await context.SaveChangesAsync();
+    }
+
+    private static FillerPreset MakeFiller(int id, FillerKind kind) =>
+        new()
+        {
+            Id = id,
+            Name = $"filler-{id}",
+            FillerKind = kind,
+            FillerMode = FillerMode.Count,
+            Count = 1,
+            CollectionType = CollectionType.Collection
+        };
+
+    private static CreateChannelFromLineupItem MovieItem(int id) =>
+        new(LibraryBrowseMediaType.Movie, CollectionType.Movie, null, null, null, null, id, null);
+
+    private static CreateChannelFromLineupItem ShowItem(int id) =>
+        new(LibraryBrowseMediaType.TelevisionShow, CollectionType.TelevisionShow, null, null, null, null, id, null);
+
+    private static CreateChannelFromLineupItem CollectionItem(int id) =>
+        new(LibraryBrowseMediaType.Collection, CollectionType.Collection, id, null, null, null, null, null);
+
+    private static CreateChannelFromLineupItem MultiCollectionItem(int id) =>
+        new(LibraryBrowseMediaType.MultiCollection, CollectionType.MultiCollection, null, id, null, null, null, null);
+
+    private static CreateChannelFromLineupItem RerunItem(int id) =>
+        new(LibraryBrowseMediaType.RerunCollection, CollectionType.RerunFirstRun, null, null, null, id, null, null);
+
+    private static CreateChannelFromLineupItem PlaylistEntry(int id) =>
+        new(LibraryBrowseMediaType.Playlist, CollectionType.Playlist, null, null, null, null, null, id);
+
+    private static CreateChannelFromLineup MakeRequest(
+        string number = "12",
+        string name = "Movies",
+        int templateId = 10,
+        bool isEnabled = true,
+        bool showInEpg = true,
+        ArtworkContentTypeModel logo = null,
+        CreateChannelFromLineupAdvancedOptions advanced = null,
+        List<CreateChannelFromLineupItem> lineup = null) =>
+        new(
+            name,
+            number,
+            "Kids",
+            string.Empty,
+            logo ?? ArtworkContentTypeModel.None,
+            isEnabled,
+            showInEpg,
+            templateId,
+            advanced ?? new CreateChannelFromLineupAdvancedOptions(PlaybackOrder.Shuffle),
+            lineup ?? [MovieItem(42)]);
+
+    private static BaseError LeftOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Left: e => e, Right: _ => throw new AssertionException("Expected a Left result"));
+
+    private static TR RightOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Left: e => throw new AssertionException($"Expected a Right result, got {e.Value}"), Right: r => r);
+}

ErsatzTV.Tests/Application/Channels/GetAllChannelsForApiHandlerTests.cs

@@ -0,0 +1,53 @@
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Channels;
+
+[TestFixture]
+public class GetAllChannelsForApiHandlerTests
+{
+    [Test]
+    public async Task Should_Project_Management_Table_Fields()
+    {
+        IChannelRepository repository = Substitute.For<IChannelRepository>();
+        repository.GetAll(Arg.Any<CancellationToken>())
+            .Returns([
+                new Channel(Guid.NewGuid())
+                {
+                    Id = 7,
+                    Number = "7.1",
+                    SortNumber = 7.1,
+                    Name = "Retro Cartoons",
+                    Group = "Kids",
+                    Categories = "animation",
+                    FFmpegProfile = new FFmpegProfile { Name = "HLS 720p" },
+                    PreferredAudioLanguageCode = "eng",
+                    StreamingMode = StreamingMode.HttpLiveStreamingSegmenter,
+                    IsEnabled = false,
+                    ShowInEpg = false
+                }
+            ]);
+        var handler = new GetAllChannelsForApiHandler(repository);
+
+        List<ChannelResponseModel> result = await handler.Handle(new GetAllChannelsForApi(), CancellationToken.None);
+
+        ChannelResponseModel channel = result.ShouldHaveSingleItem();
+        channel.Id.ShouldBe(7);
+        channel.Number.ShouldBe("7.1");
+        channel.SortNumber.ShouldBe(7.1);
+        channel.Name.ShouldBe("Retro Cartoons");
+        channel.Group.ShouldBe("Kids");
+        channel.Categories.ShouldBe("animation");
+        channel.FFmpegProfile.ShouldBe("HLS 720p");
+        channel.Language.ShouldBe("eng");
+        channel.StreamingMode.ShouldBe("HLS Segmenter");
+        channel.IsEnabled.ShouldBeFalse();
+        channel.ShowInEpg.ShouldBeFalse();
+    }
+}

ErsatzTV.Tests/Application/Channels/GetChannelGuideDataHandlerTests.cs

@@ -0,0 +1,316 @@
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Application.Configuration;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using LanguageExt;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using DomainChannel = ErsatzTV.Core.Domain.Channel;
+
+namespace ErsatzTV.Tests.Application.Channels;
+
+[TestFixture]
+public class GetChannelGuideDataHandlerTests
+{
+    private static readonly DateTime BaseTime = new(2026, 1, 1, 8, 0, 0, DateTimeKind.Utc);
+
+    private InMemoryTvContext _db = null!;
+    private IConfigElementRepository _config = null!;
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        _db = await InMemoryTvContext.CreateAsync();
+        _config = Substitute.For<IConfigElementRepository>();
+
+        // ConfigElementKey has reference equality and each static accessor returns a fresh instance, so we
+        // match by the generic value type (GetValue<T>) with Arg.Any key. Pin the time zone to UTC so
+        // projected times are deterministic regardless of the machine/CI time zone, and split block time
+        // evenly. XmltvDaysToBuild is left unconfigured (falls back to 2) except in the default-window test.
+        _config.GetValue<XmltvTimeZone>(Arg.Any<ConfigElementKey>(), Arg.Any<CancellationToken>())
+            .Returns(Option<XmltvTimeZone>.Some(XmltvTimeZone.Utc));
+        _config.GetValue<XmltvBlockBehavior>(Arg.Any<ConfigElementKey>(), Arg.Any<CancellationToken>())
+            .Returns(Option<XmltvBlockBehavior>.Some(XmltvBlockBehavior.SplitTimeEvenly));
+    }
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    private GetChannelGuideDataHandler MakeHandler() => new(_db.Factory, _config);
+
+    [Test]
+    public async Task Handle_Should_Only_Include_Visible_Channels()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel visible = NewChannel("2", "Visible", showInEpg: true);
+            DomainChannel hidden = NewChannel("3", "Hidden", showInEpg: false);
+            visible.Playouts = [MakeFloodPlayout(visible, (BaseTime, BaseTime.AddHours(1), 1, "Visible Show"))];
+            hidden.Playouts = [MakeFloodPlayout(hidden, (BaseTime, BaseTime.AddHours(1), 1, "Hidden Show"))];
+            context.Channels.AddRange(visible, hidden);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        result.Channels.Select(c => c.Number).ShouldBe(["2"]);
+    }
+
+    [Test]
+    public async Task Handle_Should_Order_Channels_By_Decimal_Number()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            context.Channels.Add(NewChannel("10", "Ten", showInEpg: true));
+            context.Channels.Add(NewChannel("2", "Two", showInEpg: true));
+            context.Channels.Add(NewChannel("5.1", "FiveOne", showInEpg: true));
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        // decimal order: 2 < 5.1 < 10 (string order would put "10" first)
+        result.Channels.Select(c => c.Number).ShouldBe(["2", "5.1", "10"]);
+    }
+
+    [Test]
+    public async Task Handle_Should_Filter_Programmes_To_Requested_Window()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel channel = NewChannel("2", "Two", showInEpg: true);
+            channel.Playouts =
+            [
+                MakeFloodPlayout(
+                    channel,
+                    (BaseTime, BaseTime.AddHours(1), 1, "Before Window"),
+                    (BaseTime.AddHours(10), BaseTime.AddHours(11), 2, "In Window"))
+            ];
+            context.Channels.Add(channel);
+            await context.SaveChangesAsync();
+        }
+
+        // window starts after the first programme has finished
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime.AddHours(5), BaseTime.AddHours(20)),
+            CancellationToken.None);
+
+        List<ChannelGuideProgrammeResponseModel> programmes = result.Channels.Single().Programmes;
+        programmes.Select(p => p.Title).ShouldBe(["In Window"]);
+    }
+
+    [Test]
+    public async Task Handle_Should_Passthrough_Custom_Title_And_Null_SubTitle()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel channel = NewChannel("2", "Two", showInEpg: true);
+            PlayoutItem item = MakeItem(BaseTime, BaseTime.AddHours(1), guideGroup: 1, movieTitle: "Ignored");
+            item.CustomTitle = "Custom Title";
+            channel.Playouts = [MakePlayout(channel, PlayoutScheduleKind.Classic, [item])];
+            context.Channels.Add(channel);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        ChannelGuideProgrammeResponseModel programme = result.Channels.Single().Programmes.Single();
+        programme.Title.ShouldBe("Custom Title");
+        programme.SubTitle.ShouldBeNull();
+        programme.Category.ShouldBe("Movie");
+    }
+
+    [Test]
+    public async Task Handle_Should_Merge_Leading_PreRoll_Filler_Into_Following_Programme()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel channel = NewChannel("2", "Two", showInEpg: true);
+            PlayoutItem preRoll = MakeItem(BaseTime, BaseTime.AddMinutes(5), guideGroup: 1, movieTitle: "Bumper");
+            preRoll.FillerKind = FillerKind.PreRoll;
+            PlayoutItem content = MakeItem(BaseTime.AddMinutes(5), BaseTime.AddHours(1), guideGroup: 1, movieTitle: "Feature");
+            channel.Playouts = [MakePlayout(channel, PlayoutScheduleKind.Classic, [preRoll, content])];
+            context.Channels.Add(channel);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        ChannelGuideProgrammeResponseModel programme = result.Channels.Single().Programmes.Single();
+        // filler is merged: the programme starts at the pre-roll start but displays the feature metadata
+        programme.Title.ShouldBe("Feature");
+        programme.Start.ShouldBe(new DateTimeOffset(BaseTime, TimeSpan.Zero));
+        programme.Stop.ShouldBe(new DateTimeOffset(BaseTime.AddHours(1), TimeSpan.Zero));
+        programme.FillerKind.ShouldBe(FillerKind.None);
+    }
+
+    [Test]
+    public async Task Handle_Should_Split_Block_Window_Evenly_Across_Content_Items()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel channel = NewChannel("2", "Two", showInEpg: true);
+            PlayoutItem one = MakeItem(BaseTime, BaseTime.AddMinutes(20), guideGroup: 7, movieTitle: "One");
+            PlayoutItem two = MakeItem(BaseTime.AddMinutes(20), BaseTime.AddMinutes(40), guideGroup: 7, movieTitle: "Two");
+            foreach (PlayoutItem item in new[] { one, two })
+            {
+                item.GuideStart = BaseTime;
+                item.GuideFinish = BaseTime.AddHours(1);
+            }
+
+            channel.Playouts = [MakePlayout(channel, PlayoutScheduleKind.Block, [one, two])];
+            context.Channels.Add(channel);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        List<ChannelGuideProgrammeResponseModel> programmes = result.Channels.Single().Programmes;
+        programmes.Count.ShouldBe(2);
+        // 1-hour guide window split evenly across the 2 content items -> 30 minutes each
+        programmes[0].Start.ShouldBe(new DateTimeOffset(BaseTime, TimeSpan.Zero));
+        programmes[0].Stop.ShouldBe(new DateTimeOffset(BaseTime.AddMinutes(30), TimeSpan.Zero));
+        programmes[1].Start.ShouldBe(new DateTimeOffset(BaseTime.AddMinutes(30), TimeSpan.Zero));
+        programmes[1].Stop.ShouldBe(new DateTimeOffset(BaseTime.AddHours(1), TimeSpan.Zero));
+    }
+
+    [Test]
+    public async Task Handle_Should_Default_Start_To_Now_And_End_To_DaysToBuild()
+    {
+        _config.GetValue<int>(Arg.Any<ConfigElementKey>(), Arg.Any<CancellationToken>())
+            .Returns(Option<int>.Some(3));
+
+        DateTimeOffset before = DateTimeOffset.UtcNow;
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(null, null),
+            CancellationToken.None);
+        DateTimeOffset after = DateTimeOffset.UtcNow;
+
+        result.Start.ShouldBeInRange(before, after);
+        (result.End - result.Start).ShouldBe(TimeSpan.FromDays(3));
+    }
+
+    [Test]
+    public async Task Handle_Should_Shift_Mirror_Channel_Programmes_By_PlayoutOffset_Without_Mutating_Source_Items()
+    {
+        PlayoutItem sourceItem = MakeItem(BaseTime, BaseTime.AddHours(1), guideGroup: 1, movieTitle: "Live Show");
+        var playoutOffset = TimeSpan.FromHours(3);
+
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel source = NewChannel("1", "Source", showInEpg: false);
+            source.Playouts = [MakePlayout(source, PlayoutScheduleKind.Classic, [sourceItem])];
+
+            DomainChannel mirror = NewChannel("2", "Mirror", showInEpg: true);
+            mirror.PlayoutSource = ChannelPlayoutSource.Mirror;
+            mirror.MirrorSourceChannel = source;
+            mirror.PlayoutOffset = playoutOffset;
+
+            context.Channels.AddRange(source, mirror);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        ChannelGuideProgrammeResponseModel programme = result.Channels.Single(c => c.Number == "2").Programmes.Single();
+        programme.Title.ShouldBe("Live Show");
+        programme.Start.ShouldBe(new DateTimeOffset(BaseTime.Add(playoutOffset), TimeSpan.Zero));
+        programme.Stop.ShouldBe(new DateTimeOffset(BaseTime.AddHours(1).Add(playoutOffset), TimeSpan.Zero));
+
+        // the WithPlayoutOffset copy fix: applying the mirror offset must not mutate the source playout's
+        // own (shared, AsNoTracking) PlayoutItem entities in place.
+        sourceItem.Start.ShouldBe(BaseTime);
+        sourceItem.Finish.ShouldBe(BaseTime.AddHours(1));
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Empty_Programmes_For_Channel_Without_Playout()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            context.Channels.Add(NewChannel("2", "Two", showInEpg: true));
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        result.Channels.Single().Programmes.ShouldBeEmpty();
+    }
+
+    // --- seeding helpers ---
+
+    private static Playout MakeFloodPlayout(
+        DomainChannel channel,
+        params (DateTime Start, DateTime Finish, int GuideGroup, string Title)[] items) =>
+        MakePlayout(
+            channel,
+            PlayoutScheduleKind.Classic,
+            items.Select(i => MakeItem(i.Start, i.Finish, i.GuideGroup, i.Title)).ToList());
+
+    private static Playout MakePlayout(
+        DomainChannel channel,
+        PlayoutScheduleKind scheduleKind,
+        List<PlayoutItem> items) =>
+        new()
+        {
+            Channel = channel,
+            ScheduleKind = scheduleKind,
+            ScheduleFile = string.Empty,
+            Items = items
+        };
+
+    private static PlayoutItem MakeItem(
+        DateTime start,
+        DateTime finish,
+        int guideGroup,
+        string movieTitle) =>
+        new()
+        {
+            Start = start,
+            Finish = finish,
+            GuideGroup = guideGroup,
+            FillerKind = FillerKind.None,
+            MediaItem = new Movie
+            {
+                MovieMetadata = [new MovieMetadata { Title = movieTitle }],
+                MediaVersions = []
+            }
+        };
+
+    private static DomainChannel 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,
+            PlayoutSource = ChannelPlayoutSource.Generated,
+            PlayoutMode = ChannelPlayoutMode.Continuous,
+            ShowInEpg = showInEpg,
+            Playouts = []
+        };
+}

ErsatzTV.Tests/Application/Channels/GetChannelStatesForApiHandlerTests.cs

@@ -0,0 +1,329 @@
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Channels;
+
+[TestFixture]
+public class GetChannelStatesForApiHandlerTests
+{
+    private static readonly DateTime Now = new(2026, 7, 2, 12, 0, 0, DateTimeKind.Utc);
+
+    private InMemoryTvContext _db = null!;
+    private IFFmpegSegmenterService _segmenter = null!;
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        _db = await InMemoryTvContext.CreateAsync();
+        _segmenter = Substitute.For<IFFmpegSegmenterService>();
+    }
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task Handle_Should_Return_OnAir_And_Current_NowPlaying()
+    {
+        DateTime start = Now.AddMinutes(-10);
+        DateTime finish = Now.AddMinutes(20);
+        await SeedChannelWithMovie(start, finish);
+        _segmenter.IsActive("7.1").Returns(true);
+        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter);
+
+        List<ChannelStateResponseModel> result =
+            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);
+
+        ChannelStateResponseModel state = result.ShouldHaveSingleItem();
+        state.ChannelId.ShouldBe(7);
+        state.ChannelNumber.ShouldBe("7.1");
+        state.OnAir.ShouldBeTrue();
+        state.NowPlaying.ShouldNotBeNull();
+        state.NowPlaying.Title.ShouldBe("Retro Cartoons");
+        state.NowPlaying.StartUtc.ShouldBe(new DateTimeOffset(start, TimeSpan.Zero));
+        state.NowPlaying.FinishUtc.ShouldBe(new DateTimeOffset(finish, TimeSpan.Zero));
+    }
+
+    [Test]
+    public async Task Handle_Should_Match_Item_When_Now_Equals_Start()
+    {
+        await SeedChannelWithMovie(Now, Now.AddMinutes(30));
+        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter);
+
+        List<ChannelStateResponseModel> result =
+            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);
+
+        result.ShouldHaveSingleItem().NowPlaying.ShouldNotBeNull();
+    }
+
+    [Test]
+    public async Task Handle_Should_Not_Match_Item_When_Now_Equals_Finish()
+    {
+        await SeedChannelWithMovie(Now.AddMinutes(-30), Now);
+        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter);
+
+        List<ChannelStateResponseModel> result =
+            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);
+
+        result.ShouldHaveSingleItem().NowPlaying.ShouldBeNull();
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Null_NowPlaying_When_No_Current_Item()
+    {
+        await using TvContext context = _db.CreateContext();
+        context.Channels.Add(MakeChannel(8, "8"));
+        await context.SaveChangesAsync();
+        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter);
+
+        List<ChannelStateResponseModel> result =
+            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);
+
+        ChannelStateResponseModel state = result.ShouldHaveSingleItem();
+        state.OnAir.ShouldBeFalse();
+        state.NowPlaying.ShouldBeNull();
+    }
+
+    [Test]
+    public async Task Handle_Should_Surface_Program_Not_Filler_During_MidRoll_Break()
+    {
+        // program part 1 / mid-roll filler / program part 2, all in one guide group
+        await using TvContext context = _db.CreateContext();
+        Channel channel = MakeChannel(12, "12");
+        var movie = new Movie
+        {
+            Id = 120,
+            MovieMetadata = [new MovieMetadata { Title = "Feature Presentation" }]
+        };
+        var filler = new OtherVideo
+        {
+            Id = 121,
+            OtherVideoMetadata = [new OtherVideoMetadata { Title = "Some Bumper" }]
+        };
+        var playout = new Playout { Id = 122, Channel = channel, ChannelId = channel.Id, Items = [] };
+        PlayoutItem MakeItem(int id, MediaItem mediaItem, DateTime start, DateTime finish, FillerKind fillerKind) =>
+            new()
+            {
+                Id = id,
+                MediaItem = mediaItem,
+                MediaItemId = mediaItem.Id,
+                Playout = playout,
+                PlayoutId = playout.Id,
+                Start = start,
+                Finish = finish,
+                FillerKind = fillerKind,
+                GuideGroup = 1,
+                ChapterTitle = string.Empty
+            };
+
+        context.Channels.Add(channel);
+        context.Movies.Add(movie);
+        context.OtherVideos.Add(filler);
+        context.Playouts.Add(playout);
+        context.PlayoutItems.AddRange(
+            MakeItem(123, movie, Now.AddMinutes(-20), Now.AddMinutes(-2), FillerKind.None),
+            MakeItem(124, filler, Now.AddMinutes(-2), Now.AddMinutes(2), FillerKind.MidRoll),
+            MakeItem(125, movie, Now.AddMinutes(2), Now.AddMinutes(40), FillerKind.None));
+        await context.SaveChangesAsync();
+
+        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter);
+
+        List<ChannelStateResponseModel> result =
+            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);
+
+        ChannelStateResponseModel state = result.ShouldHaveSingleItem();
+        state.NowPlaying.ShouldNotBeNull();
+        state.NowPlaying.Title.ShouldBe("Feature Presentation");
+        state.NowPlaying.StartUtc.ShouldBe(new DateTimeOffset(Now.AddMinutes(-20), TimeSpan.Zero));
+        state.NowPlaying.FinishUtc.ShouldBe(new DateTimeOffset(Now.AddMinutes(40), TimeSpan.Zero));
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Null_NowPlaying_For_Guide_Entry_With_Only_Filler()
+    {
+        await using TvContext context = _db.CreateContext();
+        Channel channel = MakeChannel(13, "13");
+        var filler = new OtherVideo
+        {
+            Id = 130,
+            OtherVideoMetadata = [new OtherVideoMetadata { Title = "Offline Loop" }]
+        };
+        var playout = new Playout { Id = 131, Channel = channel, ChannelId = channel.Id, Items = [] };
+        var item = new PlayoutItem
+        {
+            Id = 132,
+            MediaItem = filler,
+            MediaItemId = filler.Id,
+            Playout = playout,
+            PlayoutId = playout.Id,
+            Start = Now.AddMinutes(-5),
+            Finish = Now.AddMinutes(5),
+            FillerKind = FillerKind.Fallback,
+            GuideGroup = 1,
+            ChapterTitle = string.Empty
+        };
+
+        context.Channels.Add(channel);
+        context.OtherVideos.Add(filler);
+        context.Playouts.Add(playout);
+        context.PlayoutItems.Add(item);
+        await context.SaveChangesAsync();
+
+        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter);
+
+        List<ChannelStateResponseModel> result =
+            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);
+
+        result.ShouldHaveSingleItem().NowPlaying.ShouldBeNull();
+    }
+
+    [Test]
+    public async Task Handle_Should_Map_Remote_Stream_NowPlaying_Title()
+    {
+        DateTime start = Now.AddMinutes(-10);
+        DateTime finish = Now.AddMinutes(20);
+
+        await using TvContext context = _db.CreateContext();
+        Channel channel = MakeChannel(9, "9");
+        var remoteStream = new RemoteStream
+        {
+            Id = 90,
+            RemoteStreamMetadata = [new RemoteStreamMetadata { Title = "Live Source" }]
+        };
+        var playout = new Playout { Id = 91, Channel = channel, ChannelId = channel.Id, Items = [] };
+        var item = new PlayoutItem
+        {
+            Id = 92,
+            MediaItem = remoteStream,
+            MediaItemId = remoteStream.Id,
+            Playout = playout,
+            PlayoutId = playout.Id,
+            Start = start,
+            Finish = finish,
+            ChapterTitle = string.Empty
+        };
+
+        context.Channels.Add(channel);
+        context.RemoteStreams.Add(remoteStream);
+        context.Playouts.Add(playout);
+        context.PlayoutItems.Add(item);
+        await context.SaveChangesAsync();
+
+        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter);
+
+        ChannelStateResponseModel state =
+            (await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None))
+            .ShouldHaveSingleItem();
+
+        state.NowPlaying.ShouldNotBeNull();
+        state.NowPlaying.Title.ShouldBe("Live Source");
+    }
+
+    [Test]
+    public async Task Handle_Should_Resolve_Mirror_Channel_NowPlaying_From_Source_With_Offset()
+    {
+        TimeSpan offset = TimeSpan.FromHours(1);
+        DateTime sourceStart = Now.AddMinutes(-70);
+        DateTime sourceFinish = Now.AddMinutes(-40);
+
+        await using TvContext context = _db.CreateContext();
+        Channel source = MakeChannel(10, "10");
+        Channel mirror = MakeChannel(11, "11");
+        mirror.PlayoutSource = ChannelPlayoutSource.Mirror;
+        mirror.MirrorSourceChannelId = source.Id;
+        mirror.PlayoutOffset = offset;
+
+        var movie = new Movie
+        {
+            Id = 110,
+            MovieMetadata = [new MovieMetadata { Title = "Offset Feature" }]
+        };
+        var playout = new Playout { Id = 111, Channel = source, ChannelId = source.Id, Items = [] };
+        var item = new PlayoutItem
+        {
+            Id = 112,
+            MediaItem = movie,
+            MediaItemId = movie.Id,
+            Playout = playout,
+            PlayoutId = playout.Id,
+            Start = sourceStart,
+            Finish = sourceFinish,
+            ChapterTitle = string.Empty
+        };
+
+        context.Channels.AddRange(source, mirror);
+        context.Movies.Add(movie);
+        context.Playouts.Add(playout);
+        context.PlayoutItems.Add(item);
+        await context.SaveChangesAsync();
+
+        var handler = new GetChannelStatesForApiHandler(_db.Factory, _segmenter);
+
+        List<ChannelStateResponseModel> result =
+            await handler.Handle(new GetChannelStatesForApi(Now), CancellationToken.None);
+
+        ChannelStateResponseModel mirrorState = result.Single(s => s.ChannelId == mirror.Id);
+        mirrorState.NowPlaying.ShouldNotBeNull();
+        mirrorState.NowPlaying.Title.ShouldBe("Offset Feature");
+        mirrorState.NowPlaying.StartUtc.ShouldBe(new DateTimeOffset(sourceStart + offset, TimeSpan.Zero));
+        mirrorState.NowPlaying.FinishUtc.ShouldBe(new DateTimeOffset(sourceFinish + offset, TimeSpan.Zero));
+
+        // the source's own item is 40+ minutes in the past with no offset, so its own row is off-air
+        ChannelStateResponseModel sourceState = result.Single(s => s.ChannelId == source.Id);
+        sourceState.NowPlaying.ShouldBeNull();
+    }
+
+    private async Task SeedChannelWithMovie(DateTime start, DateTime finish)
+    {
+        await using TvContext context = _db.CreateContext();
+        Channel channel = MakeChannel(7, "7.1");
+        var movie = new Movie
+        {
+            Id = 10,
+            MovieMetadata = [new MovieMetadata { Title = "Retro Cartoons" }]
+        };
+        var playout = new Playout
+        {
+            Id = 20,
+            Channel = channel,
+            ChannelId = channel.Id,
+            Items = []
+        };
+        var item = new PlayoutItem
+        {
+            Id = 30,
+            MediaItem = movie,
+            MediaItemId = movie.Id,
+            Playout = playout,
+            PlayoutId = playout.Id,
+            Start = start,
+            Finish = finish,
+            ChapterTitle = string.Empty
+        };
+
+        context.Channels.Add(channel);
+        context.Movies.Add(movie);
+        context.Playouts.Add(playout);
+        context.PlayoutItems.Add(item);
+        await context.SaveChangesAsync();
+    }
+
+    private static Channel MakeChannel(int id, string number) =>
+        new(Guid.NewGuid())
+        {
+            Id = id,
+            Number = number,
+            SortNumber = id,
+            Name = $"Channel {number}",
+            Group = "Test",
+            Categories = string.Empty,
+            PreferredAudioLanguageCode = string.Empty
+        };
+}

ErsatzTV.Tests/Application/Channels/UpdateChannelNumbersHandlerTests.cs

@@ -0,0 +1,111 @@
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Channels;
+
+[TestFixture]
+public class UpdateChannelNumbersHandlerTests : ChannelHandlerTestBase
+{
+    private UpdateChannelNumbersHandler MakeHandler() => new(Db.Factory, Worker);
+
+    [Test]
+    public async Task Should_Renumber_All_Channels()
+    {
+        await SeedChannel(1, "5");
+        await SeedChannel(2, "6");
+
+        Option<BaseError> result = await MakeHandler().Handle(
+            new UpdateChannelNumbers(
+            [
+                new ChannelSortViewModel { Id = 1, Number = "10" },
+                new ChannelSortViewModel { Id = 2, Number = "11.1" }
+            ]),
+            CancellationToken.None);
+
+        result.IsNone.ShouldBeTrue();
+
+        await using TvContext context = Db.CreateContext();
+        var channels = await context.Channels
+            .OrderBy(c => c.Id)
+            .Select(c => new { c.Number, c.SortNumber })
+            .ToListAsync();
+        channels[0].Number.ShouldBe("10");
+        channels[0].SortNumber.ShouldBe(10);
+        channels[1].Number.ShouldBe("11.1");
+        channels[1].SortNumber.ShouldBe(11.1);
+    }
+
+    [Test]
+    public async Task Should_Return_NotFound_And_Not_Renumber_When_Any_Channel_Is_Missing()
+    {
+        await SeedChannel(1, "5");
+
+        Option<BaseError> result = await MakeHandler().Handle(
+            new UpdateChannelNumbers(
+            [
+                new ChannelSortViewModel { Id = 1, Number = "10" },
+                new ChannelSortViewModel { Id = 99, Number = "11" }
+            ]),
+            CancellationToken.None);
+
+        BaseError error = ErrorOf(result);
+        error.ShouldBeOfType<NotFoundError>();
+
+        await using TvContext context = Db.CreateContext();
+        string number = await context.Channels.Where(c => c.Id == 1).Select(c => c.Number).SingleAsync();
+        number.ShouldBe("5");
+    }
+
+    [Test]
+    public async Task Should_Reject_Duplicate_Numbers_And_Not_Renumber()
+    {
+        await SeedChannel(1, "5");
+        await SeedChannel(2, "6");
+
+        Option<BaseError> result = await MakeHandler().Handle(
+            new UpdateChannelNumbers(
+            [
+                new ChannelSortViewModel { Id = 1, Number = "10" },
+                new ChannelSortViewModel { Id = 2, Number = "10" }
+            ]),
+            CancellationToken.None);
+
+        BaseError error = ErrorOf(result);
+        error.ShouldNotBeOfType<NotFoundError>();
+        error.Value.ShouldContain("unique");
+
+        await using TvContext context = Db.CreateContext();
+        List<string> numbers = await context.Channels.OrderBy(c => c.Id).Select(c => c.Number).ToListAsync();
+        numbers.ShouldBe(["5", "6"]);
+    }
+
+    [Test]
+    public async Task Should_Reject_Invalid_Number_And_Not_Renumber()
+    {
+        await SeedChannel(1, "5");
+
+        Option<BaseError> result = await MakeHandler().Handle(
+            new UpdateChannelNumbers([new ChannelSortViewModel { Id = 1, Number = "10.123" }]),
+            CancellationToken.None);
+
+        BaseError error = ErrorOf(result);
+        error.ShouldNotBeOfType<NotFoundError>();
+        error.Value.ShouldContain("Invalid channel number");
+
+        await using TvContext context = Db.CreateContext();
+        string number = await context.Channels.Where(c => c.Id == 1).Select(c => c.Number).SingleAsync();
+        number.ShouldBe("5");
+    }
+
+    private static BaseError ErrorOf(Option<BaseError> result) =>
+        result.Match(
+            Some: error => error,
+            None: () => throw new AssertionException("Expected an error"));
+}

ErsatzTV.Tests/Application/LibraryBrowse/GetLibraryBrowseItemsHandlerTests.cs

@@ -0,0 +1,665 @@
+using ErsatzTV.Application.LibraryBrowse;
+using ErsatzTV.Core.Api.LibraryBrowse;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Search;
+using ErsatzTV.Tests.Support;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.LibraryBrowse;
+
+[TestFixture]
+public class GetLibraryBrowseItemsHandlerTests
+{
+    private InMemoryTvContext _db = null!;
+    private ISearchIndex _searchIndex = null!;
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        _db = await InMemoryTvContext.CreateAsync();
+        _searchIndex = Substitute.For<ISearchIndex>();
+    }
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task Handle_Should_Search_Index_With_Type_Library_And_Title_Filters()
+    {
+        _searchIndex.Search(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<int>(),
+                Arg.Any<int>(),
+                Arg.Any<List<string>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new SearchResult([], 0));
+        var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory);
+
+        await handler.Handle(
+            new GetLibraryBrowseItems("star", 5, LibraryBrowseMediaType.Movie, 2, 25),
+            CancellationToken.None);
+
+        await _searchIndex.Received(1).Search(
+            Arg.Is<string>(q => q.Contains("type:movie") && q.Contains("library_id:5") && q.Contains("star")),
+            string.Empty,
+            50,
+            25,
+            Arg.Is<List<string>>(fields => fields.SequenceEqual(new[] { LuceneSearchIndex.TitleAndYearSearchField })),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Handle_Should_Hydrate_Media_Items_In_Search_Order_With_Artwork_Duration_And_Counts()
+    {
+        await SeedLibraryGraph();
+        _searchIndex.Search(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<int>(),
+                Arg.Any<int>(),
+                Arg.Any<List<string>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new SearchResult(
+                [
+                    new SearchItem(LuceneSearchIndex.ShowType, 20),
+                    new SearchItem(LuceneSearchIndex.MovieType, 10)
+                ],
+                2));
+        var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory);
+
+        PagedLibraryBrowseItemsResponseModel result = await handler.Handle(
+            new GetLibraryBrowseItems("", null, null, 0, 10),
+            CancellationToken.None);
+
+        result.TotalCount.ShouldBe(2);
+        result.Page[0].MediaType.ShouldBe(LibraryBrowseMediaType.TelevisionShow);
+        result.Page[0].Title.ShouldBe("Collision Show");
+        result.Page[0].ItemCount.ShouldBe(1);
+        result.Page[0].MediaItemId.ShouldBe(20);
+        result.Page[1].MediaType.ShouldBe(LibraryBrowseMediaType.Movie);
+        result.Page[1].Title.ShouldBe("Collision Movie");
+        result.Page[1].Artwork.ShouldBe("movie-poster.jpg");
+        result.Page[1].Duration.ShouldBe(TimeSpan.FromMinutes(95));
+        result.Page[1].MediaItemId.ShouldBe(10);
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Typed_Collection_And_Playlist_Picker_Targets()
+    {
+        await SeedCollectionGraph();
+        _searchIndex.Search(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<int>(),
+                Arg.Any<int>(),
+                Arg.Any<List<string>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new SearchResult([], 0));
+        var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory);
+
+        PagedLibraryBrowseItemsResponseModel result = await handler.Handle(
+            new GetLibraryBrowseItems("", null, null, 0, 10),
+            CancellationToken.None);
+
+        result.TotalCount.ShouldBe(5);
+        result.Page.ShouldContain(i =>
+            i.MediaType == LibraryBrowseMediaType.Collection &&
+            i.CollectionKind == "Manual" &&
+            i.CollectionType == CollectionType.Collection &&
+            i.CollectionId == 20 &&
+            i.ItemCount == 1);
+        result.Page.ShouldContain(i =>
+            i.MediaType == LibraryBrowseMediaType.SmartCollection &&
+            i.CollectionKind == "Smart" &&
+            i.CollectionType == CollectionType.SmartCollection &&
+            i.SmartCollectionId == 30);
+        result.Page.ShouldContain(i =>
+            i.MediaType == LibraryBrowseMediaType.MultiCollection &&
+            i.CollectionKind == "Multi" &&
+            i.CollectionType == CollectionType.MultiCollection &&
+            i.MultiCollectionId == 40);
+        result.Page.ShouldContain(i =>
+            i.MediaType == LibraryBrowseMediaType.RerunCollection &&
+            i.CollectionKind == "Rerun" &&
+            i.CollectionType == CollectionType.RerunFirstRun &&
+            i.RerunCollectionId == 50);
+        result.Page.ShouldContain(i =>
+            i.MediaType == LibraryBrowseMediaType.Playlist &&
+            i.CollectionType == CollectionType.Playlist &&
+            i.PlaylistId == 60);
+    }
+
+    [Test]
+    public async Task Handle_Should_Page_Across_Media_Manual_Collections_And_Smart_Collections()
+    {
+        await SeedMediaAndCollectionPagingGraph();
+        _searchIndex.Search(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Is<int>(offset => offset == 0),
+                Arg.Any<int>(),
+                Arg.Any<List<string>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new SearchResult(
+                [
+                    new SearchItem(LuceneSearchIndex.MovieType, 101),
+                    new SearchItem(LuceneSearchIndex.MovieType, 102)
+                ],
+                2));
+        _searchIndex.Search(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Is<int>(offset => offset > 0),
+                Arg.Any<int>(),
+                Arg.Any<List<string>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new SearchResult([], 2));
+        var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory);
+
+        PagedLibraryBrowseItemsResponseModel page0 = await handler.Handle(
+            new GetLibraryBrowseItems("", null, null, 0, 3),
+            CancellationToken.None);
+        PagedLibraryBrowseItemsResponseModel page1 = await handler.Handle(
+            new GetLibraryBrowseItems("", null, null, 1, 3),
+            CancellationToken.None);
+        PagedLibraryBrowseItemsResponseModel page2 = await handler.Handle(
+            new GetLibraryBrowseItems("", null, null, 2, 3),
+            CancellationToken.None);
+
+        page0.TotalCount.ShouldBe(7);
+        page0.Page.Select(i => i.Title).ShouldBe(["Movie One", "Movie Two", "Manual A"]);
+        page1.TotalCount.ShouldBe(7);
+        page1.Page.Select(i => i.Title).ShouldBe(["Manual B", "Manual C", "Smart A"]);
+        page2.TotalCount.ShouldBe(7);
+        page2.Page.Select(i => i.Title).ShouldBe(["Smart B"]);
+    }
+
+    [Test]
+    public async Task Handle_Should_Hydrate_Manual_Collection_Artwork_And_Total_Duration()
+    {
+        await SeedManualCollectionMetadataGraph();
+        _searchIndex.Search(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<int>(),
+                Arg.Any<int>(),
+                Arg.Any<List<string>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new SearchResult([], 0));
+        var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory);
+
+        PagedLibraryBrowseItemsResponseModel result = await handler.Handle(
+            new GetLibraryBrowseItems("", null, LibraryBrowseMediaType.Collection, 0, 10),
+            CancellationToken.None);
+
+        result.TotalCount.ShouldBe(1);
+        result.Page.Count.ShouldBe(1);
+        result.Page[0].Title.ShouldBe("Manual Metadata");
+        result.Page[0].Artwork.ShouldBe("first-poster.jpg");
+        result.Page[0].Duration.ShouldBe(TimeSpan.FromMinutes(75));
+        result.Page[0].ItemCount.ShouldBe(2);
+    }
+
+    [Test]
+    public async Task Handle_Should_Hydrate_Seasons_With_Composed_Titles_And_Episode_Counts()
+    {
+        await SeedSeasonGraph();
+        _searchIndex.Search(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<int>(),
+                Arg.Any<int>(),
+                Arg.Any<List<string>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new SearchResult(
+                [
+                    new SearchItem(LuceneSearchIndex.SeasonType, 301),
+                    new SearchItem(LuceneSearchIndex.SeasonType, 302)
+                ],
+                2));
+        var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory);
+
+        PagedLibraryBrowseItemsResponseModel result = await handler.Handle(
+            new GetLibraryBrowseItems("", null, LibraryBrowseMediaType.TelevisionSeason, 0, 10),
+            CancellationToken.None);
+
+        result.TotalCount.ShouldBe(2);
+        result.Page[0].Title.ShouldBe("Season Show - Season 2");
+        result.Page[0].ItemCount.ShouldBe(2);
+        result.Page[0].CollectionType.ShouldBe(CollectionType.TelevisionSeason);
+        result.Page[0].MediaItemId.ShouldBe(301);
+        result.Page[1].Title.ShouldBe("Season Show - Specials");
+        result.Page[1].ItemCount.ShouldBe(1);
+        result.Page[1].MediaItemId.ShouldBe(302);
+    }
+
+    [Test]
+    public async Task Handle_Should_Hydrate_Artists_With_Music_Video_Counts()
+    {
+        await SeedArtistGraph();
+        _searchIndex.Search(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<int>(),
+                Arg.Any<int>(),
+                Arg.Any<List<string>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new SearchResult([new SearchItem(LuceneSearchIndex.ArtistType, 401)], 1));
+        var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory);
+
+        PagedLibraryBrowseItemsResponseModel result = await handler.Handle(
+            new GetLibraryBrowseItems("", null, LibraryBrowseMediaType.Artist, 0, 10),
+            CancellationToken.None);
+
+        result.TotalCount.ShouldBe(1);
+        result.Page[0].Title.ShouldBe("Counted Artist");
+        result.Page[0].ItemCount.ShouldBe(2);
+        result.Page[0].Artwork.ShouldBe("artist-thumb.jpg");
+        result.Page[0].CollectionType.ShouldBe(CollectionType.Artist);
+        result.Page[0].MediaItemId.ShouldBe(401);
+    }
+
+    [Test]
+    public async Task Handle_Should_Apply_Library_Filter_To_Manual_Collections_Only()
+    {
+        await SeedLibraryFilteredCollectionsGraph();
+        _searchIndex.Search(
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<int>(),
+                Arg.Any<int>(),
+                Arg.Any<List<string>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new SearchResult([], 0));
+        var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory);
+
+        PagedLibraryBrowseItemsResponseModel result = await handler.Handle(
+            new GetLibraryBrowseItems("", 501, null, 0, 10),
+            CancellationToken.None);
+
+        result.TotalCount.ShouldBe(1);
+        result.Page.Count.ShouldBe(1);
+        result.Page[0].Title.ShouldBe("Included Manual");
+        result.Page[0].MediaType.ShouldBe(LibraryBrowseMediaType.Collection);
+        result.Page[0].CollectionId.ShouldBe(510);
+    }
+
+    private async Task SeedLibraryGraph()
+    {
+        await using TvContext context = _db.CreateContext();
+        var library = new LocalLibrary
+        {
+            Id = 1,
+            Name = "Local Movies",
+            MediaKind = LibraryMediaKind.Movies,
+            Paths = []
+        };
+        var path = new LibraryPath
+        {
+            Id = 1,
+            Path = "/media",
+            Library = library,
+            LibraryFolders = [],
+            MediaItems = []
+        };
+        library.Paths.Add(path);
+
+        var movie = new Movie
+        {
+            Id = 10,
+            LibraryPath = path,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            MediaVersions = [new MediaVersion { Duration = TimeSpan.FromMinutes(95) }],
+            MovieMetadata =
+            [
+                MakeMovieMetadata("Collision Movie", "movie-poster.jpg")
+            ]
+        };
+        var show = new Show
+        {
+            Id = 20,
+            LibraryPath = path,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            Seasons = [],
+            ShowMetadata = [MakeShowMetadata("Collision Show", "show-poster.jpg")]
+        };
+        var season = new Season
+        {
+            Id = 11,
+            LibraryPath = path,
+            Show = show,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            Episodes = [],
+            SeasonMetadata = []
+        };
+        var episode = new Episode
+        {
+            Id = 12,
+            LibraryPath = path,
+            Season = season,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            EpisodeMetadata = [],
+            MediaVersions = [new MediaVersion { Duration = TimeSpan.FromMinutes(25) }]
+        };
+        season.Episodes.Add(episode);
+        show.Seasons.Add(season);
+        path.MediaItems.AddRange([movie, show, season, episode]);
+        context.LocalLibraries.Add(library);
+        context.Movies.Add(movie);
+        context.Shows.Add(show);
+        context.Seasons.Add(season);
+        context.Episodes.Add(episode);
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedCollectionGraph()
+    {
+        await using TvContext context = _db.CreateContext();
+        var collection = new Collection { Id = 20, Name = "Manual", MediaItems = [], CollectionItems = [] };
+        var movie = new Movie
+        {
+            Id = 21,
+            Collections = [collection],
+            CollectionItems = [],
+            TraktListItems = [],
+            MovieMetadata = [],
+            MediaVersions = []
+        };
+        collection.MediaItems.Add(movie);
+        var smart = new SmartCollection { Id = 30, Name = "Smart", Query = "tag:kids" };
+        var multi = new MultiCollection
+        {
+            Id = 40,
+            Name = "Multi",
+            Collections = [collection],
+            SmartCollections = [smart]
+        };
+        var rerun = new RerunCollection { Id = 50, Name = "Rerun", CollectionType = CollectionType.Collection };
+        var playlist = new Playlist
+        {
+            Id = 60,
+            Name = "Playlist",
+            Items = [new PlaylistItem { CollectionType = CollectionType.Collection, CollectionId = 20 }]
+        };
+
+        context.Collections.Add(collection);
+        context.Movies.Add(movie);
+        context.SmartCollections.Add(smart);
+        context.MultiCollections.Add(multi);
+        context.RerunCollections.Add(rerun);
+        context.Playlists.Add(playlist);
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedMediaAndCollectionPagingGraph()
+    {
+        await using TvContext context = _db.CreateContext();
+        (LocalLibrary library, LibraryPath path) = MakeLibrary(100, "Paging Library");
+
+        var movie1 = MakeMovie(101, path, "Movie One", "movie-one.jpg", TimeSpan.FromMinutes(10));
+        var movie2 = MakeMovie(102, path, "Movie Two", "movie-two.jpg", TimeSpan.FromMinutes(20));
+        var manualA = MakeCollection(201, "Manual A");
+        var manualB = MakeCollection(202, "Manual B");
+        var manualC = MakeCollection(203, "Manual C");
+
+        context.LocalLibraries.Add(library);
+        context.Movies.AddRange(movie1, movie2);
+        context.Collections.AddRange(manualA, manualB, manualC);
+        context.SmartCollections.AddRange(
+            new SmartCollection { Id = 301, Name = "Smart A", Query = "tag:a", MultiCollections = [], MultiCollectionSmartItems = [] },
+            new SmartCollection { Id = 302, Name = "Smart B", Query = "tag:b", MultiCollections = [], MultiCollectionSmartItems = [] });
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedManualCollectionMetadataGraph()
+    {
+        await using TvContext context = _db.CreateContext();
+        (LocalLibrary library, LibraryPath path) = MakeLibrary(200, "Manual Metadata Library");
+        var collection = MakeCollection(210, "Manual Metadata");
+        var first = MakeMovie(211, path, "First", "first-poster.jpg", TimeSpan.FromMinutes(30));
+        var second = MakeMovie(212, path, "Second", "second-poster.jpg", TimeSpan.FromMinutes(45));
+        collection.MediaItems.AddRange([first, second]);
+
+        context.LocalLibraries.Add(library);
+        context.Collections.Add(collection);
+        context.Movies.AddRange(first, second);
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedSeasonGraph()
+    {
+        await using TvContext context = _db.CreateContext();
+        (LocalLibrary library, LibraryPath path) = MakeLibrary(300, "Season Library");
+        var show = new Show
+        {
+            Id = 300,
+            LibraryPath = path,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            Seasons = [],
+            ShowMetadata = [MakeShowMetadata("Season Show", "show.jpg")]
+        };
+        var season = MakeSeason(301, path, show, 2);
+        var specials = MakeSeason(302, path, show, 0);
+        season.Episodes.AddRange([
+            MakeEpisode(311, path, season),
+            MakeEpisode(312, path, season)
+        ]);
+        specials.Episodes.Add(MakeEpisode(313, path, specials));
+        show.Seasons.AddRange([season, specials]);
+        path.MediaItems.AddRange([show, season, specials, .. season.Episodes, .. specials.Episodes]);
+
+        context.LocalLibraries.Add(library);
+        context.Shows.Add(show);
+        context.Seasons.AddRange(season, specials);
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedArtistGraph()
+    {
+        await using TvContext context = _db.CreateContext();
+        (LocalLibrary library, LibraryPath path) = MakeLibrary(400, "Artist Library");
+        var artist = new Artist
+        {
+            Id = 401,
+            LibraryPath = path,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            MusicVideos = [],
+            ArtistMetadata = [MakeArtistMetadata("Counted Artist", "artist-thumb.jpg")]
+        };
+        var musicVideo1 = MakeMusicVideo(411, path, artist);
+        var musicVideo2 = MakeMusicVideo(412, path, artist);
+        artist.MusicVideos.AddRange([musicVideo1, musicVideo2]);
+        path.MediaItems.AddRange([artist, musicVideo1, musicVideo2]);
+
+        context.LocalLibraries.Add(library);
+        context.Artists.Add(artist);
+        context.MusicVideos.AddRange(musicVideo1, musicVideo2);
+        await context.SaveChangesAsync();
+    }
+
+    private async Task SeedLibraryFilteredCollectionsGraph()
+    {
+        await using TvContext context = _db.CreateContext();
+        (LocalLibrary includedLibrary, LibraryPath includedPath) = MakeLibrary(501, "Included Library");
+        (LocalLibrary excludedLibrary, LibraryPath excludedPath) = MakeLibrary(502, "Excluded Library");
+        var includedCollection = MakeCollection(510, "Included Manual");
+        var excludedCollection = MakeCollection(511, "Excluded Manual");
+        var includedMovie = MakeMovie(520, includedPath, "Included Movie", "included.jpg", TimeSpan.FromMinutes(5));
+        var excludedMovie = MakeMovie(521, excludedPath, "Excluded Movie", "excluded.jpg", TimeSpan.FromMinutes(5));
+        includedCollection.MediaItems.Add(includedMovie);
+        excludedCollection.MediaItems.Add(excludedMovie);
+
+        context.LocalLibraries.AddRange(includedLibrary, excludedLibrary);
+        context.Movies.AddRange(includedMovie, excludedMovie);
+        context.Collections.AddRange(includedCollection, excludedCollection);
+        context.SmartCollections.Add(new SmartCollection { Id = 530, Name = "Smart", Query = "tag", MultiCollections = [], MultiCollectionSmartItems = [] });
+        context.MultiCollections.Add(new MultiCollection { Id = 540, Name = "Multi", Collections = [], SmartCollections = [], MultiCollectionItems = [], MultiCollectionSmartItems = [] });
+        context.RerunCollections.Add(new RerunCollection { Id = 550, Name = "Rerun", CollectionType = CollectionType.Collection });
+        context.Playlists.Add(new Playlist { Id = 560, Name = "Playlist", Items = [] });
+        await context.SaveChangesAsync();
+    }
+
+    private static (LocalLibrary Library, LibraryPath Path) MakeLibrary(int id, string name)
+    {
+        var library = new LocalLibrary
+        {
+            Id = id,
+            Name = name,
+            MediaKind = LibraryMediaKind.Movies,
+            Paths = []
+        };
+        var path = new LibraryPath
+        {
+            Id = id,
+            Path = $"/media/{id}",
+            Library = library,
+            LibraryFolders = [],
+            MediaItems = []
+        };
+        library.Paths.Add(path);
+        return (library, path);
+    }
+
+    private static Collection MakeCollection(int id, string name) =>
+        new()
+        {
+            Id = id,
+            Name = name,
+            MediaItems = [],
+            CollectionItems = [],
+            MultiCollections = [],
+            MultiCollectionItems = []
+        };
+
+    private static Movie MakeMovie(int id, LibraryPath path, string title, string poster, TimeSpan duration) =>
+        new()
+        {
+            Id = id,
+            LibraryPath = path,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            MovieMetadata = [MakeMovieMetadata(title, poster)],
+            MediaVersions = [new MediaVersion { Duration = duration }]
+        };
+
+    private static Season MakeSeason(int id, LibraryPath path, Show show, int seasonNumber) =>
+        new()
+        {
+            Id = id,
+            LibraryPath = path,
+            Show = show,
+            SeasonNumber = seasonNumber,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            Episodes = [],
+            SeasonMetadata = [MakeSeasonMetadata()]
+        };
+
+    private static Episode MakeEpisode(int id, LibraryPath path, Season season) =>
+        new()
+        {
+            Id = id,
+            LibraryPath = path,
+            Season = season,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            EpisodeMetadata = [],
+            MediaVersions = []
+        };
+
+    private static MusicVideo MakeMusicVideo(int id, LibraryPath path, Artist artist) =>
+        new()
+        {
+            Id = id,
+            LibraryPath = path,
+            Artist = artist,
+            Collections = [],
+            CollectionItems = [],
+            TraktListItems = [],
+            MusicVideoMetadata = [],
+            MediaVersions = []
+        };
+
+    private static MovieMetadata MakeMovieMetadata(string title, string poster) =>
+        new()
+        {
+            Title = title,
+            SortTitle = title,
+            Artwork = [new Artwork { Path = poster, ArtworkKind = ArtworkKind.Poster }],
+            Genres = [],
+            Tags = [],
+            Studios = [],
+            Actors = [],
+            Guids = [],
+            Subtitles = [],
+            Directors = [],
+            Writers = []
+        };
+
+    private static ShowMetadata MakeShowMetadata(string title, string poster) =>
+        new()
+        {
+            Title = title,
+            SortTitle = title,
+            Artwork = [new Artwork { Path = poster, ArtworkKind = ArtworkKind.Poster }],
+            Genres = [],
+            Tags = [],
+            Studios = [],
+            Actors = [],
+            Guids = [],
+            Subtitles = []
+        };
+
+    private static SeasonMetadata MakeSeasonMetadata() =>
+        new()
+        {
+            Title = string.Empty,
+            SortTitle = string.Empty,
+            Artwork = [],
+            Genres = [],
+            Tags = [],
+            Studios = [],
+            Actors = [],
+            Guids = [],
+            Subtitles = []
+        };
+
+    private static ArtistMetadata MakeArtistMetadata(string title, string thumbnail) =>
+        new()
+        {
+            Title = title,
+            SortTitle = title,
+            Artwork = [new Artwork { Path = thumbnail, ArtworkKind = ArtworkKind.Thumbnail }],
+            Genres = [],
+            Tags = [],
+            Studios = [],
+            Actors = [],
+            Guids = [],
+            Subtitles = [],
+            Styles = [],
+            Moods = []
+        };
+}

ErsatzTV.Tests/Controllers/ApiErrorResponseMetadataTests.cs

@@ -13,11 +13,29 @@ public class ApiErrorResponseMetadataTests
     [TestCase(typeof(ChannelController), nameof(ChannelController.GetById), StatusCodes.Status404NotFound)]
     [TestCase(typeof(ChannelController), nameof(ChannelController.Create), StatusCodes.Status404NotFound)]
     [TestCase(typeof(ChannelController), nameof(ChannelController.Create), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(ChannelController), nameof(ChannelController.CreateFromLineup), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelController), nameof(ChannelController.CreateFromLineup), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(ChannelController), nameof(ChannelController.Update), StatusCodes.Status404NotFound)]
     [TestCase(typeof(ChannelController), nameof(ChannelController.Update), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(ChannelController), nameof(ChannelController.Delete), StatusCodes.Status404NotFound)]
     [TestCase(typeof(ChannelController), nameof(ChannelController.Delete), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(ChannelController), nameof(ChannelController.BulkRenumber), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelController), nameof(ChannelController.BulkRenumber), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(ChannelController), nameof(ChannelController.BulkMoveToGroup), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelController), nameof(ChannelController.BulkMoveToGroup), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(ChannelController), nameof(ChannelController.BulkDelete), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelController), nameof(ChannelController.BulkDelete), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(ChannelController), nameof(ChannelController.ResetPlayout), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.GetDefault), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.SetDefault), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.SetDefault), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.GetById), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.Create), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.Create), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.Update), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.Update), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.Delete), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(ChannelTemplateController), nameof(ChannelTemplateController.Delete), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(CollectionController), nameof(CollectionController.GetById), StatusCodes.Status404NotFound)]
     [TestCase(typeof(CollectionController), nameof(CollectionController.Create), StatusCodes.Status404NotFound)]
     [TestCase(typeof(CollectionController), nameof(CollectionController.Create), StatusCodes.Status422UnprocessableEntity)]

ErsatzTV.Tests/Controllers/ChannelControllerTests.cs

@@ -6,6 +6,8 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Controllers.Api;
 using ErsatzTV.Controllers.Api.Requests;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Api.LibraryBrowse;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Scheduling;
@@ -35,6 +37,25 @@ public class ChannelControllerTests
         _controller = new ChannelController(_workerChannel.Writer, _mediator);
     }
 
+    [Test]
+    public async Task GetState_Should_Return_200_With_Channel_State()
+    {
+        var state = new ChannelStateResponseModel(
+            7,
+            "7.1",
+            true,
+            new ChannelNowPlayingResponseModel(
+                "Retro Cartoons",
+                new DateTimeOffset(2026, 7, 2, 17, 0, 0, TimeSpan.Zero),
+                new DateTimeOffset(2026, 7, 2, 17, 30, 0, TimeSpan.Zero)));
+        _mediator.Send(Arg.Any<GetChannelStatesForApi>(), Arg.Any<CancellationToken>())
+            .Returns([state]);
+
+        List<ChannelStateResponseModel> result = await _controller.GetState(CancellationToken.None);
+
+        result.ShouldBe(new List<ChannelStateResponseModel> { state });
+    }
+
     [Test]
     public async Task Create_Should_Return_201_With_Location_And_Body()
     {
@@ -78,6 +99,54 @@ public class ChannelControllerTests
         result.ShouldBeOfType<UnprocessableEntityObjectResult>();
     }
 
+    [Test]
+    public async Task CreateFromLineup_Should_Return_201_With_Location_And_Body()
+    {
+        var response = new CreateChannelFromLineupResponseModel(5, 6, 7, 8);
+        _mediator.Send(Arg.Any<CreateChannelFromLineup>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, CreateChannelFromLineupResponseModel>(response));
+
+        IActionResult result = await _controller.CreateFromLineup(MakeLineupRequest(), CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.StatusCode.ShouldBe(201);
+        created.Location.ShouldBe("/api/channels/5");
+        created.Value.ShouldBe(response);
+    }
+
+    [Test]
+    public async Task CreateFromLineup_Should_Map_Request_To_Command()
+    {
+        _mediator.Send(Arg.Any<CreateChannelFromLineup>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, CreateChannelFromLineupResponseModel>(
+                new CreateChannelFromLineupResponseModel(5, 6, 7, 8)));
+
+        await _controller.CreateFromLineup(
+            MakeLineupRequest(number: "12", name: "Movies", templateId: 9),
+            CancellationToken.None);
+
+        await _mediator.Received(1).Send(
+            Arg.Is<CreateChannelFromLineup>(c =>
+                c.Number == "12" &&
+                c.Name == "Movies" &&
+                c.TemplateId == 9 &&
+                c.Lineup.Count == 1 &&
+                c.Lineup[0].CollectionType == CollectionType.Movie &&
+                c.Lineup[0].MediaItemId == 42),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task CreateFromLineup_Should_Return_404_For_NotFoundError()
+    {
+        _mediator.Send(Arg.Any<CreateChannelFromLineup>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, CreateChannelFromLineupResponseModel>(new NotFoundError("missing")));
+
+        IActionResult result = await _controller.CreateFromLineup(MakeLineupRequest(), CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
     [Test]
     public async Task Update_Should_Return_200_And_Map_Route_Id()
     {
@@ -126,6 +195,124 @@ public class ChannelControllerTests
         result.ShouldBeOfType<NotFoundObjectResult>();
     }
 
+    [Test]
+    public async Task BulkRenumber_Should_Return_204_And_Map_Request()
+    {
+        _mediator.Send(Arg.Any<UpdateChannelNumbers>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BaseError>.None);
+
+        IActionResult result = await _controller.BulkRenumber(
+            new BulkRenumberChannelsRequest([new BulkRenumberChannelRequest(1, "10")]),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+        await _mediator.Received(1).Send(
+            Arg.Is<UpdateChannelNumbers>(
+                c => c.Channels.Count == 1 && c.Channels[0].Id == 1 && c.Channels[0].Number == "10"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetGuide_Should_Map_Query_And_Return_Model()
+    {
+        var start = new DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero);
+        var end = new DateTimeOffset(2026, 1, 3, 0, 0, 0, TimeSpan.Zero);
+        var model = new ChannelGuideResponseModel(start, end, []);
+        _mediator.Send(Arg.Any<GetChannelGuideData>(), Arg.Any<CancellationToken>()).Returns(model);
+
+        ChannelGuideResponseModel result = await _controller.GetGuide(start, end, CancellationToken.None);
+
+        result.ShouldBe(model);
+        await _mediator.Received(1).Send(
+            Arg.Is<GetChannelGuideData>(q => q.Start == start && q.End == end),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task BulkRenumber_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<UpdateChannelNumbers>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BaseError>.Some(BaseError.New("bad")));
+
+        IActionResult result = await _controller.BulkRenumber(
+            new BulkRenumberChannelsRequest([new BulkRenumberChannelRequest(1, "bad")]),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
+    [Test]
+    public async Task BulkMoveToGroup_Should_Return_204_And_Map_Request()
+    {
+        _mediator.Send(Arg.Any<BulkMoveChannelsToGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, Unit>(Unit.Default));
+
+        IActionResult result = await _controller.BulkMoveToGroup(
+            new BulkMoveChannelsToGroupRequest([1, 2], "Movies"),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+        await _mediator.Received(1).Send(
+            Arg.Is<BulkMoveChannelsToGroup>(
+                c => c.ChannelIds.SequenceEqual(new[] { 1, 2 }) && c.Group == "Movies"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetGuide_Should_Pass_Null_Bounds_Through()
+    {
+        var model = new ChannelGuideResponseModel(DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, []);
+        _mediator.Send(Arg.Any<GetChannelGuideData>(), Arg.Any<CancellationToken>()).Returns(model);
+
+        await _controller.GetGuide(null, null, CancellationToken.None);
+
+        await _mediator.Received(1).Send(
+            Arg.Is<GetChannelGuideData>(q => q.Start == null && q.End == null),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task BulkMoveToGroup_Should_Return_404_For_NotFoundError()
+    {
+        _mediator.Send(Arg.Any<BulkMoveChannelsToGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, Unit>(new NotFoundError("missing")));
+
+        IActionResult result = await _controller.BulkMoveToGroup(
+            new BulkMoveChannelsToGroupRequest([99], "Movies"),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
+    [Test]
+    public async Task BulkDelete_Should_Return_204_And_Map_Request()
+    {
+        _mediator.Send(Arg.Any<BulkDeleteChannels>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, Unit>(Unit.Default));
+
+        IActionResult result = await _controller.BulkDelete(
+            new BulkDeleteChannelsRequest([1, 2]),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+        await _mediator.Received(1).Send(
+            Arg.Is<BulkDeleteChannels>(c => c.ChannelIds.SequenceEqual(new[] { 1, 2 })),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task BulkDelete_Should_Return_404_For_NotFoundError()
+    {
+        _mediator.Send(Arg.Any<BulkDeleteChannels>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, Unit>(new NotFoundError("missing")));
+
+        IActionResult result = await _controller.BulkDelete(
+            new BulkDeleteChannelsRequest([99]),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
     [Test]
     public async Task GetById_Should_Return_200_For_Some()
     {
@@ -275,6 +462,30 @@ public class ChannelControllerTests
             true,
             false);
 
+    private static CreateChannelFromLineupRequest MakeLineupRequest(
+        string number = "5",
+        string name = "Test",
+        int templateId = 1) =>
+        new(
+            name,
+            number,
+            "ErsatzTV",
+            string.Empty,
+            ArtworkContentTypeModel.None,
+            true,
+            true,
+            templateId,
+            null,
+            [new CreateChannelFromLineupItemRequest(
+                LibraryBrowseMediaType.Movie,
+                CollectionType.Movie,
+                null,
+                null,
+                null,
+                null,
+                42,
+                null)]);
+
     private static UpdateChannelRequest MakeUpdateRequest(string number = "5", string name = "Test") =>
         new(
             name,

ErsatzTV.Tests/Controllers/ChannelTemplateControllerTests.cs

@@ -0,0 +1,276 @@
+using System.Reflection;
+using ErsatzTV.Application.ChannelTemplates;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Controllers.Api.Requests;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Scheduling;
+using LanguageExt;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using static LanguageExt.Prelude;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class ChannelTemplateControllerTests
+{
+    private ChannelTemplateController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new ChannelTemplateController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Named_Rest_Routes()
+    {
+        ShouldHaveActionRoute(
+            nameof(ChannelTemplateController.GetAll),
+            "GET",
+            "/api/channel-templates",
+            "GetChannelTemplates");
+        ShouldHaveActionRoute(
+            nameof(ChannelTemplateController.GetDefault),
+            "GET",
+            "/api/channel-templates/default",
+            "GetDefaultChannelTemplate");
+        ShouldHaveActionRoute(
+            nameof(ChannelTemplateController.SetDefault),
+            "PUT",
+            "/api/channel-templates/default/{id:int}",
+            "SetDefaultChannelTemplate");
+        ShouldHaveActionRoute(
+            nameof(ChannelTemplateController.GetById),
+            "GET",
+            "/api/channel-templates/{id:int}",
+            "GetChannelTemplateById");
+        ShouldHaveActionRoute(
+            nameof(ChannelTemplateController.Create),
+            "POST",
+            "/api/channel-templates",
+            "CreateChannelTemplate");
+        ShouldHaveActionRoute(
+            nameof(ChannelTemplateController.Update),
+            "PUT",
+            "/api/channel-templates/{id:int}",
+            "UpdateChannelTemplate");
+        ShouldHaveActionRoute(
+            nameof(ChannelTemplateController.Delete),
+            "DELETE",
+            "/api/channel-templates/{id:int}",
+            "DeleteChannelTemplate");
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_ChannelTemplates()
+    {
+        List<ChannelTemplateResponseModel> models = [MakeResponse(1, "Standard", isDefault: true)];
+        _mediator.Send(Arg.Any<GetAllChannelTemplates>(), Arg.Any<CancellationToken>())
+            .Returns(models);
+
+        List<ChannelTemplateResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBe(models);
+    }
+
+    [Test]
+    public async Task GetDefault_Should_Return_404_When_Default_Missing()
+    {
+        _mediator.Send(Arg.Any<GetDefaultChannelTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Option<ChannelTemplateResponseModel>.None);
+
+        IActionResult result = await _controller.GetDefault(CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
+    [Test]
+    public async Task Create_Should_Return_201_With_Location_And_Body()
+    {
+        ChannelTemplateResponseModel vm = MakeResponse(7, "Custom");
+        _mediator.Send(Arg.Any<CreateChannelTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, ChannelTemplateResponseModel>(vm));
+
+        IActionResult result = await _controller.Create(MakeCreateRequest("Custom"), CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/api/channel-templates/7");
+        created.Value.ShouldBe(vm);
+    }
+
+    [Test]
+    public async Task Create_Should_Map_Request_To_Command()
+    {
+        _mediator.Send(Arg.Any<CreateChannelTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, ChannelTemplateResponseModel>(MakeResponse(7, "Custom")));
+
+        await _controller.Create(MakeCreateRequest("Custom"), CancellationToken.None);
+
+        await _mediator.Received(1).Send(
+            Arg.Is<CreateChannelTemplate>(c =>
+                c.Name == "Custom" &&
+                c.FFmpegProfileId == 1 &&
+                c.PreRollFillerId == 2 &&
+                c.MidRollFillerId == 3 &&
+                c.PostRollFillerId == 4 &&
+                c.ShuffleScheduleItems),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Update_Should_Return_404_For_NotFoundError()
+    {
+        _mediator.Send(Arg.Any<UpdateChannelTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, ChannelTemplateResponseModel>(new NotFoundError("missing")));
+
+        IActionResult result = await _controller.Update(99, MakeUpdateRequest("Missing"), CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
+    [Test]
+    public async Task SetDefault_Should_Return_200_With_Default_Template()
+    {
+        ChannelTemplateResponseModel vm = MakeResponse(8, "Default", isDefault: true);
+        _mediator.Send(Arg.Any<SetDefaultChannelTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, ChannelTemplateResponseModel>(vm));
+
+        IActionResult result = await _controller.SetDefault(8, CancellationToken.None);
+
+        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBe(vm);
+        await _mediator.Received(1).Send(
+            Arg.Is<SetDefaultChannelTemplate>(c => c.ChannelTemplateId == 8),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Delete_Should_Return_204_On_Success()
+    {
+        _mediator.Send(Arg.Any<DeleteChannelTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, Unit>(Unit.Default));
+
+        IActionResult result = await _controller.Delete(9, CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+    }
+
+    [Test]
+    public async Task Delete_Should_Return_422_When_System_Template()
+    {
+        _mediator.Send(Arg.Any<DeleteChannelTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, Unit>(BaseError.New("System templates cannot be deleted.")));
+
+        IActionResult result = await _controller.Delete(9, CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
+    private static void ShouldHaveActionRoute(string actionName, string httpMethod, string route, string name)
+    {
+        MethodInfo action = typeof(ChannelTemplateController).GetMethod(actionName)
+            ?? throw new AssertionException($"Missing action {actionName}");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain(httpMethod);
+        attribute.Template.ShouldBe(route);
+        attribute.Name.ShouldBe(name);
+    }
+
+    private static CreateChannelTemplateRequest MakeCreateRequest(string name) =>
+        new(
+            name,
+            "Description",
+            1,
+            null,
+            null,
+            2,
+            3,
+            4,
+            ChannelStreamSelectorMode.Default,
+            string.Empty,
+            string.Empty,
+            string.Empty,
+            ChannelPlayoutSource.Generated,
+            ChannelPlayoutMode.Continuous,
+            StreamingMode.TransportStreamHybrid,
+            string.Empty,
+            ChannelSubtitleMode.None,
+            ChannelMusicVideoCreditsMode.None,
+            string.Empty,
+            ChannelSongVideoMode.Default,
+            ChannelTranscodeMode.OnDemand,
+            ChannelIdleBehavior.StopOnDisconnect,
+            true,
+            false,
+            FixedStartTimeBehavior.Flexible);
+
+    private static UpdateChannelTemplateRequest MakeUpdateRequest(string name) =>
+        new(
+            name,
+            "Description",
+            1,
+            null,
+            null,
+            null,
+            null,
+            null,
+            ChannelStreamSelectorMode.Default,
+            string.Empty,
+            string.Empty,
+            string.Empty,
+            ChannelPlayoutSource.Generated,
+            ChannelPlayoutMode.Continuous,
+            StreamingMode.TransportStreamHybrid,
+            string.Empty,
+            ChannelSubtitleMode.None,
+            ChannelMusicVideoCreditsMode.None,
+            string.Empty,
+            ChannelSongVideoMode.Default,
+            ChannelTranscodeMode.OnDemand,
+            ChannelIdleBehavior.StopOnDisconnect,
+            false,
+            false,
+            FixedStartTimeBehavior.Flexible);
+
+    private static ChannelTemplateResponseModel MakeResponse(int id, string name, bool isDefault = false) =>
+        new(
+            id,
+            name,
+            "Description",
+            false,
+            isDefault,
+            1,
+            null,
+            null,
+            null,
+            null,
+            null,
+            ChannelStreamSelectorMode.Default,
+            string.Empty,
+            string.Empty,
+            string.Empty,
+            ChannelPlayoutSource.Generated,
+            ChannelPlayoutMode.Continuous,
+            StreamingMode.TransportStreamHybrid,
+            string.Empty,
+            ChannelSubtitleMode.None,
+            ChannelMusicVideoCreditsMode.None,
+            string.Empty,
+            ChannelSongVideoMode.Default,
+            ChannelTranscodeMode.OnDemand,
+            ChannelIdleBehavior.StopOnDisconnect,
+            false,
+            false,
+            FixedStartTimeBehavior.Flexible);
+}

ErsatzTV.Tests/Controllers/LibraryBrowseControllerTests.cs

@@ -0,0 +1,92 @@
+using System.Reflection;
+using ErsatzTV.Application.LibraryBrowse;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core.Api.LibraryBrowse;
+using ErsatzTV.Core.Domain;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class LibraryBrowseControllerTests
+{
+    private LibraryBrowseController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new LibraryBrowseController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Browse_Route_With_Stable_Operation_Name()
+    {
+        MethodInfo action = typeof(LibraryBrowseController).GetMethod(nameof(LibraryBrowseController.Browse))
+            ?? throw new AssertionException($"Missing action {nameof(LibraryBrowseController.Browse)}");
+
+        var attribute = action.GetCustomAttributes<HttpGetAttribute>().Single();
+        attribute.Template.ShouldBe("/api/library/browse");
+        attribute.Name.ShouldBe("BrowseLibrary");
+    }
+
+    [Test]
+    public async Task Browse_Should_Clamp_Paging_And_Send_Query()
+    {
+        _mediator.Send(Arg.Any<GetLibraryBrowseItems>(), Arg.Any<CancellationToken>())
+            .Returns(new PagedLibraryBrowseItemsResponseModel(0, []));
+
+        await _controller.Browse(
+            "star",
+            123,
+            LibraryBrowseMediaType.Movie,
+            -1,
+            500,
+            CancellationToken.None);
+
+        await _mediator.Received(1).Send(
+            Arg.Is<GetLibraryBrowseItems>(q =>
+                q.Query == "star" &&
+                q.LibraryId == 123 &&
+                q.MediaType == LibraryBrowseMediaType.Movie &&
+                q.PageNum == 0 &&
+                q.PageSize == 100),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Browse_Should_Return_Paged_Response()
+    {
+        var item = new LibraryBrowseItemResponseModel(
+            10,
+            LibraryBrowseMediaType.Movie,
+            "Movie",
+            3,
+            "Movies",
+            "/artwork/posters/movie.jpg",
+            TimeSpan.FromMinutes(90),
+            1,
+            null,
+            CollectionType.Movie,
+            null,
+            null,
+            null,
+            null,
+            10,
+            null);
+        _mediator.Send(Arg.Any<GetLibraryBrowseItems>(), Arg.Any<CancellationToken>())
+            .Returns(new PagedLibraryBrowseItemsResponseModel(1, [item]));
+
+        PagedLibraryBrowseItemsResponseModel result = await _controller.Browse(
+            cancellationToken: CancellationToken.None);
+
+        result.TotalCount.ShouldBe(1);
+        result.Page.ShouldBe([item]);
+    }
+}

ErsatzTV.Tests/Controllers/OpenApiErrorResponseContractTests.cs

@@ -23,14 +23,108 @@ public class OpenApiErrorResponseContractTests
             .ShouldContain("One");
     }
 
+    [Test]
+    public void Static_OpenApi_Should_Document_Channel_List_Management_Fields()
+    {
+        using JsonDocument document = JsonDocument.Parse(File.ReadAllText(FindOpenApiDocument()));
+
+        JsonElement schema = document.RootElement
+            .GetProperty("components")
+            .GetProperty("schemas")
+            .GetProperty("ChannelResponseModel")
+            .GetProperty("properties");
+
+        schema.TryGetProperty("group", out _).ShouldBeTrue();
+        schema.TryGetProperty("isEnabled", out _).ShouldBeTrue();
+        schema.TryGetProperty("showInEpg", out _).ShouldBeTrue();
+        schema.TryGetProperty("sortNumber", out _).ShouldBeTrue();
+        schema.TryGetProperty("categories", out _).ShouldBeTrue();
+    }
+
+    [Test]
+    public void Static_OpenApi_Should_Document_Channel_State_Response()
+    {
+        using JsonDocument document = JsonDocument.Parse(File.ReadAllText(FindOpenApiDocument()));
+
+        JsonElement getState = document.RootElement
+            .GetProperty("paths")
+            .GetProperty("/api/channels/state")
+            .GetProperty("get");
+
+        JsonElement schema = getState
+            .GetProperty("responses")
+            .GetProperty("200")
+            .GetProperty("content")
+            .GetProperty("application/json")
+            .GetProperty("schema");
+
+        schema.GetProperty("type").GetString().ShouldBe("array");
+        schema.GetProperty("items").GetProperty("$ref").GetString()
+            .ShouldBe("#/components/schemas/ChannelStateResponseModel");
+
+        JsonElement stateProperties = document.RootElement
+            .GetProperty("components")
+            .GetProperty("schemas")
+            .GetProperty("ChannelStateResponseModel")
+            .GetProperty("properties");
+
+        stateProperties.TryGetProperty("channelId", out _).ShouldBeTrue();
+        stateProperties.TryGetProperty("channelNumber", out _).ShouldBeTrue();
+        stateProperties.TryGetProperty("onAir", out _).ShouldBeTrue();
+        stateProperties.TryGetProperty("nowPlaying", out JsonElement nowPlaying).ShouldBeTrue();
+
+        JsonElement nowPlayingOneOf = nowPlaying.GetProperty("oneOf");
+        nowPlayingOneOf.EnumerateArray().Count().ShouldBe(2);
+        nowPlayingOneOf.EnumerateArray()
+            .Any(s => s.TryGetProperty("type", out JsonElement type) && type.GetString() == "null")
+            .ShouldBeTrue();
+        nowPlayingOneOf.EnumerateArray()
+            .Any(s => s.TryGetProperty("$ref", out JsonElement schemaRef) &&
+                schemaRef.GetString() == "#/components/schemas/ChannelNowPlayingResponseModel")
+            .ShouldBeTrue();
+
+        JsonElement nowPlayingProperties = document.RootElement
+            .GetProperty("components")
+            .GetProperty("schemas")
+            .GetProperty("ChannelNowPlayingResponseModel")
+            .GetProperty("properties");
+
+        nowPlayingProperties.TryGetProperty("title", out _).ShouldBeTrue();
+        nowPlayingProperties.TryGetProperty("startUtc", out JsonElement startUtc).ShouldBeTrue();
+        nowPlayingProperties.TryGetProperty("finishUtc", out JsonElement finishUtc).ShouldBeTrue();
+
+        startUtc.GetProperty("type").GetString().ShouldBe("string");
+        startUtc.GetProperty("format").GetString().ShouldBe("date-time");
+        finishUtc.GetProperty("type").GetString().ShouldBe("string");
+        finishUtc.GetProperty("format").GetString().ShouldBe("date-time");
+    }
+
     [TestCase("/api/channels/{id}", "get", "404")]
     [TestCase("/api/channels", "post", "404")]
     [TestCase("/api/channels", "post", "422")]
+    [TestCase("/api/channels/from-lineup", "post", "404")]
+    [TestCase("/api/channels/from-lineup", "post", "422")]
     [TestCase("/api/channels/{id}", "put", "404")]
     [TestCase("/api/channels/{id}", "put", "422")]
     [TestCase("/api/channels/{id}", "delete", "404")]
     [TestCase("/api/channels/{id}", "delete", "422")]
+    [TestCase("/api/channels/bulk/renumber", "post", "404")]
+    [TestCase("/api/channels/bulk/renumber", "post", "422")]
+    [TestCase("/api/channels/bulk/group", "post", "404")]
+    [TestCase("/api/channels/bulk/group", "post", "422")]
+    [TestCase("/api/channels/bulk/delete", "post", "404")]
+    [TestCase("/api/channels/bulk/delete", "post", "422")]
     [TestCase("/api/channels/{channelNumber}/playout/reset", "post", "404")]
+    [TestCase("/api/channel-templates/default", "get", "404")]
+    [TestCase("/api/channel-templates/default/{id}", "put", "404")]
+    [TestCase("/api/channel-templates/default/{id}", "put", "422")]
+    [TestCase("/api/channel-templates/{id}", "get", "404")]
+    [TestCase("/api/channel-templates", "post", "404")]
+    [TestCase("/api/channel-templates", "post", "422")]
+    [TestCase("/api/channel-templates/{id}", "put", "404")]
+    [TestCase("/api/channel-templates/{id}", "put", "422")]
+    [TestCase("/api/channel-templates/{id}", "delete", "404")]
+    [TestCase("/api/channel-templates/{id}", "delete", "422")]
     [TestCase("/api/collections/{id}", "get", "404")]
     [TestCase("/api/collections", "post", "404")]
     [TestCase("/api/collections", "post", "422")]

ErsatzTV.Tests/Controllers/TrackedFileStreamResultTests.cs

@@ -0,0 +1,183 @@
+using ErsatzTV.Controllers;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Streaming;
+using ErsatzTV.Core.Streaming;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class TrackedFileStreamResultTests
+{
+    [Test]
+    public async Task Should_Track_Session_Only_While_Result_Executes()
+    {
+        var tracker = new DirectStreamSessionTracker();
+        var stream = new BlockingReadStream();
+        TrackedFileStreamResult result = new(
+            stream,
+            "video/mp2t",
+            tracker,
+            "1",
+            StreamingMode.TransportStream);
+
+        ActionContext context = GetActionContext();
+
+        tracker.IsActive("1").ShouldBeFalse();
+
+        Task execute = result.ExecuteResultAsync(context);
+        await stream.WaitForRead();
+
+        tracker.IsActive("1").ShouldBeTrue();
+        tracker.GetViewerCount("1").ShouldBe(1);
+
+        stream.Complete();
+        await execute;
+
+        tracker.IsActive("1").ShouldBeFalse();
+        tracker.GetViewerCount("1").ShouldBe(0);
+    }
+
+    [Test]
+    public async Task Should_Remove_Session_When_Response_Stream_Fails()
+    {
+        var tracker = new DirectStreamSessionTracker();
+        TrackedFileStreamResult result = new(
+            new ThrowingReadStream(new IOException("stream failed")),
+            "video/mp2t",
+            tracker,
+            "1",
+            StreamingMode.HttpLiveStreamingDirect);
+
+        Func<Task> execute = () => result.ExecuteResultAsync(GetActionContext());
+
+        await execute.ShouldThrowAsync<IOException>();
+
+        tracker.IsActive("1").ShouldBeFalse();
+        tracker.GetViewerCount("1").ShouldBe(0);
+    }
+
+    [Test]
+    public async Task Should_Remove_Session_When_Response_Stream_Is_Aborted()
+    {
+        var tracker = new DirectStreamSessionTracker();
+        TrackedFileStreamResult result = new(
+            new ThrowingReadStream(new OperationCanceledException("client aborted")),
+            "video/mp2t",
+            tracker,
+            "1",
+            StreamingMode.HttpLiveStreamingDirect);
+
+        await result.ExecuteResultAsync(GetActionContext());
+
+        tracker.IsActive("1").ShouldBeFalse();
+        tracker.GetViewerCount("1").ShouldBe(0);
+    }
+
+    [Test]
+    public async Task Should_Not_Track_Session_For_Head_Request()
+    {
+        IDirectStreamSessionTracker tracker = Substitute.For<IDirectStreamSessionTracker>();
+        var stream = new BlockingReadStream();
+        TrackedFileStreamResult result = new(
+            stream,
+            "video/mp2t",
+            tracker,
+            "1",
+            StreamingMode.TransportStream);
+
+        await result.ExecuteResultAsync(GetActionContext(HttpMethods.Head));
+
+        tracker.DidNotReceive().Register(Arg.Any<string>(), Arg.Any<StreamingMode>());
+    }
+
+    private static ActionContext GetActionContext(string method = "GET")
+    {
+        var httpContext = new DefaultHttpContext();
+        httpContext.Request.Method = method;
+        httpContext.RequestServices = new ServiceCollection()
+            .AddLogging()
+            .AddControllers()
+            .Services
+            .BuildServiceProvider();
+        httpContext.Response.Body = new MemoryStream();
+
+        return new ActionContext(httpContext, new RouteData(), new Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor());
+    }
+
+    private sealed class BlockingReadStream : Stream
+    {
+        private readonly TaskCompletionSource _continue = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        private readonly TaskCompletionSource _readStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        public override bool CanRead => true;
+        public override bool CanSeek => false;
+        public override bool CanWrite => false;
+        public override long Length => 0;
+        public override long Position { get; set; }
+
+        public Task WaitForRead() => _readStarted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        public void Complete() => _continue.SetResult();
+
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            _readStarted.TrySetResult();
+            return ReadAfterContinue();
+        }
+
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
+            ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();
+
+        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+
+        public override void Flush()
+        {
+        }
+
+        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+
+        public override void SetLength(long value) => throw new NotSupportedException();
+
+        public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+
+        private async ValueTask<int> ReadAfterContinue()
+        {
+            await _continue.Task;
+            return 0;
+        }
+    }
+
+    private sealed class ThrowingReadStream(Exception exception) : Stream
+    {
+        public override bool CanRead => true;
+        public override bool CanSeek => false;
+        public override bool CanWrite => false;
+        public override long Length => 0;
+        public override long Position { get; set; }
+
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) =>
+            ValueTask.FromException<int>(exception);
+
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
+            ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask();
+
+        public override int Read(byte[] buffer, int offset, int count) => throw exception;
+
+        public override void Flush()
+        {
+        }
+
+        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+
+        public override void SetLength(long value) => throw new NotSupportedException();
+
+        public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+    }
+}

ErsatzTV.Tests/Infrastructure/DbInitializerChannelTemplateTests.cs

@@ -0,0 +1,51 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Infrastructure;
+
+[TestFixture]
+public class DbInitializerChannelTemplateTests
+{
+    private InMemoryTvContext _db = null!;
+
+    [SetUp]
+    public async Task SetUp() => _db = await InMemoryTvContext.CreateAsync();
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task Initialize_Should_Seed_System_Channel_Templates_And_Default_Config()
+    {
+        await using TvContext context = _db.CreateContext();
+
+        await DbInitializer.Initialize(context, CancellationToken.None);
+
+        List<ChannelTemplate> templates = context.ChannelTemplates.OrderBy(t => t.Name).ToList();
+        templates.Count.ShouldBe(2);
+        templates.ShouldContain(t => t.Name == "Music videos" && t.IsSystem);
+        ChannelTemplate standard = templates.Single(t => t.Name == "Standard");
+        standard.IsSystem.ShouldBeTrue();
+
+        ConfigElement config = context.ConfigElements.Single(
+            c => c.Key == ConfigElementKey.ChannelTemplatesDefaultTemplateId.Key);
+        config.Value.ShouldBe(standard.Id.ToString());
+    }
+
+    [Test]
+    public async Task Initialize_Should_Not_Clobber_Existing_System_Template()
+    {
+        await using TvContext context = _db.CreateContext();
+        await DbInitializer.Initialize(context, CancellationToken.None);
+        ChannelTemplate standard = context.ChannelTemplates.Single(t => t.Name == "Standard");
+        standard.Description = "User adjusted description";
+        await context.SaveChangesAsync();
+
+        await DbInitializer.Initialize(context, CancellationToken.None);
+
+        context.ChannelTemplates.Single(t => t.Name == "Standard").Description.ShouldBe("User adjusted description");
+    }
+}

ErsatzTV.Tests/StartupSpaHostingTests.cs

@@ -0,0 +1,45 @@
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests;
+
+[TestFixture]
+public class StartupSpaHostingTests
+{
+    private static readonly string StartupSource = File.ReadAllText(FindStartupPath());
+
+    [Test]
+    public void Startup_Should_Mount_ChicoryTv_Spa_At_App_Path()
+    {
+        StartupSource.ShouldContain("ctx.Request.Path.StartsWithSegments(\"/app\")");
+        StartupSource.ShouldContain("MapWhen(");
+        StartupSource.ShouldContain("SpaStaticFileRoot");
+        StartupSource.ShouldContain("RequestPath = \"/app\"");
+        StartupSource.ShouldContain("appIndexFile");
+    }
+
+    [Test]
+    public void Startup_Should_Not_Send_App_Routes_To_Blazor_Fallback()
+    {
+        StartupSource.ShouldContain("!IsSpaPath(ctx.Request.Path)");
+        StartupSource.ShouldContain("bool IsSpaPath(PathString path)");
+    }
+
+    private static string FindStartupPath()
+    {
+        DirectoryInfo? directory = new(TestContext.CurrentContext.TestDirectory);
+
+        while (directory is not null)
+        {
+            string candidate = Path.Combine(directory.FullName, "ErsatzTV", "Startup.cs");
+            if (File.Exists(candidate))
+            {
+                return candidate;
+            }
+
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException("Could not find ErsatzTV/Startup.cs");
+    }
+}

ErsatzTV.Tests/Support/ChannelHandlerTestBase.cs

@@ -35,7 +35,12 @@ public abstract class ChannelHandlerTestBase
         await context.SaveChangesAsync();
     }
 
-    protected async Task SeedChannel(int id, string number, string name = "Test", int ffmpegProfileId = 1)
+    protected async Task SeedChannel(
+        int id,
+        string number,
+        string name = "Test",
+        int ffmpegProfileId = 1,
+        string group = "ErsatzTV")
     {
         await using TvContext context = Db.CreateContext();
         context.Channels.Add(
@@ -44,7 +49,7 @@ public abstract class ChannelHandlerTestBase
                 Id = id,
                 Number = number,
                 Name = name,
-                Group = "ErsatzTV",
+                Group = group,
                 Categories = string.Empty,
                 FFmpegProfileId = ffmpegProfileId,
                 StreamSelector = string.Empty,

ErsatzTV/Controllers/Api/ChannelController.cs

@@ -22,6 +22,27 @@ public class ChannelController(ChannelWriter<IBackgroundServiceRequest> workerCh
     [EndpointGroupName("general")]
     public async Task<List<ChannelResponseModel>> GetAll() => await mediator.Send(new GetAllChannelsForApi());
 
+    [HttpGet("/api/channels/state")]
+    [Tags("Channels")]
+    [EndpointSummary("Get channel runtime state")]
+    [EndpointGroupName("general")]
+    public async Task<List<ChannelStateResponseModel>> GetState(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetChannelStatesForApi(DateTime.UtcNow), cancellationToken);
+
+    [HttpGet("/api/guide")]
+    [Tags("Channels")]
+    [EndpointSummary("Get the JSON channel guide (EPG)")]
+    [EndpointDescription(
+        "Returns per-channel programme arrays for the EPG grid. When omitted, start defaults to now, " +
+        "and end defaults to start plus the configured XmltvDaysToBuild window.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(ChannelGuideResponseModel), StatusCodes.Status200OK)]
+    public async Task<ChannelGuideResponseModel> GetGuide(
+        [FromQuery] DateTimeOffset? start,
+        [FromQuery] DateTimeOffset? end,
+        CancellationToken cancellationToken) =>
+        await mediator.Send(new GetChannelGuideData(start, end), cancellationToken);
+
     [HttpGet("/api/channels/{id:int}", Name = "GetChannelById")]
     [Tags("Channels")]
     [EndpointSummary("Get a channel by id")]
@@ -58,6 +79,32 @@ public class ChannelController(ChannelWriter<IBackgroundServiceRequest> workerCh
             });
     }
 
+    [HttpPost("/api/channels/from-lineup", Name = "CreateChannelFromLineup")]
+    [Tags("Channels")]
+    [EndpointSummary("Create a channel from a library lineup")]
+    [EndpointDescription(
+        "Atomically creates the channel, program schedule, a classic playout, and (for multi-item lineups) a " +
+        "generated system playlist. A single-item lineup produces one flood schedule item that references the " +
+        "target directly (movie, show, season, artist, collection, smart/multi collection, rerun collection, or " +
+        "playlist) and no generated playlist. A lineup with two or more items produces one generated system " +
+        "playlist whose entries play in the given order (each entry played in full before the next) referenced by " +
+        "one flood schedule item; only movies, shows, seasons, artists, collections, smart collections and multi " +
+        "collections are allowed there (rerun collections and playlists are single-item only). playbackOrder sets " +
+        "how items within each lineup entry are ordered. Template defaults are stamped at create time; advanced " +
+        "overrides win.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(CreateChannelFromLineupResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> CreateFromLineup(
+        [Required] [FromBody] CreateChannelFromLineupRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, CreateChannelFromLineupResponseModel> result =
+            await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToCreatedResult(response => $"/api/channels/{response.ChannelId}", response => response);
+    }
+
     [HttpPut("/api/channels/{id:int}")]
     [Tags("Channels")]
     [EndpointSummary("Update a channel")]
@@ -88,6 +135,53 @@ public class ChannelController(ChannelWriter<IBackgroundServiceRequest> workerCh
         return result.ToDeletedResult();
     }
 
+    [HttpPost("/api/channels/bulk/renumber")]
+    [Tags("Channels")]
+    [EndpointSummary("Renumber channels")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> BulkRenumber(
+        [Required] [FromBody] BulkRenumberChannelsRequest request,
+        CancellationToken cancellationToken)
+    {
+        Option<BaseError> result = await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.Match<IActionResult>(
+            Some: error => error.ToErrorResult(),
+            None: () => new NoContentResult());
+    }
+
+    [HttpPost("/api/channels/bulk/group")]
+    [Tags("Channels")]
+    [EndpointSummary("Move channels to a group")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> BulkMoveToGroup(
+        [Required] [FromBody] BulkMoveChannelsToGroupRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, Unit> result = await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToDeletedResult();
+    }
+
+    [HttpPost("/api/channels/bulk/delete")]
+    [Tags("Channels")]
+    [EndpointSummary("Delete channels")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> BulkDelete(
+        [Required] [FromBody] BulkDeleteChannelsRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, Unit> result = await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToDeletedResult();
+    }
+
     [HttpPost("/api/channels/{channelNumber}/playout/reset")]
     [Tags("Channels")]
     [EndpointSummary("Reset channel playout")]

ErsatzTV/Controllers/Api/ChannelTemplateController.cs

@@ -0,0 +1,109 @@
+using System.ComponentModel.DataAnnotations;
+using ErsatzTV.Application.ChannelTemplates;
+using ErsatzTV.Controllers.Api.Requests;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.ChannelTemplates;
+using ErsatzTV.Extensions;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class ChannelTemplateController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/channel-templates", Name = "GetChannelTemplates")]
+    [Tags("Channel Templates")]
+    [EndpointSummary("Get all channel templates")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<ChannelTemplateResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<ChannelTemplateResponseModel>> GetAll(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetAllChannelTemplates(), cancellationToken);
+
+    [HttpGet("/api/channel-templates/default", Name = "GetDefaultChannelTemplate")]
+    [Tags("Channel Templates")]
+    [EndpointSummary("Get the default channel template")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(ChannelTemplateResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetDefault(CancellationToken cancellationToken)
+    {
+        Option<ChannelTemplateResponseModel> result =
+            await mediator.Send(new GetDefaultChannelTemplate(), cancellationToken);
+        return result.ToGetResult();
+    }
+
+    [HttpPut("/api/channel-templates/default/{id:int}", Name = "SetDefaultChannelTemplate")]
+    [Tags("Channel Templates")]
+    [EndpointSummary("Set the default channel template")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(ChannelTemplateResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> SetDefault(int id, CancellationToken cancellationToken)
+    {
+        Either<BaseError, ChannelTemplateResponseModel> result =
+            await mediator.Send(new SetDefaultChannelTemplate(id), cancellationToken);
+        return result.ToUpdatedResult();
+    }
+
+    [HttpGet("/api/channel-templates/{id:int}", Name = "GetChannelTemplateById")]
+    [Tags("Channel Templates")]
+    [EndpointSummary("Get a channel template by id")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(ChannelTemplateResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetById(int id, CancellationToken cancellationToken)
+    {
+        Option<ChannelTemplateResponseModel> result =
+            await mediator.Send(new GetChannelTemplateById(id), cancellationToken);
+        return result.ToGetResult();
+    }
+
+    [HttpPost("/api/channel-templates", Name = "CreateChannelTemplate")]
+    [Tags("Channel Templates")]
+    [EndpointSummary("Create a channel template")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(ChannelTemplateResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Create(
+        [Required] [FromBody] CreateChannelTemplateRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, ChannelTemplateResponseModel> result =
+            await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToCreatedResult(vm => $"/api/channel-templates/{vm.Id}", vm => vm);
+    }
+
+    [HttpPut("/api/channel-templates/{id:int}", Name = "UpdateChannelTemplate")]
+    [Tags("Channel Templates")]
+    [EndpointSummary("Update a channel template")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(ChannelTemplateResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Update(
+        int id,
+        [Required] [FromBody] UpdateChannelTemplateRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, ChannelTemplateResponseModel> result =
+            await mediator.Send(request.ToCommand(id), cancellationToken);
+        return result.ToUpdatedResult();
+    }
+
+    [HttpDelete("/api/channel-templates/{id:int}", Name = "DeleteChannelTemplate")]
+    [Tags("Channel Templates")]
+    [EndpointSummary("Delete a channel template")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Delete(int id, CancellationToken cancellationToken)
+    {
+        Either<BaseError, Unit> result = await mediator.Send(new DeleteChannelTemplate(id), cancellationToken);
+        return result.ToDeletedResult();
+    }
+}

ErsatzTV/Controllers/Api/LibraryBrowseController.cs

@@ -0,0 +1,33 @@
+using ErsatzTV.Application.LibraryBrowse;
+using ErsatzTV.Core.Api.LibraryBrowse;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class LibraryBrowseController(IMediator mediator) : ControllerBase
+{
+    private const int MaxPageSize = 100;
+
+    [HttpGet("/api/library/browse", Name = "BrowseLibrary")]
+    [Tags("Libraries")]
+    [EndpointSummary("Browse and search library items")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(PagedLibraryBrowseItemsResponseModel), StatusCodes.Status200OK)]
+    public async Task<PagedLibraryBrowseItemsResponseModel> Browse(
+        [FromQuery] string query = "",
+        [FromQuery] int? libraryId = null,
+        [FromQuery] LibraryBrowseMediaType? mediaType = null,
+        [FromQuery] int pageNum = 0,
+        [FromQuery] int pageSize = 100,
+        CancellationToken cancellationToken = default)
+    {
+        int clampedPageNum = Math.Max(0, pageNum);
+        int clampedPageSize = Math.Clamp(pageSize, 1, MaxPageSize);
+        return await mediator.Send(
+            new GetLibraryBrowseItems(query, libraryId, mediaType, clampedPageNum, clampedPageSize),
+            cancellationToken);
+    }
+}

ErsatzTV/Controllers/Api/Requests/BulkChannelRequests.cs

@@ -0,0 +1,22 @@
+#nullable enable
+using ErsatzTV.Application.Channels;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record BulkRenumberChannelRequest(int Id, string Number);
+
+public record BulkRenumberChannelsRequest(List<BulkRenumberChannelRequest> Channels)
+{
+    public UpdateChannelNumbers ToCommand() =>
+        new(Channels.Select(c => new ChannelSortViewModel { Id = c.Id, Number = c.Number }).ToList());
+}
+
+public record BulkMoveChannelsToGroupRequest(List<int> ChannelIds, string Group)
+{
+    public BulkMoveChannelsToGroup ToCommand() => new(ChannelIds, Group);
+}
+
+public record BulkDeleteChannelsRequest(List<int> ChannelIds)
+{
+    public BulkDeleteChannels ToCommand() => new(ChannelIds);
+}

ErsatzTV/Controllers/Api/Requests/CreateChannelFromLineupRequest.cs

@@ -0,0 +1,117 @@
+#nullable enable
+
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Core.Api.LibraryBrowse;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+/// <summary>
+///     Composite request to create a channel, its generated schedule/playlist and a classic playout in one call.
+///     Template defaults are stamped at create time; any value set in <see cref="Advanced" /> overrides the template.
+///     A single-item lineup references its target directly; a multi-item lineup is played in order via a generated
+///     system playlist.
+/// </summary>
+public record CreateChannelFromLineupRequest(
+    string Name,
+    string Number,
+    string Group,
+    string Categories,
+    ArtworkContentTypeModel Logo,
+    bool IsEnabled,
+    bool ShowInEpg,
+    int TemplateId,
+    CreateChannelFromLineupAdvancedOptionsRequest? Advanced,
+    List<CreateChannelFromLineupItemRequest> Lineup)
+{
+    public CreateChannelFromLineup ToCommand() =>
+        new(
+            Name,
+            Number,
+            Group,
+            Categories,
+            Logo,
+            IsEnabled,
+            ShowInEpg,
+            TemplateId,
+            Advanced?.ToCommand() ?? new CreateChannelFromLineupAdvancedOptions(),
+            Lineup.Map(i => i.ToCommand()).ToList());
+}
+
+public record CreateChannelFromLineupAdvancedOptionsRequest(
+    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 CreateChannelFromLineupAdvancedOptions ToCommand() =>
+        new(
+            PlaybackOrder,
+            FFmpegProfileId,
+            WatermarkId,
+            FallbackFillerId,
+            PreRollFillerId,
+            MidRollFillerId,
+            PostRollFillerId,
+            StreamSelectorMode,
+            StreamSelector,
+            PreferredAudioLanguageCode,
+            PreferredAudioTitle,
+            PlayoutSource,
+            PlayoutMode,
+            StreamingMode,
+            PreferredSubtitleLanguageCode,
+            SubtitleMode,
+            MusicVideoCreditsMode,
+            MusicVideoCreditsTemplate,
+            SongVideoMode,
+            TranscodeMode,
+            IdleBehavior,
+            ShuffleScheduleItems,
+            RandomStartPoint,
+            FixedStartTimeBehavior);
+}
+
+public record CreateChannelFromLineupItemRequest(
+    LibraryBrowseMediaType MediaType,
+    CollectionType CollectionType,
+    int? CollectionId,
+    int? MultiCollectionId,
+    int? SmartCollectionId,
+    int? RerunCollectionId,
+    int? MediaItemId,
+    int? PlaylistId)
+{
+    public CreateChannelFromLineupItem ToCommand() =>
+        new(
+            MediaType,
+            CollectionType,
+            CollectionId,
+            MultiCollectionId,
+            SmartCollectionId,
+            RerunCollectionId,
+            MediaItemId,
+            PlaylistId);
+}

ErsatzTV/Controllers/Api/Requests/CreateChannelTemplateRequest.cs

@@ -0,0 +1,63 @@
+#nullable enable
+
+using ErsatzTV.Application.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record CreateChannelTemplateRequest(
+    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)
+{
+    public CreateChannelTemplate ToCommand() =>
+        new(
+            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);
+}

ErsatzTV/Controllers/Api/Requests/UpdateChannelTemplateRequest.cs

@@ -0,0 +1,64 @@
+#nullable enable
+
+using ErsatzTV.Application.ChannelTemplates;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record UpdateChannelTemplateRequest(
+    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)
+{
+    public UpdateChannelTemplate ToCommand(int id) =>
+        new(
+            id,
+            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);
+}

ErsatzTV/Controllers/IptvController.cs

@@ -25,6 +25,7 @@ namespace ErsatzTV.Controllers;
 [ServiceFilter(typeof(ConditionalIptvAuthorizeFilter))]
 public class IptvController : StreamingControllerBase
 {
+    private readonly IDirectStreamSessionTracker _directStreamSessionTracker;
     private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
     private readonly ILogger<IptvController> _logger;
     private readonly IMediator _mediator;
@@ -33,9 +34,11 @@ public class IptvController : StreamingControllerBase
         IMediator mediator,
         IGraphicsEngine graphicsEngine,
         ILogger<IptvController> logger,
-        IFFmpegSegmenterService ffmpegSegmenterService)
+        IFFmpegSegmenterService ffmpegSegmenterService,
+        IDirectStreamSessionTracker directStreamSessionTracker)
         : base(graphicsEngine, logger)
     {
+        _directStreamSessionTracker = directStreamSessionTracker;
         _mediator = mediator;
         _logger = logger;
         _ffmpegSegmenterService = ffmpegSegmenterService;
@@ -150,7 +153,14 @@ public class IptvController : StreamingControllerBase
                     }
 
                     process.Start();
-                    return new FileStreamResult(process.StandardOutput.BaseStream, "video/mp2t");
+                    return mode == "ts-legacy"
+                        ? new TrackedFileStreamResult(
+                            process.StandardOutput.BaseStream,
+                            "video/mp2t",
+                            _directStreamSessionTracker,
+                            channelNumber,
+                            StreamingMode.TransportStream)
+                        : new FileStreamResult(process.StandardOutput.BaseStream, "video/mp2t");
                 },
                 error => BadRequest(error.Value)));
     }
@@ -353,7 +363,11 @@ public class IptvController : StreamingControllerBase
 
         Either<BaseError, PlayoutItemProcessModel> result = await _mediator.Send(request);
 
-        return GetProcessResponse(result, channelNumber, StreamingMode.HttpLiveStreamingDirect);
+        return GetProcessResponse(
+            result,
+            channelNumber,
+            StreamingMode.HttpLiveStreamingDirect,
+            _directStreamSessionTracker);
     }
 
     private string AccessTokenQuery() => string.IsNullOrWhiteSpace(Request.Query["access_token"])

ErsatzTV/Controllers/StreamingControllerBase.cs

@@ -16,7 +16,8 @@ public abstract class StreamingControllerBase(IGraphicsEngine graphicsEngine, IL
     protected IActionResult GetProcessResponse(
         Either<BaseError, PlayoutItemProcessModel> result,
         string channelNumber,
-        StreamingMode mode)
+        StreamingMode mode,
+        IDirectStreamSessionTracker directStreamSessionTracker = null)
     {
         foreach (BaseError error in result.LeftToSeq())
         {
@@ -30,14 +31,18 @@ public abstract class StreamingControllerBase(IGraphicsEngine graphicsEngine, IL
 
         foreach (PlayoutItemProcessModel processModel in result.RightToSeq())
         {
-            return StartPlayout(processModel);
+            return StartPlayout(processModel, channelNumber, mode, directStreamSessionTracker);
         }
 
         // this will never happen
         return new NotFoundResult();
     }
 
-    private FileStreamResult StartPlayout(PlayoutItemProcessModel processModel)
+    private FileStreamResult StartPlayout(
+        PlayoutItemProcessModel processModel,
+        string channelNumber,
+        StreamingMode mode,
+        IDirectStreamSessionTracker directStreamSessionTracker)
     {
         // for process counter
         var ffmpegProcess = new FFmpegProcess();
@@ -86,6 +91,10 @@ public abstract class StreamingControllerBase(IGraphicsEngine graphicsEngine, IL
             null,
             TaskScheduler.Default);
 
-        return new FileStreamResult(pipe.Reader.AsStream(), "video/mp2t");
+        Stream stream = pipe.Reader.AsStream();
+
+        return directStreamSessionTracker is null
+            ? new FileStreamResult(stream, "video/mp2t")
+            : new TrackedFileStreamResult(stream, "video/mp2t", directStreamSessionTracker, channelNumber, mode);
     }
 }

ErsatzTV/Controllers/TrackedFileStreamResult.cs

@@ -0,0 +1,27 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Streaming;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers;
+
+public class TrackedFileStreamResult(
+    Stream fileStream,
+    string contentType,
+    IDirectStreamSessionTracker directStreamSessionTracker,
+    string channelNumber,
+    StreamingMode streamingMode) : FileStreamResult(fileStream, contentType)
+{
+    public override async Task ExecuteResultAsync(ActionContext context)
+    {
+        if (HttpMethods.IsHead(context.HttpContext.Request.Method))
+        {
+            await base.ExecuteResultAsync(context);
+            return;
+        }
+
+        using IDisposable registration = directStreamSessionTracker.Register(channelNumber, streamingMode);
+
+        await base.ExecuteResultAsync(context);
+    }
+}

ErsatzTV/Startup.cs

@@ -44,6 +44,7 @@ using ErsatzTV.Core.Scheduling.Engine;
 using ErsatzTV.Core.Scheduling.ScriptedScheduling;
 using ErsatzTV.Core.Scheduling.YamlScheduling;
 using ErsatzTV.Core.Search;
+using ErsatzTV.Core.Streaming;
 using ErsatzTV.Core.Trakt;
 using ErsatzTV.Core.Troubleshooting;
 using ErsatzTV.FFmpeg.Capabilities;
@@ -681,7 +682,42 @@ public class Startup
         });
 
         app.MapWhen(
-            ctx => !IsIptvPath(ctx.Request.Path),
+            ctx => ctx.Request.Path.StartsWithSegments("/app"),
+            spa =>
+            {
+                string spaStaticFileRoot = SpaStaticFileRoot();
+                IFileProvider spaFileProvider = Directory.Exists(spaStaticFileRoot)
+                    ? new PhysicalFileProvider(spaStaticFileRoot)
+                    : new NullFileProvider();
+
+                spa.UseStaticFiles(
+                    new StaticFileOptions
+                    {
+                        FileProvider = spaFileProvider,
+                        RequestPath = "/app"
+                    });
+
+                spa.Run(
+                    async context =>
+                    {
+                        Microsoft.Extensions.FileProviders.IFileInfo appIndexFile =
+                            spaFileProvider.GetFileInfo("index.html");
+                        if (!appIndexFile.Exists)
+                        {
+                            context.Response.StatusCode = StatusCodes.Status404NotFound;
+                            return;
+                        }
+
+                        context.Response.ContentType = "text/html; charset=utf-8";
+                        context.Response.ContentLength = appIndexFile.Length;
+
+                        await using Stream stream = appIndexFile.CreateReadStream();
+                        await stream.CopyToAsync(context.Response.Body);
+                    });
+            });
+
+        app.MapWhen(
+            ctx => !IsIptvPath(ctx.Request.Path) && !IsSpaPath(ctx.Request.Path),
             blazor =>
             {
                 blazor.UseRouting();
@@ -736,6 +772,16 @@ public class Startup
                    path.StartsWithSegments("/lineup.json") ||
                    path.StartsWithSegments("/lineup_status.json");
         }
+
+        bool IsSpaPath(PathString path) => path.StartsWithSegments("/app");
+
+        string SpaStaticFileRoot()
+        {
+            string webRootPath = CurrentEnvironment.WebRootPath ??
+                                 Path.Combine(CurrentEnvironment.ContentRootPath, "wwwroot");
+
+            return Path.Combine(webRootPath, "app");
+        }
     }
 
     private static void CustomServices(IServiceCollection services)
@@ -774,6 +820,7 @@ public class Startup
         services.AddSingleton<IScannerProxyService, ScannerProxyService>();
         services.AddSingleton<IScriptedPlayoutBuilderService, ScriptedPlayoutBuilderService>();
         services.AddSingleton<IFFmpegSegmenterService, FFmpegSegmenterService>();
+        services.AddSingleton<IDirectStreamSessionTracker, DirectStreamSessionTracker>();
         services.AddSingleton<ITempFilePool, TempFilePool>();
         services.AddSingleton<IHlsPlaylistFilter, HlsPlaylistFilter>();
         services.AddSingleton<RecyclableMemoryStreamManager>();

ErsatzTV/TvContextDesignTimeFactory.cs

@@ -0,0 +1,61 @@
+using ErsatzTV.Infrastructure;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace ErsatzTV;
+
+public class TvContextDesignTimeFactory : IDesignTimeDbContextFactory<TvContext>
+{
+    public TvContext CreateDbContext(string[] args)
+    {
+        string provider = GetProvider(args);
+
+        var optionsBuilder = new DbContextOptionsBuilder<TvContext>();
+        if (provider.Equals("MySql", StringComparison.OrdinalIgnoreCase))
+        {
+            TvContext.IsSqlite = false;
+            TvContext.LastInsertedRowId = "last_insert_id()";
+            TvContext.CaseInsensitiveCollation = "utf8mb4_general_ci";
+            string connectionString =
+                Environment.GetEnvironmentVariable("MySql__ConnectionString") ??
+                "Server=localhost;Database=ersatztv_design_time;User=root;Password=ersatztv;";
+            optionsBuilder.UseMySql(
+                connectionString,
+                new MySqlServerVersion(new Version(8, 0, 36)),
+                builder => builder.MigrationsAssembly("ErsatzTV.Infrastructure.MySql"));
+        }
+        else
+        {
+            TvContext.IsSqlite = true;
+            TvContext.LastInsertedRowId = "last_insert_rowid()";
+            TvContext.CaseInsensitiveCollation = "NOCASE";
+            string configFolder = Environment.GetEnvironmentVariable("ETV_CONFIG_FOLDER");
+            string databasePath = string.IsNullOrWhiteSpace(configFolder)
+                ? Path.Combine(Path.GetTempPath(), "ersatztv-design-time.sqlite3")
+                : Path.Combine(configFolder, "ersatztv.sqlite3");
+            optionsBuilder.UseSqlite(
+                $"Data Source={databasePath}",
+                builder => builder.MigrationsAssembly("ErsatzTV.Infrastructure.Sqlite"));
+        }
+
+        return new TvContext(
+            optionsBuilder.Options,
+            NullLoggerFactory.Instance,
+            new SlowQueryInterceptor(NullLogger<SlowQueryInterceptor>.Instance));
+    }
+
+    private static string GetProvider(string[] args)
+    {
+        for (int index = 0; index < args.Length - 1; index++)
+        {
+            if (args[index].Equals("--provider", StringComparison.OrdinalIgnoreCase))
+            {
+                return args[index + 1];
+            }
+        }
+
+        return "Sqlite";
+    }
+}

design-system/Canvas.dc.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<script src="./support.js"></script>
+</head>
+<body>
+<x-dc>
+
+</x-dc>
+</body>
+</html>

design-system/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: chicorytv-design
+description: Use this skill to generate well-branded interfaces and assets for ChicoryTV, either for production or throwaway prototypes/mocks/etc. Contains essential design guidelines, colors, type, fonts, assets, and UI kit components for prototyping.
+user-invocable: true
+---
+
+Read the README.md file within this skill, and explore the other available files.
+If creating visual artifacts (slides, mocks, throwaway prototypes, etc), copy assets out and create static HTML files for the user to view. If working on production code, you can copy assets and read the rules here to become an expert in designing with this brand.
+If the user invokes this skill without any other guidance, ask them what they want to build or design, ask some questions, and act as an expert designer who outputs HTML artifacts _or_ production code, depending on the need.
+
+Quick map:
+- `readme.md` — brand context, content & visual foundations, iconography, file index.
+- `styles.css` — the single entry point; link it and use the CSS custom properties.
+- `tokens/` — color, type, spacing, radius/elevation/motion tokens + font loading.
+- `components/` — React primitives (forms, data-display, feedback, navigation).
+- `templates/chicorytv-admin/` — full admin shell to start from / copy screens out of (incl. the library-to-lineup Channel Builder).
+- `assets/` — chicory-flower mark, wordmark, app icon.

design-system/_adherence.oxlintrc.json

@@ -0,0 +1,470 @@
+{
+  "plugins": [
+    "react",
+    "import"
+  ],
+  "rules": {
+    "react/forbid-elements": [
+      "warn",
+      {
+        "forbid": []
+      }
+    ],
+    "no-restricted-imports": [
+      "warn",
+      {
+        "patterns": [
+          {
+            "group": [
+              "components/data-display/**",
+              "components/feedback/**",
+              "components/forms/**",
+              "components/navigation/**",
+              "design_handoff_channel_builder/**"
+            ],
+            "message": "Import design-system components from 'index.js', not component internals."
+          }
+        ]
+      }
+    ],
+    "no-restricted-syntax": [
+      "warn",
+      {
+        "selector": "Literal[value=/#[0-9a-fA-F]{3,8}\\b/]",
+        "message": "Raw hex color — use a design-system color token via var()."
+      },
+      {
+        "selector": "Literal[value=/\\b\\d+px\\b/]",
+        "message": "Raw px value — use a design-system spacing token via var()."
+      },
+      {
+        "selector": "Literal[value=/font-family\\s*:\\s*(?!['\\\"]?(?:Geist|Geist Mono))/i]",
+        "message": "Font not provided by the design system. Available: Geist, Geist Mono."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Badge'] > JSXAttribute > JSXIdentifier[name!=/^(?:children|tone|solid|dot|style|key|ref|className|style|children)$/]",
+        "message": "<Badge> doesn't accept that prop. Declared props: children, tone, solid, dot, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Badge'] > JSXAttribute[name.name='tone'] > Literal[value!=/^(?:neutral|accent|ok|warn|error)$/]",
+        "message": "<Badge> tone must be one of 'neutral' | 'accent' | 'ok' | 'warn' | 'error'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Button'] > JSXAttribute > JSXIdentifier[name!=/^(?:children|variant|size|startIcon|endIcon|disabled|loading|fullWidth|type|onClick|style|key|ref|className|style|children)$/]",
+        "message": "<Button> doesn't accept that prop. Declared props: children, variant, size, startIcon, endIcon, disabled, loading, fullWidth, type, onClick, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Button'] > JSXAttribute[name.name='variant'] > Literal[value!=/^(?:primary|secondary|ghost|danger)$/]",
+        "message": "<Button> variant must be one of 'primary' | 'secondary' | 'ghost' | 'danger'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Button'] > JSXAttribute[name.name='size'] > Literal[value!=/^(?:sm|md)$/]",
+        "message": "<Button> size must be one of 'sm' | 'md'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Button'] > JSXAttribute[name.name='type'] > Literal[value!=/^(?:button|submit|reset)$/]",
+        "message": "<Button> type must be one of 'button' | 'submit' | 'reset'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Card'] > JSXAttribute > JSXIdentifier[name!=/^(?:title|subtitle|actions|children|padded|inset|style|key|ref|className|style|children)$/]",
+        "message": "<Card> doesn't accept that prop. Declared props: title, subtitle, actions, children, padded, inset, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='ChannelLogo'] > JSXAttribute > JSXIdentifier[name!=/^(?:name|src|size|radius|style|key|ref|className|style|children)$/]",
+        "message": "<ChannelLogo> doesn't accept that prop. Declared props: name, src, size, radius, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Checkbox'] > JSXAttribute > JSXIdentifier[name!=/^(?:checked|onChange|label|indeterminate|disabled|style|key|ref|className|style|children)$/]",
+        "message": "<Checkbox> doesn't accept that prop. Declared props: checked, onChange, label, indeterminate, disabled, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='IconButton'] > JSXAttribute > JSXIdentifier[name!=/^(?:children|size|variant|active|disabled|title|onClick|style|key|ref|className|style|children)$/]",
+        "message": "<IconButton> doesn't accept that prop. Declared props: children, size, variant, active, disabled, title, onClick, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='IconButton'] > JSXAttribute[name.name='size'] > Literal[value!=/^(?:sm|md)$/]",
+        "message": "<IconButton> size must be one of 'sm' | 'md'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='IconButton'] > JSXAttribute[name.name='variant'] > Literal[value!=/^(?:ghost|solid)$/]",
+        "message": "<IconButton> variant must be one of 'ghost' | 'solid'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Input'] > JSXAttribute > JSXIdentifier[name!=/^(?:label|value|onChange|placeholder|leadingIcon|trailing|error|disabled|size|type|fullWidth|style|key|ref|className|style|children)$/]",
+        "message": "<Input> doesn't accept that prop. Declared props: label, value, onChange, placeholder, leadingIcon, trailing, error, disabled, size, type, fullWidth, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Input'] > JSXAttribute[name.name='size'] > Literal[value!=/^(?:sm|md)$/]",
+        "message": "<Input> size must be one of 'sm' | 'md'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='NavItem'] > JSXAttribute > JSXIdentifier[name!=/^(?:icon|label|active|badge|badgeTone|href|onClick|style|key|ref|className|style|children)$/]",
+        "message": "<NavItem> doesn't accept that prop. Declared props: icon, label, active, badge, badgeTone, href, onClick, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='NavItem'] > JSXAttribute[name.name='badgeTone'] > Literal[value!=/^(?:warn|error|accent)$/]",
+        "message": "<NavItem> badgeTone must be one of 'warn' | 'error' | 'accent'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='ProgressBar'] > JSXAttribute > JSXIdentifier[name!=/^(?:value|tone|height|showLabel|style|key|ref|className|style|children)$/]",
+        "message": "<ProgressBar> doesn't accept that prop. Declared props: value, tone, height, showLabel, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='ProgressBar'] > JSXAttribute[name.name='tone'] > Literal[value!=/^(?:accent|ok|warn|error)$/]",
+        "message": "<ProgressBar> tone must be one of 'accent' | 'ok' | 'warn' | 'error'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='SelectOption'] > JSXAttribute > JSXIdentifier[name!=/^(?:value|label|key|ref|className|style|children)$/]",
+        "message": "<SelectOption> doesn't accept that prop. Declared props: value, label."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Spinner'] > JSXAttribute > JSXIdentifier[name!=/^(?:size|tone|stroke|style|key|ref|className|style|children)$/]",
+        "message": "<Spinner> doesn't accept that prop. Declared props: size, tone, stroke, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Spinner'] > JSXAttribute[name.name='tone'] > Literal[value!=/^(?:accent|muted|ok)$/]",
+        "message": "<Spinner> tone must be one of 'accent' | 'muted' | 'ok'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Stat'] > JSXAttribute > JSXIdentifier[name!=/^(?:label|value|unit|delta|deltaTone|icon|style|key|ref|className|style|children)$/]",
+        "message": "<Stat> doesn't accept that prop. Declared props: label, value, unit, delta, deltaTone, icon, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Stat'] > JSXAttribute[name.name='deltaTone'] > Literal[value!=/^(?:up|down|neutral)$/]",
+        "message": "<Stat> deltaTone must be one of 'up' | 'down' | 'neutral'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='StatusDot'] > JSXAttribute > JSXIdentifier[name!=/^(?:status|pulse|size|label|style|key|ref|className|style|children)$/]",
+        "message": "<StatusDot> doesn't accept that prop. Declared props: status, pulse, size, label, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='StatusDot'] > JSXAttribute[name.name='status'] > Literal[value!=/^(?:live|ok|warn|error|idle)$/]",
+        "message": "<StatusDot> status must be one of 'live' | 'ok' | 'warn' | 'error' | 'idle'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Switch'] > JSXAttribute > JSXIdentifier[name!=/^(?:checked|onChange|label|disabled|size|style|key|ref|className|style|children)$/]",
+        "message": "<Switch> doesn't accept that prop. Declared props: checked, onChange, label, disabled, size, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Switch'] > JSXAttribute[name.name='size'] > Literal[value!=/^(?:sm|md)$/]",
+        "message": "<Switch> size must be one of 'sm' | 'md'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='TabItem'] > JSXAttribute > JSXIdentifier[name!=/^(?:value|label|icon|count|key|ref|className|style|children)$/]",
+        "message": "<TabItem> doesn't accept that prop. Declared props: value, label, icon, count."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Tag'] > JSXAttribute > JSXIdentifier[name!=/^(?:children|onRemove|icon|tone|style|key|ref|className|style|children)$/]",
+        "message": "<Tag> doesn't accept that prop. Declared props: children, onRemove, icon, tone, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Tag'] > JSXAttribute[name.name='tone'] > Literal[value!=/^(?:neutral|accent)$/]",
+        "message": "<Tag> tone must be one of 'neutral' | 'accent'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Toast'] > JSXAttribute > JSXIdentifier[name!=/^(?:tone|title|message|onClose|style|key|ref|className|style|children)$/]",
+        "message": "<Toast> doesn't accept that prop. Declared props: tone, title, message, onClose, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Toast'] > JSXAttribute[name.name='tone'] > Literal[value!=/^(?:info|ok|warn|error)$/]",
+        "message": "<Toast> tone must be one of 'info' | 'ok' | 'warn' | 'error'."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Tooltip'] > JSXAttribute > JSXIdentifier[name!=/^(?:label|placement|children|style|key|ref|className|style|children)$/]",
+        "message": "<Tooltip> doesn't accept that prop. Declared props: label, placement, children, style."
+      },
+      {
+        "selector": "JSXOpeningElement[name.name='Tooltip'] > JSXAttribute[name.name='placement'] > Literal[value!=/^(?:top|bottom|left|right)$/]",
+        "message": "<Tooltip> placement must be one of 'top' | 'bottom' | 'left' | 'right'."
+      }
+    ]
+  },
+  "overrides": [
+    {
+      "files": [
+        "**/index.js"
+      ],
+      "rules": {
+        "no-restricted-imports": "off"
+      }
+    }
+  ],
+  "x-omelette": {
+    "components": {
+      "Badge": {
+        "replaces": []
+      },
+      "Button": {
+        "replaces": []
+      },
+      "Card": {
+        "replaces": []
+      },
+      "ChannelLogo": {
+        "replaces": []
+      },
+      "Checkbox": {
+        "replaces": []
+      },
+      "IconButton": {
+        "replaces": []
+      },
+      "Input": {
+        "replaces": []
+      },
+      "NavItem": {
+        "replaces": []
+      },
+      "ProgressBar": {
+        "replaces": []
+      },
+      "SelectOption": {
+        "replaces": []
+      },
+      "Spinner": {
+        "replaces": []
+      },
+      "Stat": {
+        "replaces": []
+      },
+      "StatusDot": {
+        "replaces": []
+      },
+      "Switch": {
+        "replaces": []
+      },
+      "TabItem": {
+        "replaces": []
+      },
+      "Tag": {
+        "replaces": []
+      },
+      "Toast": {
+        "replaces": []
+      },
+      "Tooltip": {
+        "replaces": []
+      }
+    },
+    "tokens": [
+      "--action-primary",
+      "--action-primary-hover",
+      "--action-primary-press",
+      "--border-control",
+      "--border-hairline",
+      "--control-h",
+      "--control-h-sm",
+      "--ctv-accent",
+      "--ctv-accent-hover",
+      "--ctv-accent-press",
+      "--ctv-accent-ring",
+      "--ctv-accent-soft",
+      "--ctv-bg",
+      "--ctv-bg-sunken",
+      "--ctv-border",
+      "--ctv-border-strong",
+      "--ctv-error",
+      "--ctv-error-soft",
+      "--ctv-live",
+      "--ctv-live-soft",
+      "--ctv-ok",
+      "--ctv-ok-soft",
+      "--ctv-secondary",
+      "--ctv-secondary-soft",
+      "--ctv-surface",
+      "--ctv-surface-2",
+      "--ctv-surface-3",
+      "--ctv-text",
+      "--ctv-text-faint",
+      "--ctv-text-muted",
+      "--ctv-warn",
+      "--ctv-warn-soft",
+      "--dur-base",
+      "--dur-fast",
+      "--dur-slow",
+      "--ease-out",
+      "--ease-standard",
+      "--focus-ring",
+      "--font-mono",
+      "--font-sans",
+      "--gap-inline",
+      "--leading-normal",
+      "--leading-snug",
+      "--leading-tight",
+      "--numeric-feature",
+      "--pad-card",
+      "--pad-cell-x",
+      "--pad-cell-y",
+      "--pad-control-x",
+      "--pad-control-y",
+      "--pad-page",
+      "--radius-lg",
+      "--radius-md",
+      "--radius-pill",
+      "--radius-sm",
+      "--radius-xs",
+      "--ring-focus",
+      "--row-h",
+      "--shadow-lg",
+      "--shadow-md",
+      "--shadow-none",
+      "--shadow-pop",
+      "--shadow-sm",
+      "--sidebar-w",
+      "--space-0",
+      "--space-1",
+      "--space-10",
+      "--space-11",
+      "--space-12",
+      "--space-2",
+      "--space-3",
+      "--space-4",
+      "--space-5",
+      "--space-6",
+      "--space-7",
+      "--space-8",
+      "--space-9",
+      "--status-error",
+      "--status-live",
+      "--status-ok",
+      "--status-warn",
+      "--surface-app",
+      "--surface-card",
+      "--surface-raised",
+      "--surface-selected",
+      "--text-2xl",
+      "--text-2xs",
+      "--text-3xl",
+      "--text-disabled",
+      "--text-lg",
+      "--text-md",
+      "--text-on-accent",
+      "--text-primary",
+      "--text-secondary",
+      "--text-sm",
+      "--text-xl",
+      "--text-xs",
+      "--topbar-h",
+      "--tracking-caps",
+      "--tracking-normal",
+      "--tracking-tight",
+      "--tracking-wide",
+      "--weight-bold",
+      "--weight-medium",
+      "--weight-normal",
+      "--weight-semibold"
+    ],
+    "tokenKinds": {
+      "--ctv-bg": "color",
+      "--ctv-bg-sunken": "color",
+      "--ctv-surface": "color",
+      "--ctv-surface-2": "color",
+      "--ctv-surface-3": "color",
+      "--ctv-border": "color",
+      "--ctv-border-strong": "color",
+      "--ctv-text": "font",
+      "--ctv-text-muted": "font",
+      "--ctv-text-faint": "font",
+      "--ctv-accent": "color",
+      "--ctv-accent-hover": "color",
+      "--ctv-accent-press": "color",
+      "--ctv-accent-soft": "color",
+      "--ctv-accent-ring": "color",
+      "--ctv-secondary": "color",
+      "--ctv-secondary-soft": "color",
+      "--ctv-ok": "color",
+      "--ctv-ok-soft": "color",
+      "--ctv-warn": "color",
+      "--ctv-warn-soft": "color",
+      "--ctv-error": "color",
+      "--ctv-error-soft": "color",
+      "--ctv-live": "color",
+      "--ctv-live-soft": "color",
+      "--surface-app": "color",
+      "--surface-card": "color",
+      "--surface-raised": "color",
+      "--surface-selected": "color",
+      "--border-hairline": "color",
+      "--border-control": "color",
+      "--text-primary": "font",
+      "--text-secondary": "font",
+      "--text-disabled": "font",
+      "--text-on-accent": "font",
+      "--action-primary": "color",
+      "--action-primary-hover": "color",
+      "--action-primary-press": "color",
+      "--focus-ring": "color",
+      "--status-ok": "color",
+      "--status-warn": "color",
+      "--status-error": "color",
+      "--status-live": "color",
+      "--font-sans": "font",
+      "--font-mono": "font",
+      "--text-2xs": "font",
+      "--text-xs": "font",
+      "--text-sm": "font",
+      "--text-md": "font",
+      "--text-lg": "font",
+      "--text-xl": "font",
+      "--text-2xl": "font",
+      "--text-3xl": "font",
+      "--weight-normal": "font",
+      "--weight-medium": "font",
+      "--weight-semibold": "font",
+      "--weight-bold": "font",
+      "--leading-tight": "font",
+      "--leading-snug": "font",
+      "--leading-normal": "font",
+      "--tracking-tight": "font",
+      "--tracking-normal": "font",
+      "--tracking-wide": "font",
+      "--tracking-caps": "font",
+      "--numeric-feature": "other",
+      "--space-0": "spacing",
+      "--space-1": "spacing",
+      "--space-2": "spacing",
+      "--space-3": "spacing",
+      "--space-4": "spacing",
+      "--space-5": "spacing",
+      "--space-6": "spacing",
+      "--space-7": "spacing",
+      "--space-8": "spacing",
+      "--space-9": "spacing",
+      "--space-10": "spacing",
+      "--space-11": "spacing",
+      "--space-12": "spacing",
+      "--gap-inline": "spacing",
+      "--pad-control-x": "spacing",
+      "--pad-control-y": "spacing",
+      "--pad-card": "spacing",
+      "--pad-cell-x": "spacing",
+      "--pad-cell-y": "spacing",
+      "--pad-page": "spacing",
+      "--sidebar-w": "spacing",
+      "--topbar-h": "spacing",
+      "--row-h": "spacing",
+      "--control-h": "spacing",
+      "--control-h-sm": "spacing",
+      "--radius-xs": "radius",
+      "--radius-sm": "radius",
+      "--radius-md": "radius",
+      "--radius-lg": "radius",
+      "--radius-pill": "radius",
+      "--shadow-none": "shadow",
+      "--shadow-sm": "shadow",
+      "--shadow-md": "shadow",
+      "--shadow-lg": "shadow",
+      "--shadow-pop": "shadow",
+      "--ring-focus": "color",
+      "--ease-standard": "other",
+      "--ease-out": "other",
+      "--dur-fast": "other",
+      "--dur-base": "other",
+      "--dur-slow": "other"
+    },
+    "fontFamilies": [
+      "Geist",
+      "Geist Mono"
+    ]
+  }
+}

design-system/assets/chicory-mark.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" fill="none">
+  <g transform="translate(32 32)">
+    <rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(0)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(22.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(45)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(67.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(90)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(112.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(135)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(157.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(180)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(202.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(225)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(247.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(270)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(292.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(315)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(337.5)"></rect>
+    <circle r="8.5" fill="#0F1115"></circle>
+    <circle r="5" fill="#5B7CFA"></circle>
+    <circle r="2" fill="#0F1115"></circle>
+  </g>
+</svg>

design-system/assets/chicorytv-icon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" fill="none">
+  <rect width="64" height="64" rx="14" fill="#171A21"></rect>
+  <g transform="translate(32 32) scale(0.82)">
+    <rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(0)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(22.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(45)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(67.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(90)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(112.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(135)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(157.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(180)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(202.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(225)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(247.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(270)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(292.5)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#5B7CFA" transform="rotate(315)"></rect><rect x="-3.1" y="-30" width="6.2" height="20" rx="3.1" fill="#8AA1FC" transform="rotate(337.5)"></rect>
+    <circle r="8.5" fill="#171A21"></circle>
+    <circle r="5" fill="#5B7CFA"></circle>
+    <circle r="2" fill="#171A21"></circle>
+  </g>
+</svg>