@juangcarmona/lighthouse 0.5.0 → 0.7.0

package/README.md

@@ -6,11 +6,15 @@ This package is the core Lighthouse harness. It provides the `lighthouse` comman
 
 Install the exact Lighthouse package artifact selected for the release and run `lighthouse init --name <product>` in a new repository. Add `--profile visual-theme` when the project wants the Lighthouse UI contract. Lighthouse creates the manifest, the `src/`, `docs/`, `infra/` and `scripts/` boundaries, the repository guardrails and the generated `LIGHTHOUSE.md`. Inspect the plan and projection, then run `lighthouse verify` before adding project-specific policy or exceptions.
 
+For a Lighthouse-owned .NET backend, run `lighthouse create-dotnet <empty-target> --name <PascalCaseProduct>`. The creator seeds the modular backend, Aspire AppHost, CQRS/analyzer sources, tests, profile guidance and deterministic verifier into a new or empty directory. It refuses populated targets and never contacts a remote repository. Run `dotnet restore <Product>.slnx`, then `npm run verify` in the generated product.
+
+The manifest can declare `application.shape` and `application.stacks` when the project has enough information to select compatible profiles. `lighthouse profiles --format json` reports selected profiles, applicability, owned surfaces and verification layers without changing the repository.
+
 Use `lighthouse reconcile` to preview missing Lighthouse-managed paths in an existing adoption. It does not write by default; add `--apply` only after reviewing the plan. Existing files whose content differs from the generated projection are conflicts and are never overwritten by reconciliation.
 
 Use `lighthouse upgrade` to preview a versioned foundation update. The command is dry-run by default, accepts `--scope harness`, `--scope sdlc` or `--scope all`, preserves customized projections and stops when ownership evidence is missing. Add `--apply` only after reviewing the plan, then run `lighthouse verify`.
 
-The harness package owns the baseline command and verification contract. The SDLC package owns lifecycle skills, commands, metacommands, routes and gates, and `lighthouse init` records its selected version in `.lighthouse/sdlc.json`. The UI package owns visual tokens, native recipes, `DESIGN.md` and its agent skill. Selecting `visual-theme` projects the guide and skill into the adopter and enables its deterministic guardrail. Stack profiles own their source templates, guidance and checks.
+The harness package owns the baseline command and verification contract. The SDLC package owns lifecycle skills, commands, metacommands, routes and gates, and `lighthouse init` records its selected version in `.lighthouse/sdlc.json`. The UI package owns visual tokens, native recipes, `DESIGN.md` and its agent skill. Selecting `visual-theme` projects the guide and skill into the adopter and enables its deterministic guardrail. Stack profiles own their source templates, guidance and checks; the .NET creator is the packaged entry point for the selected backend profile.
 
 ProductShape, ArcShape and OpenSpec keep their own files and commands. Add them through their supported integration routes when the project needs them, and keep their versions and managed paths visible in the project configuration.
 
@@ -38,7 +42,7 @@ Initialization reports missing ProductShape and ArcShape authority inputs as ado
 
 ## Current command scope
 
-The command supports `init`, `authorities`, `reconcile`, `upgrade`, `capabilities` and `verify`. It checks the manifest, repository boundaries, Conventional Commits metadata, branch naming, the selected SDLC package projection and generated content. Lifecycle stages, tracker operations, agent runs and CodeGraph checks require their own configured integrations.
+The command supports `init`, `create-dotnet`, `authorities`, `reconcile`, `upgrade`, `capabilities` and `verify`. It checks the manifest, repository boundaries, Conventional Commits metadata, branch naming, the selected SDLC package projection and generated content. Lifecycle stages, tracker operations, agent runs and CodeGraph checks require their own configured integrations.
 
 Initialization installs `.husky/commit-msg`, `.husky/pre-push`, `scripts/lighthouse-guard.mjs` and `.github/workflows/lighthouse.yml` when those paths are free. Existing files remain project-owned and are reported as conflicts. Reconciliation can add missing managed paths after adoption, but it does not overwrite a path that has drifted or belongs to another tool.
 
