@opengroundplan/core 0.1.1

package/templates/architectures/mvc-mvvm/files/tests/__solutionName.dot__.ArchitectureTests/PresentationBoundaryTests.cs

@@ -0,0 +1,124 @@
+using System.ComponentModel;
+using System.Reflection;
+using NetArchTest.Rules;
+using Xunit;
+using {{ solutionName | dot }}.Presentation.ViewModels;
+
+// xUnit ships a TestResult of its own.
+using TestResult = NetArchTest.Rules.TestResult;
+
+namespace {{ solutionName | dot }}.ArchitectureTests;
+
+/// <summary>The rules of separated presentation, enforced instead of documented.</summary>
+public sealed class PresentationBoundaryTests
+{
+    private static readonly Assembly Presentation = typeof(ViewModelBase).Assembly;
+    private const string Root = "{{ solutionName | dot }}.Presentation";
+
+    /// <summary>
+    /// UI framework roots. System.Windows.Input is absent on purpose: ICommand is the binding
+    /// contract every view model needs, not a view type.
+    /// </summary>
+    private static readonly string[] UiFrameworks =
+    [
+        "Microsoft.Maui",
+        "Microsoft.UI.Xaml",
+        "Microsoft.AspNetCore.Components",
+        "System.Windows.Controls",
+        "System.Windows.Media",
+        "System.Windows.Forms",
+        "Avalonia",
+    ];
+
+    [Fact]
+    public void View_models_are_discovered()
+    {
+        // Without this, every rule below would pass by inspecting nothing: a namespace filter
+        // that matches no types satisfies every condition.
+        Assert.True(
+            ViewModels().Count > 0,
+            $"No concrete type named *ViewModel in {Root}, so every rule below would pass by "
+                + "inspecting nothing. Add one under {Root}.ViewModels.");
+    }
+
+    [Fact]
+    public void ViewModels_do_not_depend_on_views()
+    {
+        var result = Types.InAssembly(Presentation)
+            .That()
+            .ResideInNamespace($"{Root}.ViewModels")
+            .ShouldNot()
+            .HaveDependencyOnAny($"{Root}.Views")
+            .GetResult();
+
+        Assert.True(
+            result.IsSuccessful,
+            Describe("A view model references a view. The dependency runs the other way, always.", result));
+    }
+
+    [Fact]
+    public void Models_do_not_depend_on_the_presentation_above_them()
+    {
+        var result = Types.InAssembly(Presentation)
+            .That()
+            .ResideInNamespace($"{Root}.Models")
+            .ShouldNot()
+            .HaveDependencyOnAny($"{Root}.ViewModels", $"{Root}.Views")
+            .GetResult();
+
+        Assert.True(
+            result.IsSuccessful,
+            Describe("A model references the presentation that displays it, which inverts the pattern.", result));
+    }
+
+    [Fact]
+    public void Presentation_logic_never_references_a_ui_framework()
+    {
+        var result = Types.InAssembly(Presentation)
+            .That()
+            .ResideInNamespace(Root)
+            .ShouldNot()
+            .HaveDependencyOnAny(UiFrameworks)
+            .GetResult();
+
+        Assert.True(
+            result.IsSuccessful,
+            Describe(
+                "A UI framework type leaked into the presentation library. That is what makes a "
+                    + "view model untestable without a UI — move it into the view.",
+                result));
+    }
+
+    // Reflection rather than NetArchTest: ImplementInterface matches only directly declared
+    // interfaces, so every view model inheriting notification from a base would fail it.
+    [Fact]
+    public void Every_view_model_raises_change_notification()
+    {
+        var missing = ViewModels()
+            .Where(type => !typeof(INotifyPropertyChanged).IsAssignableFrom(type))
+            .Select(type => $"  {type.FullName}")
+            .ToList();
+
+        Assert.True(
+            missing.Count == 0,
+            string.Join(
+                Environment.NewLine,
+                missing.Prepend(
+                    "A view model with no change notification cannot be bound to. Derive from ViewModelBase.")));
+    }
+
+    /// <summary>The concrete view models this assembly actually contains.</summary>
+    private static List<Type> ViewModels() =>
+        Presentation.GetTypes()
+            .Where(type => type.IsClass && !type.IsAbstract)
+            .Where(type => type.Name.EndsWith("ViewModel", StringComparison.Ordinal))
+            .ToList();
+
+    private static string Describe(string violation, TestResult result)
+    {
+        // FailingTypes is null on a passing test, and this message is built either way.
+        var failing = result.FailingTypes ?? [];
+        var lines = failing.Select(type => $"  {type.FullName} — {type.Explanation}");
+        return string.Join(Environment.NewLine, lines.Prepend(violation));
+    }
+}

