ErsatzTV.Application/Scheduling/Commands/CreateDecoTemplateHandler.cs

@@ -27,12 +27,30 @@ public class CreateDecoTemplateHandler(IDbContextFactory<TvContext> dbContextFac
 
     private static async Task<Validation<BaseError, DecoTemplate>> Validate(
         TvContext dbContext,
-        CreateDecoTemplate request) =>
-        await ValidateDecoTemplateName(dbContext, request).MapT(name => new DecoTemplate
+        CreateDecoTemplate request)
+    {
+        Validation<BaseError, Unit> decoTemplateGroupValidation =
+            await ValidateDecoTemplateGroupExists(dbContext, request);
+        Validation<BaseError, string> nameValidation = await ValidateDecoTemplateName(dbContext, request);
+
+        return (decoTemplateGroupValidation, nameValidation).Apply((_, name) => new DecoTemplate
         {
             DecoTemplateGroupId = request.DecoTemplateGroupId,
             Name = name
         });
+    }
+
+    private static async Task<Validation<BaseError, Unit>> ValidateDecoTemplateGroupExists(
+        TvContext dbContext,
+        CreateDecoTemplate request)
+    {
+        bool decoTemplateGroupExists =
+            await dbContext.DecoTemplateGroups.AnyAsync(dtg => dtg.Id == request.DecoTemplateGroupId);
+
+        return decoTemplateGroupExists
+            ? Success<BaseError, Unit>(Unit.Default)
+            : BaseError.New("Deco template group does not exist");
+    }
 
     private static async Task<Validation<BaseError, string>> ValidateDecoTemplateName(
         TvContext dbContext,

ErsatzTV.Application/Scheduling/Commands/ReplaceDecoTemplateItemsHandler.cs

@@ -29,11 +29,7 @@ public class ReplaceDecoTemplateItemsHandler(IDbContextFactory<TvContext> dbCont
 
         dbContext.RemoveRange(decoTemplate.Items);
 
-        // drop items that are invalid
-        decoTemplate.Items = request.Items
-            .Map(i => BuildItem(decoTemplate, i))
-            .Filter(i => i.StartTime < i.EndTime || i.EndTime == TimeSpan.Zero)
-            .ToList();
+        decoTemplate.Items = request.Items.Map(i => BuildItem(decoTemplate, i)).ToList();
 
         await dbContext.SaveChangesAsync(cancellationToken);
 
@@ -66,7 +62,78 @@ public class ReplaceDecoTemplateItemsHandler(IDbContextFactory<TvContext> dbCont
         ReplaceDecoTemplateItems request,
         CancellationToken cancellationToken) =>
         DecoTemplateMustExist(dbContext, request.DecoTemplateId, cancellationToken)
-            .BindT(decoTemplate => DecoTemplateNameMustBeValid(dbContext, decoTemplate, request));
+            .BindT(decoTemplate => DecoTemplateNameMustBeValid(dbContext, decoTemplate, request))
+            .BindT(decoTemplate => DecoTemplateItemsMustBeValid(dbContext, decoTemplate, request));
+
+    // Hardening (deliberate deviation from the original handler): rather than silently filtering out
+    // invalid items (unknown DecoId, StartTime >= EndTime, or overlapping ranges) - the same silent-drop
+    // and silent-overlap bug class fixed for ReplaceTemplateItemsHandler in #144 S2 - reject the whole
+    // request with a 422 so the caller knows exactly what is wrong. EndTime == TimeSpan.Zero means
+    // "end of day" (24:00) and is treated as such for both the ordering and overlap checks.
+    private static async Task<Validation<BaseError, DecoTemplate>> DecoTemplateItemsMustBeValid(
+        TvContext dbContext,
+        DecoTemplate decoTemplate,
+        ReplaceDecoTemplateItems request)
+    {
+        var allDecoIds = request.Items.Map(i => i.DecoId).Distinct().ToList();
+
+        Dictionary<int, Deco> allDecos = await dbContext.Decos
+            .AsNoTracking()
+            .Filter(d => allDecoIds.Contains(d.Id))
+            .ToListAsync()
+            .Map(list => list.ToDictionary(d => d.Id, d => d));
+
+        var missingDecoIds = allDecoIds.Filter(id => !allDecos.ContainsKey(id)).ToList();
+        if (missingDecoIds.Count > 0)
+        {
+            return BaseError.New($"[DecoId] {missingDecoIds.Head()} does not exist.");
+        }
+
+        var itemsWithEffectiveEnd = request.Items
+            .Map(i => new DecoTemplateItemRange(
+                i.DecoId,
+                i.StartTime,
+                i.EndTime,
+                i.EndTime == TimeSpan.Zero ? TimeSpan.FromHours(24) : i.EndTime))
+            .ToList();
+
+        foreach (DecoTemplateItemRange item in itemsWithEffectiveEnd)
+        {
+            if (item.StartTime < TimeSpan.Zero || item.StartTime >= TimeSpan.FromHours(24) ||
+                item.EndTime < TimeSpan.Zero || item.EndTime > TimeSpan.FromHours(24))
+            {
+                return BaseError.New(
+                    $"Deco from {item.StartTime} to {item.EndTime} must be within a single day (00:00 to 24:00)");
+            }
+
+            if (item.StartTime >= item.EffectiveEndTime)
+            {
+                return BaseError.New(
+                    $"Deco from {item.StartTime} to {item.EndTime} must start before it ends");
+            }
+        }
+
+        foreach (DecoTemplateItemRange item in itemsWithEffectiveEnd)
+        {
+            foreach (DecoTemplateItemRange otherItem in itemsWithEffectiveEnd)
+            {
+                if (item == otherItem)
+                {
+                    continue;
+                }
+
+                if (item.StartTime < otherItem.EffectiveEndTime && otherItem.StartTime < item.EffectiveEndTime)
+                {
+                    return BaseError.New(
+                        $"Deco from {item.StartTime} to {item.EndTime} intersects deco from {otherItem.StartTime} to {otherItem.EndTime}");
+                }
+            }
+        }
+
+        return decoTemplate;
+    }
+
+    private sealed record DecoTemplateItemRange(int DecoId, TimeSpan StartTime, TimeSpan EndTime, TimeSpan EffectiveEndTime);
 
     private static Task<Validation<BaseError, DecoTemplate>> DecoTemplateMustExist(
         TvContext dbContext,

ErsatzTV.Core/Api/Scheduling/DecoTemplateGroupResponseModel.cs

@@ -0,0 +1,4 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record DecoTemplateGroupResponseModel(int Id, string Name, int DecoTemplateCount);

ErsatzTV.Core/Api/Scheduling/DecoTemplateItemResponseModel.cs

@@ -0,0 +1,4 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record DecoTemplateItemResponseModel(int DecoId, string DecoName, TimeSpan StartTime, TimeSpan EndTime);

ErsatzTV.Core/Api/Scheduling/DecoTemplateResponseModel.cs

@@ -0,0 +1,4 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record DecoTemplateResponseModel(int Id, int DecoTemplateGroupId, string GroupName, string Name);

ErsatzTV.Core/Api/Scheduling/DecoTemplateWithItemsResponseModel.cs

@@ -0,0 +1,9 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record DecoTemplateWithItemsResponseModel(
+    int Id,
+    int DecoTemplateGroupId,
+    string GroupName,
+    string Name,
+    List<DecoTemplateItemResponseModel> Items);

ErsatzTV.Tests/Controllers/ApiControllerSecurityTests.cs

@@ -29,6 +29,7 @@ public class ApiControllerSecurityTests
             typeof(ChannelController),
             typeof(CollectionController),
             typeof(DecoController),
+            typeof(DecoTemplateController),
             typeof(FFmpegProfileController),
             typeof(FillerPresetController),
             typeof(LibrariesController),

ErsatzTV.Tests/Controllers/ApiErrorResponseMetadataTests.cs

@@ -102,6 +102,16 @@ public class ApiErrorResponseMetadataTests
     [TestCase(typeof(DecoController), nameof(DecoController.Delete), StatusCodes.Status404NotFound)]
     [TestCase(typeof(DecoController), nameof(DecoController.Replace), StatusCodes.Status404NotFound)]
     [TestCase(typeof(DecoController), nameof(DecoController.Replace), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.GetById), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.CreateGroup), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.CreateGroup), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.DeleteGroup), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Create), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Create), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Delete), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.GetItems), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Replace), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Replace), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(PlayoutController), nameof(PlayoutController.UpdateDefaultDeco), StatusCodes.Status404NotFound)]
     [TestCase(typeof(PlayoutController), nameof(PlayoutController.UpdateDefaultDeco), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(PlayoutController), nameof(PlayoutController.GetById), StatusCodes.Status404NotFound)]

ErsatzTV.Tests/Controllers/DecoTemplateControllerTests.cs