@@ -52,6 +56,8 @@ The package does not contain the repository gallery, provider-owned integrations
 
 The CLI package owns a versioned catalog under `assets/guardrails/`; it describes the guardrails already present in the Lighthouse baseline and their applicability, level, kind, verification method and repair hint.
 
+The profile catalog under `assets/profiles/` describes the application shapes, stacks, owned surfaces and verification layers for each supported profile. A layer can be required, recommended or optional independently of whether its evidence is hard, soft, deterministic, semantic or human.
+
 `level` and `kind` are independent: `level` is `required`, `recommended` or `optional`, while `kind` is `hard` or `soft`; neither dimension selects the verification method.
 
 `lighthouse verify` keeps its existing human-readable success and failure output; `lighthouse verify --format json` exposes the same run for agents and CI without changing the default route.

package/assets/dotnet-template/Directory.Build.props

@@ -0,0 +1,22 @@
+<Project>
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>14.0</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    <AnalysisLevel>10.0-recommended</AnalysisLevel>
+    <NuGetAudit>true</NuGetAudit>
+    <NuGetAuditMode>all</NuGetAuditMode>
+    <NuGetAuditLevel>low</NuGetAuditLevel>
+    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+    <IsPackable>false</IsPackable>
+    <Authors>juangcarmona</Authors>
+    <ContinuousIntegrationBuild Condition="'$(CI)' == 'true'">true</ContinuousIntegrationBuild>
+  </PropertyGroup>
+  <ItemGroup>
+    <CompilerVisibleProperty Include="LighthouseModule" />
+  </ItemGroup>
+</Project>

package/assets/dotnet-template/Directory.Packages.props

@@ -0,0 +1,16 @@
+<Project>
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.7.0" />
+    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.13" />
+    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.13" />
+    <PackageVersion Include="Aspire.Hosting.AppHost" Version="13.6.1" />
+    <PackageVersion Include="MessagePack" Version="2.5.303" />
+  </ItemGroup>
+</Project>

package/assets/dotnet-template/Lighthouse.Analyzers/BackendContractAnalyzer.cs

@@ -0,0 +1,72 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace JuanGCarmona.Lighthouse.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class BackendContractAnalyzer : DiagnosticAnalyzer
+{
+    private static readonly DiagnosticDescriptor HandlerContract = new(
+        "LH1001", "Keep CQRS handlers internal and sealed",
+        "Handler '{0}' must be declared internal sealed", "Lighthouse.Architecture",
+        DiagnosticSeverity.Error, isEnabledByDefault: true,
+        description: "A module exposes its API and contracts; handlers remain implementation details.");
+
+    private static readonly DiagnosticDescriptor ModuleReference = new(
+        "LH1002", "Use contracts across module boundaries",
+        "Module '{0}' references implementation assembly '{1}'; depend on its Contracts assembly",
+        "Lighthouse.Architecture", DiagnosticSeverity.Error, isEnabledByDefault: true,
+        description: "Cross-module dependencies must terminate at a separately named Contracts assembly.",
+        customTags: new[] { WellKnownDiagnosticTags.CompilationEnd });
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
+        ImmutableArray.Create(HandlerContract, ModuleReference);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.RegisterCompilationStartAction(start =>
+        {
+            if (!start.Options.AnalyzerConfigOptionsProvider.GlobalOptions.TryGetValue(
+                "build_property.LighthouseModule", out var enabled)
+                || !string.Equals(enabled, "true", StringComparison.OrdinalIgnoreCase))
+                return;
+
+            start.RegisterSymbolAction(CheckHandler, SymbolKind.NamedType);
+            start.RegisterCompilationEndAction(CheckDependencies);
+        });
+    }
+
+    private static void CheckHandler(SymbolAnalysisContext context)
+    {
+        var type = (INamedTypeSymbol)context.Symbol;
+        if (type.TypeKind != TypeKind.Class || !type.AllInterfaces.Any(IsHandler)) return;
+        if (type.DeclaredAccessibility == Accessibility.Internal && type.IsSealed) return;
+        var location = type.Locations.FirstOrDefault(x => x.IsInSource);
+        if (location is not null)
+            context.ReportDiagnostic(Diagnostic.Create(HandlerContract, location, type.Name));
+    }
+
+    private static bool IsHandler(INamedTypeSymbol contract) =>
+        contract.ContainingNamespace.ToDisplayString() == "JuanGCarmona.Lighthouse.Cqrs"
+        && contract.Arity == 2
+        && (contract.Name == "ICommandHandler" || contract.Name == "IQueryHandler");
+
+    private static void CheckDependencies(CompilationAnalysisContext context)
+    {
+        var name = context.Compilation.AssemblyName;
+        const string separator = ".Modules.";
+        var boundary = name?.IndexOf(separator, StringComparison.Ordinal) ?? -1;
+        if (name is null || boundary < 0 || name.EndsWith(".Contracts", StringComparison.Ordinal)) return;
+        var family = name.Substring(0, boundary + separator.Length);
+        foreach (var dependency in context.Compilation.SourceModule.ReferencedAssemblySymbols)
+        {
+            if (dependency.Name.StartsWith(family, StringComparison.Ordinal)
+                && dependency.Name != name
+                && !dependency.Name.EndsWith(".Contracts", StringComparison.Ordinal))
+                context.ReportDiagnostic(Diagnostic.Create(ModuleReference, Location.None, name, dependency.Name));
+        }
+    }
+}