package/templates/architectures/mvc-mvvm/files/tests/__solutionName.dot__.ArchitectureTests/__solutionName.dot__.ArchitectureTests.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>{{ dotnetTargetFramework }}</TargetFramework>
+    <!-- xUnit v3 test projects are executables. -->
+    <OutputType>Exe</OutputType>
+    <RootNamespace>{{ solutionName | dot }}.ArchitectureTests</RootNamespace>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <!-- Underscored test names are the convention here; the repo builds warnings-as-errors. -->
+    <NoWarn>$(NoWarn);CA1707</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="xunit.v3" />
+    <PackageReference Include="xunit.runner.visualstudio" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <!-- NetArchTest.Rules has been unmaintained since 2021; this fork tracks current .NET. -->
+    <PackageReference Include="NetArchTest.eNhancedEdition" />
+  </ItemGroup>
+
+  <!-- Safe to reference directly: the presentation library pulls in no packages of its own,
+       so it cannot drag the API's transitive pins into this project. -->
+  <ItemGroup>
+    <ProjectReference Include="../../src/{{ solutionName | dot }}.Presentation/{{ solutionName | dot }}.Presentation.csproj" />
+  </ItemGroup>
+
+</Project>

package/templates/architectures/mvc-mvvm/files/tests/test_presentation_boundaries.py