@@ -0,0 +1,348 @@
+using System.Reflection;
+using ErsatzTV.Application.Scheduling;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Controllers.Api.Requests;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.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;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class DecoTemplateControllerTests
+{
+    private DecoTemplateController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new DecoTemplateController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Routes()
+    {
+        ShouldHaveActionRoute(nameof(DecoTemplateController.GetGroups), "GET", "/api/deco-templates/groups");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.CreateGroup), "POST", "/api/deco-templates/groups");
+        ShouldHaveActionRoute(
+            nameof(DecoTemplateController.DeleteGroup),
+            "DELETE",
+            "/api/deco-templates/groups/{id:int}");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.GetAll), "GET", "/api/deco-templates");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.GetById), "GET", "/api/deco-templates/{id:int}");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.Create), "POST", "/api/deco-templates");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.Delete), "DELETE", "/api/deco-templates/{id:int}");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.GetItems), "GET", "/api/deco-templates/{id:int}/items");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.Replace), "PUT", "/api/deco-templates/{id:int}");
+    }
+
+    [Test]
+    public async Task CreateGroup_Should_Return_201_With_Location_And_Body()
+    {
+        _mediator.Send(Arg.Any<CreateDecoTemplateGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, DecoTemplateGroupViewModel>(new DecoTemplateGroupViewModel(5, "Weekday", 0)));
+
+        IActionResult result = await _controller.CreateGroup(
+            new CreateDecoTemplateGroupRequest("Weekday"),
+            CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/api/deco-templates/groups/5");
+        created.Value.ShouldBeOfType<DecoTemplateGroupResponseModel>().Name.ShouldBe("Weekday");
+        await _mediator.Received(1).Send(
+            Arg.Is<CreateDecoTemplateGroup>(c => c.Name == "Weekday"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task CreateGroup_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<CreateDecoTemplateGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, DecoTemplateGroupViewModel>(BaseError.New("bad")));
+
+        IActionResult result = await _controller.CreateGroup(
+            new CreateDecoTemplateGroupRequest(string.Empty),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
+    [Test]
+    public async Task DeleteGroup_Should_Return_204_When_Exists()
+    {
+        _mediator.Send(Arg.Any<GetAllDecoTemplateGroups>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateGroupViewModel> { new(3, "Weekday", 0) });
+        _mediator.Send(Arg.Any<DeleteDecoTemplateGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BaseError>.None);
+
+        IActionResult result = await _controller.DeleteGroup(3, CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+        await _mediator.Received(1).Send(
+            Arg.Is<DeleteDecoTemplateGroup>(c => c.DecoTemplateGroupId == 3),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task DeleteGroup_Should_Return_404_When_Missing()
+    {
+        _mediator.Send(Arg.Any<GetAllDecoTemplateGroups>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateGroupViewModel>());
+
+        IActionResult result = await _controller.DeleteGroup(99, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<DeleteDecoTemplateGroup>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetAll_Should_Flatten_DecoTemplates_Across_Groups()
+    {
+        _mediator.Send(Arg.Any<GetAllDecoTemplateGroups>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateGroupViewModel> { new(2, "Weekday", 1) });
+        _mediator.Send(Arg.Any<GetDecoTemplatesByDecoTemplateGroupId>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateViewModel> { MakeDecoTemplate(1, 2, "Morning") });
+
+        List<DecoTemplateResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.Count.ShouldBe(1);
+        result[0].Id.ShouldBe(1);
+        result[0].DecoTemplateGroupId.ShouldBe(2);
+        result[0].Name.ShouldBe("Morning");
+        await _mediator.Received(1).Send(
+            Arg.Is<GetDecoTemplatesByDecoTemplateGroupId>(c => c.DecoTemplateGroupId == 2),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetById_Should_Return_200_For_Some()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 2, "Morning")));
+
+        IActionResult result = await _controller.GetById(4, CancellationToken.None);
+
+        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<DecoTemplateResponseModel>().Id.ShouldBe(4);
+    }
+
+    [Test]
+    public async Task GetById_Should_Return_404_For_None()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.None);
+
+        IActionResult result = await _controller.GetById(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
+    [Test]
+    public async Task Create_Should_Return_201_And_Map_Request()
+    {
+        _mediator.Send(Arg.Any<CreateDecoTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, DecoTemplateViewModel>(MakeDecoTemplate(8, 2, "Morning")));
+
+        IActionResult result = await _controller.Create(
+            new CreateDecoTemplateRequest(2, "Morning"),
+            CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/api/deco-templates/8");
+        await _mediator.Received(1).Send(
+            Arg.Is<CreateDecoTemplate>(c => c.DecoTemplateGroupId == 2 && c.Name == "Morning"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Create_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<CreateDecoTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, DecoTemplateViewModel>(BaseError.New("dupe")));
+
+        IActionResult result = await _controller.Create(
+            new CreateDecoTemplateRequest(2, "Morning"),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
+    [Test]
+    public async Task Delete_Should_Return_204_When_Exists()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<DeleteDecoTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BaseError>.None);
+
+        IActionResult result = await _controller.Delete(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+    }
+
+    [Test]
+    public async Task Delete_Should_Return_404_When_Missing()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.None);
+
+        IActionResult result = await _controller.Delete(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<DeleteDecoTemplate>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetItems_Should_Return_200_Ordered_By_StartTime()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<GetDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateItemViewModel>
+            {
+                MakeItem(20, "News Bumper", TimeSpan.FromHours(12), TimeSpan.FromHours(13)),
+                MakeItem(10, "Morning Bumper", TimeSpan.FromHours(6), TimeSpan.FromHours(7))
+            });
+
+        IActionResult result = await _controller.GetItems(4, CancellationToken.None);
+
+        var items = result.ShouldBeOfType<OkObjectResult>().Value
+            .ShouldBeOfType<List<DecoTemplateItemResponseModel>>();
+        items.Count.ShouldBe(2);
+        items[0].DecoId.ShouldBe(10);
+        items[0].StartTime.ShouldBe(TimeSpan.FromHours(6));
+        items[0].EndTime.ShouldBe(TimeSpan.FromHours(7));
+        items[1].DecoId.ShouldBe(20);
+    }
+
+    [Test]
+    public async Task GetItems_Should_Return_End_Of_Day_As_Midnight()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<GetDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateItemViewModel>
+            {
+                MakeItem(10, "Overnight Bumper", TimeSpan.FromHours(22), TimeSpan.Zero)
+            });
+
+        IActionResult result = await _controller.GetItems(4, CancellationToken.None);
+
+        var items = result.ShouldBeOfType<OkObjectResult>().Value
+            .ShouldBeOfType<List<DecoTemplateItemResponseModel>>();
+        items[0].StartTime.ShouldBe(TimeSpan.FromHours(22));
+        items[0].EndTime.ShouldBe(TimeSpan.Zero);
+    }
+
+    [Test]
+    public async Task GetItems_Should_Return_404_When_DecoTemplate_Missing()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.None);
+
+        IActionResult result = await _controller.GetItems(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
+    [Test]
+    public async Task Replace_Should_Return_200_With_Refreshed_DecoTemplate_And_Map_Items()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 7, "Morning")));
+        _mediator.Send(Arg.Any<ReplaceDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, List<DecoTemplateItemViewModel>>([]));
+        _mediator.Send(Arg.Any<GetDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateItemViewModel>
+            {
+                MakeItem(10, "Morning Bumper", TimeSpan.FromHours(6), TimeSpan.FromHours(7))
+            });
+
+        IActionResult result = await _controller.Replace(
+            4,
+            new ReplaceDecoTemplateRequest(
+                "Morning",
+                [new DecoTemplateItemRequest(10, TimeSpan.FromHours(6), TimeSpan.FromHours(7))]),
+            CancellationToken.None);
+
+        var body = result.ShouldBeOfType<OkObjectResult>().Value
+            .ShouldBeOfType<DecoTemplateWithItemsResponseModel>();
+        body.Id.ShouldBe(4);
+        body.Items.Count.ShouldBe(1);
+        await _mediator.Received(1).Send(
+            Arg.Is<ReplaceDecoTemplateItems>(c =>
+                c.DecoTemplateId == 4 &&
+                c.DecoTemplateGroupId == 7 &&
+                c.Name == "Morning" &&
+                c.Items.Count == 1 &&
+                c.Items[0].DecoId == 10 &&
+                c.Items[0].StartTime == TimeSpan.FromHours(6) &&
+                c.Items[0].EndTime == TimeSpan.FromHours(7)),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Replace_Should_Return_404_When_DecoTemplate_Missing()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.None);
+
+        IActionResult result = await _controller.Replace(
+            4,
+            new ReplaceDecoTemplateRequest("Morning", []),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<ReplaceDecoTemplateItems>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Replace_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 7, "Morning")));
+        _mediator.Send(Arg.Any<ReplaceDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, List<DecoTemplateItemViewModel>>(BaseError.New("overlap")));
+
+        IActionResult result = await _controller.Replace(
+            4,
+            new ReplaceDecoTemplateRequest("Morning", []),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<GetDecoTemplateItems>(), Arg.Any<CancellationToken>());
+    }
+
+    private static DecoTemplateViewModel MakeDecoTemplate(int id, int groupId, string name) =>
+        new(id, groupId, "Group", name);
+
+    private static DecoTemplateItemViewModel MakeItem(int decoId, string decoName, TimeSpan startTime, TimeSpan endTime)
+    {
+        DateTime start = DateTime.Today.Add(startTime);
+        DateTime end = DateTime.Today.Add(endTime);
+        if (start > end)
+        {
+            end = end.AddDays(1);
+        }
+
+        return new DecoTemplateItemViewModel(decoId, decoName, start, end);
+    }
+
+    private static void ShouldHaveActionRoute(string actionName, string httpMethod, string route)
+    {
+        MethodInfo action = typeof(DecoTemplateController).GetMethod(actionName)
+            ?? throw new AssertionException($"Missing action {actionName}");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain(httpMethod);
+        attribute.Template.ShouldBe(route);
+    }
+}

ErsatzTV/Controllers/Api/DecoTemplateController.cs