package/assets/dotnet-template/Lighthouse.Analyzers/Lighthouse.Analyzers.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <RootNamespace>JuanGCarmona.Lighthouse.Analyzers</RootNamespace>
+    <PackageId>JuanGCarmona.Lighthouse.Analyzers</PackageId>
+    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" PrivateAssets="all" />
+  </ItemGroup>
+</Project>

package/assets/dotnet-template/Lighthouse.Analyzers/packages.lock.json

@@ -0,0 +1,121 @@
+{
+  "version": 2,
+  "dependencies": {
+    ".NETStandard,Version=v2.0": {
+      "Microsoft.CodeAnalysis.Analyzers": {
+        "type": "Direct",
+        "requested": "[3.11.0, )",
+        "resolved": "3.11.0",
+        "contentHash": "v/EW3UE8/lbEYHoC2Qq7AR/DnmvpgdtAMndfQNmpuIMx/Mto8L5JnuCfdBYtgvalQOtfNCnxFejxuRrryvUTsg=="
+      },
+      "Microsoft.CodeAnalysis.CSharp": {
+        "type": "Direct",
+        "requested": "[5.0.0, )",
+        "resolved": "5.0.0",
+        "contentHash": "5DSyJ9bk+ATuDy7fp2Zt0mJStDVKbBoiz1DyfAwSa+k4H4IwykAUcV3URelw5b8/iVbfSaOwkwmPUZH6opZKCw==",
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+          "Microsoft.CodeAnalysis.Common": "[5.0.0]",
+          "System.Buffers": "4.6.0",
+          "System.Collections.Immutable": "9.0.0",
+          "System.Memory": "4.6.0",
+          "System.Numerics.Vectors": "4.6.0",
+          "System.Reflection.Metadata": "9.0.0",
+          "System.Runtime.CompilerServices.Unsafe": "6.1.0",
+          "System.Text.Encoding.CodePages": "8.0.0",
+          "System.Threading.Tasks.Extensions": "4.6.0"
+        }
+      },
+      "NETStandard.Library": {
+        "type": "Direct",
+        "requested": "[2.0.3, )",
+        "resolved": "2.0.3",
+        "contentHash": "st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "1.1.0"
+        }
+      },
+      "Microsoft.CodeAnalysis.Common": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "ZXRAdvH6GiDeHRyd3q/km8Z44RoM6FBWHd+gen/la81mVnAdHTEsEkO5J0TCNXBymAcx5UYKt5TvgKBhaLJEow==",
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+          "System.Buffers": "4.6.0",
+          "System.Collections.Immutable": "9.0.0",
+          "System.Memory": "4.6.0",
+          "System.Numerics.Vectors": "4.6.0",
+          "System.Reflection.Metadata": "9.0.0",
+          "System.Runtime.CompilerServices.Unsafe": "6.1.0",
+          "System.Text.Encoding.CodePages": "8.0.0",
+          "System.Threading.Tasks.Extensions": "4.6.0"
+        }
+      },
+      "Microsoft.NETCore.Platforms": {
+        "type": "Transitive",
+        "resolved": "1.1.0",
+        "contentHash": "kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A=="
+      },
+      "System.Buffers": {
+        "type": "Transitive",
+        "resolved": "4.6.0",
+        "contentHash": "lN6tZi7Q46zFzAbRYXTIvfXcyvQQgxnY7Xm6C6xQ9784dEL1amjM6S6Iw4ZpsvesAKnRVsM4scrDQaDqSClkjA=="
+      },
+      "System.Collections.Immutable": {
+        "type": "Transitive",
+        "resolved": "9.0.0",
+        "contentHash": "QhkXUl2gNrQtvPmtBTQHb0YsUrDiDQ2QS09YbtTTiSjGcf7NBqtYbrG/BE06zcBPCKEwQGzIv13IVdXNOSub2w==",
+        "dependencies": {
+          "System.Memory": "4.5.5",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
+        }
+      },
+      "System.Memory": {
+        "type": "Transitive",
+        "resolved": "4.6.0",
+        "contentHash": "OEkbBQoklHngJ8UD8ez2AERSk2g+/qpAaSWWCBFbpH727HxDq5ydVkuncBaKcKfwRqXGWx64dS6G1SUScMsitg==",
+        "dependencies": {
+          "System.Buffers": "4.6.0",
+          "System.Numerics.Vectors": "4.6.0",
+          "System.Runtime.CompilerServices.Unsafe": "6.1.0"
+        }
+      },
+      "System.Numerics.Vectors": {
+        "type": "Transitive",
+        "resolved": "4.6.0",
+        "contentHash": "t+SoieZsRuEyiw/J+qXUbolyO219tKQQI0+2/YI+Qv7YdGValA6WiuokrNKqjrTNsy5ABWU11bdKOzUdheteXg=="
+      },
+      "System.Reflection.Metadata": {
+        "type": "Transitive",
+        "resolved": "9.0.0",
+        "contentHash": "ANiqLu3DxW9kol/hMmTWbt3414t9ftdIuiIU7j80okq2YzAueo120M442xk1kDJWtmZTqWQn7wHDvMRipVOEOQ==",
+        "dependencies": {
+          "System.Collections.Immutable": "9.0.0",
+          "System.Memory": "4.5.5"
+        }
+      },
+      "System.Runtime.CompilerServices.Unsafe": {
+        "type": "Transitive",
+        "resolved": "6.1.0",
+        "contentHash": "5o/HZxx6RVqYlhKSq8/zronDkALJZUT2Vz0hx43f0gwe8mwlM0y2nYlqdBwLMzr262Bwvpikeb/yEwkAa5PADg=="
+      },
+      "System.Text.Encoding.CodePages": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "OZIsVplFGaVY90G2SbpgU7EnCoOO5pw1t4ic21dBF3/1omrJFpAGoNAVpPyMVOC90/hvgkGG3VFqR13YgZMQfg==",
+        "dependencies": {
+          "System.Memory": "4.5.5",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
+        }
+      },
+      "System.Threading.Tasks.Extensions": {
+        "type": "Transitive",
+        "resolved": "4.6.0",
+        "contentHash": "I5G6Y8jb0xRtGUC9Lahy7FUvlYlnGMMkbuKAQBy8Jb7Y6Yn8OlBEiUOY0PqZ0hy6Ua8poVA1ui1tAIiXNxGdsg==",
+        "dependencies": {
+          "System.Runtime.CompilerServices.Unsafe": "6.1.0"
+        }
+      }
+    }
+  }
+}

