Add ASP.NET Core backend hosting business rules; FE consumes via typed client

Move the authoritative business rules off the frontend into a real backend,
realising the BFF-lite + decision-DTO design (ADR-0001) that until now lived
only in static mock JSON.

Backend (backend/):
- ASP.NET Core (.NET 10) minimal API, contract-first, Swagger UI at /swagger.
- DDD Domain/ rules layer: profession derivation + applicable policy questions
  (DiplomaRules), herregistratie eligibility + reason (HerregistratieRule),
  scholing threshold (IntakePolicy), submit rejections + reference generation
  (SubmissionRules). In-memory seeded data, ProblemDetails (RFC 7807) errors.
- 27 xUnit tests: rule units + endpoint integration incl. BRP no-address and
  DUO not-found fallbacks and 422 submit paths.

Frontend (only infrastructure/ + contracts/ change, as the architecture promised):
- NSwag-generated typed client (api-client.ts), routed through Angular HttpClient
  via a small fetch adapter so the ?scenario= interceptor still applies.
- GET adapters use resource({ loader: client.x }); submit commands call the client
  and map ProblemDetails -> err. The hardcoded uren==0 / manual-diploma rules are
  deleted (now server-side). Domain, stores, UI and format validators unchanged.
- Deleted the now-dead public/mock/*.json.

Tooling/docs:
- npm start proxies /api -> backend; npm run gen:api regenerates the client;
  docker compose up runs both (bind mounts use :z for SELinux/Fedora).
- backend/README.md walkthrough: adding a policy question is a one-file backend
  change, no FE change, no client regen. Updated CLAUDE.md + ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

backend/tests/BigRegister.Tests/BigRegister.Tests.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.9" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\BigRegister.Api\BigRegister.Api.csproj" />
+  </ItemGroup>
+
+</Project>

backend/tests/BigRegister.Tests/EndpointTests.cs

@@ -0,0 +1,100 @@
+using System.Net;
+using System.Net.Http.Json;
+using BigRegister.Api.Contracts;
+using Microsoft.AspNetCore.Mvc.Testing;
+
+namespace BigRegister.Tests;
+
+public class EndpointTests(WebApplicationFactory<Program> factory) : IClassFixture<WebApplicationFactory<Program>>
+{
+    private readonly HttpClient _client = factory.CreateClient();
+
+    [Fact]
+    public async Task DashboardView_computes_eligibility_decision()
+    {
+        var dto = await _client.GetFromJsonAsync<DashboardViewDto>("/api/dashboard-view");
+        Assert.NotNull(dto);
+        Assert.Equal("19012345601", dto.Registration.BigNummer);
+        Assert.Equal("Geregistreerd", dto.Registration.Status.Tag);
+        // seed deadline 2027-03-01 is within 12 months of "today" (2026) → eligible
+        Assert.True(dto.Decisions.EligibleForHerregistratie);
+        Assert.NotNull(dto.Decisions.HerregistratieReason);
+    }
+
+    [Fact]
+    public async Task Notes_returns_seeded_aantekeningen()
+    {
+        var notes = await _client.GetFromJsonAsync<List<AantekeningDto>>("/api/notes");
+        Assert.Equal(3, notes!.Count);
+    }
+
+    [Fact]
+    public async Task Brp_returns_address()
+    {
+        var dto = await _client.GetFromJsonAsync<BrpAddressDto>("/api/brp/address");
+        Assert.True(dto!.Gevonden);
+        Assert.Equal("2514 EA", dto.Adres!.Postcode);
+    }
+
+    [Fact]
+    public async Task Duo_lookup_carries_server_decided_questions_and_professions()
+    {
+        var dto = await _client.GetFromJsonAsync<DuoLookupDto>("/api/duo/diplomas");
+        Assert.NotNull(dto);
+
+        var english = dto.Diplomas.Single(d => d.Id == "d2");
+        Assert.Equal("Arts", english.Beroep);
+        Assert.Contains(english.PolicyQuestions, q => q.Id == "nl-taalvaardigheid");
+
+        var dutch = dto.Diplomas.Single(d => d.Id == "d1");
+        Assert.Empty(dutch.PolicyQuestions);
+
+        // DUO "not found" fallback: an unlisted diploma → user uses the manual path,
+        // which the same lookup provides (maximal question set + declarable professions).
+        Assert.DoesNotContain(dto.Diplomas, d => d.Id == "unknown-id");
+        Assert.Equal(3, dto.Handmatig.PolicyQuestions.Count);
+        Assert.Equal(5, dto.Handmatig.Beroepen.Count);
+    }
+
+    [Fact]
+    public async Task IntakePolicy_returns_scholing_threshold()
+    {
+        var dto = await _client.GetFromJsonAsync<IntakePolicyDto>("/api/intake/policy");
+        Assert.Equal(1000, dto!.ScholingThreshold);
+    }
+
+    [Fact]
+    public async Task Registration_with_duo_diploma_succeeds()
+    {
+        var res = await _client.PostAsJsonAsync("/api/registrations", new RegistratieRequest("duo"));
+        res.EnsureSuccessStatusCode();
+        var body = await res.Content.ReadFromJsonAsync<ReferentieResponse>();
+        Assert.StartsWith("BIG-2026-", body!.Referentie);
+    }
+
+    [Fact]
+    public async Task Registration_with_manual_diploma_is_rejected_with_problem_details()
+    {
+        var res = await _client.PostAsJsonAsync("/api/registrations", new RegistratieRequest("handmatig"));
+        Assert.Equal(HttpStatusCode.UnprocessableEntity, res.StatusCode);
+        Assert.Contains("application/problem+json", res.Content.Headers.ContentType!.ToString());
+    }
+
+    [Theory]
+    [InlineData("/api/intakes")]
+    [InlineData("/api/herregistraties")]
+    public async Task Zero_hours_submission_is_rejected(string route)
+    {
+        var res = await _client.PostAsJsonAsync(route, new { uren = 0 });
+        Assert.Equal(HttpStatusCode.UnprocessableEntity, res.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("/api/intakes")]
+    [InlineData("/api/herregistraties")]
+    public async Task Worked_hours_submission_succeeds(string route)
+    {
+        var res = await _client.PostAsJsonAsync(route, new { uren = 40 });
+        res.EnsureSuccessStatusCode();
+    }
+}

backend/tests/BigRegister.Tests/RuleTests.cs

@@ -0,0 +1,117 @@
+using BigRegister.Domain.Diplomas;
+using BigRegister.Domain.Registrations;
+using BigRegister.Domain.Submissions;
+
+namespace BigRegister.Tests;
+
+public class HerregistratieRuleTests
+{
+    private static Registration Active(DateOnly deadline) => new(
+        "19012345601", "Test", "Arts",
+        new DateOnly(2012, 9, 1), new DateOnly(1985, 3, 14),
+        new RegistrationStatus(StatusTag.Geregistreerd, HerregistratieDatum: deadline));
+
+    [Fact]
+    public void Eligible_within_window()
+    {
+        var (eligible, reason) = HerregistratieRule.Evaluate(
+            Active(new DateOnly(2027, 3, 1)), today: new DateOnly(2026, 6, 26));
+        Assert.True(eligible);
+        Assert.Contains("12 maanden", reason);
+    }
+
+    [Fact]
+    public void Not_eligible_before_window()
+    {
+        var (eligible, _) = HerregistratieRule.Evaluate(
+            Active(new DateOnly(2027, 3, 1)), today: new DateOnly(2025, 1, 1));
+        Assert.False(eligible);
+    }
+
+    [Fact]
+    public void Eligible_on_window_boundary()
+    {
+        // window opens exactly 12 months before the deadline
+        var (eligible, _) = HerregistratieRule.Evaluate(
+            Active(new DateOnly(2027, 3, 1)), today: new DateOnly(2026, 3, 1));
+        Assert.True(eligible);
+    }
+
+    [Fact]
+    public void Suspended_is_not_eligible()
+    {
+        var reg = Active(new DateOnly(2027, 3, 1)) with
+        {
+            Status = new RegistrationStatus(StatusTag.Geschorst, GeschorstTot: new DateOnly(2027, 1, 1), Reden: "x"),
+        };
+        var (eligible, _) = HerregistratieRule.Evaluate(reg, today: new DateOnly(2026, 6, 26));
+        Assert.False(eligible);
+    }
+
+    [Fact]
+    public void Status_consistency_invariant()
+    {
+        Assert.True(HerregistratieRule.IsStatusConsistent(
+            new RegistrationStatus(StatusTag.Geregistreerd, HerregistratieDatum: new DateOnly(2027, 3, 1))));
+        Assert.False(HerregistratieRule.IsStatusConsistent(
+            new RegistrationStatus(StatusTag.Geregistreerd)));
+    }
+}
+
+public class DiplomaRuleTests
+{
+    private static Diploma Diploma(string opleiding, bool engelstalig) =>
+        new("x", "naam", "instelling", 2011, opleiding, engelstalig);
+
+    [Theory]
+    [InlineData("geneeskunde", "Arts")]
+    [InlineData("verpleegkunde", "Verpleegkundige")]
+    [InlineData("onbekend-programma", "Onbekend")]
+    public void Profession_is_derived_from_program(string opleiding, string expected) =>
+        Assert.Equal(expected, DiplomaRules.ProfessionFor(Diploma(opleiding, false)));
+
+    [Fact]
+    public void English_diploma_requires_dutch_proficiency()
+    {
+        var questions = DiplomaRules.QuestionsFor(Diploma("geneeskunde", engelstalig: true));
+        Assert.Single(questions);
+        Assert.Equal("nl-taalvaardigheid", questions[0].Id);
+    }
+
+    [Fact]
+    public void Dutch_diploma_has_no_policy_questions() =>
+        Assert.Empty(DiplomaRules.QuestionsFor(Diploma("geneeskunde", engelstalig: false)));
+
+    [Fact]
+    public void Manual_diploma_gets_maximal_set()
+    {
+        var questions = DiplomaRules.ManualQuestions();
+        Assert.Equal(3, questions.Count);
+        Assert.Equal(new[] { "nl-taalvaardigheid", "diploma-erkend", "toelichting" },
+            questions.Select(q => q.Id));
+    }
+
+    [Fact]
+    public void Manual_professions_match_known_programs() =>
+        Assert.Equal(new[] { "Arts", "Verpleegkundige", "Fysiotherapeut", "Apotheker", "Tandarts" },
+            DiplomaRules.ManualProfessions());
+}
+
+public class SubmissionRuleTests
+{
+    [Fact]
+    public void Manual_diploma_is_rejected() =>
+        Assert.NotNull(SubmissionRules.RejectRegistratie("handmatig"));
+
+    [Fact]
+    public void Duo_diploma_is_accepted() =>
+        Assert.Null(SubmissionRules.RejectRegistratie("duo"));
+
+    [Fact]
+    public void Zero_hours_is_rejected() =>
+        Assert.NotNull(SubmissionRules.RejectZeroUren(0));
+
+    [Fact]
+    public void Worked_hours_are_accepted() =>
+        Assert.Null(SubmissionRules.RejectZeroUren(40));
+}