@@ -0,0 +1,221 @@
+using System.ComponentModel.DataAnnotations;
+using ErsatzTV.Application.Scheduling;
+using ErsatzTV.Controllers.Api.Requests;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Scheduling;
+using ErsatzTV.Extensions;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class DecoTemplateController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/deco-templates/groups", Name = "GetDecoTemplateGroups")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Get all deco template groups")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<DecoTemplateGroupResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<DecoTemplateGroupResponseModel>> GetGroups(CancellationToken cancellationToken)
+    {
+        List<DecoTemplateGroupViewModel> groups =
+            await mediator.Send(new GetAllDecoTemplateGroups(), cancellationToken);
+        return groups.Map(ProjectToResponseModel).ToList();
+    }
+
+    [HttpPost("/api/deco-templates/groups")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Create a deco template group")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(DecoTemplateGroupResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> CreateGroup(
+        [Required] [FromBody] CreateDecoTemplateGroupRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, DecoTemplateGroupViewModel> result =
+            await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToCreatedResult(
+            vm => $"/api/deco-templates/groups/{vm.Id}",
+            vm => ProjectToResponseModel(vm));
+    }
+
+    [HttpDelete("/api/deco-templates/groups/{id:int}")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Delete a deco template group")]
+    [EndpointDescription(
+        "Deletes the deco template group. The database cascade removes every deco template (and its items) in " +
+        "the group; any playout template that used a removed deco template has that reference cleared.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> DeleteGroup(int id, CancellationToken cancellationToken)
+    {
+        List<DecoTemplateGroupViewModel> groups =
+            await mediator.Send(new GetAllDecoTemplateGroups(), cancellationToken);
+        if (groups.All(g => g.Id != id))
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        Option<BaseError> result = await mediator.Send(new DeleteDecoTemplateGroup(id), cancellationToken);
+        return result.Match<IActionResult>(
+            Some: error => error.ToErrorResult(),
+            None: () => new NoContentResult());
+    }
+
+    [HttpGet("/api/deco-templates")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Get all deco templates")]
+    [EndpointDescription(
+        "Returns every deco template as a flat list, ordered by group name then deco template name.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<DecoTemplateResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<DecoTemplateResponseModel>> GetAll(CancellationToken cancellationToken)
+    {
+        List<DecoTemplateGroupViewModel> groups =
+            await mediator.Send(new GetAllDecoTemplateGroups(), cancellationToken);
+        var result = new List<DecoTemplateResponseModel>();
+        foreach (DecoTemplateGroupViewModel group in groups)
+        {
+            List<DecoTemplateViewModel> decoTemplates =
+                await mediator.Send(new GetDecoTemplatesByDecoTemplateGroupId(group.Id), cancellationToken);
+            result.AddRange(decoTemplates.Map(ProjectToResponseModel));
+        }
+
+        return result;
+    }
+
+    [HttpGet("/api/deco-templates/{id:int}", Name = "GetDecoTemplateById")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Get a deco template by id")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(DecoTemplateResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetById(int id, CancellationToken cancellationToken)
+    {
+        Option<DecoTemplateViewModel> result = await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+        return result.Map(ProjectToResponseModel).ToGetResult();
+    }
+
+    [HttpPost("/api/deco-templates")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Create a deco template")]
+    [EndpointDescription("Creates an empty deco template in the given deco template group.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(DecoTemplateResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Create(
+        [Required] [FromBody] CreateDecoTemplateRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, DecoTemplateViewModel> result =
+            await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToCreatedResult(
+            vm => $"/api/deco-templates/{vm.Id}",
+            vm => ProjectToResponseModel(vm));
+    }
+
+    [HttpDelete("/api/deco-templates/{id:int}")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Delete a deco template")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(int id, CancellationToken cancellationToken)
+    {
+        Option<DecoTemplateViewModel> existing = await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+        if (existing.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        Option<BaseError> result = await mediator.Send(new DeleteDecoTemplate(id), cancellationToken);
+        return result.Match<IActionResult>(
+            Some: error => error.ToErrorResult(),
+            None: () => new NoContentResult());
+    }
+
+    [HttpGet("/api/deco-templates/{id:int}/items")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Get deco template items")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<DecoTemplateItemResponseModel>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetItems(int id, CancellationToken cancellationToken)
+    {
+        Option<DecoTemplateViewModel> decoTemplate = await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+        if (decoTemplate.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        List<DecoTemplateItemViewModel> items = await mediator.Send(new GetDecoTemplateItems(id), cancellationToken);
+        return new OkObjectResult(
+            items.OrderBy(i => i.StartTime.TimeOfDay).Map(ProjectToResponseModel).ToList());
+    }
+
+    [HttpPut("/api/deco-templates/{id:int}")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Replace a deco template and its items")]
+    [EndpointDescription(
+        "Replaces the deco template's name and its full item list. Each item assigns a deco to a start/end time " +
+        "of day; an end time of 00:00:00 means the item runs to the end of the day. Items must not overlap.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(DecoTemplateWithItemsResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Replace(
+        int id,
+        [Required] [FromBody] ReplaceDecoTemplateRequest request,
+        CancellationToken cancellationToken)
+    {
+        Option<DecoTemplateViewModel> maybeDecoTemplate =
+            await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+        if (maybeDecoTemplate.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        int decoTemplateGroupId = maybeDecoTemplate.Map(t => t.DecoTemplateGroupId).IfNone(0);
+
+        Either<BaseError, List<DecoTemplateItemViewModel>> result =
+            await mediator.Send(request.ToCommand(decoTemplateGroupId, id), cancellationToken);
+
+        return await result.Match(
+            Left: error => Task.FromResult(error.ToErrorResult()),
+            Right: async _ =>
+            {
+                Option<DecoTemplateViewModel> refreshed =
+                    await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+                List<DecoTemplateItemViewModel> items =
+                    await mediator.Send(new GetDecoTemplateItems(id), cancellationToken);
+                return refreshed.Match(
+                    Some: vm => (IActionResult)new OkObjectResult(ProjectToWithItemsResponseModel(vm, items)),
+                    None: () => ApiResults.NotFoundProblem());
+            });
+    }
+
+    private static DecoTemplateGroupResponseModel ProjectToResponseModel(DecoTemplateGroupViewModel vm) =>
+        new(vm.Id, vm.Name, vm.DecoTemplateCount);
+
+    private static DecoTemplateResponseModel ProjectToResponseModel(DecoTemplateViewModel vm) =>
+        new(vm.Id, vm.DecoTemplateGroupId, vm.GroupName, vm.Name);
+
+    private static DecoTemplateWithItemsResponseModel ProjectToWithItemsResponseModel(
+        DecoTemplateViewModel vm,
+        List<DecoTemplateItemViewModel> items) =>
+        new(
+            vm.Id,
+            vm.DecoTemplateGroupId,
+            vm.GroupName,
+            vm.Name,
+            items.OrderBy(i => i.StartTime.TimeOfDay).Map(ProjectToResponseModel).ToList());
+
+    private static DecoTemplateItemResponseModel ProjectToResponseModel(DecoTemplateItemViewModel vm) =>
+        new(vm.DecoId, vm.DecoName, vm.StartTime.TimeOfDay, vm.EndTime.TimeOfDay);
+}

ErsatzTV/Controllers/Api/Requests/CreateDecoTemplateGroupRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record CreateDecoTemplateGroupRequest(string Name)
+{
+    public CreateDecoTemplateGroup ToCommand() => new(Name);
+}

ErsatzTV/Controllers/Api/Requests/CreateDecoTemplateRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record CreateDecoTemplateRequest(int DecoTemplateGroupId, string Name)
+{
+    public CreateDecoTemplate ToCommand() => new(DecoTemplateGroupId, Name);
+}

ErsatzTV/Controllers/Api/Requests/DecoTemplateItemRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record DecoTemplateItemRequest(int DecoId, TimeSpan StartTime, TimeSpan EndTime)
+{
+    public ReplaceDecoTemplateItem ToReplaceItem() => new(DecoId, StartTime, EndTime);
+}

ErsatzTV/Controllers/Api/Requests/ReplaceDecoTemplateRequest.cs

@@ -0,0 +1,13 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record ReplaceDecoTemplateRequest(string Name, List<DecoTemplateItemRequest> Items)
+{
+    public ReplaceDecoTemplateItems ToCommand(int decoTemplateGroupId, int decoTemplateId) =>
+        new(
+            decoTemplateId,
+            decoTemplateGroupId,
+            Name,
+            (Items ?? []).Select(item => item.ToReplaceItem()).ToList());
+}

ErsatzTV/wwwroot/openapi/v1.json

@@ -3247,6 +3247,597 @@
         }
       }
     },
+    "/api/deco-templates/groups": {
+      "get": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Get all deco template groups",
+        "operationId": "GetDecoTemplateGroups",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                  }
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                  }
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Create a deco template group",
+        "requestBody": {
+          "content": {
+            "application/json-patch+json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateGroupRequest"
+              }
+            },
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateGroupRequest"
+              }
+            },
+            "text/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateGroupRequest"
+              }
+            },
+            "application/*+json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateGroupRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Unprocessable Entity",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/deco-templates/groups/{id}": {
+      "delete": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Delete a deco template group",
+        "description": "Deletes the deco template group. The database cascade removes every deco template (and its items) in the group; any playout template that used a removed deco template has that reference cleared.",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/deco-templates": {
+      "get": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Get all deco templates",
+        "description": "Returns every deco template as a flat list, ordered by group name then deco template name.",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                  }
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                  }
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Create a deco template",
+        "description": "Creates an empty deco template in the given deco template group.",
+        "requestBody": {
+          "content": {
+            "application/json-patch+json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateRequest"
+              }
+            },
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateRequest"
+              }
+            },
+            "text/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateRequest"
+              }
+            },
+            "application/*+json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Unprocessable Entity",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/deco-templates/{id}": {
+      "get": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Get a deco template by id",
+        "operationId": "GetDecoTemplateById",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Delete a deco template",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Replace a deco template and its items",
+        "description": "Replaces the deco template's name and its full item list. Each item assigns a deco to a start/end time of day; an end time of 00:00:00 means the item runs to the end of the day. Items must not overlap.",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json-patch+json": {
+              "schema": {
+                "$ref": "#/components/schemas/ReplaceDecoTemplateRequest"
+              }
+            },
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ReplaceDecoTemplateRequest"
+              }
+            },
+            "text/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ReplaceDecoTemplateRequest"
+              }
+            },
+            "application/*+json": {
+              "schema": {
+                "$ref": "#/components/schemas/ReplaceDecoTemplateRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateWithItemsResponseModel"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateWithItemsResponseModel"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateWithItemsResponseModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Unprocessable Entity",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/deco-templates/{id}/items": {
+      "get": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Get deco template items",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateItemResponseModel"
+                  }
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateItemResponseModel"
+                  }
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateItemResponseModel"
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/ffmpeg/profiles": {
       "get": {
         "tags": [
@@ -11876,6 +12467,39 @@
           }
         }
       },