package/assets/dotnet-template/Lighthouse.Cqrs/Handlers.cs

@@ -0,0 +1,11 @@
+namespace JuanGCarmona.Lighthouse.Cqrs;
+
+public interface ICommandHandler<in TCommand, TResponse>
+{
+    Task<TResponse> Handle(TCommand command, CancellationToken cancellationToken);
+}
+
+public interface IQueryHandler<in TQuery, TResponse>
+{
+    Task<TResponse> Handle(TQuery query, CancellationToken cancellationToken);
+}

package/assets/dotnet-template/Lighthouse.Cqrs/Lighthouse.Cqrs.csproj

@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <RootNamespace>JuanGCarmona.Lighthouse.Cqrs</RootNamespace>
+  </PropertyGroup>
+</Project>

package/assets/dotnet-template/Lighthouse.Cqrs/packages.lock.json

@@ -0,0 +1,6 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {}
+  }
+}

package/assets/dotnet-template/Lighthouse.slnx

@@ -0,0 +1,17 @@
+<Solution>
+  <Folder Name="/examples/src/modules/">
+    <Project Path="examples/src/modules/Lighthouse.Example.Modules.Catalog/Lighthouse.Example.Modules.Catalog.csproj" />
+  </Folder>
+  <Folder Name="/examples/src/root/">
+    <Project Path="examples/src/root/Lighthouse.Example.Api/Lighthouse.Example.Api.csproj" />
+    <Project Path="examples/src/root/Lighthouse.Example.AppHost/Lighthouse.Example.AppHost.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/Lighthouse.Analyzers.Tests/Lighthouse.Analyzers.Tests.csproj" />
+    <Project Path="tests/Lighthouse.Example.Tests/Lighthouse.Example.Tests.csproj" />
+  </Folder>
+  <Folder Name="/Lighthouse/">
+    <Project Path="Lighthouse.Analyzers/Lighthouse.Analyzers.csproj" />
+    <Project Path="Lighthouse.Cqrs/Lighthouse.Cqrs.csproj" />
+  </Folder>
+</Solution>