@@ -0,0 +1,33 @@
+"""The rules of this architecture, enforced instead of documented.
+
+Runs the same contracts as `lint-imports`, so CI fails whether it invokes the linter directly
+or just runs the test suite.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_presentation_contracts_hold() -> None:
+    linter = shutil.which("lint-imports")
+    if linter is None:
+        # Skipping would mean the boundary is unenforced and nobody notices.
+        pytest.fail("import-linter is not installed. Run: uv add --dev import-linter")
+
+    # Fixed argv, no shell.
+    result = subprocess.run(
+        [linter],
+        cwd=REPO_ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr

package/templates/architectures/onion/blueprint.yaml

@@ -0,0 +1,146 @@
+id: onion
+kind: architecture
+name: Onion Architecture
+description: >-
+  Palermo's concentric rings materialized as folders: Domain Model at the centre, Domain
+  Services around it, Application Services around that, and everything else on the outer
+  edge. Ships the ring skeleton plus a boundary check that fails the build — ArchUnitNET
+  fitness tests for .NET, an import-linter layers contract for Python, dependency-cruiser
+  forbidden rules for Node/TypeScript, and a stdlib import-walking test for Go.
+
+tags:
+  - onion
+  - palermo
+  - layered
+  - dependency-inversion
+  - domain-model
+  - boundary-enforcement
+  - fitness-function
+
+# The overlay contributes folders and a boundary check. It composes onto whichever base was
+# chosen and needs nothing from the layer catalog.
+requires: []
+
+# Architecture overlays are single-select in the engine, so a rival layout cannot be applied
+# alongside this one and there is no pair to declare.
+conflicts: []
+
+# Capability names a later layer can key off — a CI layer looks for `boundary-check` to know
+# there is an architecture gate worth running on every push.
+provides:
+  - architecture-onion
+  - boundary-check
+  - ring-skeleton
+
+# The layout is fully determined by the stack and the solution name. Offering a knob for the
+# one contested decision (which ring owns repository interfaces) would be theatre: the engine
+# substitutes tokens but cannot branch file *content*, so both answers would ship Palermo's
+# placement anyway. docs/architecture/onion-<stack>.md states it and cites him instead.
+variables: []
+
+files:
+  # ── .NET — one project per ring ─────────────────────────────────────────────
+  # Project-per-ring makes the boundary a compile error: an outward ProjectReference closes a
+  # cycle and MSBuild refuses it. The arch tests cover what the compiler cannot see.
+  - from: files/src/__solutionName.dot__.*/**/*
+    to: .
+    when: "stack == 'dotnet'"
+
+  - from: files/tests/__solutionName.dot__.ArchitectureTests/**/*
+    to: .
+    when: "stack == 'dotnet'"
+
+  - from: files/docs/architecture/onion-dotnet.md
+    to: .
+    when: "stack == 'dotnet'"
+
+  # ── Python — packages inside the base's src layout ──────────────────────────
+  - from: files/src/__solutionName.snake__/**/*
+    to: .
+    when: "stack == 'python'"
+
+  # Import Linter reads .importlinter before pyproject.toml, so the base keeps sole ownership
+  # of its packaging file and the contract stays readable on its own.
+  - from: files/.importlinter
+    to: .
+    when: "stack == 'python'"
+
+  - from: files/docs/architecture/onion-python.md
+    to: .
+    when: "stack == 'python'"
+
+  # ── Node / TypeScript — ring folders under the base's src ───────────────────
+  # Both stacks get the identical layout; onion.yaml rates typescript excellent. The engine
+  # only offers onion when the chosen base supports it, so this never fires on a frontend base.
+  - from: files/src/domain/**/*
+    to: .
+    when: "stack == 'node' || stack == 'typescript'"
+  - from: files/src/domain-services/**/*
+    to: .
+    when: "stack == 'node' || stack == 'typescript'"
+  - from: files/src/application-services/**/*
+    to: .
+    when: "stack == 'node' || stack == 'typescript'"
+  - from: files/src/infrastructure/**/*
+    to: .
+    when: "stack == 'node' || stack == 'typescript'"
+
+  # dependency-cruiser rather than an ESLint rule: nestjs-api and hono-api own their lint
+  # config (ESLint flat config and Biome respectively), and this overlay must not overwrite
+  # either. A standalone cruiser config and its own script collide with neither.
+  - from: files/.dependency-cruiser.cjs
+    to: .
+    when: "stack == 'node' || stack == 'typescript'"
+
+  - from: files/docs/architecture/onion-typescript.md
+    to: .
+    when: "stack == 'node' || stack == 'typescript'"
+
+  # ── Go — ring packages under internal/ ──────────────────────────────────────
+  - from: files/internal/**/*
+    to: .
+    when: "stack == 'go'"
+
+  - from: files/docs/architecture/onion-go.md
+    to: .
+    when: "stack == 'go'"
+
+  # Declared, not installed by a post-apply step: a package added after generation is
+  # missing from the first install (ADR 0005, spec 003).
+  - from: files/pyproject.toml
+    to: .
+    onConflict: merge
+    when: "stack == 'python'"
+
+  # The solution is completed declaratively rather than by `dotnet sln add`, which runs
+  # after the first build and is skippable — a solution missing projects that exist on
+  # disk builds green while covering less than the repo contains (ADR 0005, spec 003).
+  - from: files/__solutionName.dot__.slnx
+    to: .
+    onConflict: merge
+    when: "stack == 'dotnet'"
+
+  # Central package management: versions live in Directory.Packages.props and projects
+  # reference without one. A bare Version= on a PackageReference fails restore (NU1008).
+  - from: files/Directory.Packages.props
+    to: .
+    onConflict: merge
+    when: "stack == 'dotnet'"
+
+postApply:
+  # postApply strings are not token-rendered, so these use globs rather than the solution
+  # name. Every step is a manifest or solution-file edit — nothing that can half-apply.
+
+
+  - run: npm pkg set devDependencies.dependency-cruiser=^18.1.0
+    when: "stack == 'node' || stack == 'typescript'"
+    optional: true
+  # @swc/core backs the parser the cruiser config selects — see the comment there.
+  - run: npm pkg set devDependencies.@swc/core=^1.15.43
+    when: "stack == 'node' || stack == 'typescript'"
+    optional: true
+  - run: npm pkg set scripts.arch:check="depcruise src"
+    when: "stack == 'node' || stack == 'typescript'"
+    optional: true
+
+  # Go needs no dependency: the fitness test is stdlib go/parser only.

package/templates/architectures/onion/files/.dependency-cruiser.cjs

@@ -0,0 +1,50 @@
+// Onion's one rule as a build gate: `npm run arch:check` exits non-zero on a violation.
+// Each rule says what a ring may NOT reach — everything outside itself and the rings within.
+// .cjs so the config loads unchanged whether the base is ESM or CommonJS.
+
+module.exports = {
+  forbidden: [
+    {
+      name: 'domain-model-coupled-only-to-itself',
+      comment:
+        'Ring 1. Palermo: "The Domain Model is only coupled to itself." Anything it needs ' +
+        'from further out is declared as an interface in src/domain-services and injected.',
+      severity: 'error',
+      from: { path: '^src/domain/' },
+      to: { path: '^src/', pathNot: '^src/domain/' },
+    },
+    {
+      name: 'domain-services-reach-inward-only',
+      comment: 'Ring 2 may reach the Domain Model and itself. Nothing further out.',
+      severity: 'error',
+      from: { path: '^src/domain-services/' },
+      to: { path: '^src/', pathNot: '^src/(domain|domain-services)/' },
+    },
+    {
+      name: 'application-services-reach-inward-only',
+      comment:
+        'Ring 3 orchestrates use cases against interfaces. Reaching src/infrastructure here ' +
+        'is what re-couples the core to the database.',
+      severity: 'error',
+      from: { path: '^src/application-services/' },
+      to: { path: '^src/', pathNot: '^src/(domain|domain-services|application-services)/' },
+    },
+    {
+      name: 'no-circular',
+      comment: 'A cycle means two rings are really one; the layout stops describing the code.',
+      severity: 'error',
+      from: {},
+      to: { circular: true },
+    },
+  ],
+
+  options: {
+    // swc, not the bundled tsc reader: dependency-cruiser 18 supports typescript <7, and on a
+    // TypeScript 7 base it silently cruises zero modules and reports success. Verified both ways.
+    parser: 'swc',
+    doNotFollow: { path: 'node_modules' },
+    tsConfig: { fileName: 'tsconfig.json' },
+    // Tests sit on the outer edge and may reach any ring.
+    exclude: { path: '\\.(test|spec)\\.[cm]?[jt]sx?$' },
+  },
+};

package/templates/architectures/onion/files/.importlinter

@@ -0,0 +1,33 @@
+# Onion's one rule as a build gate. Run `lint-imports`; it exits non-zero on a violation.
+# Layers are listed outermost first — a module may import layers below it, never above.
+
+[importlinter]
+root_package = {{ solutionName | snake }}
+# Required by the persistence contract below — third-party names are otherwise invisible.
+include_external_packages = True
+
+[importlinter:contract:onion-rings]
+name = All coupling points toward the centre
+type = layers
+containers =
+    {{ solutionName | snake }}
+layers =
+    (main)
+    (api) | infrastructure
+    application_services
+    domain_services
+    domain
+
+# The centre must not know how it is stored. Listing the persistence libraries explicitly is
+# what makes "the database is external" checkable rather than aspirational.
+[importlinter:contract:domain-model-has-no-persistence]
+name = The Domain Model names no persistence library
+type = forbidden
+source_modules =
+    {{ solutionName | snake }}.domain
+forbidden_modules =
+    sqlalchemy
+    sqlmodel
+    psycopg
+    pymongo
+    redis

package/templates/architectures/onion/files/Directory.Packages.props

@@ -0,0 +1,8 @@
+<Project>
+  <ItemGroup>
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.8.1" />
+    <PackageVersion Include="TngTech.ArchUnitNET" Version="0.13.3" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="xunit.v3" Version="3.2.2" />
+  </ItemGroup>
+</Project>

package/templates/architectures/onion/files/__solutionName.dot__.slnx

@@ -0,0 +1,11 @@
+<Solution>
+  <Folder Name="/src/">
+    <Project Path="src/{{ solutionName | dot }}.ApplicationServices/{{ solutionName | dot }}.ApplicationServices.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.Domain/{{ solutionName | dot }}.Domain.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.DomainServices/{{ solutionName | dot }}.DomainServices.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.Infrastructure/{{ solutionName | dot }}.Infrastructure.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/{{ solutionName | dot }}.ArchitectureTests/{{ solutionName | dot }}.ArchitectureTests.csproj" />
+  </Folder>
+</Solution>

package/templates/architectures/onion/files/docs/architecture/onion-dotnet.md

@@ -0,0 +1,39 @@
+# Onion Architecture — layout
+
+Palermo's concentric rings, one .NET project per ring. Source dependencies run **inward
+only**: every project references the one nearer the centre and never the reverse.
+
+```
+src/
+  {{ solutionName | dot }}.Domain/               ring 1 — Domain Model (entities, value objects, events)
+  {{ solutionName | dot }}.DomainServices/        ring 2 — domain behaviour + repository *interfaces*
+    Repositories/                    interfaces only
+  {{ solutionName | dot }}.ApplicationServices/   ring 3 — use-case orchestration
+  {{ solutionName | dot }}.Infrastructure/        outer edge — repository impls, clients, framework code
+    Repositories/                    implementations
+tests/
+  {{ solutionName | dot }}.ArchitectureTests/     the ring rule, as a build gate
+```
+
+## The one rule
+
+> All code can depend on layers more central, but code cannot depend on layers further out
+> from the core. All coupling is toward the centre. — Palermo
+
+Two things enforce it, at two levels:
+
+- **The compiler.** An outward `ProjectReference` closes a cycle, and MSBuild refuses to
+  restore it. The ring boundary is a compile error before any test runs.
+- **`{{ solutionName | dot }}.ArchitectureTests`.** ArchUnitNET fitness tests catch what the
+  compiler cannot see *within* a correctly-referenced graph: a repository interface placed in
+  the wrong ring, or the Domain Model naming a persistence type. Run `dotnet test`.
+
+## Where things go
+
+- **Repository interfaces live in `DomainServices`**, not in the Domain Model. Palermo puts
+  them in the first ring *around* the centre; the object-saving behaviour "typically involves
+  a database", so only the interface is in the core.
+- **Repository implementations live in `Infrastructure`.** The database is external — the
+  centre defines the contract, the rim satisfies it. That inversion is the whole point.
+- Framework and persistence NuGet packages are referenced by `Infrastructure` only. If an
+  inner ring needs one, you have found a missing interface.

package/templates/architectures/onion/files/docs/architecture/onion-go.md

@@ -0,0 +1,33 @@
+# Onion Architecture — layout
+
+Palermo's concentric rings as packages under `internal/`. Imports run **inward only**: a
+package may import rings nearer the centre and never further out.
+
+```
+internal/
+  domain/                  ring 1 — Domain Model (entities, value objects, events)
+  domainservices/          ring 2 — domain behaviour + repository interfaces
+  applicationservices/     ring 3 — use-case orchestration
+  infrastructure/          outer edge — repository impls, clients, adapters
+  arch/                    the ring rule, as a go test
+cmd/                       composition root — wires concrete types into the inner rings
+```
+
+## The one rule
+
+> All coupling is toward the centre. — Palermo
+
+Enforced by `internal/arch`, a stdlib-only fitness test: it parses every `.go` file's imports
+and fails when a ring imports one further out. Run `go test ./...`. No linter to install, and
+`arch/rings.go` is the single source of the ring order.
+
+Go's own idiom already helps: `internal/` is unimportable from outside the module, and small
+interfaces defined by the consumer (in the inner ring) with implementations elsewhere (on the
+edge) is exactly the inversion Onion asks for.
+
+## Where things go
+
+- **Repository interfaces live in `domainservices`**, defined where they are consumed. Palermo
+  puts them in the first ring around the Domain Model.
+- **Implementations live in `infrastructure`** and are constructed in `cmd/` at startup, then
+  passed inward. No inner ring imports `infrastructure`.

package/templates/architectures/onion/files/docs/architecture/onion-python.md

@@ -0,0 +1,35 @@
+# Onion Architecture — layout
+
+Palermo's concentric rings as Python packages under `src/{{ solutionName | snake }}/`.
+Imports run **inward only**: a ring may import rings nearer the centre and never further out.
+
+```
+src/{{ solutionName | snake }}/
+  domain/                  ring 1 — Domain Model (entities, value objects, events)
+  domain_services/         ring 2 — domain behaviour + repository interfaces (Protocols)
+  application_services/    ring 3 — use-case orchestration
+  infrastructure/          outer edge — repository impls, clients, adapters
+```
+
+The base's own `api/` and `main` sit on the outer edge alongside `infrastructure`.
+
+## The one rule
+
+> All coupling is toward the centre. — Palermo
+
+Enforced by **Import Linter**, which fails the build on a violation. Run `lint-imports`
+(installed as a dev dependency; wire it into CI next to your other checks). Two contracts
+ship in `.importlinter`:
+
+- **`onion-rings`** — a `layers` contract, outermost first. `application_services` may reach
+  `domain_services` and `domain`; nothing may reach a ring further out.
+- **`domain-model-has-no-persistence`** — a `forbidden` contract. The Domain Model may not
+  import `sqlalchemy`, `psycopg`, `pymongo`, `redis`, or similar. The database is external, so
+  the centre never names it. Extend the list to match your stack.
+
+## Where things go
+
+- **Repository interfaces are Protocols in `domain_services`**, not in `domain`. Palermo puts
+  them in the first ring around the Domain Model.
+- **Implementations live in `infrastructure`** and are injected at the edge (in `main` /
+  route wiring). No inner ring imports `infrastructure`.

package/templates/architectures/onion/files/docs/architecture/onion-typescript.md

@@ -0,0 +1,34 @@
+# Onion Architecture — layout
+
+Palermo's concentric rings as folders under `src/`. Imports run **inward only**: a ring may
+import rings nearer the centre and never further out.
+
+```
+src/
+  domain/                  ring 1 — Domain Model (entities, value objects, events)
+  domain-services/         ring 2 — domain behaviour + repository interfaces
+  application-services/    ring 3 — use-case orchestration
+  infrastructure/          outer edge — repository impls, clients, adapters
+```
+
+The base's own entrypoint and route files sit on the outer edge alongside `infrastructure`.
+
+## The one rule
+
+> All coupling is toward the centre. — Palermo
+
+Enforced by **dependency-cruiser**, which exits non-zero on a violation. Run `npm run
+arch:check` (wire it into CI next to lint). `.dependency-cruiser.cjs` states one forbidden
+rule per ring plus a no-cycles rule; each says which paths a ring may **not** reach.
+
+Note: the config uses the swc parser deliberately. dependency-cruiser's bundled TypeScript
+reader supports typescript `<7`, and on a TypeScript 7 base it silently analyses zero files
+and reports success — a green check that checks nothing. swc parses the sources directly.
+
+## Where things go
+
+- **Repository interfaces live in `domain-services`**, not in `domain`. Palermo puts them in
+  the first ring around the Domain Model.
+- **Implementations live in `infrastructure`** and are injected at the composition root (your
+  `main`/`app` file). No inner ring imports `infrastructure`.
+- Tests are excluded from the check — they sit on the outer edge and may reach any ring.

package/templates/architectures/onion/files/internal/applicationservices/doc.go

@@ -0,0 +1,4 @@
+// Package applicationservices is ring 3 — one file per use case, orchestrating the inner rings.
+//
+// May import domainservices and domain. Never imports infrastructure or httpapi.
+package applicationservices

package/templates/architectures/onion/files/internal/arch/rings.go

@@ -0,0 +1,11 @@
+// Package arch holds the ring layout the fitness test in this package enforces.
+package arch
+
+// Rings, centre outward. A package in ring i may import rings 0..i and nothing beyond.
+// Paths are module-relative and are the architecture itself, not tunable configuration.
+var Rings = []string{
+	"internal/domain",
+	"internal/domainservices",
+	"internal/applicationservices",
+	"internal/infrastructure",
+}