+      "CreateDecoTemplateGroupRequest": {
+        "required": [
+          "name"
+        ],
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": [
+              "null",
+              "string"
+            ]
+          }
+        }
+      },
+      "CreateDecoTemplateRequest": {
+        "required": [
+          "decoTemplateGroupId",
+          "name"
+        ],
+        "type": "object",
+        "properties": {
+          "decoTemplateGroupId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "name": {
+            "type": [
+              "null",
+              "string"
+            ]
+          }
+        }
+      },
       "CreateFFmpegProfileRequest": {
         "required": [
           "name",
@@ -12724,6 +13348,132 @@
           }
         }
       },
+      "DecoTemplateGroupResponseModel": {
+        "required": [
+          "id",
+          "name",
+          "decoTemplateCount"
+        ],
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "name": {
+            "type": "string"
+          },
+          "decoTemplateCount": {
+            "type": "integer",
+            "format": "int32"
+          }
+        }
+      },
+      "DecoTemplateItemRequest": {
+        "required": [
+          "decoId",
+          "startTime",
+          "endTime"
+        ],
+        "type": "object",
+        "properties": {
+          "decoId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "startTime": {
+            "pattern": "^-?(\\d+\\.)?\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,7})?$",
+            "type": "string"
+          },
+          "endTime": {
+            "pattern": "^-?(\\d+\\.)?\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,7})?$",
+            "type": "string"
+          }
+        }
+      },
+      "DecoTemplateItemResponseModel": {
+        "required": [
+          "decoId",
+          "decoName",
+          "startTime",
+          "endTime"
+        ],
+        "type": "object",
+        "properties": {
+          "decoId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "decoName": {
+            "type": "string"
+          },
+          "startTime": {
+            "pattern": "^-?(\\d+\\.)?\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,7})?$",
+            "type": "string"
+          },
+          "endTime": {
+            "pattern": "^-?(\\d+\\.)?\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,7})?$",
+            "type": "string"
+          }
+        }
+      },
+      "DecoTemplateResponseModel": {
+        "required": [
+          "id",
+          "decoTemplateGroupId",
+          "groupName",
+          "name"
+        ],
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "decoTemplateGroupId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "groupName": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          }
+        }
+      },
+      "DecoTemplateWithItemsResponseModel": {
+        "required": [
+          "id",
+          "decoTemplateGroupId",
+          "groupName",
+          "name",
+          "items"
+        ],
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "decoTemplateGroupId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "groupName": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          },
+          "items": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/DecoTemplateItemResponseModel"
+            }
+          }
+        }
+      },
       "DeleteMediaItemsRequest": {
         "required": [
           "ids"
@@ -14815,6 +15565,30 @@
           }
         }
       },
+      "ReplaceDecoTemplateRequest": {
+        "required": [
+          "name",
+          "items"
+        ],
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "items": {
+            "type": [
+              "null",
+              "array"
+            ],
+            "items": {
+              "$ref": "#/components/schemas/DecoTemplateItemRequest"
+            }
+          }
+        }
+      },
       "ReplaceScheduleItemsRequest": {
         "required": [
           "items"
@@ -16927,6 +17701,9 @@
     {
       "name": "Decos"
     },
+    {
+      "name": "DecoTemplates"
+    },
     {
       "name": "FFmpeg Profiles"
     },

web/src/App.tsx

@@ -15,6 +15,7 @@ import {
   Palette,
   CalendarClock,
   CalendarDays,
+  CalendarRange,
   Cast,
   Check,
   ChevronDown,
@@ -75,6 +76,7 @@ import { TroubleshootingScreen } from './screens/TroubleshootingScreen';
 import { WatermarksScreen } from './screens/WatermarksScreen';
 import { BlocksScreen } from './screens/BlocksScreen';
 import { DecosScreen } from './screens/DecosScreen';
+import { DecoTemplatesScreen } from './screens/DecoTemplatesScreen';
 import { TemplatesScreen } from './screens/TemplatesScreen';
 import { navigateToPath } from './routing';
 import {
@@ -158,6 +160,7 @@ type ScreenId =
   | 'blocks'
   | 'templates'
   | 'decos'
+  | 'decoTemplates'
   | 'playouts'
   | 'media'
   | 'search'
@@ -298,6 +301,19 @@ const routes: ScreenRoute[] = [
     placeholder: 'Decos workspace',
     allowSubPaths: true
   },
+  {
+    // The editor lives at a sub-path (/app/deco-templates/{id}); DecoTemplatesScreen owns parsing the id suffix.
+    id: 'decoTemplates',
+    path: '/app/deco-templates',
+    label: 'Deco Templates',
+    title: 'Deco Templates',
+    kicker: 'Programming',
+    description: 'Group deco templates and assign decos to times of day.',
+    icon: <CalendarRange aria-hidden="true" size={16} />,
+    primaryAction: 'New Group',
+    placeholder: 'Deco templates workspace',
+    allowSubPaths: true
+  },
   {
     id: 'playouts',
     path: '/app/playouts',
@@ -464,6 +480,7 @@ const primaryNavIds: ScreenId[] = [
   'blocks',
   'templates',
   'decos',
+  'decoTemplates',
   'playouts'
 ];
 const mediaNavIds: ScreenId[] = [
@@ -3440,6 +3457,10 @@ function ScreenContent({
     return <DecosScreen key={window.location.pathname} />;
   }
 
+  if (route.id === 'decoTemplates') {
+    return <DecoTemplatesScreen key={window.location.pathname} />;
+  }
+
   if (route.id === 'playouts') {
     return <PlayoutsScreen />;
   }

web/src/api/decoTemplates.test.ts

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  createDecoTemplate,
+  createDecoTemplateGroup,
+  deleteDecoTemplate,
+  deleteDecoTemplateGroup,
+  getDecoTemplate,
+  getDecoTemplateGroups,
+  getDecoTemplateItems,
+  getDecoTemplates,
+  replaceDecoTemplate,
+  type ReplaceDecoTemplateRequest
+} from './decoTemplates';
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { headers: { 'Content-Type': 'application/json' }, status });
+}
+
+function noContent(): Response {
+  return new Response(null, { status: 204 });
+}
+
+const sampleReplace: ReplaceDecoTemplateRequest = {
+  name: 'Weekdays',
+  items: [{ decoId: 10, startTime: '06:00:00', endTime: '07:00:00' }]
+};
+
+describe('decoTemplates api client', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+    vi.restoreAllMocks();
+  });
+
+  it('getDecoTemplateGroups fetches all deco template groups', async () => {
+    const fetchMock = vi
+      .spyOn(window, 'fetch')
+      .mockResolvedValue(jsonResponse([{ id: 1, name: 'Weekday', decoTemplateCount: 2 }]));
+    await expect(getDecoTemplateGroups()).resolves.toHaveLength(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/deco-templates/groups',
+      expect.objectContaining({ method: 'GET' })
+    );
+  });
+
+  it('createDecoTemplateGroup POSTs the name', async () => {
+    const fetchMock = vi
+      .spyOn(window, 'fetch')
+      .mockResolvedValue(jsonResponse({ id: 3, name: 'Weekday', decoTemplateCount: 0 }, 201));
+    await createDecoTemplateGroup({ name: 'Weekday' });
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe('/api/deco-templates/groups');
+    expect(init).toMatchObject({ method: 'POST' });
+    expect(JSON.parse(String(init?.body)).name).toBe('Weekday');
+  });
+
+  it('deleteDecoTemplateGroup DELETEs by id', async () => {
+    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(noContent());
+    await expect(deleteDecoTemplateGroup(3)).resolves.toBeUndefined();
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/deco-templates/groups/3',
+      expect.objectContaining({ method: 'DELETE' })
+    );
+  });
+
+  it('getDecoTemplates fetches all deco templates', async () => {
+    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse([]));
+    await getDecoTemplates();
+    expect(fetchMock).toHaveBeenCalledWith('/api/deco-templates', expect.objectContaining({ method: 'GET' }));
+  });
+
+  it('getDecoTemplate fetches a deco template by id', async () => {
+    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ id: 4 }));
+    await getDecoTemplate(4);
+    expect(fetchMock).toHaveBeenCalledWith('/api/deco-templates/4', expect.objectContaining({ method: 'GET' }));
+  });
+
+  it('createDecoTemplate POSTs group id and name', async () => {
+    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ id: 8 }, 201));
+    await createDecoTemplate({ decoTemplateGroupId: 2, name: 'Weekdays' });
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe('/api/deco-templates');
+    expect(init).toMatchObject({ method: 'POST' });
+    expect(JSON.parse(String(init?.body))).toMatchObject({ decoTemplateGroupId: 2, name: 'Weekdays' });
+  });
+
+  it('deleteDecoTemplate DELETEs by id', async () => {
+    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(noContent());
+    await deleteDecoTemplate(4);
+    expect(fetchMock).toHaveBeenCalledWith('/api/deco-templates/4', expect.objectContaining({ method: 'DELETE' }));
+  });
+
+  it('getDecoTemplateItems fetches items for a deco template', async () => {
+    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse([]));
+    await getDecoTemplateItems(4);
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/deco-templates/4/items',
+      expect.objectContaining({ method: 'GET' })
+    );
+  });
+
+  it('replaceDecoTemplate PUTs the full deco template body', async () => {
+    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ id: 4, items: [] }));
+    await replaceDecoTemplate(4, sampleReplace);
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe('/api/deco-templates/4');
+    expect(init).toMatchObject({ method: 'PUT' });
+    const body = JSON.parse(String(init?.body));
+    expect(body.name).toBe('Weekdays');
+    expect(body.items).toHaveLength(1);
+    expect(body.items[0]).toMatchObject({ decoId: 10, startTime: '06:00:00', endTime: '07:00:00' });
+  });
+});