package/assets/dotnet-template/examples/src/modules/Lighthouse.Example.Modules.Catalog/CatalogModule.cs

@@ -0,0 +1,24 @@
+using JuanGCarmona.Lighthouse.Cqrs;
+using JuanGCarmona.Lighthouse.Example.Modules.Catalog.Features.Entries;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JuanGCarmona.Lighthouse.Example.Modules.Catalog;
+
+public static class CatalogModule
+{
+    public static IServiceCollection AddCatalog(this IServiceCollection services)
+    {
+        services.AddSingleton<EntryStore>();
+        services.AddScoped<ICommandHandler<CreateEntry.Command, CreateEntry.Outcome>, CreateEntry.Handler>();
+        services.AddScoped<IQueryHandler<GetEntry.Query, GetEntry.Response?>, GetEntry.Handler>();
+        return services;
+    }
+
+    public static IEndpointRouteBuilder MapCatalog(this IEndpointRouteBuilder endpoints)
+    {
+        CreateEntry.Map(endpoints);
+        GetEntry.Map(endpoints);
+        return endpoints;
+    }
+}

package/assets/dotnet-template/examples/src/modules/Lighthouse.Example.Modules.Catalog/Features/Entries/CreateEntry.cs

@@ -0,0 +1,47 @@
+using JuanGCarmona.Lighthouse.Cqrs;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace JuanGCarmona.Lighthouse.Example.Modules.Catalog.Features.Entries;
+
+internal static class CreateEntry
+{
+    internal static void Map(IEndpointRouteBuilder routes) => routes
+        .MapPost("/api/entries", async (Request request, ICommandHandler<Command, Outcome> handler, CancellationToken token) =>
+        {
+            var outcome = await handler.Handle(new Command(request.Name), token);
+            return outcome.Value is { } value
+                ? Results.Created($"/api/entries/{value.Id}", value)
+                : Results.ValidationProblem(outcome.Errors);
+        })
+        .RequireAuthorization("catalog.write");
+
+    internal sealed record Request(string? Name);
+    internal sealed record Response(Guid Id, string Name);
+    internal sealed record Command(string? Name);
+    internal sealed record Outcome(Response? Value, Dictionary<string, string[]> Errors);
+
+    internal static class Validator
+    {
+        internal static Dictionary<string, string[]> Validate(Command command)
+        {
+            var errors = new Dictionary<string, string[]>();
+            if (string.IsNullOrWhiteSpace(command.Name) || command.Name.Trim().Length > 80)
+                errors["name"] = ["Use a name between 1 and 80 characters."];
+            return errors;
+        }
+    }
+
+    internal sealed class Handler(EntryStore store) : ICommandHandler<Command, Outcome>
+    {
+        public Task<Outcome> Handle(Command command, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var errors = Validator.Validate(command);
+            if (errors.Count > 0) return Task.FromResult(new Outcome(null, errors));
+            var entry = store.Add(command.Name!.Trim());
+            return Task.FromResult(new Outcome(new Response(entry.Id, entry.Name), errors));
+        }
+    }
+}

