Extract the custom editors that make screens lie about their types

A property rendered by a custom editor does not show the control its type
implies, and the business class says nothing about it. The same category of
hidden behaviour as the Model Editor -- and worse in one way: the editors live in
the platform project beside the module, so nobody reading the business objects
ever meets them.

Detected from [PropertyEditor], [ListEditor] and [ViewItem], and from editor base
types, which catches the abstract editor a team writes once and never decorates.

Alias constants are resolved across the whole solution, and that turned out to be
required rather than nice: the attribute reads
CustomEditorAliases.BarcodeScannerPropertyEditor, the constant is declared in the
module, and the editor sits in the platform project. Reading either project alone
resolves nothing and reports the expression verbatim, which leaks an
implementation detail where the reader needs the value XAF matches on.

The DevExpress documentation corrected a design mistake before it shipped. Its
second argument is not a flag about the editor, it is the blast radius:
isDefault: true replaces the default for that type everywhere, while false means
the editor is merely selectable in the Model Editor. Linking by type in both
cases listed every entity with a string property as "uses the barcode scanner",
which is exactly the confident wrongness this project exists to stop.

The same docs surfaced a mechanism that was missing entirely:
View.CustomizeViewItemControl<T>() reconfigures a built-in editor at run time.
There is no custom editor class to find and nothing on the entity records it -- a
screen simply behaves differently from what its business class says.

Client assets are recorded too: the JavaScript an editor cannot work without is
behaviour in neither C# nor XML, and it is why a control breaks when somebody
renames a file.

Verified against a real application, which found both of its editors, resolved
the alias across projects, and picked up the controller that customises a
built-in one. The demo fixture now mirrors that shape so the same paths are
covered by tests that need nobody's private code. 160 tests.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: peopleworks

CHANGELOG.md

@@ -9,6 +9,33 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **Custom property and list editors.** A property rendered by one does not show the control its
+  type implies, and the business class says nothing about it — the same category of hidden
+  behaviour as the Model Editor. They also live in the platform project (`*.Blazor.Server`,
+  `*.Win`) *beside* the module, so nobody reading the business objects ever meets them.
+  - Detected from `[PropertyEditor]`, `[ListEditor]` and `[ViewItem]`, and from editor base types
+    for the abstract editors a team writes once and never decorates.
+  - **Alias constants are resolved across the solution.** The attribute reads
+    `CustomEditorAliases.BarcodeScannerPropertyEditor`; the reader needs the value XAF matches on,
+    and the constant is declared in the module while the editor sits in the platform project, so a
+    project read on its own resolves nothing.
+  - **Client assets are recorded** — the JavaScript an editor cannot work without. Behaviour in
+    neither C# nor XML, and the reason a control breaks when somebody renames a file.
+  - Also finds **built-in editors reconfigured at run time** through
+    `View.CustomizeViewItemControl<T>()`. There is no custom editor class to find: a controller
+    reaches into a built-in editor's component model, leaving no trace on the entity or in the
+    Model Editor.
+  - Surfaced in `AGENTS.md` as a ground rule, in the explainer, and through a new `xaf_editors`
+    MCP tool.
+  - Registration is read the way the DevExpress documentation defines it: `isDefault: true` means
+    the editor replaces the default for that type **everywhere**, while `false` means it is merely
+    *selectable* in the Model Editor. Only the first is reported as being used by an entity —
+    listing every string property in an application as "uses the barcode scanner" would be plainly
+    false.
+- A **fourteen-entity demo application** (`Fixtures/DemoSolution`) with a platform project, a
+  custom editor and a version-gated updater, so the diagrams and screenshots show a realistic
+  application that belongs to nobody.
+
 - **`xaflogic explain`** — a single self-contained HTML page explaining the application to a
   *person*. The same extraction already serves agents; this is the reader who has just inherited a
   ten-year-old XAF application, or has to hand one over.

src/XafLogicExplainer.Core/Analyzers/ControllerAnalyzer.cs

@@ -79,6 +79,7 @@ public List<ExtractedController> AnalyzeControllers(string sourceDirectory, Extr
 
         // Extract referenced entities
         controller.ReferencedEntities.AddRange(ExtractReferencedEntities(classDecl));
+        controller.CustomizedEditors.AddRange(ExtractCustomizedEditors(classDecl));
 
         // Extract comments
         if (options.IncludeComments)
@@ -314,6 +315,38 @@ private static List<ExtractedMethod> ExtractMethods(ClassDeclarationSyntax class
         return methods;
     }
 
+    /// <summary>
+    /// Finds built-in editors this controller reconfigures at run time.
+    /// </summary>
+    /// <remarks>
+    /// <c>View.CustomizeViewItemControl&lt;DateTimePropertyEditor&gt;(this, e =&gt; …)</c> is what
+    /// DevExpress recommends for small changes to a built-in editor, and it leaves no trace
+    /// anywhere else: no custom editor class, nothing on the entity, nothing in the Model Editor.
+    /// A screen simply behaves differently from what its business class implies.
+    /// </remarks>
+    private static List<string> ExtractCustomizedEditors(ClassDeclarationSyntax classDecl)
+    {
+        var editors = new List<string>();
+
+        var calls = classDecl.DescendantNodes()
+            .OfType<InvocationExpressionSyntax>()
+            .Where(i => i.Expression is MemberAccessExpressionSyntax
+            {
+                Name: GenericNameSyntax { Identifier.Text: "CustomizeViewItemControl" }
+            });
+
+        foreach (var call in calls)
+        {
+            var generic = (GenericNameSyntax)((MemberAccessExpressionSyntax)call.Expression).Name;
+            var editorType = generic.TypeArgumentList.Arguments.FirstOrDefault()?.ToString();
+
+            if (!string.IsNullOrWhiteSpace(editorType))
+                editors.Add(editorType);
+        }
+
+        return editors.Distinct(StringComparer.Ordinal).ToList();
+    }
+
     /// <summary>
     /// Resolves target object type from generic base type or constructor assignment.
     /// </summary>