web/src/api/decoTemplates.ts

@@ -0,0 +1,63 @@
+import { ApiError, request } from './client';
+import type { components } from './generated/v1';
+
+export type DecoTemplateGroup = components['schemas']['DecoTemplateGroupResponseModel'];
+export type DecoTemplate = components['schemas']['DecoTemplateResponseModel'];
+export type DecoTemplateItem = components['schemas']['DecoTemplateItemResponseModel'];
+export type DecoTemplateWithItems = components['schemas']['DecoTemplateWithItemsResponseModel'];
+export type CreateDecoTemplateGroupRequest = components['schemas']['CreateDecoTemplateGroupRequest'];
+export type CreateDecoTemplateRequest = components['schemas']['CreateDecoTemplateRequest'];
+export type ReplaceDecoTemplateRequest = components['schemas']['ReplaceDecoTemplateRequest'];
+export type DecoTemplateItemRequest = components['schemas']['DecoTemplateItemRequest'];
+
+// Deco template groups
+
+export function getDecoTemplateGroups(): Promise<DecoTemplateGroup[]> {
+  return request<DecoTemplateGroup[]>('/api/deco-templates/groups');
+}
+
+export function createDecoTemplateGroup(body: CreateDecoTemplateGroupRequest): Promise<DecoTemplateGroup> {
+  return request<DecoTemplateGroup>('/api/deco-templates/groups', { body, method: 'POST' });
+}
+
+export function deleteDecoTemplateGroup(id: number): Promise<void> {
+  return request<void>(`/api/deco-templates/groups/${id}`, { method: 'DELETE' });
+}
+
+// Deco templates
+
+export function getDecoTemplates(): Promise<DecoTemplate[]> {
+  return request<DecoTemplate[]>('/api/deco-templates');
+}
+
+export function getDecoTemplate(id: number): Promise<DecoTemplate> {
+  return request<DecoTemplate>(`/api/deco-templates/${id}`);
+}
+
+export function createDecoTemplate(body: CreateDecoTemplateRequest): Promise<DecoTemplate> {
+  return request<DecoTemplate>('/api/deco-templates', { body, method: 'POST' });
+}
+
+export function deleteDecoTemplate(id: number): Promise<void> {
+  return request<void>(`/api/deco-templates/${id}`, { method: 'DELETE' });
+}
+
+export function getDecoTemplateItems(id: number): Promise<DecoTemplateItem[]> {
+  return request<DecoTemplateItem[]>(`/api/deco-templates/${id}/items`);
+}
+
+export function replaceDecoTemplate(id: number, body: ReplaceDecoTemplateRequest): Promise<DecoTemplateWithItems> {
+  return request<DecoTemplateWithItems>(`/api/deco-templates/${id}`, { body, method: 'PUT' });
+}
+
+export function messageFromDecoTemplateError(error: unknown, fallback = 'Unable to load deco templates'): string {
+  if (error instanceof ApiError) {
+    return error.detail ?? error.message;
+  }
+
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return fallback;
+}

web/src/api/generated/v1.d.ts

@@ -358,6 +358,13 @@ export interface components {
     "CreateDecoRequest": {
     "decoGroupId": number;
     "name": null | string;
+  };
+    "CreateDecoTemplateGroupRequest": {
+    "name": null | string;
+  };
+    "CreateDecoTemplateRequest": {
+    "decoTemplateGroupId": number;
+    "name": null | string;
   };
     "CreateFFmpegProfileRequest": {
     "name": null | string;
@@ -518,6 +525,35 @@ export interface components {
     "deadAirFallbackMultiCollectionId": null | number;
     "deadAirFallbackSmartCollectionId": null | number;
     "deadAirFallbackSelectionName": null | string;
+  };
+    "DecoTemplateGroupResponseModel": {
+    "id": number;
+    "name": string;
+    "decoTemplateCount": number;
+  };
+    "DecoTemplateItemRequest": {
+    "decoId": number;
+    "startTime": string;
+    "endTime": string;
+  };
+    "DecoTemplateItemResponseModel": {
+    "decoId": number;
+    "decoName": string;
+    "startTime": string;
+    "endTime": string;
+  };
+    "DecoTemplateResponseModel": {
+    "id": number;
+    "decoTemplateGroupId": number;
+    "groupName": string;
+    "name": string;
+  };
+    "DecoTemplateWithItemsResponseModel": {
+    "id": number;
+    "decoTemplateGroupId": number;
+    "groupName": string;
+    "name": string;
+    "items": Array<components["schemas"]["DecoTemplateItemResponseModel"]>;
   };
     "DeleteMediaItemsRequest": {
     "ids": null | Array<number>;
@@ -909,6 +945,10 @@ export interface components {
     "deadAirFallbackMediaItemId": null | number;
     "deadAirFallbackMultiCollectionId": null | number;
     "deadAirFallbackSmartCollectionId": null | number;
+  };
+    "ReplaceDecoTemplateRequest": {
+    "name": null | string;
+    "items": null | Array<components["schemas"]["DecoTemplateItemRequest"]>;
   };
     "ReplaceScheduleItemsRequest": {
     "items": null | Array<components["schemas"]["ScheduleItemRequest"]>;

web/src/api/index.ts

@@ -7,6 +7,7 @@ export * from './client';
 export * from './collections';
 export * from './dashboard';
 export * from './decos';
+export * from './decoTemplates';
 export * from './ffmpegProfiles';
 export * from './fillerPresets';
 export * from './guide';

web/src/screens/DecoTemplatesScreen.test.tsx

@@ -0,0 +1,188 @@
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { DecoTemplatesScreen } from './DecoTemplatesScreen';
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { headers: { 'Content-Type': 'application/json' }, status });
+}
+
+const groups = [{ id: 2, name: 'Weekday', decoTemplateCount: 1 }];
+const decoTemplates = [{ id: 4, decoTemplateGroupId: 2, groupName: 'Weekday', name: 'Bumpers' }];
+const decoGroups = [{ id: 1, name: 'Morning Decos' }];
+const decos = [{ id: 10, decoGroupId: 1, decoGroupName: 'Morning Decos', name: 'Sunrise' }];
+
+interface MockOptions {
+  items?: unknown[];
+  onRequest?: (url: string, method: string, body: unknown) => Response | null;
+}
+
+function mockApi(options: MockOptions = {}) {
+  const items = options.items ?? [];
+
+  return vi.spyOn(window, 'fetch').mockImplementation((input: RequestInfo | URL, init?: RequestInit) => {
+    const url = input.toString();
+    const method = (init?.method ?? 'GET').toUpperCase();
+    const body = init?.body ? JSON.parse(String(init.body)) : undefined;
+
+    if (options.onRequest) {
+      const override = options.onRequest(url, method, body);
+      if (override) {
+        return Promise.resolve(override);
+      }
+    }
+
+    if (url === '/api/deco-templates/groups' && method === 'GET') {
+      return Promise.resolve(jsonResponse(groups));
+    }
+    if (url === '/api/deco-templates' && method === 'GET') {
+      return Promise.resolve(jsonResponse(decoTemplates));
+    }
+    if (url === '/api/deco-templates/4' && method === 'GET') {
+      return Promise.resolve(jsonResponse(decoTemplates[0]));
+    }
+    if (url === '/api/deco-templates/4/items' && method === 'GET') {
+      return Promise.resolve(jsonResponse(items));
+    }
+    if (url === '/api/decos/groups' && method === 'GET') {
+      return Promise.resolve(jsonResponse(decoGroups));
+    }
+    if (url === '/api/decos' && method === 'GET') {
+      return Promise.resolve(jsonResponse(decos));
+    }
+    if (url === '/api/deco-templates/4' && method === 'PUT') {
+      return Promise.resolve(jsonResponse({ ...decoTemplates[0], items: [] }));
+    }
+
+    return Promise.resolve(new Response(null, { status: 204 }));
+  });
+}
+
+describe('DecoTemplatesScreen', () => {
+  afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+    window.history.pushState({}, '', '/app/deco-templates');
+  });
+
+  beforeEach(() => {
+    window.localStorage.clear();
+    window.history.pushState({}, '', '/app/deco-templates');
+  });
+
+  it('renders deco template groups and their deco templates', async () => {
+    mockApi();
+    render(<DecoTemplatesScreen />);
+
+    expect(await screen.findByText('Weekday')).toBeInTheDocument();
+    expect(screen.getByText('Bumpers')).toBeInTheDocument();
+  });
+
+  it('loads the editor at a sub-path and lists items sorted by start time', async () => {
+    window.history.pushState({}, '', '/app/deco-templates/4');
+    mockApi({
+      items: [
+        { decoId: 10, decoName: 'Sunrise', startTime: '12:00:00', endTime: '13:00:00' },
+        { decoId: 10, decoName: 'Sunrise', startTime: '06:00:00', endTime: '07:00:00' }
+      ]
+    });
+    render(<DecoTemplatesScreen />);
+
+    await waitFor(() => expect(screen.getByDisplayValue('Bumpers')).toBeInTheDocument());
+
+    const rows = screen.getAllByText(/^\d{2}:\d{2}-\d{2}:\d{2}$/);
+    expect(rows[0]).toHaveTextContent('06:00-07:00');
+    expect(rows[1]).toHaveTextContent('12:00-13:00');
+  });
+
+  it('renders an end-of-day item as ending at 24:00', async () => {
+    window.history.pushState({}, '', '/app/deco-templates/4');
+    mockApi({
+      items: [{ decoId: 10, decoName: 'Sunrise', startTime: '22:00:00', endTime: '00:00:00' }]
+    });
+    render(<DecoTemplatesScreen />);
+
+    await waitFor(() => expect(screen.getByDisplayValue('Bumpers')).toBeInTheDocument());
+
+    expect(screen.getByText('22:00-24:00')).toBeInTheDocument();
+  });
+
+  it('adds an item via the deco group/deco/start-time/duration pickers', async () => {
+    window.history.pushState({}, '', '/app/deco-templates/4');
+    mockApi({ items: [] });
+    render(<DecoTemplatesScreen />);
+
+    await waitFor(() => expect(screen.getByDisplayValue('Bumpers')).toBeInTheDocument());
+
+    fireEvent.change(screen.getByLabelText('Deco group'), { target: { value: '1' } });
+    fireEvent.change(screen.getByLabelText('Deco'), { target: { value: '10' } });
+    fireEvent.change(screen.getByLabelText('Hours'), { target: { value: '1' } });
+    fireEvent.click(screen.getByRole('button', { name: 'Add' }));
+
+    const cell = await screen.findByRole('cell', { name: 'Sunrise' });
+    expect(cell).toBeInTheDocument();
+  });
+
+  it('saves the deco template with items via PUT', async () => {
+    window.history.pushState({}, '', '/app/deco-templates/4');
+    const fetchMock = mockApi({
+      items: [{ decoId: 10, decoName: 'Sunrise', startTime: '06:00:00', endTime: '07:00:00' }]
+    });
+    render(<DecoTemplatesScreen />);
+
+    await waitFor(() => expect(screen.getByDisplayValue('Bumpers')).toBeInTheDocument());
+    fireEvent.click(screen.getByRole('button', { name: /Save deco template/ }));
+
+    await waitFor(() => {
+      const call = fetchMock.mock.calls.find(([u, init]) => u === '/api/deco-templates/4' && init?.method === 'PUT');
+      expect(call).toBeTruthy();
+    });
+
+    const putCall = fetchMock.mock.calls.find(([u, init]) => u === '/api/deco-templates/4' && init?.method === 'PUT');
+    const sent = JSON.parse(String(putCall?.[1]?.body));
+    expect(sent.name).toBe('Bumpers');
+    expect(sent.items).toEqual([{ decoId: 10, startTime: '06:00:00', endTime: '07:00:00' }]);
+  });
+
+  it('shows an ordering warning and blocks save when an item starts on or after its end time', async () => {
+    window.history.pushState({}, '', '/app/deco-templates/4');
+    mockApi({
+      items: [{ decoId: 10, decoName: 'Sunrise', startTime: '12:00:00', endTime: '11:00:00' }]
+    });
+    render(<DecoTemplatesScreen />);
+
+    await waitFor(() => expect(screen.getByDisplayValue('Bumpers')).toBeInTheDocument());
+
+    expect(await screen.findByText(/must start before it ends/)).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /Save deco template/ })).toBeDisabled();
+  });
+
+  it('shows an overlap warning and blocks save when two items intersect', async () => {
+    window.history.pushState({}, '', '/app/deco-templates/4');
+    mockApi({
+      items: [
+        { decoId: 10, decoName: 'Sunrise', startTime: '06:00:00', endTime: '07:00:00' },
+        { decoId: 10, decoName: 'Sunrise', startTime: '06:30:00', endTime: '07:30:00' }
+      ]
+    });
+    render(<DecoTemplatesScreen />);
+
+    await waitFor(() => expect(screen.getByDisplayValue('Bumpers')).toBeInTheDocument());
+
+    expect(await screen.findByText(/overlaps/)).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /Save deco template/ })).toBeDisabled();
+  });
+
+  it('treats an end-of-day item (endTime 00:00:00) as not overlapping the very start of the next day', async () => {
+    window.history.pushState({}, '', '/app/deco-templates/4');
+    mockApi({
+      items: [{ decoId: 10, decoName: 'Sunrise', startTime: '22:00:00', endTime: '00:00:00' }]
+    });
+    render(<DecoTemplatesScreen />);
+
+    await waitFor(() => expect(screen.getByDisplayValue('Bumpers')).toBeInTheDocument());
+
+    expect(screen.queryByText(/overlaps/)).not.toBeInTheDocument();
+    expect(screen.queryByText(/must start before it ends/)).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /Save deco template/ })).not.toBeDisabled();
+  });
+});