package/assets/dotnet-template/examples/src/modules/Lighthouse.Example.Modules.Catalog/Features/Entries/EntryStore.cs

@@ -0,0 +1,17 @@
+using System.Collections.Concurrent;
+
+namespace JuanGCarmona.Lighthouse.Example.Modules.Catalog.Features.Entries;
+
+internal sealed record Entry(Guid Id, string Name);
+
+internal sealed class EntryStore
+{
+    private readonly ConcurrentDictionary<Guid, Entry> entries = new();
+    internal Entry Add(string name)
+    {
+        var entry = new Entry(Guid.CreateVersion7(), name);
+        entries[entry.Id] = entry;
+        return entry;
+    }
+    internal Entry? Find(Guid id) => entries.GetValueOrDefault(id);
+}

package/assets/dotnet-template/examples/src/modules/Lighthouse.Example.Modules.Catalog/Features/Entries/GetEntry.cs

@@ -0,0 +1,30 @@
+using JuanGCarmona.Lighthouse.Cqrs;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+namespace JuanGCarmona.Lighthouse.Example.Modules.Catalog.Features.Entries;
+
+internal static class GetEntry
+{
+    internal static void Map(IEndpointRouteBuilder routes) => routes
+        .MapGet("/api/entries/{id:guid}", async (Guid id, IQueryHandler<Query, Response?> handler, CancellationToken token) =>
+        {
+            var value = await handler.Handle(new Query(id), token);
+            return value is null ? Results.NotFound() : Results.Ok(value);
+        })
+        .RequireAuthorization();
+
+    internal sealed record Query(Guid Id);
+    internal sealed record Response(Guid Id, string Name);
+
+    internal sealed class Handler(EntryStore store) : IQueryHandler<Query, Response?>
+    {
+        public Task<Response?> Handle(Query query, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var value = store.Find(query.Id);
+            return Task.FromResult(value is null ? null : new Response(value.Id, value.Name));
+        }
+    }
+}

package/assets/dotnet-template/examples/src/modules/Lighthouse.Example.Modules.Catalog/Lighthouse.Example.Modules.Catalog.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AssemblyName>JuanGCarmona.Lighthouse.Example.Modules.Catalog</AssemblyName>
+    <RootNamespace>JuanGCarmona.Lighthouse.Example.Modules.Catalog</RootNamespace>
+    <LighthouseModule>true</LighthouseModule>
+  </PropertyGroup>
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+    <ProjectReference Include="../../../../Lighthouse.Cqrs/Lighthouse.Cqrs.csproj" />
+    <ProjectReference Include="../../../../Lighthouse.Analyzers/Lighthouse.Analyzers.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
+  </ItemGroup>
+</Project>