web/src/screens/DecoTemplatesScreen.tsx

@@ -0,0 +1,763 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { ArrowLeft, Check, FolderPlus, Plus, Trash2, TriangleAlert } from 'lucide-react';
+import { navigateToPath } from '../routing';
+import { Badge, Button, Card, ConfirmDialog, Dialog, IconButton, Input, Select, Spinner } from '../components';
+import {
+  createDecoTemplate,
+  createDecoTemplateGroup,
+  deleteDecoTemplate,
+  deleteDecoTemplateGroup,
+  getDecoGroups,
+  getDecoTemplate,
+  getDecoTemplateGroups,
+  getDecoTemplateItems,
+  getDecoTemplates,
+  getDecos,
+  messageFromDecoTemplateError,
+  replaceDecoTemplate,
+  type DecoGroup,
+  type DecoListItem,
+  type DecoTemplate,
+  type DecoTemplateGroup,
+  type DecoTemplateItem
+} from '../api';
+
+const BASE_PATH = '/app/deco-templates';
+const MINUTES_PER_DAY = 24 * 60;
+
+// Every start time is a five-minute increment across a full day (mirrors Blazor DecoTemplateEditor.razor's picker).
+const START_TIME_OPTIONS = Array.from({ length: 288 }, (_, index) => {
+  const totalMinutes = index * 5;
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  const value = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:00`;
+  return { label: value.slice(0, 5), value };
+});
+
+const DURATION_MINUTE_OPTIONS = [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55].map((minutes) => ({
+  label: String(minutes),
+  value: String(minutes)
+}));
+
+function timeToMinutes(time: string): number {
+  const [hours, minutes] = time.split(':').map(Number);
+  return hours * 60 + minutes;
+}
+
+// An end time of 00:00:00 means "end of day" (24:00), not midnight-of-the-same-day; this mirrors
+// ReplaceDecoTemplateItemsHandler.DecoTemplateItemsMustBeValid's EffectiveEndTime treatment.
+function effectiveEndMinutes(endTime: string): number {
+  const minutes = timeToMinutes(endTime);
+  return minutes === 0 ? MINUTES_PER_DAY : minutes;
+}
+
+function minutesToClock(totalMinutes: number): string {
+  if (totalMinutes >= MINUTES_PER_DAY) {
+    return '24:00';
+  }
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
+}
+
+interface DraftItem {
+  key: string;
+  decoId: number;
+  decoName: string;
+  startTime: string;
+  endTime: string;
+}
+
+interface Draft {
+  name: string;
+  items: DraftItem[];
+}
+
+let keySeq = 0;
+function nextKey(): string {
+  keySeq += 1;
+  return `item-${keySeq}`;
+}
+
+function itemFromResponse(item: DecoTemplateItem): DraftItem {
+  return {
+    key: nextKey(),
+    decoId: item.decoId,
+    decoName: item.decoName,
+    startTime: item.startTime,
+    endTime: item.endTime
+  };
+}
+
+// Mirrors DecoTemplateItemsMustBeValid: an item must start before its (effective) end time, and no
+// two items may overlap.
+function findOrderingError(items: DraftItem[]): null | string {
+  for (const item of items) {
+    if (timeToMinutes(item.startTime) >= effectiveEndMinutes(item.endTime)) {
+      return `"${item.decoName}" (${minutesToClock(timeToMinutes(item.startTime))}-${minutesToClock(effectiveEndMinutes(item.endTime))}) must start before it ends`;
+    }
+  }
+
+  return null;
+}
+
+function findOverlap(items: DraftItem[]): null | string {
+  const spans = items.map((item) => ({
+    item,
+    start: timeToMinutes(item.startTime),
+    end: effectiveEndMinutes(item.endTime)
+  }));
+
+  for (let i = 0; i < spans.length; i += 1) {
+    for (let j = i + 1; j < spans.length; j += 1) {
+      const a = spans[i];
+      const b = spans[j];
+      if (a.start < b.end && b.start < a.end) {
+        return `"${a.item.decoName}" (${minutesToClock(a.start)}-${minutesToClock(a.end)}) overlaps "${b.item.decoName}" (${minutesToClock(b.start)}-${minutesToClock(b.end)})`;
+      }
+    }
+  }
+
+  return null;
+}
+
+function validate(draft: Draft): null | string {
+  if (!draft.name.trim()) {
+    return 'Deco template name is required';
+  }
+
+  return findOrderingError(draft.items) ?? findOverlap(draft.items);
+}
+
+type Mode = { id: number; kind: 'edit' } | { kind: 'list' };
+
+function modeFromPath(pathname: string): Mode {
+  const normalized = pathname.replace(/\/+$/, '');
+  if (normalized === BASE_PATH || !normalized.startsWith(`${BASE_PATH}/`)) {
+    return { kind: 'list' };
+  }
+  const suffix = normalized.slice(BASE_PATH.length + 1).split('/')[0];
+  const id = Number(suffix);
+  return Number.isInteger(id) && id > 0 ? { id, kind: 'edit' } : { kind: 'list' };
+}
+
+export function DecoTemplatesScreen() {
+  const [pathname, setPathname] = useState(() => window.location.pathname);
+
+  useEffect(() => {
+    const onPop = () => setPathname(window.location.pathname);
+    window.addEventListener('popstate', onPop);
+    return () => window.removeEventListener('popstate', onPop);
+  }, []);
+
+  const mode = modeFromPath(pathname);
+
+  if (mode.kind === 'list') {
+    return <DecoTemplateList key={pathname} />;
+  }
+
+  return <DecoTemplateEditor decoTemplateId={mode.id} key={pathname} />;
+}
+
+function DecoTemplateList() {
+  const [groups, setGroups] = useState<DecoTemplateGroup[] | null>(null);
+  const [decoTemplates, setDecoTemplates] = useState<DecoTemplate[] | null>(null);
+  const [error, setError] = useState<null | string>(null);
+  const [groupDialogOpen, setGroupDialogOpen] = useState(false);
+  const [newGroupName, setNewGroupName] = useState('');
+  const [decoTemplateDialogGroup, setDecoTemplateDialogGroup] = useState<DecoTemplateGroup | null>(null);
+  const [newDecoTemplateName, setNewDecoTemplateName] = useState('');
+  const [deleteGroupTarget, setDeleteGroupTarget] = useState<DecoTemplateGroup | null>(null);
+  const [deleteDecoTemplateTarget, setDeleteDecoTemplateTarget] = useState<DecoTemplate | null>(null);
+  const [busy, setBusy] = useState(false);
+  const activeRef = useRef(true);
+
+  const load = useCallback(() => {
+    Promise.all([getDecoTemplateGroups(), getDecoTemplates()])
+      .then(([groupData, decoTemplateData]) => {
+        if (activeRef.current) {
+          setGroups(groupData);
+          setDecoTemplates(decoTemplateData);
+          setError(null);
+        }
+      })
+      .catch((loadError: unknown) => {
+        if (activeRef.current) {
+          setError(messageFromDecoTemplateError(loadError));
+        }
+      });
+  }, []);
+
+  useEffect(() => {
+    activeRef.current = true;
+    load();
+    return () => {
+      activeRef.current = false;
+    };
+  }, [load]);
+
+  const createGroup = async () => {
+    if (!newGroupName.trim() || busy) {
+      return;
+    }
+    setBusy(true);
+    try {
+      await createDecoTemplateGroup({ name: newGroupName.trim() });
+      setGroupDialogOpen(false);
+      setNewGroupName('');
+      load();
+    } catch (createError) {
+      setError(messageFromDecoTemplateError(createError, 'Unable to create deco template group'));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const createDecoTemplateInGroup = async () => {
+    if (!decoTemplateDialogGroup || !newDecoTemplateName.trim() || busy) {
+      return;
+    }
+    setBusy(true);
+    try {
+      const decoTemplate = await createDecoTemplate({
+        decoTemplateGroupId: decoTemplateDialogGroup.id,
+        name: newDecoTemplateName.trim()
+      });
+      setDecoTemplateDialogGroup(null);
+      setNewDecoTemplateName('');
+      navigateToPath(`${BASE_PATH}/${decoTemplate.id}`);
+    } catch (createError) {
+      setError(messageFromDecoTemplateError(createError, 'Unable to create deco template'));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const confirmDeleteGroup = async () => {
+    if (!deleteGroupTarget) {
+      return;
+    }
+    setBusy(true);
+    try {
+      await deleteDecoTemplateGroup(deleteGroupTarget.id);
+      setDeleteGroupTarget(null);
+      load();
+    } catch (deleteError) {
+      setError(messageFromDecoTemplateError(deleteError, 'Unable to delete deco template group'));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const confirmDeleteDecoTemplate = async () => {
+    if (!deleteDecoTemplateTarget) {
+      return;
+    }
+    setBusy(true);
+    try {
+      await deleteDecoTemplate(deleteDecoTemplateTarget.id);
+      setDeleteDecoTemplateTarget(null);
+      load();
+    } catch (deleteError) {
+      setError(messageFromDecoTemplateError(deleteError, 'Unable to delete deco template'));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  if (error && (!groups || !decoTemplates)) {
+    return (
+      <div className="ctv-collections">
+        <div className="ctv-channels-error" role="alert">
+          <TriangleAlert aria-hidden="true" size={15} />
+          <span>{error}</span>
+          <span className="ctv-channels-spacer" />
+          <Button onClick={load} size="sm" variant="secondary">
+            Retry
+          </Button>
+        </div>
+      </div>
+    );
+  }
+
+  if (!groups || !decoTemplates) {
+    return (
+      <div className="ctv-collections-loading" role="status">
+        <Spinner size={18} />
+        <span>Loading deco templates…</span>
+      </div>
+    );
+  }
+
+  const sortedGroups = [...groups].sort((a, b) => a.name.localeCompare(b.name));
+
+  return (
+    <div className="ctv-collections">
+      <div className="ctv-channels-actionbar">
+        <Badge tone="neutral">{decoTemplates.length} deco templates</Badge>
+        <span className="ctv-channels-spacer" />
+        <Button
+          onClick={() => {
+            setNewGroupName('');
+            setGroupDialogOpen(true);
+          }}
+          size="sm"
+          startIcon={<FolderPlus aria-hidden="true" size={14} />}
+        >
+          New group
+        </Button>
+      </div>
+
+      {error && (
+        <div className="ctv-channels-error" role="alert">
+          <TriangleAlert aria-hidden="true" size={15} />
+          <span>{error}</span>
+        </div>
+      )}
+
+      {sortedGroups.length === 0 ? (
+        <Card>
+          <div className="ctv-collections-empty">No deco template groups yet. Create one to get started.</div>
+        </Card>
+      ) : (
+        sortedGroups.map((group) => {
+          const groupDecoTemplates = decoTemplates
+            .filter((t) => t.decoTemplateGroupId === group.id && t.id > 0)
+            .sort((a, b) => a.name.localeCompare(b.name));
+          return (
+            <Card
+              key={group.id}
+              padded={false}
+              title={group.name}
+              actions={
+                <div style={{ display: 'flex', gap: 8 }}>
+                  <Button
+                    onClick={() => {
+                      setNewDecoTemplateName('');
+                      setDecoTemplateDialogGroup(group);
+                    }}
+                    size="sm"
+                    startIcon={<Plus aria-hidden="true" size={14} />}
+                    variant="secondary"
+                  >
+                    New deco template
+                  </Button>
+                  <IconButton
+                    onClick={() => setDeleteGroupTarget(group)}
+                    size="sm"
+                    title="Delete group"
+                    variant="ghost"
+                  >
+                    <Trash2 aria-hidden="true" size={14} />
+                  </IconButton>
+                </div>
+              }
+            >
+              {groupDecoTemplates.length === 0 ? (
+                <div className="ctv-collections-empty">No deco templates in this group.</div>
+              ) : (
+                groupDecoTemplates.map((decoTemplate, index) => (
+                  <div
+                    className="ctv-settings-flush-row"
+                    key={decoTemplate.id}
+                    style={index === 0 ? { borderTop: 'none' } : undefined}
+                  >
+                    <button
+                      className="ctv-settings-flush-row-main ctv-settings-flush-row-title ctv-collections-linkbtn"
+                      onClick={() => navigateToPath(`${BASE_PATH}/${decoTemplate.id}`)}
+                      type="button"
+                    >
+                      {decoTemplate.name}
+                    </button>
+                    <IconButton
+                      onClick={() => setDeleteDecoTemplateTarget(decoTemplate)}
+                      size="sm"
+                      title="Delete deco template"
+                      variant="ghost"
+                    >
+                      <Trash2 aria-hidden="true" size={14} />
+                    </IconButton>
+                  </div>
+                ))
+              )}
+            </Card>
+          );
+        })
+      )}
+
+      <Dialog
+        footer={
+          <>
+            <Button onClick={() => setGroupDialogOpen(false)} size="sm" variant="ghost">
+              Cancel
+            </Button>
+            <Button disabled={!newGroupName.trim() || busy} loading={busy} onClick={() => void createGroup()} size="sm">
+              Create
+            </Button>
+          </>
+        }
+        onClose={() => setGroupDialogOpen(false)}
+        open={groupDialogOpen}
+        title="New deco template group"
+      >
+        <Input
+          label="Name"
+          onChange={(event) => setNewGroupName(event.target.value)}
+          placeholder="Deco template group name"
+          value={newGroupName}
+        />
+      </Dialog>
+
+      <Dialog
+        footer={
+          <>
+            <Button onClick={() => setDecoTemplateDialogGroup(null)} size="sm" variant="ghost">
+              Cancel
+            </Button>
+            <Button
+              disabled={!newDecoTemplateName.trim() || busy}
+              loading={busy}
+              onClick={() => void createDecoTemplateInGroup()}
+              size="sm"
+            >
+              Create
+            </Button>
+          </>
+        }
+        onClose={() => setDecoTemplateDialogGroup(null)}
+        open={decoTemplateDialogGroup !== null}
+        title={decoTemplateDialogGroup ? `New deco template in ${decoTemplateDialogGroup.name}` : 'New deco template'}
+      >
+        <Input
+          label="Name"
+          onChange={(event) => setNewDecoTemplateName(event.target.value)}
+          placeholder="Deco template name"
+          value={newDecoTemplateName}
+        />
+      </Dialog>
+
+      <ConfirmDialog
+        busy={busy}
+        confirmLabel="Delete"
+        message={
+          deleteGroupTarget
+            ? `Delete group "${deleteGroupTarget.name}"? Every deco template in it will also be deleted. This cannot be undone.`
+            : ''
+        }
+        onCancel={() => setDeleteGroupTarget(null)}
+        onConfirm={() => void confirmDeleteGroup()}
+        open={deleteGroupTarget !== null}
+        title="Delete deco template group"
+        tone="danger"
+      />
+
+      <ConfirmDialog
+        busy={busy}
+        confirmLabel="Delete"
+        message={
+          deleteDecoTemplateTarget
+            ? `Delete deco template "${deleteDecoTemplateTarget.name}"? This cannot be undone.`
+            : ''
+        }
+        onCancel={() => setDeleteDecoTemplateTarget(null)}
+        onConfirm={() => void confirmDeleteDecoTemplate()}
+        open={deleteDecoTemplateTarget !== null}
+        title="Delete deco template"
+        tone="danger"
+      />
+    </div>
+  );
+}
+
+function DecoTemplateEditor({ decoTemplateId }: { decoTemplateId: number }) {
+  const [decoTemplate, setDecoTemplate] = useState<DecoTemplate | null>(null);
+  const [draft, setDraft] = useState<Draft | null>(null);
+  const [decoGroups, setDecoGroups] = useState<DecoGroup[]>([]);
+  const [decos, setDecos] = useState<DecoListItem[]>([]);
+  const [loadError, setLoadError] = useState<null | string>(null);
+  const [saveError, setSaveError] = useState<null | string>(null);
+  const [saving, setSaving] = useState(false);
+
+  const [addGroupId, setAddGroupId] = useState('');
+  const [addDecoId, setAddDecoId] = useState('');
+  const [addStartTime, setAddStartTime] = useState('00:00:00');
+  const [addDurationHours, setAddDurationHours] = useState('0');
+  const [addDurationMinutes, setAddDurationMinutes] = useState('15');
+
+  useEffect(() => {
+    let active = true;
+
+    Promise.all([
+      getDecoTemplate(decoTemplateId),
+      getDecoTemplateItems(decoTemplateId),
+      getDecoGroups(),
+      getDecos()
+    ])
+      .then(([decoTemplateData, items, groupData, decoData]) => {
+        if (!active) {
+          return;
+        }
+        setDecoTemplate(decoTemplateData);
+        setDecoGroups(groupData);
+        setDecos(decoData);
+        setDraft({
+          name: decoTemplateData.name,
+          items: items.map(itemFromResponse)
+        });
+      })
+      .catch((error: unknown) => {
+        if (active) {
+          setLoadError(messageFromDecoTemplateError(error, 'Unable to load deco template'));
+        }
+      });
+
+    return () => {
+      active = false;
+    };
+  }, [decoTemplateId]);
+
+  if (loadError) {
+    return (
+      <div className="ctv-settings-error" role="alert">
+        <TriangleAlert aria-hidden="true" size={16} />
+        <span>{loadError}</span>
+        <Button onClick={() => navigateToPath(BASE_PATH)} size="sm" variant="secondary">
+          Back to deco templates
+        </Button>
+      </div>
+    );
+  }
+
+  if (!draft || !decoTemplate) {
+    return (
+      <div className="ctv-settings-loading">
+        <Spinner size={18} />
+        <span>Loading deco template…</span>
+      </div>
+    );
+  }
+
+  const setDraftValue = (patch: Partial<Draft>) => {
+    setDraft((current) => (current ? { ...current, ...patch } : current));
+  };
+
+  const removeItem = (key: string) => {
+    setDraft((current) => (current ? { ...current, items: current.items.filter((item) => item.key !== key) } : current));
+  };
+
+  // Decos belong to a group by id; the group picker narrows the deco picker's options (derived
+  // during render, not via an effect, since it's a pure function of addGroupId + decos).
+  const groupOptions = [{ label: 'Select a deco group…', value: '' }].concat(
+    [...decoGroups].sort((a, b) => a.name.localeCompare(b.name)).map((g) => ({ label: g.name, value: String(g.id) }))
+  );
+  const decosInGroup = addGroupId
+    ? decos.filter((d) => d.decoGroupId === Number(addGroupId) && d.id > 0).sort((a, b) => a.name.localeCompare(b.name))
+    : [];
+  const decoOptions = [{ label: 'Select a deco…', value: '' }].concat(
+    decosInGroup.map((d) => ({ label: d.name, value: String(d.id) }))
+  );
+
+  const addDurationMinutesTotal = Number(addDurationHours) * 60 + Number(addDurationMinutes);
+  const addEndMinutes = timeToMinutes(addStartTime) + addDurationMinutesTotal;
+  const addCrossesMidnight = addDurationMinutesTotal <= 0 || addEndMinutes > MINUTES_PER_DAY;
+
+  const addItem = () => {
+    if (!addDecoId || addCrossesMidnight) {
+      return;
+    }
+    const deco = decos.find((d) => d.id === Number(addDecoId));
+    if (!deco) {
+      return;
+    }
+    const endTime = addEndMinutes >= MINUTES_PER_DAY ? '00:00:00' : `${minutesToClock(addEndMinutes)}:00`;
+    const item: DraftItem = {
+      key: nextKey(),
+      decoId: deco.id,
+      decoName: deco.name,
+      startTime: addStartTime,
+      endTime
+    };
+    setDraft((current) => (current ? { ...current, items: [...current.items, item] } : current));
+  };
+
+  const sortedItems = [...draft.items].sort((a, b) => timeToMinutes(a.startTime) - timeToMinutes(b.startTime));
+  const validationError = validate(draft);
+
+  const save = async () => {
+    if (validationError || saving) {
+      return;
+    }
+    setSaving(true);
+    setSaveError(null);
+    try {
+      await replaceDecoTemplate(decoTemplateId, {
+        name: draft.name.trim(),
+        items: draft.items.map((item) => ({
+          decoId: item.decoId,
+          startTime: item.startTime,
+          endTime: item.endTime
+        }))
+      });
+      navigateToPath(BASE_PATH);
+    } catch (error) {
+      setSaveError(messageFromDecoTemplateError(error, 'Unable to save deco template'));
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  return (
+    <div className="ctv-collections">
+      <div className="ctv-channels-actionbar">
+        <Button
+          onClick={() => navigateToPath(BASE_PATH)}
+          size="sm"
+          startIcon={<ArrowLeft aria-hidden="true" size={14} />}
+          variant="ghost"
+        >
+          All deco templates
+        </Button>
+        <span className="ctv-collections-detail-title">{decoTemplate.groupName} / Edit deco template</span>
+        <span className="ctv-channels-spacer" />
+        {saveError && <span className="ctv-settings-savebar-error">{saveError}</span>}
+        <Button
+          disabled={validationError !== null || saving}
+          loading={saving}
+          onClick={() => void save()}
+          size="sm"
+          startIcon={<Check aria-hidden="true" size={14} />}
+        >
+          Save deco template
+        </Button>
+      </div>
+
+      {validationError && (
+        <div className="ctv-channels-error" role="alert">
+          <TriangleAlert aria-hidden="true" size={15} />
+          <span>{validationError}</span>
+        </div>
+      )}
+
+      <Card padded={false} title="Deco template">
+        <div className="ctv-settings-row" style={{ borderTop: 'none' }}>
+          <div className="ctv-settings-row-main">
+            <div className="ctv-settings-row-label">Deco template group</div>
+          </div>
+          <div className="ctv-settings-row-control" style={{ flex: '0 0 360px' }}>
+            <Input disabled size="sm" value={decoTemplate.groupName} />
+          </div>
+        </div>
+        <div className="ctv-settings-row">
+          <div className="ctv-settings-row-main">
+            <div className="ctv-settings-row-label">Deco template name</div>
+          </div>
+          <div className="ctv-settings-row-control" style={{ flex: '0 0 360px' }}>
+            <Input
+              error={draft.name.trim() ? null : 'Deco template name is required'}
+              onChange={(event) => setDraftValue({ name: event.target.value })}
+              size="sm"
+              value={draft.name}
+            />
+          </div>
+        </div>
+      </Card>
+
+      <Card padded={false} title="Add content">
+        <div style={{ display: 'flex', gap: 12, padding: 16, flexWrap: 'wrap', alignItems: 'flex-end' }}>
+          <div style={{ minWidth: 200 }}>
+            <Select
+              label="Deco group"
+              onChange={(event) => {
+                setAddGroupId(event.target.value);
+                setAddDecoId('');
+              }}
+              options={groupOptions}
+              value={addGroupId}
+            />
+          </div>
+          <div style={{ minWidth: 200 }}>
+            <Select
+              label="Deco"
+              onChange={(event) => setAddDecoId(event.target.value)}
+              options={decoOptions}
+              value={addDecoId}
+            />
+          </div>
+          <div style={{ minWidth: 140 }}>
+            <Select
+              label="Start time"
+              onChange={(event) => setAddStartTime(event.target.value)}
+              options={START_TIME_OPTIONS}
+              value={addStartTime}
+            />
+          </div>
+          <div style={{ width: 90 }}>
+            <Input
+              label="Hours"
+              onChange={(event) => setAddDurationHours(event.target.value)}
+              type="number"
+              value={addDurationHours}
+            />
+          </div>
+          <div style={{ width: 110 }}>
+            <Select
+              label="Minutes"
+              onChange={(event) => setAddDurationMinutes(event.target.value)}
+              options={DURATION_MINUTE_OPTIONS}
+              value={addDurationMinutes}
+            />
+          </div>
+          <Button
+            disabled={!addDecoId || addCrossesMidnight}
+            onClick={addItem}
+            size="sm"
+            startIcon={<Plus aria-hidden="true" size={14} />}
+          >
+            Add
+          </Button>
+        </div>
+        {addCrossesMidnight && addDecoId && (
+          <div className="ctv-channels-error" role="alert" style={{ margin: '0 16px 16px' }}>
+            <TriangleAlert aria-hidden="true" size={15} />
+            <span>Duration must be greater than zero and must not cross midnight.</span>
+          </div>
+        )}
+      </Card>
+
+      <Card padded={false} title="Deco template items">
+        {sortedItems.length === 0 ? (
+          <div className="ctv-collections-empty">No items yet. Add one above to build the deco template.</div>
+        ) : (
+          <table className="ctv-channels-table">
+            <thead>
+              <tr>
+                <th>Time</th>
+                <th>Deco</th>
+                <th />
+              </tr>
+            </thead>
+            <tbody>
+              {sortedItems.map((item) => {
+                const start = timeToMinutes(item.startTime);
+                const end = effectiveEndMinutes(item.endTime);
+                return (
+                  <tr key={item.key}>
+                    <td>
+                      {minutesToClock(start)}-{minutesToClock(end)}
+                    </td>
+                    <td>{item.decoName}</td>
+                    <td>
+                      <IconButton onClick={() => removeItem(item.key)} size="sm" title="Remove" variant="ghost">
+                        <Trash2 aria-hidden="true" size={14} />
+                      </IconButton>
+                    </td>
+                  </tr>
+                );
+              })}
+            </tbody>
+          </table>
+        )}
+      </Card>
+    </div>
+  );
+}