package/assets/dotnet-template/examples/src/modules/Lighthouse.Example.Modules.Catalog/packages.lock.json

@@ -0,0 +1,10 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "lighthouse.cqrs": {
+        "type": "Project"
+      }
+    }
+  }
+}

package/assets/dotnet-template/examples/src/root/Lighthouse.Example.Api/Lighthouse.Example.Api.csproj

@@ -0,0 +1,6 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+  <ItemGroup>
+    <ProjectReference Include="../../modules/Lighthouse.Example.Modules.Catalog/Lighthouse.Example.Modules.Catalog.csproj" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" />
+  </ItemGroup>
+</Project>

package/assets/dotnet-template/examples/src/root/Lighthouse.Example.Api/Program.cs

@@ -0,0 +1,25 @@
+using JuanGCarmona.Lighthouse.Example.Modules.Catalog;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+
+namespace JuanGCarmona.Lighthouse.Example.Api;
+
+public partial class Program
+{
+    public static void Main(string[] args)
+    {
+        var builder = WebApplication.CreateBuilder(args);
+        builder.Services.AddCatalog();
+        builder.Services.AddProblemDetails();
+        builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+            .AddJwtBearer(options => builder.Configuration.GetSection("Authentication").Bind(options));
+        builder.Services.AddAuthorization(options => options.AddPolicy("catalog.write",
+            policy => policy.RequireAuthenticatedUser().RequireClaim("permission", "catalog.write")));
+        var app = builder.Build();
+        app.UseExceptionHandler();
+        app.UseAuthentication();
+        app.UseAuthorization();
+        app.MapGet("/health", () => Results.Ok(new { status = "ready" }));
+        app.MapCatalog();
+        app.Run();
+    }
+}

package/assets/dotnet-template/examples/src/root/Lighthouse.Example.Api/Properties/launchSettings.json

@@ -0,0 +1,10 @@
+{
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "launchBrowser": false,
+      "applicationUrl": "http://127.0.0.1:5097",
+      "environmentVariables": { "ASPNETCORE_ENVIRONMENT": "Development" }
+    }
+  }
+}

package/assets/dotnet-template/examples/src/root/Lighthouse.Example.Api/packages.lock.json

@@ -0,0 +1,86 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Microsoft.AspNetCore.Authentication.JwtBearer": {
+        "type": "Direct",
+        "requested": "[10.0.13, )",
+        "resolved": "10.0.13",
+        "contentHash": "cEPhQWsaUKymSdQ+NB2rF4GnWtjofAcRrzr2aGPzbjSFyeDtIlBzrbX1Qeh/OAHjvdwBe05SbsukoSbz27AD6g==",
+        "dependencies": {
+          "Microsoft.IdentityModel.Protocols.OpenIdConnect": "8.19.2"
+        }
+      },
+      "Microsoft.Bcl.Cryptography": {
+        "type": "Transitive",
+        "resolved": "10.0.2",
+        "contentHash": "LG9Yll3B5aNpxv0+D47g6LiOiKBIlodhcHdQwcYzo8VeexFLGqx5ymetmA2aBRyo9cCcWsQWrFsdbsr8LvmWDw=="
+      },
+      "Microsoft.IdentityModel.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.19.2",
+        "contentHash": "HJbo/lnSfNHUfphPRT910poQc4T2/9+8svFLvzuaYHGAOJ2Tu+oEDqpX0BVP3BJ4OuUM1kylEKyaiX2fCAK3Cw=="
+      },
+      "Microsoft.IdentityModel.JsonWebTokens": {
+        "type": "Transitive",
+        "resolved": "8.19.2",
+        "contentHash": "ui3fuBT4fs8kdKfBthI4NzLYIBIneEVS8UrL1JVBzAn80UiKmngBBi0BEByE7n/9c+EElcfFlCMFFTqpkBSLNA==",
+        "dependencies": {
+          "Microsoft.IdentityModel.Tokens": "8.19.2"
+        }
+      },
+      "Microsoft.IdentityModel.Logging": {
+        "type": "Transitive",
+        "resolved": "8.19.2",
+        "contentHash": "r5YLDIxGOnkVJHrqXv/iD1FM1CgGrQOdriXuvuWvTPmKbnGANhEysq9XKmN6IHjf2a+9bAGEpnoRBsAQlvJU5w==",
+        "dependencies": {
+          "Microsoft.IdentityModel.Abstractions": "8.19.2"
+        }
+      },
+      "Microsoft.IdentityModel.Protocols": {
+        "type": "Transitive",
+        "resolved": "8.19.2",
+        "contentHash": "sGxSsSrZXNmca6D+jHH2rVRyo2nNRd/g4H9CFbPmLLq0xgoH1U0orLWE5minfijw7+zq49tBs7txenbfAErRoQ==",
+        "dependencies": {
+          "Microsoft.IdentityModel.Tokens": "8.19.2"
+        }
+      },
+      "Microsoft.IdentityModel.Protocols.OpenIdConnect": {
+        "type": "Transitive",
+        "resolved": "8.19.2",
+        "contentHash": "1XOcyY36cVymzE3qKdzKaUEZ4Pzt7ZpSa14JZoPPK1NLFUkQDs85TCqpV6XDo0YjFXj6nVK00AfOHppjghjhtw==",
+        "dependencies": {
+          "Microsoft.IdentityModel.Protocols": "8.19.2",
+          "System.IdentityModel.Tokens.Jwt": "8.19.2"
+        }
+      },
+      "Microsoft.IdentityModel.Tokens": {
+        "type": "Transitive",
+        "resolved": "8.19.2",
+        "contentHash": "GtPC1S02uH1gOO4fQ+zRysIicKmEXaYFP8PIkdJYXqMyruYhopre4ozVHp0XiDSA0+GJvOZH9prxCPvgBMg4Ww==",
+        "dependencies": {
+          "Microsoft.Bcl.Cryptography": "10.0.2",
+          "Microsoft.IdentityModel.Logging": "8.19.2"
+        }
+      },
+      "System.IdentityModel.Tokens.Jwt": {
+        "type": "Transitive",
+        "resolved": "8.19.2",
+        "contentHash": "gqhDC/icByKEutygpr+OFgAmjwTVowyzFjWB8K0q1ww8uFj5a1BQNL+QvijUl9uhq4p8OdDwcAIrjVC+eC9FVA==",
+        "dependencies": {
+          "Microsoft.IdentityModel.JsonWebTokens": "8.19.2",
+          "Microsoft.IdentityModel.Tokens": "8.19.2"
+        }
+      },
+      "JuanGCarmona.Lighthouse.Example.Modules.Catalog": {
+        "type": "Project",
+        "dependencies": {
+          "Lighthouse.Cqrs": "[1.0.0, )"
+        }
+      },
+      "lighthouse.cqrs": {
+        "type": "Project"
+      }
+    }
+  }
+}

package/assets/dotnet-template/examples/src/root/Lighthouse.Example.AppHost/Lighthouse.Example.AppHost.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Sdk Name="Aspire.AppHost.Sdk" Version="13.6.1" />
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <IsAspireHost>true</IsAspireHost>
+    <AspireUseCliBundle>true</AspireUseCliBundle>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Aspire.Hosting.AppHost" />
+    <PackageReference Include="MessagePack" PrivateAssets="all" />
+    <ProjectReference Include="../Lighthouse.Example.Api/Lighthouse.Example.Api.csproj" />
+  </ItemGroup>
+</Project>

package/assets/dotnet-template/examples/src/root/Lighthouse.Example.AppHost/Program.cs

@@ -0,0 +1,3 @@
+var builder = DistributedApplication.CreateBuilder(args);
+builder.AddProject<Projects.Lighthouse_Example_Api>("api");
+builder.Build().Run();