diff --git a/CLAUDE.md b/CLAUDE.md
index db2a1a95..efc2eb8a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -57,7 +57,7 @@ The projects wired together in `CSharpCodeAnalyst.sln` (the load-bearing ones):
 
 `DartExtractor/` is a standalone **Dart** package (not in the .NET solution) used by the Dart/Flutter import — see **Dart/Flutter import** below.
 
-`TestSuite/` is a handcrafted C# solution used purely as parser input for the approval tests, and `TestSuiteDart/` is its Dart equivalent for the Dart import. Do not consume either from production code — they are intentionally full of odd language constructs. `ReferencedAssemblies/` contains the MSAGL DLLs referenced directly by `CSharpCodeAnalyst.csproj` and `Tests.csproj` (MSAGL is not on NuGet for the versions used here).
+`TestSuite/` is a handcrafted C# solution used purely as parser input for the approval tests, and `TestSuiteDart/` is its Dart equivalent for the Dart import. Do not consume either from production code — they are intentionally full of odd language constructs. `TestSuiteGenerated/` is a third fixture solution, for the **source-generator** path only (`SourceGeneratorFixtureTests`): it uses `[GeneratedRegex]`, which ships with the SDK, so it needs no package reference and neither a restore nor a build — MSBuildWorkspace's design-time build runs the generator. None of the three is part of `CSharpCodeAnalyst.sln`. `ReferencedAssemblies/` contains the MSAGL DLLs referenced directly by `CSharpCodeAnalyst.csproj` and `Tests.csproj` (MSAGL is not on NuGet for the versions used here).
 
 ## Architectural notes worth knowing before editing
 
@@ -93,7 +93,7 @@ Analyzers are the boxes under the **Analyzers** ribbon button. Each implements `
 Data flow, end to end:
 1. **Algorithm** in `CodeGraph/Algorithms/...` takes the `CodeGraph` and returns a plain result object. Type-level analyses lift relationships to the containing type, deduplicate, and exclude `IsExternal` nodes (see `TypeDependencyAnalysis` / `SystemMetricsAnalysis` as the reference); reuse `Type.IsDependency()` to decide which edges count.
 2. **`Analyze`** runs the algorithm; on an empty result it calls `_userNotification.ShowSuccess(...NoData)` and returns, otherwise it builds a **table view model** and publishes `new ShowTabularDataRequest(Id, Name, vm)` on the message bus.
-3. **Table VM** derives from `Table` (`AnalyzerSdk/DynamicDataGrid/Contracts/TabularData/`): `GetColumns()` returns `TableColumnDefinition`s (each binds a `PropertyName` on the row VM), `GetData()` returns the `TableRow`s. Optional: `CanFilter`/`Filter`, `GetCommands()` (context-menu / double-click actions), row-details template, and per-column `Rating` (an `IMetricRating` → colored cell background, see `ThresholdRating` and `RatingToBrushConverter`).
+3. **Table VM** derives from `Table` (`AnalyzerSdk/DynamicDataGrid/Contracts/TabularData/`): `GetColumns()` returns `TableColumnDefinition`s (each binds a `PropertyName` on the row VM), `GetData()` returns the `TableRow`s. Optional: `CanFilter`/`Filter`, `GetCommands()` (context-menu / double-click actions), row-details template, and per-column `Rating` (an `IMetricRating` → colored cell background, see `ThresholdRating` and `RatingToBrushConverter`). **"Copy table as CSV" comes for free** — `DynamicDataGrid` appends it to every table's context menu and copies the rows currently on screen (after filtering and sorting) via `TableCsv`; no analyzer implements its own export.
 4. **Row VM** derives from `TableRow` and exposes one property per column (plus a `SortMemberName`/`RatingValuePropertyName` numeric backer when the displayed column is a formatted string).
 5. **Register** the analyzer in `CSharpCodeAnalyst/Features/Analyzers/AnalyzerManager.LoadAnalyzers` (add a `using <Feature> = ...` alias and an `_analyzers.Add`). **No XAML change** is needed: the ribbon `RibbonSplitButton` binds `ItemsSource` to `MainViewModel.Analyzers` (= `AnalyzerManager.All`) and runs `ExecuteAnalyzerCommand` with the analyzer `Id`; `MainViewModel` publishes the result into a `DynamicTab` that hosts a `DynamicDataGrid`.
 6. **Strings** live in `CSharpCodeAnalyst.Analyzers/Resources/Strings.resx` **and** its hand-maintained `Strings.Designer.cs` (add the getter yourself). Convention: `Analyzer_<Id>_Label` / `_Tooltip` / `_NoData`, `Column_<Id>_<Col>`.
diff --git a/CSharpCodeAnalyst.AnalyzerSdk/DynamicDataGrid/Contracts/TabularData/TableCsv.cs b/CSharpCodeAnalyst.AnalyzerSdk/DynamicDataGrid/Contracts/TabularData/TableCsv.cs
new file mode 100644
index 00000000..c2fa8682
--- /dev/null
+++ b/CSharpCodeAnalyst.AnalyzerSdk/DynamicDataGrid/Contracts/TabularData/TableCsv.cs
@@ -0,0 +1,87 @@
+using System.Globalization;
+using System.Text;
+
+namespace CSharpCodeAnalyst.AnalyzerSdk.DynamicDataGrid.Contracts.TabularData;
+
+/// <summary>
+///     Turns a table into CSV, so a result can be counted, sorted or pivoted somewhere else. Separate from
+///     the grid that offers it, because the interesting part - quoting, and reading a cell the way the
+///     column binds it - is worth testing on its own.
+/// </summary>
+public static class TableCsv
+{
+    /// <param name="columns">The columns, in display order. Their <c>PropertyName</c> reads the cell.</param>
+    /// <param name="rows">
+    ///     The rows to write. The caller passes what is on screen - filtered and sorted - rather than the
+    ///     table's full data, because narrowing the result down is usually the first step.
+    /// </param>
+    /// <param name="separator">
+    ///     Null takes the list separator of the current culture, which is what a spreadsheet on the same
+    ///     machine expects: a comma in en-US, a semicolon in de-DE. With the wrong one the paste lands in a
+    ///     single column.
+    /// </param>
+    public static string Build(IEnumerable<TableColumnDefinition> columns, IEnumerable<object> rows,
+        string? separator = null)
+    {
+        ArgumentNullException.ThrowIfNull(columns);
+        ArgumentNullException.ThrowIfNull(rows);
+
+        separator ??= CultureInfo.CurrentCulture.TextInfo.ListSeparator;
+
+        var columnList = columns.ToList();
+        var csv = new StringBuilder();
+
+        csv.AppendLine(string.Join(separator, columnList.Select(column => Escape(column.Header, separator))));
+
+        foreach (var row in rows)
+        {
+            csv.AppendLine(string.Join(separator,
+                columnList.Select(column => Escape(ReadCell(row, column.PropertyName), separator))));
+        }
+
+        return csv.ToString();
+    }
+
+    /// <summary>
+    ///     Reads the property the column binds to. A column without a property name - a button, an image -
+    ///     contributes an empty cell instead of breaking the row.
+    /// </summary>
+    private static string ReadCell(object row, string? propertyName)
+    {
+        if (string.IsNullOrEmpty(propertyName))
+        {
+            return string.Empty;
+        }
+
+        var value = row.GetType().GetProperty(propertyName)?.GetValue(row);
+
+        return value switch
+        {
+            null => string.Empty,
+
+            // The same culture the cell was rendered with, so a number reads the same in both places.
+            IFormattable formattable => formattable.ToString(null, CultureInfo.CurrentCulture),
+            _ => value.ToString() ?? string.Empty
+        };
+    }
+
+    /// <summary>
+    ///     RFC 4180: quote a value that holds the separator, a quote or a line break, and double the quotes
+    ///     inside it. Names and hints in this application contain all three.
+    /// </summary>
+    private static string Escape(string? value, string separator)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            return string.Empty;
+        }
+
+        if (!value.Contains(separator, StringComparison.Ordinal) && !value.Contains('"') &&
+            !value.Contains('\n') && !value.Contains('\r'))
+        {
+            return value;
+        }
+
+        return $"\"{value.Replace("\"", "\"\"", StringComparison.Ordinal)}\"";
+    }
+}
diff --git a/CSharpCodeAnalyst.AnalyzerSdk/Search/SearchExpression.cs b/CSharpCodeAnalyst.AnalyzerSdk/Search/SearchExpression.cs
index 72ba1c79..e3aac223 100644
--- a/CSharpCodeAnalyst.AnalyzerSdk/Search/SearchExpression.cs
+++ b/CSharpCodeAnalyst.AnalyzerSdk/Search/SearchExpression.cs
@@ -38,6 +38,12 @@ protected Term(string searchTerm)
         {
             SearchMode = SearchType.ExternalCode;
         }
+        else if (lowerSearchTerm is "source:generated")
+        {
+            // Code a tool wrote. Mostly useful negated ("-source:generated"), because a resx designer or
+            // the XAML markup compiler contributes rows nobody can act on.
+            SearchMode = SearchType.GeneratedCode;
+        }
         else
         {
             var (isPascalCase, regex) = PascalCaseSearch.CreateSearchRegex(searchTerm);
@@ -88,7 +94,10 @@ internal enum SearchType
 
         FullNameResharperStyle,
         ExternalCode,
-        InternalCode
+        InternalCode,
+
+        // Written by a tool rather than a person (CodeElement.IsGenerated).
+        GeneratedCode
     }
 
     internal class And : IExpression
@@ -120,6 +129,31 @@ public bool Evaluate(CodeElement? item)
             return _conditions.Any(c => c.Evaluate(item));
         }
     }
+
+    /// <summary>
+    ///     Negates a condition, so a search can exclude instead of select ("-Strings." hides everything
+    ///     whose name contains "Strings.").
+    ///     <para>
+    ///         An item without a code element never matches, not even a negated condition. Every term
+    ///         answers "no" for a null item, and negation must not silently turn that into a match - the
+    ///         tree has a virtual root without a code element that would otherwise light up on every
+    ///         exclusion.
+    ///     </para>
+    /// </summary>
+    internal class Not : IExpression
+    {
+        private readonly IExpression _condition;
+
+        public Not(IExpression condition)
+        {
+            _condition = condition;
+        }
+
+        public bool Evaluate(CodeElement? item)
+        {
+            return item is not null && !_condition.Evaluate(item);
+        }
+    }
 }
 
 internal class FullNameSearch(string searchTerm) : Term(searchTerm)
@@ -136,6 +170,7 @@ public override bool Evaluate(CodeElement? item)
             SearchType.Type => item.ElementType == Type,
             SearchType.InternalCode => !item.IsExternal,
             SearchType.ExternalCode => item.IsExternal,
+            SearchType.GeneratedCode => item.IsGenerated,
             SearchType.FullNameResharperStyle => Regex!.IsMatch(item.FullName),
             _ => item.FullName.Contains(SearchTerm, StringComparison.InvariantCultureIgnoreCase)
         };
@@ -156,6 +191,7 @@ public override bool Evaluate(CodeElement? item)
             SearchType.Type => item.ElementType == Type,
             SearchType.InternalCode => !item.IsExternal,
             SearchType.ExternalCode => item.IsExternal,
+            SearchType.GeneratedCode => item.IsGenerated,
             SearchType.FullNameResharperStyle => Regex!.IsMatch(item.Name),
             _ => item.Name.Contains(SearchTerm, StringComparison.InvariantCultureIgnoreCase)
         };
diff --git a/CSharpCodeAnalyst.AnalyzerSdk/Search/SearchExpressionFactory.cs b/CSharpCodeAnalyst.AnalyzerSdk/Search/SearchExpressionFactory.cs
index 21d57a83..b01a620e 100644
--- a/CSharpCodeAnalyst.AnalyzerSdk/Search/SearchExpressionFactory.cs
+++ b/CSharpCodeAnalyst.AnalyzerSdk/Search/SearchExpressionFactory.cs
@@ -2,6 +2,13 @@
 
 public static class SearchExpressionFactory
 {
+    /// <summary>
+    ///     Marks a term as excluding rather than selecting. A minus sign cannot start a C# identifier, so
+    ///     it is free to use here; imported graphs may contain one inside a name, but not at the start of
+    ///     a search term.
+    /// </summary>
+    private const char NegationPrefix = '-';
+
     private static Term CreateTerm(string search, TextSearchField searchField)
     {
         if (searchField == TextSearchField.FullName)
@@ -12,7 +19,29 @@ private static Term CreateTerm(string search, TextSearchField searchField)
         return new NameSearch(search);
     }
 
-    public static IExpression CreateSearchExpression(string searchText, TextSearchField searchField = TextSearchField.FullName)
+    /// <summary>
+    ///     Wraps the term in a negation when it starts with '-'. The negation belongs to its own term, so
+    ///     it binds tighter than the AND of a group and than the OR between groups: "-a b | c" reads as
+    ///     "((NOT a) AND b) OR c". A lone '-' has nothing to negate and stays a literal search term.
+    /// </summary>
+    private static IExpression CreateTermOrNegation(string token, TextSearchField searchField, bool allowNegation)
+    {
+        if (allowNegation && token.Length > 1 && token[0] == NegationPrefix)
+        {
+            return new Term.Not(CreateTerm(token[1..], searchField));
+        }
+
+        return CreateTerm(token, searchField);
+    }
+
+    /// <param name="allowNegation">
+    ///     Whether a leading '-' excludes the term. Pass false where an expression that matches almost
+    ///     everything is harmful rather than useful: the tree expands and highlights every ancestor of a
+    ///     match, so an exclusion would unfold the whole tree at once. With negation off the '-' is part
+    ///     of the search term like any other character.
+    /// </param>
+    public static IExpression CreateSearchExpression(string searchText,
+        TextSearchField searchField = TextSearchField.FullName, bool allowNegation = true)
     {
         // Or binds less.
         var orTerms = searchText
@@ -24,7 +53,7 @@ public static IExpression CreateSearchExpression(string searchText, TextSearchFi
         {
             var andExpressions = orTerm
                 .Split([' '], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
-                .Select(IExpression (t) => CreateTerm(t, searchField))
+                .Select(t => CreateTermOrNegation(t, searchField, allowNegation))
                 .ToArray();
 
             orExpressions.Add(new Term.And(andExpressions));
diff --git a/CSharpCodeAnalyst.Analyzers/DeadCode/Analyzer.cs b/CSharpCodeAnalyst.Analyzers/DeadCode/Analyzer.cs
new file mode 100644
index 00000000..f6549255
--- /dev/null
+++ b/CSharpCodeAnalyst.Analyzers/DeadCode/Analyzer.cs
@@ -0,0 +1,69 @@
+using CSharpCodeAnalyst.Analyzers.DeadCode.Presentation;
+using CSharpCodeAnalyst.Analyzers.Resources;
+using CSharpCodeAnalyst.AnalyzerSdk.Contracts;
+using CSharpCodeAnalyst.AnalyzerSdk.Messages;
+using CSharpCodeAnalyst.AnalyzerSdk.Notifications;
+using CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+using CSharpCodeAnalyst.CodeGraph.Declarations;
+
+namespace CSharpCodeAnalyst.Analyzers.DeadCode;
+
+/// <summary>
+///     Lists the code nobody references any more - the topmost element of every dead subtree, together
+///     with the hint that explains why it might still be alive.
+/// </summary>
+public class Analyzer : IAnalyzer
+{
+    private readonly ExternalContractStore _externalContracts;
+    private readonly IPublisher _messaging;
+    private readonly IUserNotification _userNotification;
+
+    public Analyzer(IPublisher messaging, IUserNotification userNotification,
+        ExternalContractStore externalContracts)
+    {
+        _messaging = messaging;
+        _userNotification = userNotification;
+        _externalContracts = externalContracts;
+    }
+
+    public string Id { get; } = "DeadCode";
+    public string Name { get; } = Strings.Analyzer_DeadCode_Label;
+    public string Description { get; set; } = Strings.Analyzer_DeadCode_Tooltip;
+
+    public void Analyze(CodeGraph.Graph.CodeGraph graph)
+    {
+        var findings = DeadCodeAnalysis.Calculate(graph, _externalContracts);
+
+        if (findings.Count == 0)
+        {
+            _userNotification.ShowSuccess(Strings.Analyzer_DeadCode_NoData);
+            return;
+        }
+
+        var vm = new DeadCodeViewModel(findings, _messaging);
+        _messaging.Publish(new ShowTabularDataRequest(Id, Name, vm));
+    }
+
+    public string? GetPersistentData()
+    {
+        // No configuration or state to persist.
+        return null;
+    }
+
+    public void SetPersistentData(string? data)
+    {
+        // No configuration or state to persist.
+    }
+
+    public bool IsDirty()
+    {
+        return false;
+    }
+
+    public event EventHandler? DataChanged;
+
+    protected virtual void OnDataChanged()
+    {
+        DataChanged?.Invoke(this, EventArgs.Empty);
+    }
+}
diff --git a/CSharpCodeAnalyst.Analyzers/DeadCode/Presentation/DeadCodeRowViewModel.cs b/CSharpCodeAnalyst.Analyzers/DeadCode/Presentation/DeadCodeRowViewModel.cs
new file mode 100644
index 00000000..399ab2c6
--- /dev/null
+++ b/CSharpCodeAnalyst.Analyzers/DeadCode/Presentation/DeadCodeRowViewModel.cs
@@ -0,0 +1,114 @@
+using CSharpCodeAnalyst.Analyzers.Resources;
+using CSharpCodeAnalyst.AnalyzerSdk.DynamicDataGrid.Contracts.TabularData;
+using CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+
+namespace CSharpCodeAnalyst.Analyzers.DeadCode.Presentation;
+
+public class DeadCodeRowViewModel : TableRow
+{
+    /// <summary>Beyond this many related members the hint only states the count - the cell has to stay readable.</summary>
+    private const int MaxNamedRelatedMembers = 3;
+
+    internal DeadCodeRowViewModel(DeadCodeFinding finding)
+    {
+        Element = finding.Element;
+        Name = finding.Element.FullName;
+        Kind = finding.Element.ElementType.ToString();
+        // Fully qualified: WPF pulls a global "Accessibility" namespace into scope; ours is AccessLevel.
+        Access = finding.Element.AccessLevel == CodeGraph.Graph.AccessLevel.Unknown
+            ? string.Empty
+            : finding.Element.AccessLevel.ToString();
+
+        Confidence = finding.Confidence.ToString();
+
+        // Bound for the colour rating and for sorting; the column displays the word.
+        ConfidenceValue = (int)finding.Confidence;
+        Hint = FormatHint(finding);
+    }
+
+    /// <summary>The underlying graph node, used to jump to the source and to add it to the Code Explorer.</summary>
+    public CodeElement Element { get; }
+
+    public string Name { get; }
+    public string Kind { get; }
+
+    /// <summary>The element's visibility, empty when the producer did not supply one.</summary>
+    public string Access { get; }
+
+    public string Confidence { get; }
+
+    /// <summary>Numeric backer of <see cref="Confidence" /> for the colour rating and for sorting.</summary>
+    public int ConfidenceValue { get; }
+
+    /// <summary>
+    ///     Two kinds of note, joined into one cell: why the element might be alive despite having no
+    ///     visible reference (entry point, test code, attributes), and - for a contract finding - what
+    ///     dies together with it. Empty means neither applies, so nothing speaks against deleting it.
+    /// </summary>
+    public string Hint { get; }
+
+    private static string FormatHint(DeadCodeFinding finding)
+    {
+        var parts = new List<string>();
+
+        if (finding.Hints.HasFlag(DeadCodeHint.EntryPoint))
+        {
+            parts.Add(Strings.DeadCode_Hint_EntryPoint);
+        }
+
+        if (finding.Hints.HasFlag(DeadCodeHint.TestCode))
+        {
+            parts.Add(Strings.DeadCode_Hint_TestCode);
+        }
+
+        if (finding.Hints.HasFlag(DeadCodeHint.Generated))
+        {
+            parts.Add(Strings.DeadCode_Hint_Generated);
+        }
+
+        if (finding.Hints.HasFlag(DeadCodeHint.UsedOnlyByTests))
+        {
+            parts.Add(finding.TestReferences.Count == 0
+                ? Strings.DeadCode_Hint_UsedOnlyByTestsWithoutCaller
+                : string.Format(Strings.DeadCode_Hint_UsedOnlyByTests, Format(finding.TestReferences)));
+        }
+
+        if (finding.Hints.HasFlag(DeadCodeHint.ContractNeverCalled))
+        {
+            parts.Add(string.Format(Strings.DeadCode_Hint_ContractNeverCalled, FormatRelated(finding)));
+        }
+
+        if (finding.Hints.HasFlag(DeadCodeHint.ImplementsDeadContract))
+        {
+            parts.Add(string.Format(Strings.DeadCode_Hint_ImplementsDeadContract, FormatRelated(finding)));
+        }
+
+        if (finding.Hints.HasFlag(DeadCodeHint.ImplementsExternalContract))
+        {
+            parts.Add(string.Format(Strings.DeadCode_Hint_ImplementsExternalContract, finding.ExternalContract));
+        }
+
+        if (finding.Hints.HasFlag(DeadCodeHint.Attributed))
+        {
+            parts.Add(string.Format(Strings.DeadCode_Hint_Attributed, string.Join(", ", finding.Attributes)));
+        }
+
+        return string.Join("; ", parts);
+    }
+
+    private static string FormatRelated(DeadCodeFinding finding)
+    {
+        return Format(finding.RelatedMembers);
+    }
+
+    private static string Format(IReadOnlyList<CodeElement> members)
+    {
+        if (members.Count > MaxNamedRelatedMembers)
+        {
+            return string.Format(Strings.DeadCode_Hint_RelatedCount, members.Count);
+        }
+
+        return string.Join(", ", members.Select(m => m.FullName));
+    }
+}
diff --git a/CSharpCodeAnalyst.Analyzers/DeadCode/Presentation/DeadCodeViewModel.cs b/CSharpCodeAnalyst.Analyzers/DeadCode/Presentation/DeadCodeViewModel.cs
new file mode 100644
index 00000000..6c998803
--- /dev/null
+++ b/CSharpCodeAnalyst.Analyzers/DeadCode/Presentation/DeadCodeViewModel.cs
@@ -0,0 +1,141 @@
+using System.Collections.ObjectModel;
+using System.Windows;
+using CSharpCodeAnalyst.Analyzers.Resources;
+using CSharpCodeAnalyst.AnalyzerSdk.Contracts;
+using CSharpCodeAnalyst.AnalyzerSdk.DynamicDataGrid.Contracts.TabularData;
+using CSharpCodeAnalyst.AnalyzerSdk.Messages;
+using CSharpCodeAnalyst.AnalyzerSdk.Search;
+using CSharpCodeAnalyst.AnalyzerSdk.Wpf;
+using CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+
+namespace CSharpCodeAnalyst.Analyzers.DeadCode.Presentation;
+
+internal class DeadCodeViewModel : Table
+{
+    private readonly IPublisher _messaging;
+    private readonly ObservableCollection<TableRow> _rows;
+
+    internal DeadCodeViewModel(List<DeadCodeFinding> findings, IPublisher messaging)
+    {
+        _messaging = messaging;
+
+        // Highest confidence first: that is the part of the result you can work through without checking
+        // every entry by hand, so it belongs at the top before anyone touches a column header. The
+        // analysis already sorts by name, which stays the tie breaker within a confidence band.
+        var rows = findings
+            .OrderByDescending(f => f.Confidence)
+            .Select(f => new DeadCodeRowViewModel(f));
+        _rows = new ObservableCollection<TableRow>(rows);
+    }
+
+    public override bool CanFilter => true;
+
+    public override IEnumerable<TableColumnDefinition> GetColumns()
+    {
+        return new List<TableColumnDefinition>
+        {
+            new()
+            {
+                Type = ColumnType.Text,
+                Header = Strings.Column_DeadCode_Element,
+                PropertyName = nameof(DeadCodeRowViewModel.Name)
+            },
+            new()
+            {
+                Type = ColumnType.Text,
+                Header = Strings.Column_DeadCode_Kind,
+                PropertyName = nameof(DeadCodeRowViewModel.Kind),
+                Width = 90
+            },
+            new()
+            {
+                Type = ColumnType.Text,
+                Header = Strings.Column_DeadCode_Access,
+                PropertyName = nameof(DeadCodeRowViewModel.Access),
+                Width = 80
+            },
+            new()
+            {
+                Type = ColumnType.Text,
+                Header = Strings.Column_DeadCode_Confidence,
+                PropertyName = nameof(DeadCodeRowViewModel.Confidence),
+                Width = 80,
+
+                // High (2) green, Medium (1) orange, Low (0) red - here a larger value is better.
+                Rating = new ThresholdRating(2, 1, false),
+                RatingValuePropertyName = nameof(DeadCodeRowViewModel.ConfidenceValue),
+                SortMemberName = nameof(DeadCodeRowViewModel.ConfidenceValue)
+            },
+            new()
+            {
+                // Carries both the doubts (entry point, test code, attributes) and the explanation of a
+                // contract finding. Empty means nothing speaks against deleting the element, and sorting
+                // brings those rows together.
+                Type = ColumnType.Text,
+                Header = Strings.Column_DeadCode_Hint,
+                PropertyName = nameof(DeadCodeRowViewModel.Hint)
+            }
+        };
+    }
+
+    public override ObservableCollection<TableRow> GetData()
+    {
+        return _rows;
+    }
+
+    /// <summary>
+    ///     Filters by element name using the same search expression as the Advanced Search (camel-case,
+    ///     OR via '|', AND via spaces, exclusion via a leading '-'). Exclusion is what makes a long result
+    ///     usable: "-Strings. -Tests" drops whole groups of findings at once.
+    /// </summary>
+    public override ObservableCollection<TableRow> Filter(string searchText)
+    {
+        if (string.IsNullOrWhiteSpace(searchText))
+        {
+            return _rows;
+        }
+
+        var expression = SearchExpressionFactory.CreateSearchExpression(searchText);
+        var filtered = _rows
+            .Cast<DeadCodeRowViewModel>()
+            .Where(row => expression.Evaluate(row.Element));
+        return new ObservableCollection<TableRow>(filtered);
+    }
+
+    public override DataTemplate? GetRowDetailsTemplate()
+    {
+        return null;
+    }
+
+    public override List<CommandDefinition> GetCommands()
+    {
+        return
+        [
+            new CommandDefinition
+            {
+                Header = Strings.JumpToCode,
+                Command = new WpfCommand<DeadCodeRowViewModel>(JumpToCode, CanJumpToCode)
+            },
+            new CommandDefinition
+            {
+                Header = Strings.CopyToExplorerGraph_MenuItem,
+                Command = new WpfCommand<DeadCodeRowViewModel>(ShowInExplorer)
+            }
+        ];
+    }
+
+    private void ShowInExplorer(DeadCodeRowViewModel row)
+    {
+        _messaging.Publish(new AddNodeToGraphRequest(row.Element));
+    }
+
+    private static bool CanJumpToCode(DeadCodeRowViewModel row)
+    {
+        return row.Element.SourceLocations.Count > 0;
+    }
+
+    private void JumpToCode(DeadCodeRowViewModel row)
+    {
+        _messaging.Publish(new OpenSourceLocationRequest(row.Element.SourceLocations[0]));
+    }
+}
diff --git a/CSharpCodeAnalyst.Analyzers/Resources/Strings.Designer.cs b/CSharpCodeAnalyst.Analyzers/Resources/Strings.Designer.cs
index cd584a66..d591af2c 100644
--- a/CSharpCodeAnalyst.Analyzers/Resources/Strings.Designer.cs
+++ b/CSharpCodeAnalyst.Analyzers/Resources/Strings.Designer.cs
@@ -257,6 +257,168 @@ public static string Analyzer_SystemMetrics_Tooltip {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Dead Code.
+        /// </summary>
+        public static string Analyzer_DeadCode_Label {
+            get {
+                return ResourceManager.GetString("Analyzer_DeadCode_Label", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to No unreferenced elements found.
+        /// </summary>
+        public static string Analyzer_DeadCode_NoData {
+            get {
+                return ResourceManager.GetString("Analyzer_DeadCode_NoData", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Finds elements nothing references any more. Only the topmost element of a dead subtree is listed; the hint column marks the cases that may still be used through XAML, reflection or a test runner..
+        /// </summary>
+        public static string Analyzer_DeadCode_Tooltip {
+            get {
+                return ResourceManager.GetString("Analyzer_DeadCode_Tooltip", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Element.
+        /// </summary>
+        public static string Column_DeadCode_Element {
+            get {
+                return ResourceManager.GetString("Column_DeadCode_Element", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Notes.
+        /// </summary>
+        public static string Column_DeadCode_Hint {
+            get {
+                return ResourceManager.GetString("Column_DeadCode_Hint", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Kind.
+        /// </summary>
+        public static string Column_DeadCode_Kind {
+            get {
+                return ResourceManager.GetString("Column_DeadCode_Kind", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Access.
+        /// </summary>
+        public static string Column_DeadCode_Access {
+            get {
+                return ResourceManager.GetString("Column_DeadCode_Access", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Confidence.
+        /// </summary>
+        public static string Column_DeadCode_Confidence {
+            get {
+                return ResourceManager.GetString("Column_DeadCode_Confidence", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Attributes: {0}.
+        /// </summary>
+        public static string DeadCode_Hint_Attributed {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_Attributed", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Implemented but never called: {0}.
+        /// </summary>
+        public static string DeadCode_Hint_ContractNeverCalled {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_ContractNeverCalled", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Entry point.
+        /// </summary>
+        public static string DeadCode_Hint_EntryPoint {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_EntryPoint", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Implements unused contract: {0}.
+        /// </summary>
+        public static string DeadCode_Hint_ImplementsDeadContract {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_ImplementsDeadContract", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Implements external contract: {0}.
+        /// </summary>
+        public static string DeadCode_Hint_ImplementsExternalContract {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_ImplementsExternalContract", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to {0} members.
+        /// </summary>
+        public static string DeadCode_Hint_RelatedCount {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_RelatedCount", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Test code.
+        /// </summary>
+        public static string DeadCode_Hint_TestCode {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_TestCode", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Used only by tests: {0}.
+        /// </summary>
+        public static string DeadCode_Hint_UsedOnlyByTests {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_UsedOnlyByTests", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Used only by tests.
+        /// </summary>
+        public static string DeadCode_Hint_UsedOnlyByTestsWithoutCaller {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_UsedOnlyByTestsWithoutCaller", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Generated code.
+        /// </summary>
+        public static string DeadCode_Hint_Generated {
+            get {
+                return ResourceManager.GetString("DeadCode_Hint_Generated", resourceCulture);
+            }
+        }
+
         /// <summary>
         ///   Looks up a localized string similar to Type Cohesion.
         /// </summary>
diff --git a/CSharpCodeAnalyst.Analyzers/Resources/Strings.resx b/CSharpCodeAnalyst.Analyzers/Resources/Strings.resx
index 1762903e..0809af49 100644
--- a/CSharpCodeAnalyst.Analyzers/Resources/Strings.resx
+++ b/CSharpCodeAnalyst.Analyzers/Resources/Strings.resx
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
     <!--
       Microsoft ResX Schema
@@ -203,6 +203,60 @@
   </data>
     <data name="Analyzer_TypeDependencies_NoData" xml:space="preserve">
     <value>No types found to rank</value>
+  </data>
+    <data name="Analyzer_DeadCode_Label" xml:space="preserve">
+    <value>Dead Code</value>
+  </data>
+    <data name="Analyzer_DeadCode_Tooltip" xml:space="preserve">
+    <value>Finds elements nothing references any more. Only the topmost element of a dead subtree is listed; the hint column marks the cases that may still be used through XAML, reflection or a test runner.</value>
+  </data>
+    <data name="Analyzer_DeadCode_NoData" xml:space="preserve">
+    <value>No unreferenced elements found</value>
+  </data>
+    <data name="Column_DeadCode_Element" xml:space="preserve">
+    <value>Element</value>
+  </data>
+    <data name="Column_DeadCode_Kind" xml:space="preserve">
+    <value>Kind</value>
+  </data>
+    <data name="Column_DeadCode_Access" xml:space="preserve">
+    <value>Access</value>
+  </data>
+    <data name="Column_DeadCode_Confidence" xml:space="preserve">
+    <value>Confidence</value>
+  </data>
+    <data name="Column_DeadCode_Hint" xml:space="preserve">
+    <value>Notes</value>
+  </data>
+    <data name="DeadCode_Hint_EntryPoint" xml:space="preserve">
+    <value>Entry point</value>
+  </data>
+    <data name="DeadCode_Hint_TestCode" xml:space="preserve">
+    <value>Test code</value>
+  </data>
+    <data name="DeadCode_Hint_Attributed" xml:space="preserve">
+    <value>Attributes: {0}</value>
+  </data>
+    <data name="DeadCode_Hint_ContractNeverCalled" xml:space="preserve">
+    <value>Implemented but never called: {0}</value>
+  </data>
+    <data name="DeadCode_Hint_ImplementsDeadContract" xml:space="preserve">
+    <value>Implements unused contract: {0}</value>
+  </data>
+    <data name="DeadCode_Hint_ImplementsExternalContract" xml:space="preserve">
+    <value>Implements external contract: {0}</value>
+  </data>
+    <data name="DeadCode_Hint_RelatedCount" xml:space="preserve">
+    <value>{0} members</value>
+  </data>
+    <data name="DeadCode_Hint_UsedOnlyByTests" xml:space="preserve">
+    <value>Used only by tests: {0}</value>
+  </data>
+    <data name="DeadCode_Hint_UsedOnlyByTestsWithoutCaller" xml:space="preserve">
+    <value>Used only by tests</value>
+  </data>
+    <data name="DeadCode_Hint_Generated" xml:space="preserve">
+    <value>Generated code</value>
   </data>
     <data name="Analyzer_TypeCohesion_Label" xml:space="preserve">
     <value>Type Cohesion</value>
diff --git a/CSharpCodeAnalyst.Analyzers/TypeDependencies/Presentation/TypeDependenciesViewModel.cs b/CSharpCodeAnalyst.Analyzers/TypeDependencies/Presentation/TypeDependenciesViewModel.cs
index a33e4232..d76526c9 100644
--- a/CSharpCodeAnalyst.Analyzers/TypeDependencies/Presentation/TypeDependenciesViewModel.cs
+++ b/CSharpCodeAnalyst.Analyzers/TypeDependencies/Presentation/TypeDependenciesViewModel.cs
@@ -81,7 +81,8 @@ public override ObservableCollection<TableRow> GetData()
 
     /// <summary>
     ///     Filters by type name using the same search expression as the Advanced Search
-    ///     (supports camel-case, OR via '|', AND via spaces). The searched column is the type name.
+    ///     (camel-case, OR via '|', AND via spaces, exclusion via a leading '-'). The searched column is
+    ///     the type name.
     /// </summary>
     public override ObservableCollection<TableRow> Filter(string searchText)
     {
diff --git a/CSharpCodeAnalyst.CodeGraph/Algorithms/DeadCode/DeadCodeAnalysis.cs b/CSharpCodeAnalyst.CodeGraph/Algorithms/DeadCode/DeadCodeAnalysis.cs
new file mode 100644
index 00000000..a6a0f724
--- /dev/null
+++ b/CSharpCodeAnalyst.CodeGraph/Algorithms/DeadCode/DeadCodeAnalysis.cs
@@ -0,0 +1,813 @@
+using CSharpCodeAnalyst.CodeGraph.Declarations;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+
+namespace CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+
+/// <summary>
+///     Finds code nobody references any more.
+///     <para>
+///         The rule is expressed over the subtree, not over the single element: an element is dead when no
+///         relationship enters its subtree from the outside. That makes the obvious case work - a class
+///         whose method is called from elsewhere is alive even though nothing names the class itself - and
+///         it also stops a class from keeping itself alive: methods that only call each other are internal
+///         to the subtree and prove nothing. Because a dead element implies a dead subtree, only the
+///         topmost dead element of a subtree is reported.
+///     </para>
+///     <para>
+///         Polymorphism is handled by propagating liveness instead of counting the edge as a reference.
+///         "Implements" / "Overrides" point from the implementation to the contract, so an implementation
+///         never has an incoming reference and a contract member always looks used. Both are wrong. We
+///         therefore ignore those edges as references and instead push liveness the other way: a contract
+///         member that is called keeps all its implementations (and their types) alive. A contract that is
+///         never called dies together with its implementations, which is exactly the finding one wants.
+///         Contracts from outside the analyzed code are the exception - we cannot see who calls them, so
+///         the implementation is still reported, but with
+///         <see cref="DeadCodeHint.ImplementsExternalContract" /> and the lowest confidence: the decision
+///         stays visible instead of silently removing the row. The note deliberately does not extend to
+///         the containing type: a class whose only "use" is implementing IDisposable is still dead code.
+///     </para>
+///     <para>
+///         References are counted in two colours. An element nothing references at all is the obvious
+///         finding; an element only <i>test</i> code references is the same statement about the production
+///         code, and is reported with <see cref="DeadCodeHint.UsedOnlyByTests" />. Without that rule,
+///         analyzing the tests along with the production code would <i>hide</i> dead code - exactly the
+///         elements one would see by excluding the test projects. Test code is decided per type (see
+///         <see cref="FindTestTypes" />), and inside a test type the rule is off: a fixture's own helper
+///         members and nested fakes are what the tests are made of. An unattributed helper class outside
+///         the fixtures is reported like anything else - only the tests need it, it goes when they go.
+///     </para>
+///     <para>
+///         The analysis reports exactly what nothing references <i>right now</i>. It does not chase the
+///         consequences: code that is only kept alive by the code just reported stays out of the result.
+///         That is a deliberate step back from an earlier cascading version, which multiplied every false
+///         positive - one invisible XAML binding took seven further elements with it. Deleting a finding
+///         and running the analysis again gives the same answer without stacking the uncertainty.
+///     </para>
+///     <para>
+///         Every finding carries a <see cref="DeadCodeFinding.Confidence" />, and
+///         <see cref="AccessLevel" /> is what makes the top level reachable: an element confined to its
+///         type or assembly cannot be referenced from code we did not analyze, so "nothing references it"
+///         and "nothing can reference it" coincide. A producer that supplies no visibility never reaches
+///         that level - which is the honest answer, not a penalty.
+///     </para>
+///     <para>
+///         Two cases are dropped instead of reported. A public property of a type marked as a
+///         serialization target (see <see cref="IsSerializedProperty" />): a serializer reaches it by
+///         reflection, so on such a type an unreferenced property is the rule rather than the exception.
+///         And the members only the runtime ever calls, static constructor and finalizer (see
+///         <see cref="IsRuntimeInvoked" />): no code can reference them, so the row would be wrong on
+///         every live type.
+///     </para>
+///     <para>
+///         A single property accessor <i>is</i> reported. Rolling it up into the property used to halve the
+///         output, but it answered a question nobody asked: "is this property used at all" instead of "is
+///         anything reading it". A setter nothing calls is a real finding, and hiding it contradicts the
+///         rest of this class, which reports and annotates rather than drops. Accessors only exist in the
+///         graph at all when <c>ParserConfig.SplitPropertyAccessors</c> is on.
+///     </para>
+///     <para>
+///         Limitations, by construction: references the parser cannot see (reflection, dependency
+///         injection, serialization) look like dead code - see <see cref="DeadCodeHint" />. Dead cycles are
+///         not found either: two elements that only reference each other keep each other alive, which needs
+///         reachability from an explicit set of entry points rather than a cascade.
+///     </para>
+/// </summary>
+public static class DeadCodeAnalysis
+{
+    /// <summary>
+    ///     The notes that say "the caller is somewhere we cannot see". They are what pins a finding to the
+    ///     lowest confidence: we already know we might be wrong about it.
+    /// </summary>
+    private const DeadCodeHint CallerOutsideTheGraph =
+        DeadCodeHint.EntryPoint | DeadCodeHint.TestCode | DeadCodeHint.Attributed |
+        DeadCodeHint.ImplementsExternalContract;
+
+    /// <summary>
+    ///     Attribute names (with and without the "Attribute" suffix) of the common test frameworks. A test
+    ///     method is called by a runner, never from the code, so it always looks unreferenced. Matching is
+    ///     case-sensitive: the framework names are exact, and a domain attribute that happens to be called
+    ///     "test" must not turn its class into test code.
+    /// </summary>
+    private static readonly HashSet<string> TestAttributes = new(StringComparer.Ordinal)
+    {
+        "Test", "TestAttribute",
+        "TestCase", "TestCaseAttribute",
+        "TestCaseSource", "TestCaseSourceAttribute",
+        "TestFixture", "TestFixtureAttribute",
+        "SetUp", "SetUpAttribute",
+        "TearDown", "TearDownAttribute",
+        "OneTimeSetUp", "OneTimeSetUpAttribute",
+        "OneTimeTearDown", "OneTimeTearDownAttribute",
+        "Fact", "FactAttribute",
+        "Theory", "TheoryAttribute",
+        "TestMethod", "TestMethodAttribute",
+        "DataTestMethod", "DataTestMethodAttribute",
+        "TestClass", "TestClassAttribute",
+        "TestInitialize", "TestInitializeAttribute",
+        "TestCleanup", "TestCleanupAttribute",
+        "ClassInitialize", "ClassInitializeAttribute",
+        "ClassCleanup", "ClassCleanupAttribute",
+        "Benchmark", "BenchmarkAttribute"
+    };
+
+    /// <summary>
+    ///     Attribute names (with and without the "Attribute" suffix) that talk to the compiler, the
+    ///     debugger or a code analyzer - not to a runtime that would find the element by reflection. They
+    ///     say nothing about a caller, so they do not raise <see cref="DeadCodeHint.Attributed" />;
+    ///     without this list a single [Obsolete] or [DebuggerDisplay] pushed a finding down to the lowest
+    ///     confidence. Every attribute <i>not</i> listed here keeps the doubt - a custom or framework
+    ///     attribute ([Export], [HttpGet], ...) usually means exactly that some framework drives the
+    ///     element. [Obsolete] is the extreme case: it argues for deleting the element, not against it.
+    /// </summary>
+    private static readonly HashSet<string> ToolingAttributes = new(StringComparer.Ordinal)
+    {
+        "Obsolete", "ObsoleteAttribute",
+        "Flags", "FlagsAttribute",
+        "AttributeUsage", "AttributeUsageAttribute",
+        "Conditional", "ConditionalAttribute",
+        "MethodImpl", "MethodImplAttribute",
+        "CLSCompliant", "CLSCompliantAttribute",
+        "DebuggerDisplay", "DebuggerDisplayAttribute",
+        "DebuggerStepThrough", "DebuggerStepThroughAttribute",
+        "DebuggerHidden", "DebuggerHiddenAttribute",
+        "DebuggerNonUserCode", "DebuggerNonUserCodeAttribute",
+        "DebuggerBrowsable", "DebuggerBrowsableAttribute",
+        "DebuggerTypeProxy", "DebuggerTypeProxyAttribute",
+        "ExcludeFromCodeCoverage", "ExcludeFromCodeCoverageAttribute",
+        "SuppressMessage", "SuppressMessageAttribute",
+        "EditorBrowsable", "EditorBrowsableAttribute",
+        "GeneratedCode", "GeneratedCodeAttribute"
+    };
+
+    /// <summary>
+    ///     Attribute names (with and without the "Attribute" suffix) that mark a whole type as a
+    ///     serialization target. A serializer reads and writes the public properties by reflection, so on
+    ///     such a type they look unreferenced no matter how heavily the type is used.
+    /// </summary>
+    private static readonly HashSet<string> SerializationAttributes = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "Serializable", "SerializableAttribute",
+        "DataContract", "DataContractAttribute",
+        "JsonObject", "JsonObjectAttribute",
+        "JsonConverter", "JsonConverterAttribute",
+        "XmlRoot", "XmlRootAttribute",
+        "XmlType", "XmlTypeAttribute",
+        "ProtoContract", "ProtoContractAttribute",
+        "MessagePackObject", "MessagePackObjectAttribute"
+    };
+
+    /// <param name="externalContracts">
+    ///     What the parser recorded beside the graph: which members implement or override something from
+    ///     outside the analyzed code. Optional - without it those members are reported like any other
+    ///     unreferenced member, which is what they look like from the graph alone.
+    /// </param>
+    public static List<DeadCodeFinding> Calculate(Graph.CodeGraph graph,
+        ExternalContractStore? externalContracts = null)
+    {
+        ArgumentNullException.ThrowIfNull(graph);
+
+        // Element -> the contract outside the analyzed code it implements. Two sources: the store the
+        // parser fills from the symbols, and - when external code is part of the graph - the edges.
+        var external = new Dictionary<string, string>();
+        if (externalContracts is not null)
+        {
+            foreach (var (elementId, contract) in externalContracts.Contracts)
+            {
+                external[elementId] = contract;
+            }
+        }
+
+        // Internal contract member -> the members implementing / overriding it, and the reverse.
+        var implementations = new Dictionary<string, List<CodeElement>>();
+        var contracts = new Dictionary<string, List<CodeElement>>();
+
+        var referenceEdges = new List<(CodeElement Source, CodeElement Target)>();
+        CollectEdges(graph, referenceEdges, external, implementations, contracts);
+
+        var testTypes = FindTestTypes(graph);
+
+        // The types whose public properties a XAML {Binding} may read - see IsBindable. Recorded by the
+        // parser; an importer graph or a project file saved before the set existed simply has none.
+        var bindingSources = externalContracts?.NotifyingTypes.ToHashSet() ?? [];
+
+        var context = new AnalysisContext(external, implementations, contracts,
+            bindingSources, FindSerializableTypes(graph),
+            testTypes, CollectTestReferences(referenceEdges, testTypes));
+
+        var references = ComputeReferenced(referenceEdges, implementations, testTypes);
+
+        return Report(graph, references, context)
+            .OrderBy(f => f.Element.FullName, StringComparer.Ordinal)
+            .ToList();
+    }
+
+    /// <summary>The structural facts of one run, all derived once from the graph.</summary>
+    private sealed record AnalysisContext(
+        Dictionary<string, string> External,
+        Dictionary<string, List<CodeElement>> Implementations,
+        Dictionary<string, List<CodeElement>> Contracts,
+        HashSet<string> BindingSources,
+        HashSet<string> SerializableTypes,
+        HashSet<string> TestTypes,
+        Dictionary<string, List<CodeElement>> TestReferences);
+
+    /// <summary>
+    ///     What a relationship reaches, once counting every relationship and once counting only those that
+    ///     do not start in test code. An element in <see cref="All" /> but not in
+    ///     <see cref="FromProduction" /> is used by tests and by nothing else.
+    /// </summary>
+    private sealed record ReferenceSets(HashSet<string> All, HashSet<string> FromProduction);
+
+    /// <summary>
+    ///     The types holding the tests: every type on the ancestor chain of an element carrying a known
+    ///     test-framework attribute.
+    ///     <para>
+    ///         The chain, not just the attributed element: xUnit has no class-level attribute at all
+    ///         (only the [Fact] methods carry one) and NUnit finds classes without [TestFixture] too, so
+    ///         it is the subtree that marks a fixture. Marking every ancestor type also covers the fakes
+    ///         and test-data classes nested inside one.
+    ///     </para>
+    ///     <para>
+    ///         Deliberately the type and not the assembly (which this used to be). One embedded test
+    ///         class poisoned its whole assembly, in both directions: every reference leaving the
+    ///         assembly counted as a test reference, so code in <i>other</i> assemblies used from there
+    ///         was falsely used-only-by-tests - and production code beside the embedded tests, used only
+    ///         by them, was never found, because the whole assembly was exempt. The price of the type
+    ///         granularity is the unattributed helper outside the fixtures (builders, fakes), which is
+    ///         now reported as used-only-by-tests. That is accepted, and it is a true statement: the
+    ///         helper goes when the tests go.
+    ///     </para>
+    /// </summary>
+    private static HashSet<string> FindTestTypes(Graph.CodeGraph graph)
+    {
+        var testTypes = new HashSet<string>();
+
+        foreach (var element in graph.Nodes.Values)
+        {
+            if (!element.Attributes.Any(TestAttributes.Contains))
+            {
+                continue;
+            }
+
+            for (var current = element; current is not null; current = current.Parent)
+            {
+                if (current.IsType())
+                {
+                    testTypes.Add(current.Id);
+                }
+            }
+        }
+
+        return testTypes;
+    }
+
+    /// <summary>Whether the element is a test type or sits inside one.</summary>
+    private static bool IsTestCode(CodeElement element, HashSet<string> testTypes)
+    {
+        for (var current = element; current is not null; current = current.Parent)
+        {
+            if (testTypes.Contains(current.Id))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Element -&gt; the test elements referencing it, so a used-only-by-tests finding can name what has
+    ///     to be deleted with it. Only the relationships starting in test code are walked.
+    /// </summary>
+    private static Dictionary<string, List<CodeElement>> CollectTestReferences(
+        List<(CodeElement Source, CodeElement Target)> referenceEdges, HashSet<string> testTypes)
+    {
+        var testReferences = new Dictionary<string, List<CodeElement>>();
+
+        // Reused across relationships, like in ComputeReferenced.
+        var reached = new HashSet<string>();
+        var sourceChain = new HashSet<string>();
+
+        foreach (var (source, target) in referenceEdges)
+        {
+            if (!IsTestCode(source, testTypes))
+            {
+                continue;
+            }
+
+            reached.Clear();
+            MarkReferenced(source, target, reached, sourceChain);
+
+            foreach (var id in reached)
+            {
+                if (!testReferences.TryGetValue(id, out var callers))
+                {
+                    callers = [];
+                    testReferences[id] = callers;
+                }
+
+                // The same test typically reaches an element over several relationships.
+                if (!callers.Contains(source))
+                {
+                    callers.Add(source);
+                }
+            }
+        }
+
+        return testReferences;
+    }
+
+    /// <summary>
+    ///     The types a serializer drives: everything carrying one of the
+    ///     <see cref="SerializationAttributes" />. Unlike the binding sources this is not spread down the
+    ///     inheritance edges - none of those attributes is inherited, a derived type has to carry its own.
+    /// </summary>
+    private static HashSet<string> FindSerializableTypes(Graph.CodeGraph graph)
+    {
+        return graph.Nodes.Values
+            .Where(element => element.IsType() && element.Attributes.Any(SerializationAttributes.Contains))
+            .Select(element => element.Id)
+            .ToHashSet();
+    }
+
+    private static CodeElement? ContainingType(CodeElement? element)
+    {
+        var current = element;
+        while (current is not null && !current.IsType())
+        {
+            current = current.Parent;
+        }
+
+        return current;
+    }
+
+    /// <summary>
+    ///     Everything a relationship enters from the outside, plus what a used contract keeps alive - the
+    ///     same walk twice, once over all relationships and once leaving out those that start in test code.
+    ///     <para>
+    ///         The contract propagation has to run per colour, not once at the end: the UI calling
+    ///         <c>ICodeGraphExplorer.FindIncomingCalls</c> keeps the implementation alive for production,
+    ///         a test calling it does not. Sharing one propagation would mark every implementation of a
+    ///         contract that any test uses as production code.
+    ///     </para>
+    /// </summary>
+    private static ReferenceSets ComputeReferenced(
+        List<(CodeElement Source, CodeElement Target)> referenceEdges,
+        Dictionary<string, List<CodeElement>> implementations,
+        HashSet<string> testTypes)
+    {
+        return new ReferenceSets(
+            Mark(referenceEdges, implementations, _ => true),
+            Mark(referenceEdges, implementations, source => !IsTestCode(source, testTypes)));
+    }
+
+    private static HashSet<string> Mark(
+        List<(CodeElement Source, CodeElement Target)> referenceEdges,
+        Dictionary<string, List<CodeElement>> implementations,
+        Func<CodeElement, bool> includeSource)
+    {
+        var referenced = new HashSet<string>();
+
+        // Reused across relationships to keep the walk allocation free.
+        var sourceChain = new HashSet<string>();
+
+        foreach (var (source, target) in referenceEdges)
+        {
+            if (includeSource(source))
+            {
+                MarkReferenced(source, target, referenced, sourceChain);
+            }
+        }
+
+        PropagateContractUsage(referenced, implementations);
+        return referenced;
+    }
+
+    private static void CollectEdges(Graph.CodeGraph graph,
+        List<(CodeElement Source, CodeElement Target)> referenceEdges,
+        Dictionary<string, string> external,
+        Dictionary<string, List<CodeElement>> implementations, Dictionary<string, List<CodeElement>> contracts)
+    {
+        foreach (var relationship in graph.GetAllRelationships())
+        {
+            var source = graph.TryGetCodeElement(relationship.SourceId);
+            var target = graph.TryGetCodeElement(relationship.TargetId);
+            if (source is null || target is null)
+            {
+                continue;
+            }
+
+            if (IsPolymorphicEdge(relationship.Type, source))
+            {
+                RecordPolymorphicEdge(source, target, external, implementations, contracts);
+                continue;
+            }
+
+            // Containment, Bundled and Handles are not references. Handles (handler -> event) is the
+            // callback wiring; the registration site itself produces the method group "Uses" edge that
+            // keeps the handler alive, so nothing is lost by ignoring it here.
+            if (!relationship.Type.IsDependency())
+            {
+                continue;
+            }
+
+            referenceEdges.Add((source, target));
+        }
+    }
+
+    /// <summary>
+    ///     A relationship keeps alive every element whose subtree it enters from the outside: walking up
+    ///     from the target, that is everything below the lowest common ancestor with the source. The common
+    ///     ancestor and everything above it contain the source as well, so for them the relationship is an
+    ///     internal one and proves nothing.
+    /// </summary>
+    private static void MarkReferenced(CodeElement source, CodeElement target, HashSet<string> referenced,
+        HashSet<string> sourceChain)
+    {
+        sourceChain.Clear();
+        for (var current = source; current is not null; current = current.Parent)
+        {
+            sourceChain.Add(current.Id);
+        }
+
+        for (var current = target; current is not null; current = current.Parent)
+        {
+            if (sourceChain.Contains(current.Id))
+            {
+                break;
+            }
+
+            referenced.Add(current.Id);
+        }
+    }
+
+    /// <summary>
+    ///     Marks an element alive whose caller is not part of the graph (a contract call reaching all
+    ///     implementations). Without a source there is no common ancestor, so the whole chain is alive.
+    /// </summary>
+    private static void MarkReferencedFromOutside(CodeElement element, HashSet<string> referenced)
+    {
+        for (var current = element; current is not null; current = current.Parent)
+        {
+            referenced.Add(current.Id);
+        }
+    }
+
+    /// <summary>
+    ///     "Implements" and "Overrides" starting at a member express polymorphism, not use. Starting at a
+    ///     type ("class C : IFoo") the same relationship names the interface in C's declaration and is an
+    ///     ordinary reference - which is why the source, not the target, decides.
+    /// </summary>
+    private static bool IsPolymorphicEdge(RelationshipType type, CodeElement source)
+    {
+        return (type is RelationshipType.Implements or RelationshipType.Overrides) && !source.IsType();
+    }
+
+    private static void RecordPolymorphicEdge(CodeElement source, CodeElement target,
+        Dictionary<string, string> external,
+        Dictionary<string, List<CodeElement>> implementations, Dictionary<string, List<CodeElement>> contracts)
+    {
+        if (target.IsExternal || target.IsType())
+        {
+            // Either a framework contract, or the parser's fallback to the containing type because it
+            // could not resolve the exact base member (generic base methods). Both mean the caller is
+            // invisible. Recorded on the member only - implementing IDisposable is not a use of the class,
+            // so the class itself stays reportable as dead code.
+            external.TryAdd(source.Id, target.FullName);
+            return;
+        }
+
+        Add(implementations, target.Id, source);
+        Add(contracts, source.Id, target);
+    }
+
+    /// <summary>
+    ///     Pushes liveness from a used contract member to its implementations: calling IFoo.Bar calls every
+    ///     implementation of Bar, so the implementations and the types holding them are alive. Transitive,
+    ///     because an override can itself be overridden.
+    ///     <para>
+    ///         Deliberately <i>every</i> implementation, not only those whose type is visibly instantiated
+    ///         (the class-hierarchy-analysis choice, not the rapid-type-analysis refinement). The
+    ///         refinement would need a Creates edge to exist for every live type - but implementations of
+    ///         an interface are exactly the classes a dependency container instantiates, and a container
+    ///         registration produces no Creates edge (or, with assembly scanning, no edge at all). The
+    ///         refinement would report precisely the code it cannot see being created.
+    ///     </para>
+    /// </summary>
+    private static void PropagateContractUsage(HashSet<string> referenced,
+        Dictionary<string, List<CodeElement>> implementations)
+    {
+        var queue = new Queue<string>(implementations.Keys.Where(referenced.Contains));
+        var enqueued = new HashSet<string>(queue);
+
+        while (queue.Count > 0)
+        {
+            foreach (var implementation in implementations[queue.Dequeue()])
+            {
+                MarkReferencedFromOutside(implementation, referenced);
+
+                if (implementations.ContainsKey(implementation.Id) && enqueued.Add(implementation.Id))
+                {
+                    queue.Enqueue(implementation.Id);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Everything the production code does not reference, reduced to the topmost element of each dead
+    ///     subtree.
+    /// </summary>
+    private static List<DeadCodeFinding> Report(Graph.CodeGraph graph, ReferenceSets references,
+        AnalysisContext context)
+    {
+        var findings = new List<DeadCodeFinding>();
+
+        foreach (var element in graph.Nodes.Values)
+        {
+            if (!IsReported(element, references, context))
+            {
+                continue;
+            }
+
+            if (IsSerializedProperty(element, context.SerializableTypes))
+            {
+                continue;
+            }
+
+            // Roll-up: a dead element inside a dead element is reported as part of it. Namespaces and
+            // assemblies are no candidates, so an element directly below them is always the topmost one.
+            if (element.Parent is not null && IsReported(element.Parent, references, context))
+            {
+                continue;
+            }
+
+            findings.Add(CreateFinding(element, references, context));
+        }
+
+        return findings;
+    }
+
+    /// <summary>
+    ///     Whether nothing in the production code references the element. Two ways to get there: nothing
+    ///     references it at all, or only test code does.
+    ///     <para>
+    ///         The second one is a finding only outside a test type. Inside one it is what is supposed to
+    ///         happen - a fixture's own helper members and nested fakes are what the tests are made of.
+    ///     </para>
+    ///     <para>
+    ///         An external contract does not make an element alive either; it is reported with a note
+    ///         instead, so the decision stays visible rather than silently removing rows from the result.
+    ///     </para>
+    /// </summary>
+    private static bool IsReported(CodeElement element, ReferenceSets references, AnalysisContext context)
+    {
+        if (!IsCandidate(element) || references.FromProduction.Contains(element.Id))
+        {
+            return false;
+        }
+
+        return !references.All.Contains(element.Id) || !IsTestCode(element, context.TestTypes);
+    }
+
+    private static DeadCodeFinding CreateFinding(CodeElement element, ReferenceSets references,
+        AnalysisContext context)
+    {
+        var hints = DeadCodeHint.None;
+        var attributes = new SortedSet<string>(StringComparer.Ordinal);
+
+        // The hints are collected over the whole subtree: what is reported is a dead class, but the
+        // evidence that it may still be alive usually sits on its members ([Test] methods, Main, ...).
+        foreach (var member in element.GetSubtreeIncludingSelf())
+        {
+            if (IsEntryPoint(member))
+            {
+                hints |= DeadCodeHint.EntryPoint;
+            }
+
+            foreach (var attribute in member.Attributes)
+            {
+                if (TestAttributes.Contains(attribute))
+                {
+                    hints |= DeadCodeHint.TestCode;
+                }
+                else if (!ToolingAttributes.Contains(attribute))
+                {
+                    hints |= DeadCodeHint.Attributed;
+                }
+
+                attributes.Add(attribute);
+            }
+        }
+
+        var related = new List<CodeElement>();
+
+        // Reported although it implements an internal contract means the contract is dead as well -
+        // otherwise the propagation would have marked this element alive.
+        if (context.Contracts.TryGetValue(element.Id, out var implemented))
+        {
+            hints |= DeadCodeHint.ImplementsDeadContract;
+            related.AddRange(implemented);
+        }
+
+        if (context.Implementations.TryGetValue(element.Id, out var implementors))
+        {
+            hints |= DeadCodeHint.ContractNeverCalled;
+            related.AddRange(implementors);
+        }
+
+        // Element level only. A dead class whose members implement IDisposable is still dead - saying
+        // "might be used" about the class would be wrong, the note belongs to the member.
+        context.External.TryGetValue(element.Id, out var externalContract);
+        if (externalContract is not null)
+        {
+            hints |= DeadCodeHint.ImplementsExternalContract;
+        }
+
+        if (element.IsGenerated)
+        {
+            hints |= DeadCodeHint.Generated;
+        }
+
+        // Reported although something references it means that something was test code - IsReported has
+        // already established that the production code does not.
+        var testReferences = new List<CodeElement>();
+        if (references.All.Contains(element.Id))
+        {
+            hints |= DeadCodeHint.UsedOnlyByTests;
+            testReferences = context.TestReferences.GetValueOrDefault(element.Id, []);
+        }
+
+        return new DeadCodeFinding(element)
+        {
+            Confidence = RateConfidence(element, hints, context),
+            Hints = hints,
+            Attributes = attributes.ToList(),
+            RelatedMembers = related,
+            TestReferences = testReferences,
+            ExternalContract = externalContract
+        };
+    }
+
+    /// <summary>
+    ///     Three rules, in order. A note about a caller outside the graph beats everything - we already
+    ///     know the finding may be wrong. Otherwise visibility decides, capped at
+    ///     <see cref="DeadCodeConfidence.Medium" /> for a used-only-by-tests finding.
+    ///     <para>
+    ///         The cap, not a fixed level: the ladder measures whether a caller we cannot see could exist,
+    ///         and that question stays valid here - a public element could still be used from an assembly
+    ///         outside the analysis. <see cref="DeadCodeConfidence.High" /> is the one level it must not
+    ///         reach, because that level claims nothing <i>can</i> reference the element while something
+    ///         demonstrably does. Whether a test alone justifies keeping it is a decision, not a
+    ///         measurement.
+    ///     </para>
+    /// </summary>
+    private static DeadCodeConfidence RateConfidence(CodeElement element, DeadCodeHint hints,
+        AnalysisContext context)
+    {
+        if ((hints & CallerOutsideTheGraph) != DeadCodeHint.None)
+        {
+            return DeadCodeConfidence.Low;
+        }
+
+        if (IsConfinedToAnalyzedCode(element) && !IsBindable(element, context.BindingSources) &&
+            !hints.HasFlag(DeadCodeHint.UsedOnlyByTests))
+        {
+            return DeadCodeConfidence.High;
+        }
+
+        return DeadCodeConfidence.Medium;
+    }
+
+    /// <summary>
+    ///     Whether a XAML <c>{Binding}</c> could read this element without us seeing it - bindings are
+    ///     resolved by reflection at runtime and are the one XAML construct the parser deliberately does
+    ///     not follow. That takes two things: a <b>public</b> property - the binding engine resolves by
+    ///     public reflection, so private, internal and protected members are out of its reach - on a type
+    ///     that raises change notifications.
+    ///     <para>
+    ///         Which types those are comes straight from the parser
+    ///         (<see cref="ExternalContractStore.NotifyingTypes" />): every analyzed type with
+    ///         <c>INotifyPropertyChanged</c> anywhere in its interface set, no matter which class of the
+    ///         inheritance chain implements it - so a view model deriving from a base class outside the
+    ///         analyzed code (ObservableObject, BindableBase, ...) counts too, although from the graph
+    ///         alone it is indistinguishable from any other class.
+    ///     </para>
+    ///     <para>
+    ///         Note that being confined does not help here. A public property of an internal class cannot
+    ///         be referenced from another assembly, but the binding sits <i>inside</i> the assembly and is
+    ///         merely invisible, which is a different thing.
+    ///     </para>
+    /// </summary>
+    private static bool IsBindable(CodeElement element, HashSet<string> bindingSources)
+    {
+        return IsPublicPropertyOf(element, bindingSources);
+    }
+
+    /// <summary>
+    ///     Whether the element is a public property of a type marked as a serialization target. The
+    ///     serializer reaches it by reflection, so "nothing references it" says nothing about it at all -
+    ///     such a property is not reported.
+    ///     <para>
+    ///         Dropping it rather than reporting it with a note is deliberate: on a DTO <i>every</i>
+    ///         property looks dead, so the note would be the rule rather than the exception and would fill
+    ///         the result with rows nobody can act on.
+    ///     </para>
+    /// </summary>
+    private static bool IsSerializedProperty(CodeElement element, HashSet<string> serializableTypes)
+    {
+        return IsPublicPropertyOf(element, serializableTypes);
+    }
+
+    /// <summary>
+    ///     Whether the element is a public property of one of the given types. The property is what carries
+    ///     the visibility, so this is where the rule applies; its accessors are dropped with it by the
+    ///     roll-up.
+    /// </summary>
+    private static bool IsPublicPropertyOf(CodeElement element, HashSet<string> types)
+    {
+        if (element is not { ElementType: CodeElementType.Property, AccessLevel: AccessLevel.Public })
+        {
+            return false;
+        }
+
+        var type = ContainingType(element);
+        return type is not null && types.Contains(type.Id);
+    }
+
+    /// <summary>
+    ///     Whether the element is out of reach for code we did not analyze. It is enough that *any*
+    ///     container is private or internal: a public method of an internal class cannot be called from
+    ///     another assembly either. An element whose visibility is unknown contributes nothing, so a graph
+    ///     from an importer that does not supply it never reaches high confidence.
+    ///     <para>
+    ///         "InternalsVisibleTo" is not considered. A friend assembly inside the analysis would show its
+    ///         references anyway; one outside it is the rare case this misses.
+    ///     </para>
+    /// </summary>
+    private static bool IsConfinedToAnalyzedCode(CodeElement element)
+    {
+        for (var current = element; current is not null; current = current.Parent)
+        {
+            if (current.AccessLevel.IsConfinedToAnalyzedCode())
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Containers never carry relationships of their own, so they would all look dead. External
+    ///     elements are out of scope - we see neither their callers nor their bodies. And the members
+    ///     only the runtime calls can never be dead on their own.
+    /// </summary>
+    private static bool IsCandidate(CodeElement element)
+    {
+        return !element.IsExternal &&
+               element.ElementType is not (CodeElementType.Assembly or CodeElementType.Namespace) &&
+               !IsRuntimeInvoked(element);
+    }
+
+    /// <summary>
+    ///     Members only the runtime ever calls: the static constructor (run before the first use of the
+    ///     type) and the finalizer (run by the garbage collector - C# cannot even spell a call to it;
+    ///     the destructor arrives from the parser as an ordinary method named "Finalize"). No code can
+    ///     reference them, so "nothing references it" carries no information here: on a live type the
+    ///     row would be wrong in every single case, and on a dead type they disappear into the roll-up.
+    ///     Unlike an entry point this is not a doubt worth a note - the finding is dropped. Both are
+    ///     effectively private, so without this they would land in the highest confidence band.
+    /// </summary>
+    private static bool IsRuntimeInvoked(CodeElement element)
+    {
+        return element is { ElementType: CodeElementType.Method, Name: ".cctor" or "Finalize" };
+    }
+
+    /// <summary>
+    ///     Started from outside the analyzed code: the program entry point, and the synthetic
+    ///     "GlobalStatements" class the parser creates per assembly for top-level statements.
+    /// </summary>
+    private static bool IsEntryPoint(CodeElement element)
+    {
+        if (element is { ElementType: CodeElementType.Method, Name: "Main" })
+        {
+            return true;
+        }
+
+        return element is { ElementType: CodeElementType.Class, Name: "GlobalStatements" } &&
+               (element.Parent?.ElementType == CodeElementType.Assembly ||
+                element.Parent is { ElementType: CodeElementType.Namespace, Name: CodeElement.GlobalNamespaceName });
+    }
+
+    private static void Add(Dictionary<string, List<CodeElement>> map, string key, CodeElement value)
+    {
+        if (!map.TryGetValue(key, out var list))
+        {
+            list = [];
+            map[key] = list;
+        }
+
+        list.Add(value);
+    }
+}
diff --git a/CSharpCodeAnalyst.CodeGraph/Algorithms/DeadCode/DeadCodeFinding.cs b/CSharpCodeAnalyst.CodeGraph/Algorithms/DeadCode/DeadCodeFinding.cs
new file mode 100644
index 00000000..7eff8df3
--- /dev/null
+++ b/CSharpCodeAnalyst.CodeGraph/Algorithms/DeadCode/DeadCodeFinding.cs
@@ -0,0 +1,123 @@
+using CSharpCodeAnalyst.CodeGraph.Graph;
+
+namespace CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+
+/// <summary>
+///     Reasons why a reported element may nevertheless be alive. The analysis works on the relationships
+///     the parser could see, so everything reached through XAML, reflection, dependency injection or
+///     serialization looks unreferenced. Rather than silently dropping such elements, they are reported
+///     with the hint that explains why they are suspicious - the caller decides what to do with them.
+/// </summary>
+[Flags]
+public enum DeadCodeHint
+{
+    None = 0,
+
+    /// <summary>Called from outside the analyzed code by definition (program entry point).</summary>
+    EntryPoint = 1,
+
+    /// <summary>The element or something in its subtree carries a known test-framework attribute.</summary>
+    TestCode = 2,
+
+    /// <summary>
+    ///     Carries attributes beyond the tooling ones (compiler, debugger, analyzer - [Obsolete],
+    ///     [DebuggerDisplay], ...). Such an attribute often means an external framework drives the
+    ///     element by reflection.
+    /// </summary>
+    Attributed = 4,
+
+    /// <summary>
+    ///     A contract member (interface or base member) that is implemented but never called through the
+    ///     contract - the abstraction itself is unused.
+    /// </summary>
+    ContractNeverCalled = 8,
+
+    /// <summary>
+    ///     Implements or overrides an internal contract member that is itself dead, so it can only be
+    ///     removed together with that contract.
+    /// </summary>
+    ImplementsDeadContract = 16,
+
+    /// <summary>
+    ///     Implements or overrides a contract from outside the analyzed code (a framework interface, a
+    ///     base member from a referenced assembly). The caller is the framework, so nothing in the graph
+    ///     references it - it is almost certainly alive.
+    /// </summary>
+    ImplementsExternalContract = 32,
+
+    /// <summary>
+    ///     Referenced, but only from test code. The production code has no use for it any more, so
+    ///     the test is the only thing keeping it alive - removing it means removing that test too.
+    /// </summary>
+    UsedOnlyByTests = 64,
+
+    /// <summary>
+    ///     A tool wrote it, not a person (<see cref="CodeElement.IsGenerated" />). Deleting it is
+    ///     pointless - the next build writes it again. The finding is correct, it is just not for you.
+    /// </summary>
+    Generated = 128
+}
+
+/// <summary>
+///     How much the finding can be trusted. Three levels, each from one stated rule - this is a summary of
+///     what we know, not a measurement.
+/// </summary>
+public enum DeadCodeConfidence
+{
+    /// <summary>
+    ///     A note says the caller may sit outside the graph (entry point, test code, attributes, an
+    ///     external contract). We know we might be wrong here.
+    /// </summary>
+    Low,
+
+    /// <summary>
+    ///     Nothing references it, but it could be reached from code we did not analyze - it is public or
+    ///     protected, or the producer did not tell us its visibility.
+    /// </summary>
+    Medium,
+
+    /// <summary>
+    ///     Nothing references it, and nothing outside the analyzed code could: the element or one of its
+    ///     containers is private or internal. "Nothing references it" and "nothing can reference it" mean
+    ///     the same thing here.
+    /// </summary>
+    High
+}
+
+/// <summary>
+///     One reported element: the topmost element of a dead subtree, plus what we know about it.
+/// </summary>
+public sealed class DeadCodeFinding(CodeElement element)
+{
+    /// <summary>The unreferenced element. Everything below it is dead too and is not reported separately.</summary>
+    public CodeElement Element { get; } = element;
+
+    /// <summary>How much the finding can be trusted - see <see cref="DeadCodeConfidence" />.</summary>
+    public DeadCodeConfidence Confidence { get; init; } = DeadCodeConfidence.Medium;
+
+    public DeadCodeHint Hints { get; init; }
+
+    /// <summary>Distinct attribute names found on the element and its subtree.</summary>
+    public IReadOnlyList<string> Attributes { get; init; } = [];
+
+    /// <summary>
+    ///     The contract outside the analyzed code this element implements or overrides, e.g.
+    ///     "IDisposable.Dispose". Set together with <see cref="DeadCodeHint.ImplementsExternalContract" />.
+    /// </summary>
+    public string? ExternalContract { get; init; }
+
+    /// <summary>
+    ///     The polymorphically related members: the internal contract members this element implements
+    ///     (<see cref="DeadCodeHint.ImplementsDeadContract" />) and the implementations that die with it
+    ///     (<see cref="DeadCodeHint.ContractNeverCalled" />).
+    /// </summary>
+    public IReadOnlyList<CodeElement> RelatedMembers { get; init; } = [];
+
+    /// <summary>
+    ///     The test elements that reference this one, set together with
+    ///     <see cref="DeadCodeHint.UsedOnlyByTests" /> - what has to go with it. Can be empty although the
+    ///     hint is set: liveness reaching the element through a contract member is not an edge we could
+    ///     name a caller for.
+    /// </summary>
+    public IReadOnlyList<CodeElement> TestReferences { get; init; } = [];
+}
diff --git a/CSharpCodeAnalyst.CodeGraph/Contracts/ParseResult.cs b/CSharpCodeAnalyst.CodeGraph/Contracts/ParseResult.cs
index f64d6079..84ba77e8 100644
--- a/CSharpCodeAnalyst.CodeGraph/Contracts/ParseResult.cs
+++ b/CSharpCodeAnalyst.CodeGraph/Contracts/ParseResult.cs
@@ -1,13 +1,21 @@
+using CSharpCodeAnalyst.CodeGraph.Declarations;
 using CSharpCodeAnalyst.CodeGraph.Metrics;
 
 namespace CSharpCodeAnalyst.CodeGraph.Contracts;
 
 /// <summary>
-///     The complete output of a parse or import: the code graph together with the (optional)
-///     per-member source metrics collected alongside it. Bundling them makes it explicit that both
-///     belong to the same run and travel together - there is no separate, mutable "last metrics"
-///     state on the producer.
+///     The complete output of a parse or import: the code graph together with the (optional) per-member
+///     facts collected alongside it - source metrics, and the contracts implemented from outside the
+///     analyzed code. Bundling them makes it explicit that they belong to the same run and travel
+///     together - there is no separate, mutable "last metrics" state on the producer.
 ///     Lives here rather than next to the C# parser because every graph producer returns one, and
 ///     the importers must not have to reference the Roslyn-based parser to do so.
+///     <para>
+///         <see cref="ExternalContracts" /> is optional and defaults to an empty store, so a producer that
+///         knows nothing about it (every importer) stays unchanged.
+///     </para>
 /// </summary>
-public sealed record ParseResult(Graph.CodeGraph CodeGraph, MetricStore Metrics);
+public sealed record ParseResult(Graph.CodeGraph CodeGraph, MetricStore Metrics)
+{
+    public ExternalContractStore ExternalContracts { get; init; } = new();
+}
diff --git a/CSharpCodeAnalyst.CodeGraph/Declarations/ExternalContractStore.cs b/CSharpCodeAnalyst.CodeGraph/Declarations/ExternalContractStore.cs
new file mode 100644
index 00000000..cc918ef8
--- /dev/null
+++ b/CSharpCodeAnalyst.CodeGraph/Declarations/ExternalContractStore.cs
@@ -0,0 +1,102 @@
+using System.Collections.Concurrent;
+
+namespace CSharpCodeAnalyst.CodeGraph.Declarations;
+
+/// <summary>
+///     Records which members implement or override a contract that is <b>not part of the analyzed
+///     code</b> - a framework interface member (<c>ICommand.Execute</c>) or a base member from a
+///     referenced assembly (<c>object.ToString</c>, <c>CSharpSyntaxVisitor.VisitGenericName</c>), keyed by
+///     <see cref="Graph.CodeElement.Id" /> and valued with the contract's display name.
+///     <para>
+///         Such a member has no incoming reference anywhere in the graph - the caller is the framework -
+///         so without this information it looks like dead code. The relationship model cannot carry the
+///         fact: with external code excluded there is no element to point an <c>Overrides</c> edge at, and
+///         with it included the edge is flattened to a <c>Uses</c> edge on the containing type, which is
+///         indistinguishable from ordinary use of that type.
+///     </para>
+///     <para>
+///         Kept beside the code graph rather than on <see cref="Graph.CodeElement" />, following
+///         <see cref="Metrics.MetricStore" />: the graph model stays pure, the store is trivially optional
+///         (an importer that knows nothing about this simply leaves it empty), and the shared
+///         <see cref="Graph.CodeElement" /> type does not grow a field that only the C# parser ever fills.
+///     </para>
+///     <para>
+///         Beside the member-level contracts the store carries one type-level fact: the
+///         <see cref="NotifyingTypes" /> - every analyzed type that raises change notifications
+///         (<c>INotifyPropertyChanged</c> anywhere in its interface set). The member-level route cannot
+///         express this when the implementation sits in a base class outside the analyzed code
+///         (<c>ObservableObject</c>, <c>BindableBase</c>, ...): the derived type then has no
+///         <c>PropertyChanged</c> member of its own, so nothing in the graph says it is a view model.
+///         The dead code analysis uses the set to keep public properties of such types - the ones a XAML
+///         <c>{Binding}</c> may read - out of the highest confidence.
+///     </para>
+///     <para>
+///         Filled from the parallel phase 2 of the parser, hence the concurrent dictionaries.
+///     </para>
+/// </summary>
+public sealed class ExternalContractStore
+{
+    private readonly ConcurrentDictionary<string, string> _contracts = new();
+
+    /// <summary>Value-less; a concurrent set does not exist in the BCL.</summary>
+    private readonly ConcurrentDictionary<string, byte> _notifyingTypes = new();
+
+    public IReadOnlyDictionary<string, string> Contracts => _contracts;
+
+    /// <summary>The ids of the types that raise change notifications - see the class remarks.</summary>
+    public IReadOnlyCollection<string> NotifyingTypes => _notifyingTypes.Keys.ToList();
+
+    public int Count => _contracts.Count;
+
+    public bool IsEmpty => _contracts.IsEmpty && _notifyingTypes.IsEmpty;
+
+    /// <summary>
+    ///     Records the contract for an element. A member can implement several external contracts; the
+    ///     first one wins, because the store answers "is this member bound by code we cannot see" and one
+    ///     example is enough to explain it.
+    /// </summary>
+    public void Add(string elementId, string contractName)
+    {
+        _contracts.TryAdd(elementId, contractName);
+    }
+
+    public string? TryGet(string elementId)
+    {
+        return _contracts.GetValueOrDefault(elementId);
+    }
+
+    public bool Contains(string elementId)
+    {
+        return _contracts.ContainsKey(elementId);
+    }
+
+    /// <summary>Records a type that raises change notifications.</summary>
+    public void AddNotifyingType(string typeId)
+    {
+        _notifyingTypes.TryAdd(typeId, 0);
+    }
+
+    public void Clear()
+    {
+        _contracts.Clear();
+        _notifyingTypes.Clear();
+    }
+
+    /// <summary>
+    ///     Replaces the current contents. Used to refill the shared store after an import or when loading
+    ///     a project.
+    /// </summary>
+    public void LoadFrom(IReadOnlyDictionary<string, string> contracts, IEnumerable<string> notifyingTypes)
+    {
+        Clear();
+        foreach (var (id, contract) in contracts)
+        {
+            _contracts[id] = contract;
+        }
+
+        foreach (var typeId in notifyingTypes)
+        {
+            _notifyingTypes.TryAdd(typeId, 0);
+        }
+    }
+}
diff --git a/CSharpCodeAnalyst.CodeGraph/Export/CodeGraphSerializer.cs b/CSharpCodeAnalyst.CodeGraph/Export/CodeGraphSerializer.cs
index 30053320..64a2c5d6 100644
--- a/CSharpCodeAnalyst.CodeGraph/Export/CodeGraphSerializer.cs
+++ b/CSharpCodeAnalyst.CodeGraph/Export/CodeGraphSerializer.cs
@@ -76,6 +76,11 @@ private static void SerializeElement(StringBuilder sb, CodeElement element)
             sb.Append($"{Separator}external");
         }
 
+        if (element.AccessLevel != AccessLevel.Unknown)
+        {
+            sb.Append($"{Separator}access={element.AccessLevel}");
+        }
+
         if (element.Attributes.Count > 0)
         {
             var attrs = string.Join(",", element.Attributes.OrderBy(a => a));
@@ -256,6 +261,7 @@ private static (CodeElement element, string? parentId, int linesConsumed) ParseE
         string? fullName = null;
         string? parentId = null;
         var isExternal = false;
+        var accessLevel = AccessLevel.Unknown;
         var attributes = new HashSet<string>();
 
         // Parse optional fields
@@ -279,6 +285,11 @@ private static (CodeElement element, string? parentId, int linesConsumed) ParseE
             {
                 isExternal = true;
             }
+            else if (part.StartsWith("access="))
+            {
+                // An unreadable value stays Unknown - never guess a visibility.
+                Enum.TryParse(part.Substring("access=".Length), out accessLevel);
+            }
             else if (part.StartsWith("attr="))
             {
                 var attrList = part.Substring("attr=".Length).Split(',');
@@ -296,7 +307,8 @@ private static (CodeElement element, string? parentId, int linesConsumed) ParseE
         // Create element without parent - will be linked later
         var element = new CodeElement(id, elementType, name, fullName, null)
         {
-            IsExternal = isExternal
+            IsExternal = isExternal,
+            AccessLevel = accessLevel
         };
 
         foreach (var attr in attributes)
diff --git a/CSharpCodeAnalyst.CodeGraph/Graph/AccessLevel.cs b/CSharpCodeAnalyst.CodeGraph/Graph/AccessLevel.cs
new file mode 100644
index 00000000..7f50e1ea
--- /dev/null
+++ b/CSharpCodeAnalyst.CodeGraph/Graph/AccessLevel.cs
@@ -0,0 +1,56 @@
+namespace CSharpCodeAnalyst.CodeGraph.Graph;
+
+/// <summary>
+///     How far a code element can be reached from. Modelled after C#, but the concept exists in every
+///     language the tool imports.
+///     <para>
+///         <see cref="Unknown" /> is the default and means exactly that: nobody told us. Every importer
+///         that does not know about visibility leaves it there, and so does a project file written before
+///         this existed. It must never be read as "public" or as "private" - an analysis that draws a
+///         conclusion from visibility has to treat Unknown as "no information".
+///     </para>
+///     <para>
+///         Deliberately not called "Accessibility": WPF drags a global <c>Accessibility</c> namespace into
+///         scope, so every file in the UI projects would have to fully qualify the type.
+///     </para>
+/// </summary>
+public enum AccessLevel
+{
+    Unknown,
+
+    /// <summary>Reachable only from inside the declaring type.</summary>
+    Private,
+
+    /// <summary>Reachable from the declaring type and everything derived from it.</summary>
+    Protected,
+
+    /// <summary>Reachable from inside the declaring assembly.</summary>
+    Internal,
+
+    /// <summary>C# "private protected": derived types, but only within the declaring assembly.</summary>
+    ProtectedAndInternal,
+
+    /// <summary>C# "protected internal": the declaring assembly, plus derived types anywhere.</summary>
+    ProtectedOrInternal,
+
+    /// <summary>Reachable from anywhere, including code that is not part of the analysis.</summary>
+    Public
+}
+
+public static class AccessLevelExtensions
+{
+    /// <summary>
+    ///     Whether everything that could reach this element is necessarily part of the analyzed code. Only
+    ///     then is "nothing references it" the same as "nothing can reference it".
+    ///     <para>
+    ///         Private and internal (in either combination) are confined to the declaring type or assembly,
+    ///         both of which we analyzed. Protected and public can be reached from code outside the
+    ///         analysis, and <see cref="AccessLevel.Unknown" /> tells us nothing at all - all three answer
+    ///         false.
+    ///     </para>
+    /// </summary>
+    public static bool IsConfinedToAnalyzedCode(this AccessLevel accessLevel)
+    {
+        return accessLevel is AccessLevel.Private or AccessLevel.Internal or AccessLevel.ProtectedAndInternal;
+    }
+}
diff --git a/CSharpCodeAnalyst.CodeGraph/Graph/CodeElement.cs b/CSharpCodeAnalyst.CodeGraph/Graph/CodeElement.cs
index de370251..cb8eec44 100644
--- a/CSharpCodeAnalyst.CodeGraph/Graph/CodeElement.cs
+++ b/CSharpCodeAnalyst.CodeGraph/Graph/CodeElement.cs
@@ -41,6 +41,24 @@ public class CodeElement(string id, CodeElementType elementType, string name, st
     /// </summary>
     public bool IsExternal { get; init; }
 
+    /// <summary>
+    ///     Whether a tool wrote this element rather than a person - every declaration of it sits in a
+    ///     generated file. Generated code is always parsed, because it holds relationships nothing else
+    ///     does; the flag exists so a result can leave out what nobody can edit anyway.
+    ///     <para>
+    ///         A partial type that a generator only extends is <i>not</i> marked: half of it is hand
+    ///         written. Only what lives exclusively in the generated file is.
+    ///     </para>
+    /// </summary>
+    public bool IsGenerated { get; set; }
+
+    /// <summary>
+    ///     How far the element can be reached from. <see cref="Graph.AccessLevel.Unknown" /> when the
+    ///     producer does not supply it - every importer except the C# parser, and any project file written
+    ///     before this existed. Never read Unknown as a value; it means "no information".
+    /// </summary>
+    public AccessLevel AccessLevel { get; init; }
+
     public override bool Equals(object? obj)
     {
         if (obj != null && obj.GetType() == GetType())
@@ -107,7 +125,9 @@ public CodeElement CloneSimple()
         var element = new CodeElement(Id, ElementType, Name,
             FullName, null)
         {
-            IsExternal = IsExternal
+            IsExternal = IsExternal,
+            IsGenerated = IsGenerated,
+            AccessLevel = AccessLevel
         };
 
         element.SourceLocations.AddRange(SourceLocations);
diff --git a/CSharpCodeAnalyst.CodeGraph/Graph/RelationshipAttribute.cs b/CSharpCodeAnalyst.CodeGraph/Graph/RelationshipAttribute.cs
index e3c77592..4e0c500f 100644
--- a/CSharpCodeAnalyst.CodeGraph/Graph/RelationshipAttribute.cs
+++ b/CSharpCodeAnalyst.CodeGraph/Graph/RelationshipAttribute.cs
@@ -17,7 +17,14 @@ public enum RelationshipAttribute : uint
     IsExtensionMethodCall = 16,
     IsMethodGroup = 32,
     EventRegistration = 64,
-    EventUnregistration = 128
+    EventUnregistration = 128,
+
+    /// <summary>
+    ///     The relationship was read out of a XAML file, not out of C#. Declarative XAML (element tags,
+    ///     {x:Static}, {x:Type}) is compiled into BAML and resolved by reflection at runtime, so the
+    ///     markup compiler generates no C# for it and Roslyn cannot see it.
+    /// </summary>
+    IsXamlReference = 256
 }
 
 public static class RelationshipAttributeExtensions
diff --git a/CSharpCodeAnalyst.CodeParser/CSharpCodeAnalyst.CodeParser.csproj b/CSharpCodeAnalyst.CodeParser/CSharpCodeAnalyst.CodeParser.csproj
index 52a60500..c7c4d9b4 100644
--- a/CSharpCodeAnalyst.CodeParser/CSharpCodeAnalyst.CodeParser.csproj
+++ b/CSharpCodeAnalyst.CodeParser/CSharpCodeAnalyst.CodeParser.csproj
@@ -32,6 +32,15 @@
     </ItemGroup>
 
     <ItemGroup>
+        <!--
+          Compile-time only, exactly like Microsoft.Build.Framework below: XamlFileLocator evaluates the
+          project files to find their XAML items. The assemblies are loaded at runtime from the installed
+          SDK by MSBuild.Locator - see the note in Directory.Build.props for why they must not land in bin.
+        -->
+        <PackageReference Include="Microsoft.Build" Version="18.8.2">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>compile; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
         <PackageReference Update="Microsoft.Build.Framework" Version="18.8.2">
           <PrivateAssets>all</PrivateAssets>
           <IncludeAssets>compile; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/CSharpCodeAnalyst.CodeParser/Parser/Config/ParserConfig.cs b/CSharpCodeAnalyst.CodeParser/Parser/Config/ParserConfig.cs
index 6cb505f5..2865e3dd 100644
--- a/CSharpCodeAnalyst.CodeParser/Parser/Config/ParserConfig.cs
+++ b/CSharpCodeAnalyst.CodeParser/Parser/Config/ParserConfig.cs
@@ -5,23 +5,21 @@ public class ParserConfig
     private readonly ProjectExclusionRegExCollection _projectExclusionFilters;
 
     public ParserConfig(ProjectExclusionRegExCollection projectExclusionFilters, bool includeExternals,
-        bool includeGeneratedCode = false, bool splitPropertyAccessors = false)
+        bool splitPropertyAccessors = false, bool includeXamlReferences = true)
     {
         _projectExclusionFilters = projectExclusionFilters;
         IncludeExternals = includeExternals;
-        IncludeGeneratedCode = includeGeneratedCode;
         SplitPropertyAccessors = splitPropertyAccessors;
+        IncludeXamlReferences = includeXamlReferences;
     }
 
     public bool IncludeExternals { get; }
 
-    /// <summary>
-    ///     When enabled, source-generated documents (e.g. CommunityToolkit.Mvvm [ObservableProperty] /
-    ///     [RelayCommand], [GeneratedRegex], ...) are included in phase 1 so the generated members get
-    ///     their own code element instead of being collapsed onto the containing type via the phase-2
-    ///     fallback.
-    /// </summary>
-    public bool IncludeGeneratedCode { get; }
+    // There is no "include generated code" option. Generated code is always parsed: leaving it out
+    // removes the only reference many hand-written elements have (the markup compiler's Connect is the
+    // sole caller of every XAML event handler, an [ObservableProperty] the only reader of its backing
+    // field), which turns them into dead code. What a tool wrote carries CodeElement.IsGenerated instead,
+    // so a result can leave it out without the graph losing an edge.
 
     /// <summary>
     ///     When enabled, each property is split into its getter and setter accessor as separate child
@@ -31,6 +29,14 @@ public ParserConfig(ProjectExclusionRegExCollection projectExclusionFilters, boo
     /// </summary>
     public bool SplitPropertyAccessors { get; }
 
+    /// <summary>
+    ///     When enabled, the XAML files next to the analyzed projects are scanned for the references the
+    ///     markup compiler does not turn into C# (element tags, <c>{x:Static}</c>, <c>{x:Type}</c>) and
+    ///     those become relationships in the graph. Without it a control that is only instantiated from
+    ///     XAML looks unreferenced.
+    /// </summary>
+    public bool IncludeXamlReferences { get; }
+
     public bool IsProjectIncluded(string projectName)
     {
 
diff --git a/CSharpCodeAnalyst.CodeParser/Parser/DeclarationAnalyzer.cs b/CSharpCodeAnalyst.CodeParser/Parser/DeclarationAnalyzer.cs
index c14249bd..645d7733 100644
--- a/CSharpCodeAnalyst.CodeParser/Parser/DeclarationAnalyzer.cs
+++ b/CSharpCodeAnalyst.CodeParser/Parser/DeclarationAnalyzer.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using CSharpCodeAnalyst.CodeGraph.Declarations;
 using CSharpCodeAnalyst.CodeGraph.Graph;
 using CSharpCodeAnalyst.CodeParser.Parser.Config;
 using Microsoft.CodeAnalysis;
@@ -20,14 +21,16 @@ internal class DeclarationAnalyzer
     private readonly SyntaxNodeAnalyzer _bodyAnalyzer;
     private readonly RelationshipBuilder _builder;
     private readonly ParserConfig _config;
+    private readonly ExternalContractStore _externalContracts;
 
     internal DeclarationAnalyzer(RelationshipBuilder builder, SyntaxNodeAnalyzer bodyAnalyzer, Artifacts artifacts,
-        ParserConfig config)
+        ParserConfig config, ExternalContractStore externalContracts)
     {
         _builder = builder;
         _bodyAnalyzer = bodyAnalyzer;
         _artifacts = artifacts;
         _config = config;
+        _externalContracts = externalContracts;
     }
 
     /// <summary>
@@ -50,6 +53,8 @@ public void Analyze(Solution solution, CodeElement element, ISymbol symbol)
             AnalyzeInheritanceRelationships(element, typeSymbol);
             AnalyzeEnumMemberInitializers(solution, element, typeSymbol);
             AnalyzePrimaryConstructorBaseArguments(solution, element, typeSymbol);
+            RecordExternalInterfaceImplementations(typeSymbol);
+            RecordIfNotifyingType(element, typeSymbol);
         }
         else if (symbol is IMethodSymbol methodSymbol)
         {
@@ -390,6 +395,91 @@ private void AddMethodOverrideRelationship(CodeElement sourceElement, IMethodSym
         // Maybe we override a framework method. Happens also if the base method is a generic one.
         // In this case the GetSymbolKey is different. One uses T, the overriding method uses the actual type.
         _builder.AddRelationshipWithFallbackToContainingType(sourceElement, methodSymbol, RelationshipType.Overrides, locations, RelationshipAttribute.None);
+
+        RecordIfExternalContract(sourceElement, methodSymbol);
+    }
+
+    /// <summary>
+    ///     An override whose base member lives outside the analyzed code produces no relationship at all -
+    ///     there is no element to point at - so the member ends up without a single incoming reference and
+    ///     looks like dead code. The fact is recorded beside the graph instead.
+    ///     The containing type decides: when it is one of ours the contract is internal, and the
+    ///     <see cref="RelationshipType.Overrides" /> edge already expresses it.
+    /// </summary>
+    private void RecordIfExternalContract(CodeElement sourceElement, ISymbol contractMember)
+    {
+        var containingType = contractMember.ContainingType;
+        if (containingType is null || _builder.FindInternalCodeElement(containingType.OriginalDefinition) is not null)
+        {
+            return;
+        }
+
+        _externalContracts.Add(sourceElement.Id, $"{containingType.Name}.{contractMember.Name}");
+    }
+
+    /// <summary>
+    ///     Members that implement an interface from outside the analyzed code (<c>ICommand.Execute</c>,
+    ///     <c>IValueConverter.Convert</c>, ...). Nothing in the graph shows this: the interface is not an
+    ///     element, and the implementation is called by the framework, never from our code.
+    ///     <para>
+    ///         Only foreign interfaces are scanned. For our own, <see cref="AddImplementationsForInterfaceMember" />
+    ///         creates real <see cref="RelationshipType.Implements" /> edges from the interface side.
+    ///     </para>
+    ///     <para>
+    ///         The interfaces come from <see cref="INamedTypeSymbol.AllInterfaces" /> and are therefore
+    ///         already constructed, so <see cref="INamedTypeSymbol.FindImplementationForInterfaceMember" />
+    ///         can be called directly - the mapping trap described at
+    ///         <see cref="FindImplementationsForInterfaceMember" /> does not apply here.
+    ///     </para>
+    /// </summary>
+    private void RecordExternalInterfaceImplementations(INamedTypeSymbol typeSymbol)
+    {
+        foreach (var contract in typeSymbol.AllInterfaces)
+        {
+            // A constructed generic interface (IHandler<Widget>) is not in the map - the definition is.
+            if (_builder.FindInternalCodeElement(contract.OriginalDefinition) is not null)
+            {
+                continue;
+            }
+
+            foreach (var contractMember in contract.GetMembers())
+            {
+                var implementation = typeSymbol.FindImplementationForInterfaceMember(contractMember);
+                if (implementation is null)
+                {
+                    continue;
+                }
+
+                var element = _builder.FindInternalCodeElement(implementation)
+                              ?? _builder.FindInternalCodeElement(implementation.OriginalDefinition);
+                if (element is not null)
+                {
+                    _externalContracts.Add(element.Id, $"{contract.Name}.{contractMember.Name}");
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Records a type that raises change notifications - <c>INotifyPropertyChanged</c> appears
+    ///     anywhere in its interface set, no matter which class of the inheritance chain implements it.
+    ///     The member-level contract cannot carry this fact when the implementation sits in a base class
+    ///     outside the analyzed code (ObservableObject, BindableBase, ...): the derived type then has no
+    ///     PropertyChanged member of its own, so from the graph alone nothing says it is a view model,
+    ///     and the dead code analysis would rate its bindable properties too confidently.
+    /// </summary>
+    private void RecordIfNotifyingType(CodeElement element, INamedTypeSymbol typeSymbol)
+    {
+        var raisesChangeNotifications = typeSymbol.AllInterfaces.Any(contract => contract is
+        {
+            Name: "INotifyPropertyChanged",
+            ContainingNamespace: { Name: "ComponentModel", ContainingNamespace.Name: "System" }
+        });
+
+        if (raisesChangeNotifications)
+        {
+            _externalContracts.AddNotifyingType(element.Id);
+        }
     }
 
     private void AnalyzeFieldRelationships(Solution solution, CodeElement fieldElement, IFieldSymbol fieldSymbol)
@@ -553,6 +643,8 @@ private void AnalyzePropertyAbstractions(CodeElement propertyElement, IPropertyS
         {
             _builder.AddRelationshipWithFallbackToContainingType(propertyElement, overriddenProperty,
                 RelationshipType.Overrides, propertySymbol.GetSymbolLocations(), RelationshipAttribute.None);
+
+            RecordIfExternalContract(propertyElement, overriddenProperty);
         }
     }
 
diff --git a/CSharpCodeAnalyst.CodeParser/Parser/GeneratedCode.cs b/CSharpCodeAnalyst.CodeParser/Parser/GeneratedCode.cs
new file mode 100644
index 00000000..abb4f738
--- /dev/null
+++ b/CSharpCodeAnalyst.CodeParser/Parser/GeneratedCode.cs
@@ -0,0 +1,94 @@
+using CSharpCodeAnalyst.CodeGraph.Graph;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace CSharpCodeAnalyst.CodeParser.Parser;
+
+/// <summary>
+///     Recognizes code a tool wrote. Generated code is always parsed - it holds relationships nothing else
+///     does, and dropping it would turn the code it references into dead code (the markup compiler's
+///     <c>Connect</c> is the only caller of every XAML event handler, and a CommunityToolkit
+///     <c>[ObservableProperty]</c> is the only thing reading the backing field). It is marked instead, so a
+///     consumer can leave it out of a result it would only clutter.
+///     <para>
+///         The rules are Roslyn's own (<c>GeneratedCodeUtilities</c>, what every analyzer uses): a file name
+///         from the known list, or an <c>&lt;auto-generated&gt;</c> comment before the first token.
+///     </para>
+/// </summary>
+internal static class GeneratedCode
+{
+    /// <summary>
+    ///     File names a tool owns. <c>.g.cs</c> / <c>.g.i.cs</c> come from the XAML markup compiler,
+    ///     <c>.designer.cs</c> from the resx and WinForms designers.
+    /// </summary>
+    private static readonly string[] GeneratedFileSuffixes =
+    [
+        ".g.cs", ".g.i.cs", ".designer.cs", ".generated.cs", ".assemblyattributes.cs"
+    ];
+
+    private const string TemporaryGeneratedFilePrefix = "TemporaryGeneratedFile_";
+
+    public static bool IsGeneratedFile(SyntaxTree tree)
+    {
+        return HasGeneratedFileName(tree.FilePath) || HasAutoGeneratedComment(tree);
+    }
+
+    /// <summary>
+    ///     Whether every declaration of the element sits in a generated file.
+    ///     <para>
+    ///         "Every" is the point. A WPF code-behind class is <c>partial</c>: half of it is
+    ///         <c>MainWindow.xaml.cs</c>, which you wrote, and half is <c>MainWindow.g.cs</c>, which the
+    ///         markup compiler wrote - one element with two source locations. Asking whether *any*
+    ///         declaration is generated would mark your own class; asking about the first one would make
+    ///         the answer depend on the order the files were walked in. Only the generated half's own
+    ///         members (<c>Connect</c>, the <c>x:Name</c> fields) are declared nowhere else, and those are
+    ///         exactly the ones this is meant to catch.
+    ///     </para>
+    ///     <para>
+    ///         An element without any source location - an assembly, a namespace - is never generated.
+    ///     </para>
+    /// </summary>
+    public static bool IsGeneratedElement(CodeElement element, HashSet<string> generatedFilePaths)
+    {
+        return element.SourceLocations.Count > 0 &&
+               element.SourceLocations.All(location =>
+                   location.File is not null && generatedFilePaths.Contains(location.File));
+    }
+
+    private static bool HasGeneratedFileName(string? filePath)
+    {
+        if (string.IsNullOrEmpty(filePath))
+        {
+            return false;
+        }
+
+        var fileName = Path.GetFileName(filePath);
+
+        return fileName.StartsWith(TemporaryGeneratedFilePrefix, StringComparison.OrdinalIgnoreCase) ||
+               GeneratedFileSuffixes.Any(suffix => fileName.EndsWith(suffix, StringComparison.OrdinalIgnoreCase));
+    }
+
+    /// <summary>
+    ///     The header convention. The comment has to sit before the first token - otherwise a file merely
+    ///     talking about generated code would count. This is what catches the files the name list does not:
+    ///     the AssemblyInfo under obj, and anything a tool writes under its own name.
+    /// </summary>
+    private static bool HasAutoGeneratedComment(SyntaxTree tree)
+    {
+        foreach (var trivia in tree.GetRoot().GetFirstToken(true).LeadingTrivia)
+        {
+            if (!trivia.IsKind(SyntaxKind.SingleLineCommentTrivia) &&
+                !trivia.IsKind(SyntaxKind.MultiLineCommentTrivia))
+            {
+                continue;
+            }
+
+            if (trivia.ToString().Contains("<auto-generated", StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/CSharpCodeAnalyst.CodeParser/Parser/HierarchyAnalyzer.cs b/CSharpCodeAnalyst.CodeParser/Parser/HierarchyAnalyzer.cs
index cd9c6d69..fa078284 100644
--- a/CSharpCodeAnalyst.CodeParser/Parser/HierarchyAnalyzer.cs
+++ b/CSharpCodeAnalyst.CodeParser/Parser/HierarchyAnalyzer.cs
@@ -23,6 +23,10 @@ public class HierarchyAnalyzer
 
     private readonly IProgress<string>? _progress;
     private readonly HashSet<string> _projectFilePaths = [];
+
+    /// <summary>The files a tool wrote, collected while walking - see <see cref="MarkGeneratedElements" />.</summary>
+    private readonly HashSet<string> _generatedFilePaths = new(StringComparer.OrdinalIgnoreCase);
+
     private readonly Dictionary<string, CodeElement> _symbolKeyToElementMap = new();
 
     internal HierarchyAnalyzer(IProgress<string>? progress, ParserConfig config, ParserDiagnostics diagnostics)
@@ -49,11 +53,11 @@ internal HierarchyAnalyzer(IProgress<string>? progress, ParserConfig config, Par
             // Source-generated documents (e.g. CommunityToolkit.Mvvm [ObservableProperty]/[RelayCommand],
             // [GeneratedRegex], ...) are not part of project.Documents and their syntax trees are not in
             // the compilation, so they have to be requested explicitly.
-            IEnumerable<Document> generatedDocuments = [];
-            if (_config.IncludeGeneratedCode)
-            {
-                generatedDocuments = await project.GetSourceGeneratedDocumentsAsync();
-            }
+            // Always, and deliberately so: leaving them out does not just hide the generated members, it
+            // removes the only reference many hand-written ones have. Nothing else reads the backing field
+            // of an [ObservableProperty], and nothing else calls the method behind a [RelayCommand] - they
+            // would all turn into dead code. What is generated is marked instead (see MarkGeneratedElements).
+            var generatedDocuments = await project.GetSourceGeneratedDocumentsAsync();
 
             // Build also a list of all named types in the solution
             // We need this in phase 2 to resolve relationships
@@ -64,6 +68,8 @@ internal HierarchyAnalyzer(IProgress<string>? progress, ParserConfig config, Par
             await BuildHierarchy(compilation, generatedDocuments);
         }
 
+        MarkGeneratedElements();
+
         var result = new Artifacts(
             _allNamedTypesInSolution.AsReadOnly(),
             _elementIdToSymbolMap.AsReadOnly(),
@@ -176,6 +182,27 @@ private bool ShouldAnalyzeProject(Project project)
         return true;
     }
 
+    /// <summary>
+    ///     Roslyn's accessibility onto ours. <c>NotApplicable</c> (namespaces, and anything Roslyn cannot
+    ///     decide) maps to Unknown - the graph must not claim a visibility that does not exist.
+    /// </summary>
+    private static CodeGraph.Graph.AccessLevel MapAccessLevel(
+        Microsoft.CodeAnalysis.Accessibility accessibility)
+    {
+        return accessibility switch
+        {
+            Microsoft.CodeAnalysis.Accessibility.Private => CodeGraph.Graph.AccessLevel.Private,
+            Microsoft.CodeAnalysis.Accessibility.Protected => CodeGraph.Graph.AccessLevel.Protected,
+            Microsoft.CodeAnalysis.Accessibility.Internal => CodeGraph.Graph.AccessLevel.Internal,
+            Microsoft.CodeAnalysis.Accessibility.ProtectedAndInternal => CodeGraph.Graph.AccessLevel
+                .ProtectedAndInternal,
+            Microsoft.CodeAnalysis.Accessibility.ProtectedOrInternal => CodeGraph.Graph.AccessLevel
+                .ProtectedOrInternal,
+            Microsoft.CodeAnalysis.Accessibility.Public => CodeGraph.Graph.AccessLevel.Public,
+            _ => CodeGraph.Graph.AccessLevel.Unknown
+        };
+    }
+
     private async Task BuildHierarchy(Compilation compilation, IEnumerable<Document> generatedDocuments)
     {
         // Assembly has no source location.
@@ -190,6 +217,11 @@ private async Task BuildHierarchy(Compilation compilation, IEnumerable<Document>
                 continue;
             }
 
+            if (GeneratedCode.IsGeneratedFile(syntaxTree))
+            {
+                _generatedFilePaths.Add(syntaxTree.FilePath);
+            }
+
             var semanticModel = compilation.GetSemanticModel(syntaxTree);
             var root = syntaxTree.GetRoot();
 
@@ -197,10 +229,10 @@ private async Task BuildHierarchy(Compilation compilation, IEnumerable<Document>
             ProcessNodeForHierarchy(root, semanticModel, assemblyElement);
         }
 
-        // Process the source-generated documents (only present when IncludeGeneratedCode is enabled)
-        // through the same hierarchy walk. The generated members then get their own code element
-        // instead of being collapsed onto the containing type via the phase-2 fallback. Generated
-        // members extend existing partial types, so the named types are already collected above.
+        // Process the source-generated documents through the same hierarchy walk. The generated members
+        // then get their own code element instead of being collapsed onto the containing type via the
+        // phase-2 fallback. Generated members extend existing partial types, so the named types are
+        // already collected above.
         foreach (var generatedDocument in generatedDocuments)
         {
             var semanticModel = await generatedDocument.GetSemanticModelAsync();
@@ -210,10 +242,35 @@ private async Task BuildHierarchy(Compilation compilation, IEnumerable<Document>
                 continue;
             }
 
+            // Generated by definition - no file-name or header check needed.
+            if (!string.IsNullOrEmpty(root.SyntaxTree.FilePath))
+            {
+                _generatedFilePaths.Add(root.SyntaxTree.FilePath);
+            }
+
             ProcessNodeForHierarchy(root, semanticModel, assemblyElement);
         }
     }
 
+    /// <summary>
+    ///     Flags what a tool wrote. Runs after the whole solution is walked, because the decision needs
+    ///     <i>all</i> declarations of an element: a WPF code-behind class is partial and lives in both a
+    ///     generated and a hand-written file, and only the members that exist nowhere but the generated
+    ///     half are generated (see <see cref="GeneratedCode.IsGeneratedElement" />).
+    /// </summary>
+    private void MarkGeneratedElements()
+    {
+        if (_generatedFilePaths.Count == 0)
+        {
+            return;
+        }
+
+        foreach (var element in _codeGraph.Nodes.Values)
+        {
+            element.IsGenerated = GeneratedCode.IsGeneratedElement(element, _generatedFilePaths);
+        }
+    }
+
     private void ProcessNodeForHierarchy(SyntaxNode node, SemanticModel semanticModel,
         CodeElement parent)
     {
@@ -429,7 +486,10 @@ private CodeElement GetOrCreateCodeElement(ISymbol symbol, CodeElementType eleme
         var fullName = symbol.BuildSymbolName();
         var newId = Guid.NewGuid().ToString();
 
-        var element = new CodeElement(newId, elementType, name, fullName, parent);
+        var element = new CodeElement(newId, elementType, name, fullName, parent)
+        {
+            AccessLevel = MapAccessLevel(symbol.DeclaredAccessibility)
+        };
 
         UpdateCodeElementLocations(element, location);
 
@@ -478,7 +538,11 @@ private void CreatePropertyAccessorElement(IMethodSymbol? accessor, CodeElement
         var name = accessor.Name;
         var fullName = propertyElement.FullName + "." + name;
         var id = Guid.NewGuid().ToString();
-        var accessorElement = new CodeElement(id, CodeElementType.PropertyAccessor, name, fullName, propertyElement);
+        var accessorElement = new CodeElement(id, CodeElementType.PropertyAccessor, name, fullName, propertyElement)
+        {
+            // An accessor may narrow the property ("public int P { get; private set; }").
+            AccessLevel = MapAccessLevel(accessor.DeclaredAccessibility)
+        };
 
         foreach (var accessorLocation in accessor.GetSymbolLocations())
         {
diff --git a/CSharpCodeAnalyst.CodeParser/Parser/Parser.cs b/CSharpCodeAnalyst.CodeParser/Parser/Parser.cs
index 54a31abd..8af7f6fb 100644
--- a/CSharpCodeAnalyst.CodeParser/Parser/Parser.cs
+++ b/CSharpCodeAnalyst.CodeParser/Parser/Parser.cs
@@ -1,8 +1,10 @@
 using System.Diagnostics;
 using CSharpCodeAnalyst.CodeGraph.Contracts;
+using CSharpCodeAnalyst.CodeGraph.Declarations;
 using CSharpCodeAnalyst.CodeGraph.Graph;
 using CSharpCodeAnalyst.CodeGraph.Metrics;
 using CSharpCodeAnalyst.CodeParser.Parser.Config;
+using CSharpCodeAnalyst.CodeParser.Xaml;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.MSBuild;
@@ -161,6 +163,10 @@ private static MetadataReference[] BuildFrameworkReferences()
             "System.Linq.Expressions.dll",
             "System.Collections.dll",
             "System.Console.dll",
+
+            // INotifyPropertyChanged, ObservableCollection - netstandard.dll only forwards to this
+            // assembly, so without it those types stay unresolved and miss from AllInterfaces.
+            "System.ObjectModel.dll",
             "netstandard.dll"
         ];
 
@@ -195,12 +201,20 @@ private async Task<ParseResult> ParseSolutionInternal(Solution solution)
         sw = Stopwatch.StartNew();
 
         // Second Pass: Build Relationships
+        var externalContracts = new ExternalContractStore();
         var phase2 = new RelationshipAnalyzer(progress, config);
-        await phase2.AnalyzeRelationships(solution, codeGraph, artifacts);
+        await phase2.AnalyzeRelationships(solution, codeGraph, artifacts, externalContracts);
 
         sw.Stop();
         Trace.TraceInformation("Analyzing relationships: " + sw.Elapsed);
 
+        // Third pass: the XAML references Roslyn cannot see. Runs before the global namespace is inserted
+        // so the synthetic elements for code-behind-less files are moved along with everything else.
+        if (config.IncludeXamlReferences)
+        {
+            LinkXamlReferences(solution, codeGraph);
+        }
+
         // Makes the cycle detection easier because I never get to the assembly as shared ancestor
         // for a nested relationships.
         InsertGlobalNamespaceIfUsed(codeGraph);
@@ -210,10 +224,48 @@ private async Task<ParseResult> ParseSolutionInternal(Solution solution)
 #endif
         //await File.WriteAllTextAsync("d:\\debug0.txt", codeGraph.ToDebug());
 
-        return new ParseResult(codeGraph, metrics);
+        return new ParseResult(codeGraph, metrics) { ExternalContracts = externalContracts };
     }
 
 
+    /// <summary>
+    ///     Adds the references that only exist in XAML. The assembly elements are matched to the Roslyn
+    ///     projects by assembly name; which XAML files a project owns is answered by
+    ///     <see cref="XamlFileLocator" />, because MSBuildWorkspace does not expose the "Page" items.
+    /// </summary>
+    private void LinkXamlReferences(Solution solution, CodeGraph.Graph.CodeGraph codeGraph)
+    {
+        progress?.Report("Reading XAML references ...");
+        var sw = Stopwatch.StartNew();
+
+        var assembliesByName = codeGraph.GetRoots()
+            .Where(root => root.ElementType == CodeElementType.Assembly)
+            .ToDictionary(root => root.Name, root => root);
+
+        var projects = new List<XamlProject>();
+
+        // Constructed only here, and only now: it holds an MSBuild ProjectCollection, so the type must not
+        // be touched before Initializer.InitializeMsBuildLocator has run.
+        using (var locator = new XamlFileLocator())
+        {
+            foreach (var project in solution.Projects)
+            {
+                var directory = Path.GetDirectoryName(project.FilePath);
+                if (directory is null || !config.IsProjectIncluded(project.Name) ||
+                    !assembliesByName.TryGetValue(project.AssemblyName, out var assembly))
+                {
+                    continue;
+                }
+
+                projects.Add(new XamlProject(assembly, directory, locator.Locate(project.FilePath, directory)));
+            }
+        }
+
+        var added = XamlGraphLinker.Link(codeGraph, projects);
+        sw.Stop();
+        Trace.TraceInformation($"Reading XAML references: {sw.Elapsed} ({added} relationships)");
+    }
+
     /// <summary>
     ///     Computes per-member source metrics from the symbol map built in phase 1.
     ///     Only method-like symbols with an actual implementation are measured; abstract/extern/
diff --git a/CSharpCodeAnalyst.CodeParser/Parser/RelationshipAnalyzer.cs b/CSharpCodeAnalyst.CodeParser/Parser/RelationshipAnalyzer.cs
index 84140cf8..8af92a2f 100644
--- a/CSharpCodeAnalyst.CodeParser/Parser/RelationshipAnalyzer.cs
+++ b/CSharpCodeAnalyst.CodeParser/Parser/RelationshipAnalyzer.cs
@@ -1,3 +1,4 @@
+using CSharpCodeAnalyst.CodeGraph.Declarations;
 using CSharpCodeAnalyst.CodeGraph.Graph;
 using CSharpCodeAnalyst.CodeParser.Parser.Config;
 using Microsoft.CodeAnalysis;
@@ -34,15 +35,16 @@ public RelationshipAnalyzer(IProgress<string>? progress, ParserConfig config)
     ///     (useful when debugging); the default (-1) lets the scheduler use all available cores.
     /// </summary>
     public Task AnalyzeRelationships(Solution solution, CodeGraph.Graph.CodeGraph codeGraph, Artifacts artifacts,
-        int maxDegreeOfParallelism = -1)
+        ExternalContractStore externalContracts, int maxDegreeOfParallelism = -1)
     {
         ArgumentNullException.ThrowIfNull(solution, nameof(solution));
         ArgumentNullException.ThrowIfNull(codeGraph, nameof(codeGraph));
         ArgumentNullException.ThrowIfNull(artifacts, nameof(artifacts));
+        ArgumentNullException.ThrowIfNull(externalContracts, nameof(externalContracts));
 
         var builder = new RelationshipBuilder(codeGraph, artifacts, _config);
         var bodyAnalyzer = new SyntaxNodeAnalyzer(builder, _config);
-        var declarationAnalyzer = new DeclarationAnalyzer(builder, bodyAnalyzer, artifacts, _config);
+        var declarationAnalyzer = new DeclarationAnalyzer(builder, bodyAnalyzer, artifacts, _config, externalContracts);
 
         var numberOfCodeElements = codeGraph.Nodes.Count;
         _processedCodeElements = 0;
diff --git a/CSharpCodeAnalyst.CodeParser/Xaml/XamlFileLocator.cs b/CSharpCodeAnalyst.CodeParser/Xaml/XamlFileLocator.cs
new file mode 100644
index 00000000..e6166525
--- /dev/null
+++ b/CSharpCodeAnalyst.CodeParser/Xaml/XamlFileLocator.cs
@@ -0,0 +1,139 @@
+using System.Diagnostics;
+using Microsoft.Build.Evaluation;
+using Microsoft.Build.Locator;
+
+namespace CSharpCodeAnalyst.CodeParser.Xaml;
+
+/// <summary>
+///     Answers which XAML files belong to a project.
+///     <para>
+///         Roslyn cannot tell us: a <c>Microsoft.CodeAnalysis.Project</c> exposes Documents,
+///         AdditionalDocuments and AnalyzerConfigDocuments, and a <c>Page</c> is none of them. The project
+///         file is therefore evaluated a second time, with the MSBuild engine
+///         <c>Initializer.InitializeMsBuildLocator</c> has already put in place. That gives the item list
+///         the build itself works with - in particular a file taken out again by
+///         <c>&lt;Page Remove="..." /&gt;</c> appears in no item group at all and is correctly gone.
+///     </para>
+///     <para>
+///         Scanning the directory - what this did before - reads whatever happens to lie there: a file
+///         excluded from the project, a leftover from another branch, or the XAML of a project nested
+///         inside this one. It remains the fallback for a project file that cannot be evaluated.
+///     </para>
+///     <para>
+///         A linked file (<c>&lt;Page Include="..\Shared\Foo.xaml"&gt;</c>) comes along for free, because
+///         the item carries its real path. That is a side effect, not the goal - the directory scan misses
+///         those and always did.
+///     </para>
+///     <para>
+///         The evaluation costs a few hundred milliseconds per project (the first one more, it warms up the
+///         engine). Every project shares one <see cref="ProjectCollection" /> so the SDK imports are
+///         evaluated once, which is why this is an instance and not a static helper.
+///     </para>
+/// </summary>
+public sealed class XamlFileLocator : IDisposable
+{
+    /// <summary>
+    ///     The item types a XAML file can legitimately have. Everything else is either not XAML we could
+    ///     read or not ours: the SDK contributes twenty <c>PropertyPageSchema</c> items pointing into the
+    ///     dotnet installation, which a plain "all evaluated items ending in .xaml" would pick up.
+    /// </summary>
+    private static readonly HashSet<string> XamlItemTypes = new(StringComparer.OrdinalIgnoreCase)
+    {
+        // Compiled to BAML by the WPF markup compiler.
+        "ApplicationDefinition", "Page",
+
+        // Embedded or copied and loaded at runtime (loose XAML, themes).
+        "Resource", "Content",
+
+        // What the SDK default glob puts a stray XAML file into when the project does not compile it.
+        "None"
+    };
+
+    /// <summary>
+    ///     The <see cref="ProjectCollection" />, created on first use and typed as <see cref="object" /> on
+    ///     purpose: the field's type appears in <see cref="Dispose" />, and touching an MSBuild type there
+    ///     would load the assembly even for a run that never evaluates a project - an in-memory parse has
+    ///     no MSBuild at all.
+    /// </summary>
+    private object? _collection;
+
+    public void Dispose()
+    {
+        (_collection as IDisposable)?.Dispose();
+    }
+
+    /// <param name="projectFilePath">
+    ///     The project file. Null for a project Roslyn produced without one, which leaves only the scan.
+    /// </param>
+    /// <param name="projectDirectory">The directory used by the fallback scan.</param>
+    public IReadOnlyList<string> Locate(string? projectFilePath, string projectDirectory)
+    {
+        // Two ways to have nothing to evaluate, both of them normal rather than a defect: an in-memory
+        // parse (ParseSourceAsync) builds its project around the synthetic path "InMemory.csproj" and
+        // never registers a locator, and without a registered locator there is no MSBuild at all.
+        if (projectFilePath is not null && File.Exists(projectFilePath) && MSBuildLocator.IsRegistered)
+        {
+            try
+            {
+                return FromProjectFile(projectFilePath);
+            }
+            catch (Exception exception)
+            {
+                // A project we cannot evaluate must not cost us its references - and it must not break the
+                // parse run either. Broad on purpose: MSBuild throws its own exception type for an invalid
+                // project, IO exceptions for a file that moved, the SDK resolvers can fail on their own,
+                // and preparing FromProjectFile is where a missing MSBuild assembly would surface.
+                Trace.TraceWarning(
+                    $"XAML: cannot evaluate '{projectFilePath}', falling back to a directory scan. {exception.Message}");
+            }
+        }
+
+        return EnumerateDirectory(projectDirectory);
+    }
+
+    /// <summary>
+    ///     An empty result is an answer, not a failure: a project without XAML items has no XAML, and
+    ///     falling back to the scan here would bring the excluded files straight back in.
+    /// </summary>
+    private IReadOnlyList<string> FromProjectFile(string projectFilePath)
+    {
+        // Evaluated without global properties. The XAML item groups are not written per configuration in
+        // any project we have seen, and guessing the configuration Roslyn used would be worse than not
+        // setting one.
+        var collection = (ProjectCollection)(_collection ??= new ProjectCollection());
+        var project = collection.LoadProject(projectFilePath);
+
+        return project.AllEvaluatedItems
+            .Where(item => XamlItemTypes.Contains(item.ItemType))
+            .Select(item => item.GetMetadataValue("FullPath"))
+            .Where(IsXamlFile)
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToList();
+    }
+
+    /// <summary>
+    ///     The fallback: every XAML file below the directory. The output directories are skipped - the
+    ///     markup compiler copies XAML into <c>obj</c>, and everything found there is a duplicate.
+    /// </summary>
+    public static IReadOnlyList<string> EnumerateDirectory(string directory)
+    {
+        if (!Directory.Exists(directory))
+        {
+            return [];
+        }
+
+        return Directory.EnumerateFiles(directory, "*.xaml", SearchOption.AllDirectories)
+            .Where(file => !file.Contains($"{Path.DirectorySeparatorChar}obj{Path.DirectorySeparatorChar}") &&
+                           !file.Contains($"{Path.DirectorySeparatorChar}bin{Path.DirectorySeparatorChar}"))
+            .ToList();
+    }
+
+    /// <summary>
+    ///     An item type from the list above can hold anything (a <c>Content</c> item is usually not XAML),
+    ///     and an item can name a file that is not on disk.
+    /// </summary>
+    private static bool IsXamlFile(string path)
+    {
+        return path.EndsWith(".xaml", StringComparison.OrdinalIgnoreCase) && File.Exists(path);
+    }
+}
diff --git a/CSharpCodeAnalyst.CodeParser/Xaml/XamlGraphLinker.cs b/CSharpCodeAnalyst.CodeParser/Xaml/XamlGraphLinker.cs
new file mode 100644
index 00000000..43e1f6e6
--- /dev/null
+++ b/CSharpCodeAnalyst.CodeParser/Xaml/XamlGraphLinker.cs
@@ -0,0 +1,270 @@
+using CSharpCodeAnalyst.CodeGraph.Graph;
+
+namespace CSharpCodeAnalyst.CodeParser.Xaml;
+
+/// <summary>
+///     One analyzed project: its assembly element in the graph, its directory and the XAML files belonging
+///     to it. Which files those are is an MSBuild question and is answered by <see cref="XamlFileLocator" />
+///     - the directory is only needed to name the synthetic element of a file without code-behind.
+/// </summary>
+public sealed record XamlProject(CodeElement Assembly, string Directory, IReadOnlyList<string> Files);
+
+/// <summary>
+///     Turns the references <see cref="XamlReferenceExtractor" /> finds into real relationships in the code
+///     graph, so a type that is only ever instantiated from XAML no longer looks unused.
+///     <para>
+///         The source of such a relationship is the code-behind class named by <c>x:Class</c>. A resource
+///         dictionary has no code-behind, so a synthetic class named after the file takes its place -
+///         the same device the parser already uses for top-level statements ("GlobalStatements"). Those
+///         synthetic elements have no incoming references of their own (nothing resolves the
+///         <c>MergedDictionaries</c> URIs), so they show up in a dead code analysis. That is a known and
+///         accepted cost; there were 14 of them in this repository against 1050 findings.
+///     </para>
+///     <para>
+///         Resolution is by exact name, never by guessing: the xmlns gives the CLR namespace and optionally
+///         the assembly. Without <c>;assembly=</c> XAML means the assembly the file is compiled into, which
+///         is what is tried first; a unique match elsewhere is accepted as a fallback.
+///     </para>
+/// </summary>
+public static class XamlGraphLinker
+{
+    /// <summary>The element name the parser gives a constructor (it comes straight from the symbol).</summary>
+    private const string ConstructorName = ".ctor";
+
+    public static int Link(CodeGraph.Graph.CodeGraph graph, IReadOnlyList<XamlProject> projects)
+    {
+        ArgumentNullException.ThrowIfNull(graph);
+        ArgumentNullException.ThrowIfNull(projects);
+
+        var typesByAssembly = BuildTypeLookup(graph);
+        var added = 0;
+
+        foreach (var project in projects)
+        {
+            foreach (var file in project.Files)
+            {
+                added += LinkFile(graph, project, file, typesByAssembly);
+            }
+        }
+
+        return added;
+    }
+
+    private static int LinkFile(CodeGraph.Graph.CodeGraph graph, XamlProject project, string file,
+        Dictionary<string, Dictionary<string, CodeElement>> typesByAssembly)
+    {
+        XamlFileReferences references;
+        try
+        {
+            references = XamlReferenceExtractor.Extract(File.ReadAllText(file));
+        }
+        catch (IOException)
+        {
+            // An unreadable file must not break the parse run.
+            return 0;
+        }
+
+        if (references.References.Count == 0)
+        {
+            return 0;
+        }
+
+        var source = ResolveSource(graph, project, file, references, typesByAssembly);
+        var added = 0;
+
+        foreach (var reference in references.References)
+        {
+            foreach (var target in ResolveTargets(project, reference, typesByAssembly))
+            {
+                if (target.Id == source.Id)
+                {
+                    continue;
+                }
+
+                if (AddReference(source, target, file, reference))
+                {
+                    added++;
+                }
+            }
+        }
+
+        return added;
+    }
+
+    /// <summary>
+    ///     Adds the relationship, or merges the location into the existing one. The relationship set is
+    ///     keyed by (source, target, type), so a plain Add would silently drop the new source location.
+    /// </summary>
+    private static bool AddReference(CodeElement source, CodeElement target, string file, XamlReference reference)
+    {
+        var location = new SourceLocation(file, reference.Line, reference.Column);
+        var existing = source.Relationships.FirstOrDefault(
+            r => r.TargetId == target.Id && r.Type == RelationshipType.Uses);
+
+        if (existing is not null)
+        {
+            if (!existing.SourceLocations.Contains(location))
+            {
+                existing.SourceLocations.Add(location);
+            }
+
+            existing.SetAttribute(RelationshipAttribute.IsXamlReference);
+            return false;
+        }
+
+        var relationship = new Relationship(source.Id, target.Id, RelationshipType.Uses,
+            RelationshipAttribute.IsXamlReference);
+        relationship.SourceLocations.Add(location);
+        source.Relationships.Add(relationship);
+        return true;
+    }
+
+    private static CodeElement ResolveSource(CodeGraph.Graph.CodeGraph graph, XamlProject project, string file,
+        XamlFileReferences references, Dictionary<string, Dictionary<string, CodeElement>> typesByAssembly)
+    {
+        if (references.CodeBehindClass is not null &&
+            typesByAssembly.TryGetValue(project.Assembly.Name, out var types) &&
+            types.TryGetValue(references.CodeBehindClass, out var codeBehind))
+        {
+            return codeBehind;
+        }
+
+        return GetOrCreateSyntheticElement(graph, project, file);
+    }
+
+    /// <summary>
+    ///     The stand-in for a XAML file that has no code-behind class. Named after the path relative to the
+    ///     project so two files with the same name stay distinguishable. A linked file lies outside the
+    ///     project directory, where a relative path would only produce a row of dots - its file name has to
+    ///     do.
+    /// </summary>
+    private static CodeElement GetOrCreateSyntheticElement(CodeGraph.Graph.CodeGraph graph, XamlProject project,
+        string file)
+    {
+        var relativePath = Path.GetRelativePath(project.Directory, file);
+        if (relativePath.StartsWith("..", StringComparison.Ordinal) || Path.IsPathRooted(relativePath))
+        {
+            relativePath = Path.GetFileName(file);
+        }
+
+        var name = Path.ChangeExtension(relativePath, null)
+            .Replace(Path.DirectorySeparatorChar, '.')
+            .Replace(Path.AltDirectorySeparatorChar, '.');
+
+        var fullName = project.Assembly.FullName + "." + name;
+
+        var existing = project.Assembly.Children.FirstOrDefault(c => c.FullName == fullName);
+        if (existing is not null)
+        {
+            return existing;
+        }
+
+        var element = new CodeElement(Guid.NewGuid().ToString(), CodeElementType.Class, name, fullName,
+            project.Assembly);
+        element.SourceLocations.Add(new SourceLocation(file, 1, 1));
+
+        project.Assembly.Children.Add(element);
+        graph.Nodes[element.Id] = element;
+        return element;
+    }
+
+    private static IEnumerable<CodeElement> ResolveTargets(XamlProject project, XamlReference reference,
+        Dictionary<string, Dictionary<string, CodeElement>> typesByAssembly)
+    {
+        var type = ResolveType(project, reference, typesByAssembly);
+        if (type is null)
+        {
+            yield break;
+        }
+
+        if (reference.MemberName is not null)
+        {
+            // {x:Static Type.Member} - prefer the member, fall back to the type when it has no element
+            // (e.g. an enum value or a member the parser did not model).
+            yield return type.Children.FirstOrDefault(c => c.Name == reference.MemberName) ?? type;
+            yield break;
+        }
+
+        yield return type;
+
+        if (!reference.IsInstantiation)
+        {
+            yield break;
+        }
+
+        // An object element runs the constructor. Without this edge the constructor has no incoming
+        // reference at all, and everything only it calls dies with it in the cascade - the body of a
+        // XAML-instantiated control lives almost entirely below its constructor.
+        // Overloads share the element name, so all of them are linked: XAML picks the parameterless one,
+        // but the graph cannot tell them apart, and an edge too many is far cheaper here than a missing
+        // one.
+        foreach (var constructor in type.Children.Where(IsConstructor))
+        {
+            yield return constructor;
+        }
+    }
+
+    private static bool IsConstructor(CodeElement element)
+    {
+        return element is { ElementType: CodeElementType.Method, Name: ConstructorName };
+    }
+
+    private static CodeElement? ResolveType(XamlProject project, XamlReference reference,
+        Dictionary<string, Dictionary<string, CodeElement>> typesByAssembly)
+    {
+        // An explicit ";assembly=" wins; without it XAML means the assembly the file is compiled into.
+        var assemblyName = reference.AssemblyName ?? project.Assembly.Name;
+        if (typesByAssembly.TryGetValue(assemblyName, out var types) &&
+            types.TryGetValue(reference.TypeFullName, out var declared))
+        {
+            return declared;
+        }
+
+        // Fallback: a unique match anywhere. Ambiguous names are dropped rather than guessed.
+        var matches = typesByAssembly.Values
+            .Select(candidates => candidates.GetValueOrDefault(reference.TypeFullName))
+            .Where(candidate => candidate is not null)
+            .Take(2)
+            .ToList();
+
+        return matches.Count == 1 ? matches[0] : null;
+    }
+
+    /// <summary>
+    ///     Maps assembly name -&gt; CLR full name ("Namespace.Type") -&gt; type element. The assembly node and
+    ///     the synthetic global namespace are not part of a CLR name and are skipped.
+    /// </summary>
+    private static Dictionary<string, Dictionary<string, CodeElement>> BuildTypeLookup(
+        CodeGraph.Graph.CodeGraph graph)
+    {
+        var lookup = new Dictionary<string, Dictionary<string, CodeElement>>();
+
+        foreach (var element in graph.Nodes.Values)
+        {
+            if (!element.IsType() || element.IsExternal)
+            {
+                continue;
+            }
+
+            var path = element.GetPathToRoot(true);
+            if (path.Count < 2 || path[0].ElementType != CodeElementType.Assembly)
+            {
+                continue;
+            }
+
+            var segments = path.Skip(1)
+                .Where(p => p.ElementType != CodeElementType.Namespace ||
+                            p.Name != CodeElement.GlobalNamespaceName)
+                .Select(p => p.Name);
+
+            var types = lookup.TryGetValue(path[0].Name, out var existing) ? existing : lookup[path[0].Name] = [];
+
+            // A name collision would mean two types with the same full name in one assembly, which the
+            // compiler would already have rejected.
+            types[string.Join(".", segments)] = element;
+        }
+
+        return lookup;
+    }
+
+}
diff --git a/CSharpCodeAnalyst.CodeParser/Xaml/XamlReferenceExtractor.cs b/CSharpCodeAnalyst.CodeParser/Xaml/XamlReferenceExtractor.cs
new file mode 100644
index 00000000..b1eda486
--- /dev/null
+++ b/CSharpCodeAnalyst.CodeParser/Xaml/XamlReferenceExtractor.cs
@@ -0,0 +1,211 @@
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Linq;
+
+namespace CSharpCodeAnalyst.CodeParser.Xaml;
+
+/// <summary>
+///     A single reference to CLR code found in a XAML file. <see cref="MemberName" /> is null when the
+///     whole type is referenced (an element tag, <c>{x:Type}</c>), and set for <c>{x:Static}</c>.
+///     <see cref="AssemblyName" /> comes from the <c>;assembly=</c> part of the xmlns and is null when the
+///     xmlns omits it - which means the type lives in the same assembly as the XAML file.
+/// </summary>
+public sealed record XamlReference(
+    string NamespaceName,
+    string TypeName,
+    string? MemberName,
+    string? AssemblyName,
+    int Line,
+    int Column)
+{
+    /// <summary>
+    ///     True for an object element (<c>&lt;local:MyControl/&gt;</c>) - XAML creates an instance there,
+    ///     so the constructor runs. False for everything that only names a type: property element syntax
+    ///     (<c>&lt;local:MyControl.Items&gt;</c>), an attached property and <c>{x:Type}</c>.
+    /// </summary>
+    public bool IsInstantiation { get; init; }
+
+    public string TypeFullName => $"{NamespaceName}.{TypeName}";
+}
+
+/// <summary>
+///     Everything one XAML file contributes: the code-behind class it belongs to (from <c>x:Class</c>, null
+///     for a resource dictionary) and the CLR references it makes.
+/// </summary>
+public sealed class XamlFileReferences
+{
+    public string? CodeBehindClass { get; init; }
+    public IReadOnlyList<XamlReference> References { get; init; } = [];
+}
+
+/// <summary>
+///     Reads the CLR references out of a XAML file - the ones the markup compiler does *not* turn into C#.
+///     <para>
+///         The WPF markup compiler generates a partial class per XAML file that contains the event handler
+///         wiring and a field per <c>x:Name</c>, so those references are already visible to Roslyn. What
+///         never reaches C# is everything declarative: it is compiled into BAML and resolved by reflection
+///         at runtime. Three of those constructs carry a fully qualified CLR name and can therefore be
+///         resolved exactly, which is what this extractor collects:
+///     </para>
+///     <list type="bullet">
+///         <item>element tags - <c>&lt;local:MyControl/&gt;</c>, including property element syntax</item>
+///         <item><c>{x:Static local:Texts.Caption}</c></item>
+///         <item><c>{x:Type local:Foo}</c></item>
+///     </list>
+///     <para>
+///         <c>{Binding Path}</c> is deliberately NOT collected. Without evaluating the DataContext it is a
+///         bare member name, and matching that by name across the whole codebase would suppress far more
+///         than it explains.
+///     </para>
+///     <para>
+///         Prefixes are resolved through the XML namespace declarations, so a <c>clr-namespace</c> xmlns is
+///         mapped exactly - there is no name guessing anywhere in here.
+///     </para>
+/// </summary>
+public static class XamlReferenceExtractor
+{
+    private const string ClrNamespacePrefix = "clr-namespace:";
+    
+    /// <summary>
+    /// Typically named x:
+    /// </summary>
+    private const string XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml";
+
+    /// <summary>
+    ///     Matches "{prefix:Static target:Type.Member}" and "{prefix:Type target:Type}", also when nested
+    ///     inside another markup extension. Both prefixes are resolved against the element, never assumed.
+    /// </summary>
+    private static readonly Regex MarkupExtension = new(
+        @"\{\s*(?<xamlPrefix>\w+)\s*:\s*(?<kind>Static|Type)\s+(?<prefix>\w+)\s*:\s*(?<path>[\w.]+)",
+        RegexOptions.Compiled);
+
+    public static XamlFileReferences Extract(string xaml)
+    {
+        ArgumentNullException.ThrowIfNull(xaml);
+
+        XDocument document;
+        try
+        {
+            document = XDocument.Parse(xaml, LoadOptions.SetLineInfo);
+        }
+        catch (XmlException)
+        {
+            // A malformed or unsupported file contributes nothing. It must never break the parse run.
+            return new XamlFileReferences();
+        }
+
+        var references = new List<XamlReference>();
+
+        foreach (var element in document.Descendants())
+        {
+            CollectElementTag(element, references);
+
+            foreach (var attribute in element.Attributes())
+            {
+                CollectAttachedProperty(attribute, references);
+                CollectMarkupExtensions(element, attribute, references);
+            }
+        }
+
+        return new XamlFileReferences
+        {
+            CodeBehindClass = document.Root?.Attribute(XName.Get("Class", XamlNamespace))?.Value,
+            References = references
+        };
+    }
+
+    /// <summary>
+    ///     The element tag itself: &lt;local:MyControl/&gt;. Property element syntax puts the property
+    ///     behind a dot (&lt;local:MyControl.Items&gt;), so only the part in front of it is the type.
+    /// </summary>
+    private static void CollectElementTag(XElement element, List<XamlReference> references)
+    {
+        // Only a tag without a dot creates an object; with one it is property element syntax.
+        // This is not necessary redundant: <Grid><local:GridHelper.Columns>...</local:GridHelper.Columns></Grid>
+        var isInstantiation = !element.Name.LocalName.Contains('.');
+        Add(element.Name.NamespaceName, element.Name.LocalName, element, references,
+            isInstantiation: isInstantiation);
+    }
+
+    /// <summary>An attached property written as local:MyPanel.Dock="..." references MyPanel.</summary>
+    private static void CollectAttachedProperty(XAttribute attribute, List<XamlReference> references)
+    {
+        Add(attribute.Name.NamespaceName, attribute.Name.LocalName, attribute, references);
+    }
+
+    private static void CollectMarkupExtensions(XElement element, XAttribute attribute,
+        List<XamlReference> references)
+    {
+        foreach (Match match in MarkupExtension.Matches(attribute.Value))
+        {
+            // "x" is only a convention - verify the prefix really maps to the XAML language namespace.
+            var xamlNamespace = element.GetNamespaceOfPrefix(match.Groups["xamlPrefix"].Value);
+            if (xamlNamespace?.NamespaceName != XamlNamespace)
+            {
+                continue;
+            }
+
+            var targetNamespace = element.GetNamespaceOfPrefix(match.Groups["prefix"].Value);
+            if (targetNamespace is null)
+            {
+                continue;
+            }
+
+            var path = match.Groups["path"].Value;
+            if (match.Groups["kind"].Value == "Type")
+            {
+                Add(targetNamespace.NamespaceName, path, attribute, references);
+                continue;
+            }
+
+            // {x:Static Type.Member} - the last segment is the member.
+            var separator = path.LastIndexOf('.');
+            if (separator <= 0 || separator == path.Length - 1)
+            {
+                continue;
+            }
+
+            Add(targetNamespace.NamespaceName, path[..separator], attribute, references,
+                path[(separator + 1)..]);
+        }
+    }
+
+    private static void Add(string namespaceName, string localName, IXmlLineInfo position,
+        List<XamlReference> references, string? memberName = null, bool isInstantiation = false)
+    {
+        if (!namespaceName.StartsWith(ClrNamespacePrefix, StringComparison.Ordinal))
+        {
+            // A framework namespace (presentation, xaml, ...) - nothing of ours is referenced.
+            return;
+        }
+
+        // "clr-namespace:Some.Namespace;assembly=Some.Assembly" - the assembly part is optional and
+        // absent exactly when the type lives in the same assembly as the XAML file.
+        var declaration = namespaceName[ClrNamespacePrefix.Length..];
+        var semicolon = declaration.IndexOf(';');
+        var clrNamespace = semicolon < 0 ? declaration : declaration[..semicolon];
+
+        string? assemblyName = null;
+        if (semicolon >= 0)
+        {
+            const string assemblyKey = "assembly=";
+            var assemblyPart = declaration[(semicolon + 1)..].Trim();
+            if (assemblyPart.StartsWith(assemblyKey, StringComparison.Ordinal))
+            {
+                assemblyName = assemblyPart[assemblyKey.Length..].Trim();
+            }
+        }
+
+        // Property element syntax: <local:MyControl.Items> names the type in front of the dot.
+        var dot = localName.IndexOf('.');
+        var typeName = dot < 0 ? localName : localName[..dot];
+
+        if (clrNamespace.Length == 0 || typeName.Length == 0)
+        {
+            return;
+        }
+
+        references.Add(new XamlReference(clrNamespace, typeName, memberName, assemblyName,
+            position.LineNumber, position.LinePosition) { IsInstantiation = isInstantiation });
+    }
+}
diff --git a/CSharpCodeAnalyst/App.xaml.cs b/CSharpCodeAnalyst/App.xaml.cs
index 91236643..c772ad10 100644
--- a/CSharpCodeAnalyst/App.xaml.cs
+++ b/CSharpCodeAnalyst/App.xaml.cs
@@ -103,8 +103,12 @@ private void StartUi()
         // project load, read by the Method Complexity analyzer.
         var metricStore = new CodeGraph.Metrics.MetricStore();
 
+        // Same shape: which members implement a contract from outside the analyzed code. Read by the
+        // Dead Code analyzer, which would otherwise report every framework override as unused.
+        var externalContractStore = new CodeGraph.Declarations.ExternalContractStore();
+
         var analyzerManager = new AnalyzerManager();
-        analyzerManager.LoadAnalyzers(messaging, uiNotification, metricStore);
+        analyzerManager.LoadAnalyzers(messaging, uiNotification, metricStore, externalContractStore);
 
         var explorer = new CodeGraphExplorer();
         var mainWindow = new MainWindow();
@@ -123,7 +127,7 @@ private void StartUi()
         var projectStorage = new JsonProjectStorage();
         var projectService = new ProjectService(projectStorage, uiNotification, userSettings);
 
-        var viewModel = new MainViewModel(messaging, applicationSettings, userSettings, analyzerManager, refactoringService, projectService, metricStore);
+        var viewModel = new MainViewModel(messaging, applicationSettings, userSettings, analyzerManager, refactoringService, projectService, metricStore, externalContractStore);
         var graphViewModel = new GraphViewModel(graphViewState, explorer, messaging, applicationSettings, refactoringService);
         var treeViewModel = new TreeViewModel(messaging, refactoringService);
         var searchViewModel = new AdvancedSearchViewModel(messaging, refactoringService);
diff --git a/CSharpCodeAnalyst/CommandLine/ConsoleValidationCommand.cs b/CSharpCodeAnalyst/CommandLine/ConsoleValidationCommand.cs
index c929640c..5e0b9213 100644
--- a/CSharpCodeAnalyst/CommandLine/ConsoleValidationCommand.cs
+++ b/CSharpCodeAnalyst/CommandLine/ConsoleValidationCommand.cs
@@ -1,4 +1,4 @@
-using CSharpCodeAnalyst.CodeGraph.Contracts;
+using CSharpCodeAnalyst.CodeGraph.Contracts;
 using System.Diagnostics;
 using System.IO;
 using System.Text;
@@ -93,7 +93,7 @@ private static RuleAnalysisResult RunAnalysis(string rulesFilePath, CodeGraph.Gr
     {
         var filter = new ProjectExclusionRegExCollection();
         filter.Initialize(settings.DefaultProjectExcludeFilter);
-        var parser = new Parser(new ParserConfig(filter, settings.IncludeExternalCode, settings.IncludeGeneratedCode, settings.SplitPropertyAccessors));
+        var parser = new Parser(new ParserConfig(filter, settings.IncludeExternalCode, settings.SplitPropertyAccessors));
         var parseResult = await parser.ParseAsync(solutionPath).ConfigureAwait(false);
 
         var failures = parser.Diagnostics.FormatFailures();
diff --git a/CSharpCodeAnalyst/Configuration/AppSettings.cs b/CSharpCodeAnalyst/Configuration/AppSettings.cs
index cee208b7..452f53c5 100644
--- a/CSharpCodeAnalyst/Configuration/AppSettings.cs
+++ b/CSharpCodeAnalyst/Configuration/AppSettings.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using System.Text.Json;
 
 namespace CSharpCodeAnalyst.Configuration;
@@ -17,8 +17,6 @@ public string DefaultProjectExcludeFilter
 
     public bool IncludeExternalCode { get; set; }
 
-    public bool IncludeGeneratedCode { get; set; }
-
     public bool SplitPropertyAccessors { get; set; } = true;
 
     public bool WarnIfFiltersActive { get; set; } = true;
@@ -58,7 +56,6 @@ public AppSettings Clone()
             DefaultProjectExcludeFilter = this.DefaultProjectExcludeFilter,
             AutomaticallyAddContainingType = this.AutomaticallyAddContainingType,
             IncludeExternalCode = this.IncludeExternalCode,
-            IncludeGeneratedCode = this.IncludeGeneratedCode,
             SplitPropertyAccessors = this.SplitPropertyAccessors,
             WarnIfFiltersActive = this.WarnIfFiltersActive,
             ShowOverviewOnImport = this.ShowOverviewOnImport
diff --git a/CSharpCodeAnalyst/Configuration/SettingsDialog.xaml b/CSharpCodeAnalyst/Configuration/SettingsDialog.xaml
index 21fa0ebd..3686613f 100644
--- a/CSharpCodeAnalyst/Configuration/SettingsDialog.xaml
+++ b/CSharpCodeAnalyst/Configuration/SettingsDialog.xaml
@@ -1,4 +1,4 @@
-<Window x:Class="CSharpCodeAnalyst.Configuration.SettingsDialog"
+<Window x:Class="CSharpCodeAnalyst.Configuration.SettingsDialog"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:resources="clr-namespace:CSharpCodeAnalyst.Resources"
@@ -41,11 +41,6 @@
                                           Margin="0,5"
                                           ToolTip="{x:Static resources:Strings.Settings_IncludeExternalCode_Tooltip}" />
 
-                                <CheckBox x:Name="IncludeGeneratedCodeCheckBox"
-                                          Content="{x:Static resources:Strings.Settings_IncludeGeneratedCode}"
-                                          Margin="0,5"
-                                          ToolTip="{x:Static resources:Strings.Settings_IncludeGeneratedCode_Tooltip}" />
-
                                 <CheckBox x:Name="SplitPropertyAccessorsCheckBox"
                                           Content="{x:Static resources:Strings.Settings_SplitPropertyAccessors}"
                                           Margin="0,5"
diff --git a/CSharpCodeAnalyst/Configuration/SettingsDialog.xaml.cs b/CSharpCodeAnalyst/Configuration/SettingsDialog.xaml.cs
index f3d92830..9d280a52 100644
--- a/CSharpCodeAnalyst/Configuration/SettingsDialog.xaml.cs
+++ b/CSharpCodeAnalyst/Configuration/SettingsDialog.xaml.cs
@@ -1,4 +1,4 @@
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 using System.Windows;
 using CSharpCodeAnalyst.CodeParser.Parser.Config;
 using CSharpCodeAnalyst.Resources;
@@ -28,7 +28,6 @@ private void LoadSettingsToUi()
         // Internal format to new line separated.
         ProjectExcludeFilterTextBox.Text = AppSettings.DefaultProjectExcludeFilter.Replace(";", Environment.NewLine);
         IncludeExternalCodeCheckBox.IsChecked = AppSettings.IncludeExternalCode;
-        IncludeGeneratedCodeCheckBox.IsChecked = AppSettings.IncludeGeneratedCode;
         SplitPropertyAccessorsCheckBox.IsChecked = AppSettings.SplitPropertyAccessors;
         WarnIfFiltersActiveCheckBox.IsChecked = AppSettings.WarnIfFiltersActive;
         ShowOverviewOnImportCheckBox.IsChecked = AppSettings.ShowOverviewOnImport;
@@ -49,7 +48,6 @@ private void SaveSettingsFromUi()
     {
         AppSettings.AutomaticallyAddContainingType = AutoAddContainingTypeCheckBox.IsChecked ?? true;
         AppSettings.IncludeExternalCode = IncludeExternalCodeCheckBox.IsChecked ?? true;
-        AppSettings.IncludeGeneratedCode = IncludeGeneratedCodeCheckBox.IsChecked ?? false;
         AppSettings.SplitPropertyAccessors = SplitPropertyAccessorsCheckBox.IsChecked ?? false;
         AppSettings.WarnIfFiltersActive = WarnIfFiltersActiveCheckBox.IsChecked ?? true;
         AppSettings.ShowOverviewOnImport = ShowOverviewOnImportCheckBox.IsChecked ?? true;
diff --git a/CSharpCodeAnalyst/Features/Analyzers/AnalyzerManager.cs b/CSharpCodeAnalyst/Features/Analyzers/AnalyzerManager.cs
index 29186599..34f260d0 100644
--- a/CSharpCodeAnalyst/Features/Analyzers/AnalyzerManager.cs
+++ b/CSharpCodeAnalyst/Features/Analyzers/AnalyzerManager.cs
@@ -1,10 +1,12 @@
 using CSharpCodeAnalyst.Analyzers.EventRegistration;
 using CSharpCodeAnalyst.AnalyzerSdk.Contracts;
 using CSharpCodeAnalyst.AnalyzerSdk.Notifications;
+using CSharpCodeAnalyst.CodeGraph.Declarations;
 using CSharpCodeAnalyst.CodeGraph.Metrics;
 using CSharpCodeAnalyst.Shared.Contracts;
 using CSharpCodeAnalyst.Shared.Notifications;
 using ArchitecturalRules = CSharpCodeAnalyst.Analyzers.ArchitecturalRules;
+using DeadCode = CSharpCodeAnalyst.Analyzers.DeadCode;
 using MethodComplexity = CSharpCodeAnalyst.Analyzers.MethodComplexity;
 using SystemMetrics = CSharpCodeAnalyst.Analyzers.SystemMetrics;
 using TypeCohesion = CSharpCodeAnalyst.Analyzers.TypeCohesion;
@@ -66,7 +68,8 @@ private void RaiseAnalyzerDataChanged()
         AnalyzerDataChanged?.Invoke(this, EventArgs.Empty);
     }
 
-    public void LoadAnalyzers(IPublisher messaging, IUserNotification userNotification, MetricStore metricStore)
+    public void LoadAnalyzers(IPublisher messaging, IUserNotification userNotification, MetricStore metricStore,
+        ExternalContractStore externalContractStore)
     {
         _analyzers.Clear();
 
@@ -94,6 +97,10 @@ public void LoadAnalyzers(IPublisher messaging, IUserNotification userNotificati
         analyzer.DataChanged += (_, _) => RaiseAnalyzerDataChanged();
         _analyzers.Add(analyzer.Id, analyzer);
 
+        analyzer = new DeadCode.Analyzer(messaging, userNotification, externalContractStore);
+        analyzer.DataChanged += (_, _) => RaiseAnalyzerDataChanged();
+        _analyzers.Add(analyzer.Id, analyzer);
+
        
     }
 
diff --git a/CSharpCodeAnalyst/Features/Import/Importer.cs b/CSharpCodeAnalyst/Features/Import/Importer.cs
index 58a47339..51f3888a 100644
--- a/CSharpCodeAnalyst/Features/Import/Importer.cs
+++ b/CSharpCodeAnalyst/Features/Import/Importer.cs
@@ -1,4 +1,4 @@
-using CSharpCodeAnalyst.AnalyzerSdk.Notifications;
+using CSharpCodeAnalyst.AnalyzerSdk.Notifications;
 using CSharpCodeAnalyst.CodeGraph.Contracts;
 using CSharpCodeAnalyst.CodeParser.Parser;
 using CSharpCodeAnalyst.CodeParser.Parser.Config;
@@ -45,7 +45,7 @@ public Importer(IUserNotification ui, IProgress<BusyState> busy)
     }
 
     public async Task<Result<ParseResult>> ImportSolutionAsync(ProjectExclusionRegExCollection filters, bool includeExternalCode,
-        bool includeGeneratedCode, bool splitPropertyAccessors)
+        bool splitPropertyAccessors)
     {
         var fileName = TryGetImportSolutionPath();
         if (string.IsNullOrEmpty(fileName))
@@ -56,7 +56,7 @@ public async Task<Result<ParseResult>> ImportSolutionAsync(ProjectExclusionRegEx
         var result = await ExecuteGuardedImportAsync(
             Strings.Load_Message_Default,
             async () => (ParseResult?)await Task.Run(() =>
-                ImportSolutionFuncAsync(fileName, filters, includeExternalCode, includeGeneratedCode, splitPropertyAccessors)));
+                ImportSolutionFuncAsync(fileName, filters, includeExternalCode, splitPropertyAccessors)));
 
         if (_parserDiagnostics is { HasDiagnostics: true })
         {
@@ -87,9 +87,9 @@ public async Task<Result<ParseResult>> RunImporterAsync(IImporter importer)
     }
 
     private async Task<ParseResult> ImportSolutionFuncAsync(string solutionPath, ProjectExclusionRegExCollection filters,
-        bool includeExternalCode, bool includeGeneratedCode, bool splitPropertyAccessors)
+        bool includeExternalCode, bool splitPropertyAccessors)
     {
-        var parser = new Parser(new ParserConfig(filters, includeExternalCode, includeGeneratedCode, splitPropertyAccessors), _progress);
+        var parser = new Parser(new ParserConfig(filters, includeExternalCode, splitPropertyAccessors), _progress);
 
         _parserDiagnostics = null;
         var parseResult = await parser.ParseAsync(solutionPath).ConfigureAwait(true);
diff --git a/CSharpCodeAnalyst/Features/Tree/TreeViewModel.cs b/CSharpCodeAnalyst/Features/Tree/TreeViewModel.cs
index 7ebb4fc2..adca4fc0 100644
--- a/CSharpCodeAnalyst/Features/Tree/TreeViewModel.cs
+++ b/CSharpCodeAnalyst/Features/Tree/TreeViewModel.cs
@@ -398,7 +398,10 @@ public void ExecuteSearch()
         }
         else
         {
-            var expr = SearchExpressionFactory.CreateSearchExpression(SearchText, SearchExpressionFactory.TextSearchField.Name);
+            // No negation here: SearchAndExpandNodes expands and highlights every ancestor of a match, so
+            // an excluding search would match nearly everything and unfold the whole tree at once.
+            var expr = SearchExpressionFactory.CreateSearchExpression(SearchText,
+                SearchExpressionFactory.TextSearchField.Name, false);
             SearchAndExpandNodes(TreeItems, expr);
         }
     }
diff --git a/CSharpCodeAnalyst/MainViewModel.cs b/CSharpCodeAnalyst/MainViewModel.cs
index b71ce85e..cb2f13c5 100644
--- a/CSharpCodeAnalyst/MainViewModel.cs
+++ b/CSharpCodeAnalyst/MainViewModel.cs
@@ -1,4 +1,4 @@
-using CSharpCodeAnalyst.CodeGraph.Contracts;
+using CSharpCodeAnalyst.CodeGraph.Contracts;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Diagnostics;
@@ -15,6 +15,7 @@
 using CSharpCodeAnalyst.CodeGraph.Algorithms.Cycles;
 using CSharpCodeAnalyst.CodeGraph.Algorithms.Partitioning;
 using CSharpCodeAnalyst.CodeGraph.Graph;
+using CSharpCodeAnalyst.CodeGraph.Declarations;
 using CSharpCodeAnalyst.CodeGraph.Metrics;
 using CSharpCodeAnalyst.CodeParser.Parser;
 using CSharpCodeAnalyst.CodeParser.Parser.Config;
@@ -65,6 +66,7 @@ internal sealed class MainViewModel : INotifyPropertyChanged
     private readonly ImporterManager _importerManager = new();
 
     private readonly MessageBus _messaging;
+    private readonly ExternalContractStore _externalContractStore;
     private readonly MetricStore _metricStore;
 
     private readonly ProjectExclusionRegExCollection _projectExclusionFilters;
@@ -90,7 +92,7 @@ internal sealed class MainViewModel : INotifyPropertyChanged
 
     internal MainViewModel(MessageBus messaging, AppSettings settings, UserPreferences userSettings,
         AnalyzerManager analyzerManager, RefactoringService refactoringService, IProjectService projectService,
-        MetricStore metricStore)
+        MetricStore metricStore, ExternalContractStore externalContractStore)
     {
         // Initialize settings
         _applicationSettings = settings;
@@ -98,6 +100,7 @@ internal MainViewModel(MessageBus messaging, AppSettings settings, UserPreferenc
         _analyzerManager = analyzerManager;
         _refactoringService = refactoringService;
         _metricStore = metricStore;
+        _externalContractStore = externalContractStore;
 
         analyzerManager.AnalyzerDataChanged += OnAnalyzerDataChanged;
 
@@ -977,6 +980,7 @@ private void LoadCodeGraph(CodeGraph.Graph.CodeGraph codeGraph)
         Cycles = null;
         DynamicTabs.Clear();
         _metricStore.Clear();
+        _externalContractStore.Clear();
         InfoPanelViewModel?.ClearQuickInfo();
 
         UpdateStatistics(codeGraph);
@@ -999,7 +1003,7 @@ private async void OnImportSolution()
         {
             AskUserToSaveProject();
 
-            var result = await _importer.ImportSolutionAsync(_projectExclusionFilters, _applicationSettings.IncludeExternalCode, _applicationSettings.IncludeGeneratedCode,
+            var result = await _importer.ImportSolutionAsync(_projectExclusionFilters, _applicationSettings.IncludeExternalCode,
                 _applicationSettings.SplitPropertyAccessors);
 
             if (result.IsCanceled)
@@ -1026,6 +1030,10 @@ private void CompleteImport(ParseResult parseResult)
         // Carry the freshly collected source metrics into the shared store (empty if the option was off).
         _metricStore.LoadFrom(parseResult.Metrics.Metrics);
 
+        // Same for the external contracts (empty for every importer except the C# parser).
+        _externalContractStore.LoadFrom(parseResult.ExternalContracts.Contracts,
+            parseResult.ExternalContracts.NotifyingTypes);
+
         // Give an immediate overview of the freshly imported solution: the whole graph, every
         // container collapsed, so the user starts from a map instead of an empty canvas. Only on
         // import - loading a saved project restores the user's own view instead. Opt-out via setting.
@@ -1247,6 +1255,7 @@ private ProjectData CollectProjectData()
         projectData.Settings.ExclusionFilter = _projectExclusionFilters.ToString();
         projectData.AnalyzerData = _analyzerManager.CollectAnalyzerData();
         projectData.SetMetrics(_metricStore);
+        projectData.SetExternalContracts(_externalContractStore);
         return projectData;
     }
 
@@ -1284,6 +1293,7 @@ private void RestoreProjectData(ProjectData projectData)
         // Restore the source metrics (LoadCodeGraph cleared the shared store).
         // Singleton share with analyzer!
         _metricStore.LoadFrom(projectData.GetMetrics());
+        _externalContractStore.LoadFrom(projectData.GetExternalContracts(), projectData.GetNotifyingTypes());
 
         // Restore analyzer data
         _analyzerManager.RestoreAnalyzerData(projectData.AnalyzerData);
diff --git a/CSharpCodeAnalyst/Persistence/Dto/ProjectData.cs b/CSharpCodeAnalyst/Persistence/Dto/ProjectData.cs
index 09ca2be0..70e81012 100644
--- a/CSharpCodeAnalyst/Persistence/Dto/ProjectData.cs
+++ b/CSharpCodeAnalyst/Persistence/Dto/ProjectData.cs
@@ -1,3 +1,4 @@
+using CSharpCodeAnalyst.CodeGraph.Declarations;
 using CSharpCodeAnalyst.CodeGraph.Graph;
 using CSharpCodeAnalyst.CodeGraph.Metrics;
 using CSharpCodeAnalyst.Features.Gallery;
@@ -26,6 +27,21 @@ public class ProjectData
     /// </summary>
     public List<SerializableMemberMetrics> MemberMetrics { get; set; } = [];
 
+    /// <summary>
+    ///     Which members implement a contract from outside the analyzed code, keyed by element id.
+    ///     Empty for every graph producer except the C# parser. An older project file simply has none,
+    ///     and those members show up as unreferenced again until the solution is parsed anew.
+    /// </summary>
+    public Dictionary<string, string> ExternalContracts { get; set; } = new();
+
+    /// <summary>
+    ///     The element ids of the types that raise change notifications (INotifyPropertyChanged anywhere
+    ///     in the interface set). Complements <see cref="ExternalContracts" />: the member-level contract
+    ///     cannot see a view model whose base class lives outside the analyzed code. An older project
+    ///     file simply has none, and the binding rule is off until the solution is parsed anew.
+    /// </summary>
+    public List<string> NotifyingTypes { get; set; } = [];
+
     /// <summary>
     ///     Gallery is already serializable.
     /// </summary>
@@ -62,6 +78,22 @@ public Dictionary<string, MemberMetrics> GetMetrics()
             });
     }
 
+    public void SetExternalContracts(ExternalContractStore store)
+    {
+        ExternalContracts = store.Contracts.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+        NotifyingTypes = store.NotifyingTypes.ToList();
+    }
+
+    public IReadOnlyDictionary<string, string> GetExternalContracts()
+    {
+        return ExternalContracts;
+    }
+
+    public IReadOnlyCollection<string> GetNotifyingTypes()
+    {
+        return NotifyingTypes;
+    }
+
     /// <summary>
     ///     Flatten the recursive structures.
     /// </summary>
@@ -70,7 +102,7 @@ public void SetCodeGraph(CodeGraph.Graph.CodeGraph codeGraph)
         CodeElements = codeGraph.Nodes.Values
             .Select(n =>
                 new SerializableCodeElement(n.Id, n.Name, n.FullName, n.ElementType, n.SourceLocations, n.Attributes,
-                    n.IsExternal))
+                    n.IsExternal, n.AccessLevel, n.IsGenerated))
             .ToList();
 
         // We iterate over children, so we expect to have a parent
@@ -98,7 +130,9 @@ public CodeGraph.Graph.CodeGraph GetCodeGraph()
             {
                 SourceLocations = se.SourceLocations,
                 Attributes = se.Attributes,
-                IsExternal = se.IsExternal
+                IsExternal = se.IsExternal,
+                IsGenerated = se.IsGenerated,
+                AccessLevel = se.AccessLevel
             };
             codeStructure.Nodes.Add(element.Id, element);
         }
diff --git a/CSharpCodeAnalyst/Persistence/Dto/SerializableCodeElement.cs b/CSharpCodeAnalyst/Persistence/Dto/SerializableCodeElement.cs
index 48d81f4e..a324fa48 100644
--- a/CSharpCodeAnalyst/Persistence/Dto/SerializableCodeElement.cs
+++ b/CSharpCodeAnalyst/Persistence/Dto/SerializableCodeElement.cs
@@ -1,4 +1,4 @@
-using CSharpCodeAnalyst.CodeGraph.Graph;
+using CSharpCodeAnalyst.CodeGraph.Graph;
 
 namespace CSharpCodeAnalyst.Persistence.Dto;
 
@@ -10,7 +10,9 @@ public class SerializableCodeElement(
     CodeElementType elementType,
     List<SourceLocation> sourceLocations,
     HashSet<string> attributes,
-    bool isExternal = false)
+    bool isExternal = false,
+    AccessLevel accessLevel = AccessLevel.Unknown,
+    bool isGenerated = false)
 {
     public string Id { get; set; } = id;
     public string Name { get; set; } = name;
@@ -23,4 +25,16 @@ public class SerializableCodeElement(
     ///     Whether the element belongs to a referenced assembly rather than the parsed solution.
     /// </summary>
     public bool IsExternal { get; set; } = isExternal;
+
+    /// <summary>
+    ///     Whether a tool wrote the element. Defaults to false, so a project file written before this
+    ///     existed keeps loading - its elements simply carry no marking until the next parse.
+    /// </summary>
+    public bool IsGenerated { get; set; } = isGenerated;
+
+    /// <summary>
+    ///     How far the element can be reached from. Defaults to Unknown, so a project file written before
+    ///     this existed keeps loading - the elements simply carry no visibility until the next parse.
+    /// </summary>
+    public AccessLevel AccessLevel { get; set; } = accessLevel;
 }
diff --git a/CSharpCodeAnalyst/Resources/Strings.Designer.cs b/CSharpCodeAnalyst/Resources/Strings.Designer.cs
index da564b4a..1fd8f493 100644
--- a/CSharpCodeAnalyst/Resources/Strings.Designer.cs
+++ b/CSharpCodeAnalyst/Resources/Strings.Designer.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
 //
@@ -724,6 +724,15 @@ public static string DeselectAllVisible_Label {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Copy table as CSV.
+        /// </summary>
+        public static string DynamicGrid_CopyAsCsv {
+            get {
+                return ResourceManager.GetString("DynamicGrid_CopyAsCsv", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Error while loading data!.
         /// </summary>
@@ -2783,8 +2792,9 @@ public static string SearchingCycles_Message {
         ///   Looks up a localized string similar to Search in code element full name.
         ///
         ///Logical operations: space = AND, &apos;|&apos; = OR
+        ///Exclude a term = prefix it with &apos;-&apos; (e.g. &quot;-Strings.&quot; or &quot;-type:property&quot;)
         ///Search for type = type:xxx
-        ///Search for internal code elements = source:intern      
+        ///Search for internal code elements = source:intern
         ///Search for external code elements = source:extern
         ///Search with resharper style = Use at least one uppercase character in a search term..
         /// </summary>
@@ -2976,24 +2986,6 @@ public static string Settings_IncludeExternalCode_Tooltip {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Include _generated code.
-        /// </summary>
-        public static string Settings_IncludeGeneratedCode {
-            get {
-                return ResourceManager.GetString("Settings_IncludeGeneratedCode", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Include source-generated code (e.g. [ObservableProperty], [RelayCommand]) when parsing the solution. Without this, calls to generated members appear as a relationship to the containing type..
-        /// </summary>
-        public static string Settings_IncludeGeneratedCode_Tooltip {
-            get {
-                return ResourceManager.GetString("Settings_IncludeGeneratedCode_Tooltip", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Performance Settings.
         /// </summary>
@@ -3328,7 +3320,7 @@ public static string TooMuchElementsTitle {
         ///
         ///Logical operations: space = AND, &apos;|&apos; = OR
         ///Search for type = type:xxx
-        ///Search for internal code elements = source:intern      
+        ///Search for internal code elements = source:intern
         ///Search for external code elements = source:extern
         ///Search with resharper style = Use at least one uppercase character in a search term..
         /// </summary>
diff --git a/CSharpCodeAnalyst/Resources/Strings.resx b/CSharpCodeAnalyst/Resources/Strings.resx
index 44af5c86..e8155ae6 100644
--- a/CSharpCodeAnalyst/Resources/Strings.resx
+++ b/CSharpCodeAnalyst/Resources/Strings.resx
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
       Microsoft ResX Schema 
@@ -675,8 +675,9 @@ If you abort the graph is maintained but not rendered. Use undo to get to the pr
     <value>Search in code element full name.
 
 Logical operations: space = AND, '|' = OR
+Exclude a term = prefix it with '-' (e.g. "-Strings." or "-type:property")
 Search for type = type:xxx
-Search for internal code elements = source:intern      
+Search for internal code elements = source:intern
 Search for external code elements = source:extern
 Search with resharper style = Use at least one uppercase character in a search term.</value>
   </data>
@@ -686,7 +687,7 @@ Search with resharper style = Use at least one uppercase character in a search t
 
 Logical operations: space = AND, '|' = OR
 Search for type = type:xxx
-Search for internal code elements = source:intern      
+Search for internal code elements = source:intern
 Search for external code elements = source:extern
 Search with resharper style = Use at least one uppercase character in a search term.</value>
   </data>
@@ -780,6 +781,9 @@ Search with resharper style = Use at least one uppercase character in a search t
   <data name="Statistics_Relationships" xml:space="preserve">
     <value># Relationships</value>
   </data>
+  <data name="DynamicGrid_CopyAsCsv" xml:space="preserve">
+    <value>Copy table as CSV</value>
+  </data>
   <data name="DynamicGrid_LoadError" xml:space="preserve">
     <value>Error while loading data!</value>
   </data>
@@ -822,12 +826,6 @@ Search with resharper style = Use at least one uppercase character in a search t
   <data name="Settings_IncludeExternalCode_Tooltip" xml:space="preserve">
     <value>Include external code when parsing the solution.</value>
   </data>
-  <data name="Settings_IncludeGeneratedCode" xml:space="preserve">
-    <value>Include _generated code</value>
-  </data>
-  <data name="Settings_IncludeGeneratedCode_Tooltip" xml:space="preserve">
-    <value>Include source-generated code (e.g. [ObservableProperty], [RelayCommand]) when parsing the solution. Without this, calls to generated members appear as a relationship to the containing type.</value>
-  </data>
   <data name="Settings_SplitPropertyAccessors" xml:space="preserve">
     <value>Split property _getter/setter</value>
   </data>
diff --git a/CSharpCodeAnalyst/Shared/DynamicDataGrid/DynamicDataGrid.xaml b/CSharpCodeAnalyst/Shared/DynamicDataGrid/DynamicDataGrid.xaml
index 52dbaaab..81ac0c0d 100644
--- a/CSharpCodeAnalyst/Shared/DynamicDataGrid/DynamicDataGrid.xaml
+++ b/CSharpCodeAnalyst/Shared/DynamicDataGrid/DynamicDataGrid.xaml
@@ -3,6 +3,7 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:resources="clr-namespace:CSharpCodeAnalyst.Resources"
              mc:Ignorable="d"
              d:DesignHeight="300" d:DesignWidth="400">
     <UserControl.Resources>
@@ -35,6 +36,7 @@
                      Margin="0"
                      Background="LightYellow"
                      FontSize="12"
+                     ToolTip="{x:Static resources:Strings.SearchPattern_Tooltip}"
                      TextChanged="SearchTextBox_TextChanged" />
         </DockPanel>
 
diff --git a/CSharpCodeAnalyst/Shared/DynamicDataGrid/DynamicDataGrid.xaml.cs b/CSharpCodeAnalyst/Shared/DynamicDataGrid/DynamicDataGrid.xaml.cs
index 10f1c135..0ffe898f 100644
--- a/CSharpCodeAnalyst/Shared/DynamicDataGrid/DynamicDataGrid.xaml.cs
+++ b/CSharpCodeAnalyst/Shared/DynamicDataGrid/DynamicDataGrid.xaml.cs
@@ -522,11 +522,6 @@ private void RowOnContextMenuOpening(object sender, ContextMenuEventArgs e)
 
         // Only Table may provide commands.
         var commands = TableData?.GetCommands() ?? [];
-        if (commands.Count == 0)
-        {
-            e.Handled = true;
-            return;
-        }
 
         var dataContext = row.DataContext;
         foreach (var command in commands)
@@ -534,10 +529,61 @@ private void RowOnContextMenuOpening(object sender, ContextMenuEventArgs e)
             row.ContextMenu.Items.Add(new MenuItem { Header = command.Header, Command = command.Command, CommandParameter = dataContext });
         }
 
+        // Offered by the grid for every table, so no analyzer has to implement its own export.
+        if (TableData is not null)
+        {
+            if (commands.Count > 0)
+            {
+                row.ContextMenu.Items.Add(new Separator());
+            }
+
+            var copy = new MenuItem { Header = Strings.DynamicGrid_CopyAsCsv };
+            copy.Click += (_, _) => CopyTableToClipboard();
+            row.ContextMenu.Items.Add(copy);
+        }
+
+        if (row.ContextMenu.Items.Count == 0)
+        {
+            e.Handled = true;
+            return;
+        }
+
         row.ContextMenu.IsOpen = true;
         e.Handled = true;
     }
 
+    /// <summary>
+    ///     Puts the table on the clipboard as CSV. What is copied is what is on screen - the rows after
+    ///     filtering, in the current sort order - because counting or pivoting a result usually starts with
+    ///     narrowing it down first.
+    ///     <para>
+    ///         The separator is the one the current culture uses for lists, which is what Excel expects on
+    ///         the same machine: a comma in en-US, a semicolon in de-DE. Without that the paste ends up in
+    ///         a single column.
+    ///     </para>
+    /// </summary>
+    private void CopyTableToClipboard()
+    {
+        var columns = TableData?.GetColumns().ToList();
+        if (columns is null || columns.Count == 0)
+        {
+            return;
+        }
+
+        // MainDataGrid.Items, not TableData.GetData(): that is the view after filtering and sorting.
+        var csv = TableCsv.Build(columns, MainDataGrid.Items.OfType<object>());
+
+        try
+        {
+            Clipboard.SetText(csv);
+        }
+        catch (Exception ex)
+        {
+            // The WPF clipboard fails when another process holds it. Not worth interrupting the user over.
+            Debug.WriteLine($"Could not copy the table to the clipboard: {ex.Message}");
+        }
+    }
+
     /// <summary>
     ///     Updates RowDetails Visibility based on IsExpanded Property (TableRow)
     /// </summary>
diff --git a/CSharpCodeAnalyst/appsettings.json b/CSharpCodeAnalyst/appsettings.json
index f83f2405..54666168 100644
--- a/CSharpCodeAnalyst/appsettings.json
+++ b/CSharpCodeAnalyst/appsettings.json
@@ -4,7 +4,6 @@
     "DefaultProjectExcludeFilter": ".*Tests",
     "AutomaticallyAddContainingType": false,
     "IncludeExternalCode": false,
-    "IncludeGeneratedCode": false,
     "SplitPropertyAccessors": true,
     "ShowOverviewOnImport": true
   }
diff --git a/CSharpCodeAnalyst/board.txt b/CSharpCodeAnalyst/board.txt
index 6ff8d1a4..ccbfa8af 100644
--- a/CSharpCodeAnalyst/board.txt
+++ b/CSharpCodeAnalyst/board.txt
@@ -1,6 +1,8 @@
 IMPROVEMENTS
 ---------------------
 
+- Duplicate names with generics (for example WpfCommand and WpfCommand<T>)
+- Root folder is quite crowded. Move to sub folders.
 - Track calls should add also Uses relationships. They are called black vs blue anyway.
   This way we see which method define a lambda.
 
@@ -22,7 +24,3 @@ BUGS
 
 MISSING TEST CASES
 ---------------------
-
-CHECk
------
-FillGapsInHierarchy vs FillContainerGaps
\ No newline at end of file
diff --git a/Documentation/Design/dead-code-algorithm.md b/Documentation/Design/dead-code-algorithm.md
new file mode 100644
index 00000000..6699a67e
--- /dev/null
+++ b/Documentation/Design/dead-code-algorithm.md
@@ -0,0 +1,252 @@
+# Generierter Code
+
+## Schritt 1: Welche Dateien es gibt und wie sie hereinkommen
+
+Es gibt genau **zwei Türen** in den Graph. Danach ist alles gleich.
+
+| Datei                                                        | Wer schreibt sie         | Tür              | Elemente daraus                          |
+| ------------------------------------------------------------ | ------------------------ | ---------------- | ---------------------------------------- |
+| `obj\…\MainWindow.g.cs`                                      | WPF-Markup-Compiler      | A                | `Connect`, die `x:Name`-Felder           |
+| `obj\…\GeneratedInternalTypeHelper.g.cs`                     | WPF-Markup-Compiler      | A                | die Hilfsklasse                          |
+| `Resources\Strings.Designer.cs`                              | resx-Designer            | A                | `ResourceManager`, jeder String-Getter   |
+| `obj\…\AssemblyInfo.cs`, `GlobalUsings.g.cs`                 | .NET SDK                 | A                | keine (nur Attribute/Usings)             |
+| `[ObservableProperty]`, `[RelayCommand]`, `[GeneratedRegex]` | Roslyn, zur Compile-Zeit | B                | die generierten Properties/Commands      |
+| `MainWindow.xaml` selbst                                     | du                       | *(dritter Pass)* | keine – das ist der XAML-Linker, kein C# |
+
+**Tür A – Dateien auf der Platte.** Das sind ganz normale `Compile`-Items. `CollectAllFilePathInSolution` sammelt alles aus `project.Documents` in `_projectFilePaths`, und die Schleife über `compilation.SyntaxTrees` lässt durch, was `IsProjectFile` bejaht. Diese Dateien waren **schon immer** drin – sie hatten mit der alten Option nie etwas zu tun.
+
+**Tür B – Source-Generatoren.** Die stehen nicht in `project.Documents` und ihre Syntaxbäume nicht in der Compilation. Sie müssen extra geholt werden: `project.GetSourceGeneratedDocumentsAsync()`. Genau das war die alte Option. Jetzt passiert es immer.
+
+Beide Türen führen in dieselbe Methode, `ProcessNodeForHierarchy` – ab da gibt es keinen Unterschied mehr.
+
+## Schritt 2: Beim Durchlaufen wird notiert, welche Datei generiert ist
+
+Während Phase 1 läuft, füllt sich ein Set `_generatedFilePaths`:
+
+- Tür A: `GeneratedCode.IsGeneratedFile(syntaxTree)` – Dateiname (`.g.cs`, `.g.i.cs`, `.designer.cs`, `.generated.cs`, `.AssemblyAttributes.cs`, `TemporaryGeneratedFile_*`) **oder** ein `<auto-generated>`-Kommentar vor dem ersten Token.
+- Tür B: ohne Prüfung – ein Source-Generator-Dokument ist es per Definition.
+
+Das ist erst mal nur eine Liste von Pfaden. Es wird noch nichts markiert.
+
+## Schritt 3: Markieren, wenn alles gelaufen ist
+
+Am Ende von Phase 1 läuft `MarkGeneratedElements()` einmal über alle Knoten:
+
+> Ein Element ist generiert, wenn es mindestens eine `SourceLocation` hat und **alle** davon in generierten Dateien liegen.
+
+Warum erst am Ende und warum „alle": eine Code-Behind-Klasse ist `partial`. `MainWindow` hat zwei Deklarationen – deine in `MainWindow.xaml.cs` und die des Markup-Compilers in `MainWindow.g.cs`. Ein Element, zwei Locations. Beim Durchlaufen weiß man noch nicht, ob noch eine dritte kommt.
+
+Das Ergebnis im echten Lauf:
+
+```
+IsGenerated=False  MainWindow               (2 Deklarationen)  → deine Klasse
+IsGenerated=True   MainWindow.Connect       (1 Deklaration)    → nur in .g.cs
+IsGenerated=True   MainWindow.TreeControl   (1 Deklaration)    → das x:Name-Feld
+```
+
+Deine Hälfte bleibt deine. Nur was ausschließlich in der generierten Hälfte existiert, wird markiert.
+
+## Schritt 4: Phase 2 braucht keine Regel
+
+`RelationshipAnalyzer` läuft über die Elemente, die Phase 1 angelegt hat, und holt sich den Syntax über `DeclaringSyntaxReferences` des Symbols. Es gibt dort keinen Dateifilter. Was Phase 1 angelegt hat, wird analysiert – egal aus welcher Tür.
+
+Deshalb hält `Connect` die Event-Handler am Leben, und deshalb hält eine generierte Property ihr Backing-Field am Leben.
+
+## Wer die Markierung heute benutzt
+
+Nur einer: die Dead-Code-Analyse setzt daraus die Notiz `Generated code` (83 von 866 Findings). Sonst niemand – Metriken, Zyklen, DSM und der XAML-Linker sehen die Markierung nicht an. Sie ist eine reine Beschriftung, keine Verhaltensänderung.
+
+## Grenzen, die du kennen solltest
+
+- **Projekt-Ausschluss geht vor.** `ShouldAnalyzeProject` filtert vorher nach `.csproj` und dem Regex-Filter. Ein ausgeschlossenes Projekt bringt auch keinen generierten Code mit.
+- **`.g.i.cs` ist in der Namensliste, taucht in dieser Solution aber nicht auf.** Bei MSBuildWorkspace kommt hier `.g.cs` in die Compilation. Die Regel deckt es ab, falls es woanders anders ist.
+- Nicht erkannt wird eine `.cs`-Datei, die ein Nicht-Roslyn-Werkzeug auf die Platte schreibt, wenn sie weder einem bekannten Namensmuster folgt noch einen `<auto-generated>`-Header trägt. Roslyns eigene Analyzer haben dieselbe Lücke (z.B. T4)
+- Ein einzelner generierter Member in einer sonst handgeschriebenen Klasse wird markiert; die Klasse nicht. Das ist so gewollt.
+
+# Dead Code Analysis
+
+Der Algorithmus in einem Satz: **Ein Element ist tot, wenn keine Beziehung aus dem Produktivcode in seinen Teilbaum hineinführt.**
+
+Alles andere sind Verfeinerungen davon. Hier der Ablauf.
+
+------
+
+## Schritt 1: Kanten sortieren (`CollectEdges`)
+
+Jede Beziehung im Graph landet in genau einem von drei Töpfen.
+
+| Beziehung                                                    | Topf            | Warum           |
+| ------------------------------------------------------------ | --------------- | --------------- |
+| `Calls`, `Uses`, `Creates`, `Invokes`, `UsesAttribute`, `Inherits` | **Verweise**    | echte Benutzung |
+| `Implements`/`Overrides`, **ausgehend von einem Member**     | **Polymorphie** | siehe Schritt 3 |
+| `Containment`, `Bundled`, `Handles`                          | **verworfen**   | keine Benutzung |
+
+`Containment` ist die Eltern-Kind-Hierarchie. `Bundled` malt nur die Graphansicht. `Handles` zeigt vom Handler zum Event – die Registrierung `x.Click += OnClick` erzeugt daneben eine `Uses`-Kante, die den Handler am Leben hält.
+
+Ausnahme bei der Polymorphie: `class C : IFoo` geht **vom Typ** aus. Das ist ein normaler Verweis, denn `IFoo` steht in Cs Deklaration. Nur wenn ein *Member* implementiert, ist es Polymorphie.
+
+## Schritt 2: Die Kernregel (`MarkReferenced`)
+
+Für jede Verweiskante wird markiert, was sie „von außen betritt".
+
+Beispiel: `B.M` ruft `A.M`.
+
+```
+1. Kette der Quelle nach oben sammeln:   B.M → B → Namespace → Assembly
+2. Vom Ziel nach oben laufen und markieren, bis man diese Kette trifft:
+      A.M    markieren
+      A      markieren
+      Namespace  ← steckt in der Quellkette → Stopp
+```
+
+Ergebnis: `A.M` und `A` sind referenziert. Der gemeinsame Namespace nicht.
+
+Zwei Dinge folgen daraus, und beide entsprechen dem, was man von Hand urteilen würde:
+
+- **Eine Klasse lebt, wenn eines ihrer Member benutzt wird** – auch wenn die Klasse selbst nie genannt wird.
+- **Eine Klasse kann sich nicht selbst am Leben halten.** Rufen ihre Methoden nur einander auf, bleibt jede dieser Kanten *innerhalb* des Teilbaums. Der Lauf stoppt sofort. Die ganze Klasse ist tot.
+
+## Schritt 3: Polymorphie umdrehen (`PropagateContractUsage`)
+
+`Implements`/`Overrides` zeigt von der Implementierung **zum** Contract. Als Verweis gezählt wäre beides falsch:
+
+- Jedes Interface-Member sähe benutzt aus (die Implementierung „verweist" ja darauf).
+- Jede Implementierung sähe unbenutzt aus (auf sie zeigt nichts).
+
+Also wird die Lebendigkeit stattdessen in die andere Richtung geschoben: **Wird `IService.Run` aufgerufen, leben alle Implementierungen von `Run`** – und die Typen, die sie enthalten. Transitiv, denn ein Override kann selbst überschrieben werden.
+
+Wird der Contract nie aufgerufen, stirbt er zusammen mit seinen Implementierungen. Genau das will man sehen.
+
+Zeigt der Contract nach draußen (`ICommand.Execute`, `object.GetHashCode`), können wir den Aufrufer nicht sehen. Das macht **nicht** lebendig, sondern erzeugt nur eine Notiz.
+
+## Schritt 4: Zweimal laufen, in zwei Farben (`ComputeReferenced`)
+
+Schritt 2 und 3 laufen zweimal über dieselben Kanten:
+
+- **`All`** – alle Kanten.
+- **`FromProduction`** – nur Kanten, deren *Quelle* kein Testcode ist.
+
+Testcode wird **pro Typ** entschieden: Ein Typ ist ein Test-Typ, wenn er selbst oder etwas in seinem Subtree ein Testattribut trägt (`[Test]`, `[Fact]`, `[TestFixture]`, … – der Subtree, weil xUnit kein Klassen-Attribut hat). Früher galt die ganze Assembly; das vergiftete bei einer eingebetteten Testklasse alle Referenzen der Assembly und unterdrückte zugleich Funde neben den eingebetteten Tests.
+
+Wichtig: Die Contract-Propagation läuft **pro Farbe**, nicht einmal am Ende. Ruft die UI `ICodeGraphExplorer.FindIncomingCalls`, lebt die Implementierung produktiv. Ruft nur ein Test sie, nicht. Eine gemeinsame Propagation würde jede Implementierung eines Contracts, den irgendein Test benutzt, für produktiv erklären.
+
+Daraus ergibt sich:
+
+| in `All` | in `FromProduction` | Bedeutung                  |
+| -------- | ------------------- | -------------------------- |
+| ja       | ja                  | lebendig                   |
+| ja       | nein                | **nur von Tests benutzt**  |
+| nein     | nein                | **gar nicht referenziert** |
+
+## Schritt 5: Melden (`Report`)
+
+Jetzt geht es einmal über alle Knoten. Vier Filter, in dieser Reihenfolge:
+
+**1. Ist es überhaupt ein Fund?** (`IsReported`)
+
+- Assemblies, Namespaces und externe Elemente sind nie Kandidaten. Statische Konstruktoren und Finalizer auch nicht: Die ruft nur die Runtime, kein Code kann sie referenzieren – auf einem lebendigen Typ wäre die Zeile immer falsch, auf einem toten deckt sie das Roll-up ab.
+- Steht es in `FromProduction`? → lebendig, fertig.
+- Sonst: gar nicht referenziert **oder** nur von Tests. Letzteres zählt nur *außerhalb* eines Test-Typs – innerhalb einer Fixture ist „von Tests benutzt" ja der Zweck ihrer Helfer. Eine Helper-*Klasse* außerhalb der Fixtures wird dagegen gemeldet – der akzeptierte Preis der Typ-Granularität: Die Aussage stimmt (der Helper geht mit den Tests), sie ist nur Rauschen, solange er seinen Job tut.
+
+**2. Serialisierte Property?** Eine public Property auf einem Typ mit `[Serializable]`, `[DataContract]`, `[JsonObject]` … wird fallengelassen. Der Serializer greift per Reflection zu; auf so einem Typ wäre jede Property ein Fund.
+
+**3. Roll-up.** Würde der Parent auch gemeldet, überspringen. Eine tote Klasse ergibt eine Zeile, nicht eine pro Methode.
+
+**4. Notizen und Confidence sammeln** (`CreateFinding`).
+
+## Die Notizen
+
+Zwei Sorten. **Zweifel** – der Verweis könnte da sein, wo der Parser nicht hinsieht:
+
+| Notiz                             | Woher                                              |
+| --------------------------------- | -------------------------------------------------- |
+| `Entry point`                     | `Main`, `GlobalStatements` |
+| `Test code`                       | Testattribut im Teilbaum                           |
+| `Attributes: …`                   | ein Attribut im Teilbaum – außer den reinen Tooling-Attributen (`[Obsolete]`, `[DebuggerDisplay]`, …), die sagen nichts über einen Aufrufer |
+| `Implements external contract: …` | aus dem `ExternalContractStore` des Parsers        |
+| `Generated code`                  | `CodeElement.IsGenerated`                          |
+
+**Erklärungen** – der Fund ist verstanden, die Notiz nennt, was mitstirbt:
+
+| Notiz                             | Woher                                                        |
+| --------------------------------- | ------------------------------------------------------------ |
+| `Implemented but never called: …` | Sieht den **Contract**: mich implementieren A und B, aber niemand ruft durch mich hindurch. |
+| `Implements unused contract: …`   | Sieht die **Implementierung**: der Contract, den ich erfülle, ist selbst tot |
+| `Used only by tests: …`           | plus die Namen der Tests                                     |
+
+Entry-Point-, Test- und Attribut-Notizen werden über den **ganzen Teilbaum** gesammelt. Gemeldet wird eine tote Klasse – aber die `[Test]`-Attribute hängen an ihren Methoden.
+
+Gleicher Code in allen drei Fällen, nur der Aufrufer wechselt:
+
+```csharp
+public interface IService { void Run(); }
+
+public class ServiceA : IService { public void Run() { } }
+public class ServiceB : IService { public void Run() { } }
+
+public class Factory                       // hält beide Klassen am Leben,
+{                                          // ruft Run aber nie
+    public object MakeA() => new ServiceA();
+    public object MakeB() => new ServiceB();
+}
+```
+
+**Fall 1 – niemand ruft `Run`**
+
+```
+IService.Run   ContractNeverCalled      → ServiceA.Run, ServiceB.Run
+ServiceA.Run   ImplementsDeadContract   → IService.Run
+ServiceB.Run   ImplementsDeadContract   → IService.Run
+```
+
+Drei Zeilen. Der Contract nennt seine beiden Implementierungen, jede Implementierung nennt den Contract.
+
+**Fall 2 – zusätzlich `b.Run()` direkt auf `ServiceB`**
+
+```csharp
+public class Caller { public void Go(ServiceB b) { b.Run(); } }
+```
+
+```
+IService.Run   ContractNeverCalled      → ServiceA.Run, ServiceB.Run
+ServiceA.Run   ImplementsDeadContract   → IService.Run
+```
+
+`ServiceB.Run` verschwindet – es hat eine eingehende Kante. Der Contract bleibt gemeldet, denn *durch das Interface* ruft weiterhin niemand. Und er listet weiter **beide** Implementierungen: die Liste sagt „wer mich implementiert", nicht „wer mit mir stirbt".
+
+**Fall 3 – `s.Run()` über das Interface**
+
+```csharp
+public class Caller { public void Go(IService s) { s.Run(); } }
+```
+
+```
+(nichts)
+```
+
+`IService.Run` ist referenziert, die Propagation macht beide Implementierungen lebendig.
+
+
+
+## Die Confidence
+
+Drei Regeln, in dieser Reihenfolge:
+
+1. **Low** – eine der Zweifel-Notizen (Entry Point, Test Code, Attribute, externer Contract) ist gesetzt. Wir wissen schon, dass wir falsch liegen könnten.
+2. **High** – keine solche Notiz, und das Element **oder einer seiner Container** ist `private`/`internal`. Dann fallen „nichts referenziert es" und „nichts *kann* es referenzieren" zusammen.
+3. **Medium** – alles andere: public, protected, oder Sichtbarkeit unbekannt.
+
+Zwei Abzüge von High:
+
+- Eine public Property auf einem Typ, der `INotifyPropertyChanged` implementiert. Ein `{Binding}` erreicht genau das, und Bindings verfolgt der Parser bewusst nicht. Der Parser zeichnet diese Typen über die Symbole auf (`ExternalContractStore.NotifyingTypes`) – damit zählt auch ein ViewModel, dessen Basisklasse außerhalb des analysierten Codes liegt (`ObservableObject`, `BindableBase`, ...) und dem man das Interface im Graphen nicht ansieht.
+- Ein `Used only by tests`-Fund. Etwas referenziert es ja nachweislich – ob ein Test allein das Behalten rechtfertigt, ist eine Entscheidung, keine Messung.
+
+## Was der Algorithmus bewusst *nicht* tut
+
+**Keine Kaskade.** Gemeldet wird, was *jetzt* unreferenziert ist. Sitzt der einzige Aufrufer von `Formatter` in der Klasse `Report`, die du gerade gemeldet bekommen hast, ist `Formatter` **kein** Fund – er ist referenziert, von totem Code. Lösche den Fund und lass es nochmal laufen, dann kommt die nächste Schicht.
+
+Eine frühere Version kaskadierte. Sie funktionierte, aber sie multiplizierte jeden Fehlalarm: ein unsichtbares `{Binding}` riss sieben weitere Elemente mit.
+
+**Keine toten Zyklen.** Zwei Elemente, die nur einander referenzieren, halten sich gegenseitig am Leben. Das zu finden bräuchte Erreichbarkeit von einer expliziten Menge von Einstiegspunkten – eine andere Analyse als diese.
+
+**Keine Instanziierungs-Prüfung bei der Contract-Propagation.** Ein aufgerufener Contract-Member hält *jede* Implementierung am Leben – auch die einer Klasse, die nirgends sichtbar instanziiert wird (Class Hierarchy Analysis, nicht Rapid Type Analysis). Die Verfeinerung „nur Implementierungen, deren Typ auch erzeugt wird" wurde bewusst verworfen: Implementierungen von Interfaces sind genau die Klassen, die ein Dependency Container instanziiert, und eine Container-Registrierung erzeugt keine `Creates`-Kante (beim Assembly-Scanning gar keine). Die Verfeinerung würde also genau den Code melden, dessen Erzeugung sie nicht sehen kann.
\ No newline at end of file
diff --git a/Documentation/Reviews/CodeReview-2026-08-06.md b/Documentation/Reviews/CodeReview-2026-08-06.md
new file mode 100644
index 00000000..45f99b4a
--- /dev/null
+++ b/Documentation/Reviews/CodeReview-2026-08-06.md
@@ -0,0 +1,66 @@
+# Code Review 2026-08-06
+
+Review fertig — ich habe `DeadCodeAnalysis`, `DeadCodeFinding`, die Helfer (`AccessLevel`, `RelationshipTypeExtensions`), den Parser-Kontext (`DeclarationAnalyzer`, `ExternalContractStore`) und die Tests gelesen. Vorab das Gesamturteil: Der Ansatz ist solide und die zentralen Entscheidungen (Subtree-Regel, Liveness-Propagation statt Kanten-Zählung, kein Kaskadieren, zweifarbige Referenzmengen) halte ich für richtig. Viel vereinfachen würde ich nicht — die Datei ist lang, weil sie gut dokumentiert ist, nicht weil der Algorithmus kompliziert wäre. Es gibt aber ein paar echte Schwachstellen.
+
+## False Positives (bzw. falsches High-Confidence)
+
+**1. ViewModels mit externer Basisklasse — der wahrscheinlichste echte Treffer in der Praxis.** `FindBindingSources` ([DeadCodeAnalysis.cs:284](https://claude.ai/epitaxy/CSharpCodeAnalyst.CodeGraph/Algorithms/DeadCode/DeadCodeAnalysis.cs:284)) erkennt INPC nur über den external contract des `PropertyChanged`-Members und verteilt das über `Inherits`-Kanten nach unten. Ein ViewModel, das von `ObservableObject` (CommunityToolkit.Mvvm), `BindableBase` (Prism) oder `DependencyObject` erbt, hat *kein eigenes* `PropertyChanged`-Member — die Basisklasse ist extern und unsichtbar. Dessen gebundene public Properties bekommen dann **High** confidence, obwohl XAML sie liest. Der Kommentar (Zeile 280–282) kennt das Problem, aber angesichts der Verbreitung von CommunityToolkit ist das die gefährlichste Lücke. Der saubere Fix liegt im Parser, nicht hier: `DeclarationAnalyzer` hat das Symbol und könnte `type.AllInterfaces` auf `INotifyPropertyChanged` prüfen und das im `ExternalContractStore` (oder einem eigenen Set) ablegen — dann ist es egal, wo im Vererbungsbaum die Implementierung sitzt.
+
+=> DONE
+
+**2. Ein Test-Attribut in einer Produktions-Assembly vergiftet assemblyübergreifend.** `FindTestAssemblies` behauptet, Tests in der Produktions-Assembly seien „the harmless direction to fail in" (Zeile 193–194). Das stimmt nur nach innen (Findings dort werden unterdrückt). Nach außen nicht: Ist Assembly P als Test-Assembly klassifiziert, zählen *alle* ausgehenden Kanten von P nicht mehr für `FromProduction`. Ein Element in Assembly B, das nur von P benutzt wird, wird fälschlich als `UsedOnlyByTests` gemeldet, obwohl es echte Produktionsnutzung ist. Dazu kommt: Das Matching ist case-insensitive auf dem bloßen Namen — ein domäneneigenes Attribut namens `Test` (A/B-Tests, Prüfstand …) reicht, um eine ganze Produktions-Assembly umzuklassifizieren. Ordinal-case-sensitive plus ggf. Prüfung, ob das Attribut extern ist, würde das Risiko deutlich senken.
+
+=> DONE (Jetzt pro Klasse)
+
+**3. Finalizer.** `~C()` wird als Methode `Finalize` geparst ([HierarchyAnalyzer.cs:331](https://claude.ai/epitaxy/CSharpCodeAnalyst.CodeParser/Parser/HierarchyAnalyzer.cs:331)), und die Override-Erfassung im `DeclarationAnalyzer` hängt an `IsOverride` — das ist für Source-Destruktoren `false`, also gibt es weder eine `Overrides`-Kante noch einen external contract. Niemand referenziert einen Finalizer je im Code → in einer `internal` Klasse ein **High**-confidence-FP. Analog zu `.cctor` gehört `Finalize` in `IsEntryPoint` ([DeadCodeAnalysis.cs:766](https://claude.ai/epitaxy/CSharpCodeAnalyst.CodeGraph/Algorithms/DeadCode/DeadCodeAnalysis.cs:766)).
+
+=> DONE
+
+**4. Confidence-Verwässerung durch `Attributed`.** `CallerOutsideTheGraph` enthält `Attributed`, und die Hints werden über den ganzen Subtree gesammelt. Ein ungenutztes privates Member mit `[Obsolete]`, `[DebuggerDisplay]` oder `[ExcludeFromCodeCoverage]` — eigentlich ein besonders guter Fund — landet auf **Low**. Kein FP im engeren Sinn, aber die Konfidenz misst hier nicht mehr das, was sie behauptet. Eine kleine Ignorier-Liste harmloser Attribute (die nachweislich keinen externen Aufrufer implizieren) würde die Trennschärfe der Stufen spürbar verbessern.
+
+=> DONE
+
+## False Negatives
+
+**5. CHA statt RTA bei der Contract-Propagation.** `PropagateContractUsage` markiert *alle* Implementierungen eines benutzten Contract-Members als lebendig — auch die einer Klasse, die nirgends instanziiert wird (`Creates`/`Uses` fehlen komplett). Das ist klassische Class Hierarchy Analysis; die Verfeinerung Richtung Rapid Type Analysis wäre: Liveness nur zu Implementierungen propagieren, deren Typ selbst irgendwo referenziert/erzeugt wird. Konservativ falsch ist für ein Dead-Code-Tool die richtige Richtung, aber es ist der größte systematische FN-Topf neben den dokumentierten Inseln.
+
+**6. Der Interface-\*Typ\* stirbt nie, solange ein (toter) Implementierer existiert.** `class C : IFoo` ist eine gewöhnliche Referenzkante (Quelle ist ein Typ, `IsPolymorphicEdge` greift nicht) — die hält `IFoo` am Leben, auch wenn C selbst tot ist. Ergebnis: Man sieht `C` und `IFoo.Bar` als Findings, aber nie `IFoo` selbst. Das ist konsistent mit dem Nicht-Kaskadieren, widerspricht aber dem Satz im Header „A contract that is never called dies together with its implementations" (Zeile 22) — der gilt nur auf Member-Ebene.
+
+## Dokumentationswiderspruch (sollte korrigiert werden)
+
+Der Klassen-Header sagt in Zeile 23–24: externe Contracts → „the implementation is **assumed alive**". `IsReported` (Zeile 558–560) und die Tests (`Calculate_ExternalContractFromTheStore_...`) sagen das Gegenteil: Das Member wird **gemeldet**, nur mit Hint und Low confidence. Das Verhalten ist das richtige (melden statt verschweigen), der Header ist falsch. Da diese Klasse ihre Doku sehr ernst nimmt, ist das ein echter Bug.
+
+Kleinigkeit in derselben Ecke: `external` wird aus zwei Quellen gefüllt — der Store liefert Kurznamen (`INotifyPropertyChanged.PropertyChanged`, siehe [DeclarationAnalyzer.cs:416](https://claude.ai/epitaxy/CSharpCodeAnalyst.CodeParser/Parser/DeclarationAnalyzer.cs:416)), der Kanten-Fallback `target.FullName` (mit Namespace). Der `StartsWith("INotifyPropertyChanged.")`-Check in `FindBindingSources` funktioniert nur mit dem Kurzformat. Beim C#-Parser gewinnt der Store immer (`TryAdd`), für Importer-Graphen ohne Store läuft die Binding-Erkennung über den Fallback aber ins Leere.
+
+=> DONE
+
+## Vereinfachung — mein Fazit
+
+Der Algorithmus selbst ist bereits nah am Minimum für das, was er leisten soll. Die beiden Entscheidungen, die ihn einfach *halten* — kein Kaskadieren und die Subtree-Regel statt Erreichbarkeitsanalyse — sind genau richtig und gut begründet. Was ich mechanisch aufräumen würde:
+
+- **`CollectEdges` mit fünf Out-Parametern** ist die unschönste Stelle. Ein `private sealed record CollectedEdges(...)` als Rückgabewert (analog zum bestehenden `AnalysisContext`) würde `Calculate` deutlich entschlacken, inklusive des zweistufigen Befüllens von `external`.
+- **Drei Walks über dieselben Kanten** (`Mark` ×2 plus `CollectTestReferences`). Zusammenlegen geht, kostet aber Lesbarkeit — die drei kleinen Funktionen sind jede für sich trivial. Wenn überhaupt, würde ich nur `CollectTestReferences` nachgelagert einschränken: Test-Aufrufer nur für Elemente sammeln, die nicht in `FromProduction` sind — das spart Speicher und Arbeit, weil heute Aufruferlisten für massenhaft lebendige Elemente aufgebaut werden, die nie jemand abfragt.
+- `IsBindable`/`IsSerializedProperty` als benannte Einzeiler über `IsPublicPropertyOf` würde ich lassen — das ist Doku, keine Redundanz.
+
+Wenn ich priorisieren müsste: (1) den Header-Widerspruch fixen, (2) INPC-Erkennung in den Parser ziehen (`AllInterfaces`), (3) `Finalize` als Entry Point, (4) Test-Attribut-Matching härten. Punkt 5 (RTA) wäre das nächste größere Genauigkeits-Feature, kein Bugfix. Sag Bescheid, welche davon ich umsetzen soll.
+
+=> DONE Nach 1 war weitere Vereinfachung möglich.
+
+
+
+# Fazit
+
+Festgehalten — CHA bleibt, die RTA-Verfeinerung ist bewusst verworfen. Die Begründung steht jetzt an zwei Stellen, damit sie nicht verloren geht: als Absatz in der Doku von `PropagateContractUsage` in [DeadCodeAnalysis.cs](https://claude.ai/epitaxy/CSharpCodeAnalyst.CodeGraph/Algorithms/DeadCode/DeadCodeAnalysis.cs) („deliberately every implementation … the refinement would report precisely the code it cannot see being created") und als neuer Punkt unter „Was der Algorithmus bewusst *nicht* tut" in [dead-code-algorithm.md](https://claude.ai/epitaxy/Documentation/Design/dead-code-algorithm.md), neben Kaskade und toten Zyklen — wo solche Entscheidungen in diesem Projekt hingehören. Nur Kommentar- und Markdown-Änderungen, kein Codeverhalten betroffen.
+
+Damit ist das Review vom Anfang der Session vollständig abgearbeitet:
+
+| Punkt                                                  | Ausgang                                                      |
+| ------------------------------------------------------ | ------------------------------------------------------------ |
+| Header-Widerspruch (external contract „assumed alive") | Korrigiert                                                   |
+| ViewModels mit externer Basisklasse (INPC)             | `NotifyingTypes` im Parser, `FindBindingSources` komplett entfallen |
+| Test-Attribut-Härtung                                  | Pro Typ statt pro Assembly, Ordinal-Matching                 |
+| Finalizer / statische Konstruktoren                    | Beide gedroppt (`IsRuntimeInvoked`) statt annotiert          |
+| `Attributed`-Verwässerung                              | `ToolingAttributes`-Ignorierliste                            |
+| CHA→RTA                                                | Bewusst verworfen (DI-Container), dokumentiert               |
+
+Als bekannte, bewusst offene Themen bleiben nur die von früher: Inseln/tote Zyklen und die DataTemplate-Lücke bei Bindings ohne INPC.
diff --git a/Documentation/Roslyn/corrections-and-updates.md b/Documentation/Roslyn/corrections-and-updates.md
index 4ed55759..ee540791 100644
--- a/Documentation/Roslyn/corrections-and-updates.md
+++ b/Documentation/Roslyn/corrections-and-updates.md
@@ -275,3 +275,199 @@ Phase 2 now walks the declarations of **both** parts
 (`GetDeclaringSyntaxReferencesIncludingPartial`, using `PartialImplementationPart` /
 `PartialDefinitionPart`), for methods and for partial properties (C# 13) alike. The source metrics
 measure the implementation part. Partial *events* (C# 14) are not special-cased yet.
+
+## XAML: the half the markup compiler does not generate
+
+The WPF markup compiler writes a partial class per XAML file (`obj/.../MyView.g.cs`) and MSBuildWorkspace
+runs that pass during its design-time build, so the file is part of the compilation even for a solution
+that was never built. It contains the event handler wiring (`IComponentConnector.Connect`, and
+`IStyleConnector.Connect` for handlers inside templates) and one field per `x:Name`. Those references are
+therefore plain C# and need nothing special.
+
+Two things are *not* in there, and both were mistaken for dead code before:
+
+- Everything declarative - element tags, `{x:Static}`, `{x:Type}`, `{Binding}`, `{StaticResource}` - is
+  compiled into BAML and resolved by reflection at runtime.
+- `x:Name` only produces a field in the file's **main name scope**. A `DataTemplate`, `ControlTemplate` or
+  `Style` is its own name scope and gets no field. `MainWindow.xaml` in this repository has ten `x:Name`s
+  and nine generated fields; the missing one sits inside a `DataTemplate`.
+
+So a control can be used three times in XAML, once even with a name, and produce no C# reference at all.
+
+A third pass (`Xaml/XamlReferenceExtractor` + `Xaml/XamlGraphLinker`, enabled by
+`ParserConfig.IncludeXamlReferences`) therefore reads the XAML files of each project and adds the
+references that carry a **fully qualified CLR name**: element tags, `{x:Static}` and `{x:Type}`. Prefixes
+are resolved through the `clr-namespace` xmlns declarations, so nothing is matched by guessing. The
+relationships are `Uses` and carry `RelationshipAttribute.IsXamlReference`.
+
+### Which files belong to a project
+
+Roslyn cannot say: a `Project` exposes `Documents`, `AdditionalDocuments` and `AnalyzerConfigDocuments`,
+and a `Page` is none of them. `Xaml/XamlFileLocator` therefore **evaluates the project file a second time**
+with `Microsoft.Build.Evaluation` - the MSBuild engine `Initializer.InitializeMsBuildLocator` has already
+put in place, which is why the package is referenced compile-only (`ExcludeAssets=runtime`, same trap as
+in `Directory.Build.props`) and why the type must not be touched before the locator is registered.
+
+The first version scanned the project directory instead, which reads whatever lies around: a file excluded
+from the project, a leftover from another branch, or the XAML of a nested project. A file taken out with
+`<Page Remove="..." />` lands in **no** item group at all - not even in the SDK's default `None` glob - so
+the evaluated item list gets this right where a scan cannot. Two things to know about the item list:
+the SDK contributes ~20 `PropertyPageSchema` items pointing into the dotnet installation, which is why the
+item type is filtered (`ApplicationDefinition`, `Page`, `Resource`, `Content`, `None`) rather than the file
+extension alone; and the default `Page` items are flagged `IsImported` because they come from the SDK
+props, so that flag must *not* be used to tell ours from the SDK's.
+
+An empty result is an answer, not a failure - a project without XAML items has no XAML, and falling back
+to a scan there would bring the excluded files straight back in. The scan survives only for a project file
+that cannot be evaluated at all. Cost is a few hundred milliseconds per project; one shared
+`ProjectCollection` evaluates the SDK imports once.
+
+A linked file (`<Page Include="..\Shared\Foo.xaml">`) now comes along for free, because the item carries
+its real path - a side effect, not the goal. Its synthetic element (see below) is named after the file
+name, because a path relative to the project directory would only produce a row of dots.
+
+`{Binding Path=...}` is deliberately left out. Without evaluating the DataContext it is a bare member name,
+and matching that across the codebase would suppress far more than it explains.
+
+An **object element** (`<local:MyControl/>`) is not only a type reference - XAML creates the instance
+there, so the constructor runs. The linker therefore also connects the type's `.ctor` elements. Without
+that edge the constructor of a XAML-instantiated control has no incoming reference at all, and since the
+body of such a control largely hangs below its constructor (`DynamicDataGrid` wires its search timer
+there), everything it calls dies with it as soon as the dead code analysis cascades. Property element
+syntax (`<local:MyControl.Items>`), attached properties and `{x:Type}` only name a type and are not
+treated as an instantiation. Constructor overloads share the element name, so all of them are linked -
+XAML picks the parameterless one, but the graph cannot tell them apart and a missing edge costs far more
+than a superfluous one.
+
+The source of such a relationship is the code-behind class from `x:Class`. A resource dictionary has none,
+so a synthetic class named after the file path takes its place - the same device already used for top-level
+statements (`GlobalStatements`). It is created only when the file actually contains a resolvable reference.
+Since nothing resolves the `Source` / `StartupUri` URIs of merged dictionaries, those synthetic elements
+have no incoming reference and do show up in a dead code analysis; there were six of them in this
+repository.
+
+MSBuildWorkspace note: opening a WPF project runs the markup compile through a temporary `_wpftmp.csproj`,
+which can invalidate the incremental build state of the real project - a following `dotnet build` may fail
+with `CS2001` for every `.g.cs` until it is rebuilt.
+
+## Generated code is always parsed, and marked
+
+There is no "include generated code" option any more. It used to gate `GetSourceGeneratedDocumentsAsync`,
+which was doubly wrong: it covered only Roslyn *source generators* while the files on disk (`*.g.cs` from
+the markup compiler, `*.Designer.cs`) always came in through `project.Documents` anyway - and switching it
+off did not just hide generated members, it removed the only reference many hand-written ones have.
+`IComponentConnector.Connect` is the sole caller of every XAML event handler; an `[ObservableProperty]`
+is the only reader of its backing field, a `[RelayCommand]` the only caller of its method. Excluding
+generated code turns all of them into dead code, so the option could produce a wrong graph and nothing
+else.
+
+`Parser/GeneratedCode.cs` marks instead: `CodeElement.IsGenerated` is set when **every** declaration of the
+element sits in a generated file. "Every", because a WPF code-behind class is partial and lives in
+`MainWindow.xaml.cs` and `MainWindow.g.cs` at the same time - one element with two source locations. Asking
+whether *any* declaration is generated would mark the user's own class; asking about the first one would
+make the answer depend on the walk order. What is left are the members that exist nowhere but the generated
+half (`Connect`, the `x:Name` fields, the resource designer members), which is exactly the set a consumer
+wants to leave out.
+
+Detection follows Roslyn's own `GeneratedCodeUtilities`: the file name (`.g.cs`, `.g.i.cs`, `.designer.cs`,
+`.generated.cs`, `.AssemblyAttributes.cs`, `TemporaryGeneratedFile_*`) or an `<auto-generated>` comment in
+the leading trivia of the first token. Source-generated documents are marked without a check.
+
+The flag is a marking, not a filter: nothing in the parser or the graph algorithms treats a generated
+element differently. Only results do - the dead code analysis reports it with a `Generated code` note.
+
+Both halves are covered by tests, and they need different machinery. The files on disk are reachable from
+an in-memory parse, so `GeneratedCodeTests` passes a document path (`Widget.g.cs`) or a header to
+`ParseSourceAsync`. The source generators are not: `GetSourceGeneratedDocumentsAsync` needs a real MSBuild
+project, which is what the `TestSuiteGenerated/` fixture is for - one class using `[GeneratedRegex]`,
+asserted on by `SourceGeneratorFixtureTests`. That fixture is where the partial cases are pinned: the class
+*and* the partial method are completed by the generator and must stay unmarked, while everything the
+generator adds beside them must not be.
+
+## Contracts from outside the analyzed code
+
+A member that implements or overrides something we did not analyze - `ICommand.Execute`,
+`object.GetHashCode`, `CSharpSyntaxVisitor.VisitGenericName` - has **no incoming reference anywhere in the
+graph**. The framework is the caller. Every such member therefore looks like dead code, and worse: it looks
+like a *confident* finding, because nothing hints at doubt.
+
+The relationship model cannot express it, in either configuration:
+
+- With `IncludeExternals` off (the default) `AddRelationshipWithFallbackToContainingType` finds neither the
+  member nor its containing type internally and adds **nothing at all**. There is no element to point at.
+- With `IncludeExternals` on, only *types* become external elements ("Always returns the containing TYPE
+  element"), and member relationships are flattened to `Uses`. The result,
+  `VisitGenericName -Uses-> CSharpSyntaxVisitor`, is indistinguishable from a method that merely uses that
+  type as a parameter. Measured on this repository, turning externals on adds 954 nodes and 78 % more edges
+  and still does not answer the question.
+
+The fact is therefore recorded **beside the graph** in `ExternalContractStore` (element id -> contract
+name), carried in `ParseResult` next to the source metrics. It deliberately does not live on
+`CodeElement`: that type is shared with every importer, and a field only the C# parser ever fills would sit
+there empty forever. `MetricStore` established the pattern - "kept beside the code graph so the graph model
+stays pure".
+
+Two detection routes in `DeclarationAnalyzer`, both needed:
+
+- **`override`** - the existing hook (`methodSymbol.IsOverride`, and the property equivalent) records the
+  contract when the *containing type* of the overridden member is not one of ours.
+- **Implicit interface implementation** - `ICommand.Execute` carries no `override` keyword, and
+  `AddImplementationsForInterfaceMember` only ever walks from the *interface* side, so an external interface
+  is never visited. `RecordExternalInterfaceImplementations` therefore walks the type's `AllInterfaces`,
+  skips the internal ones (those get real `Implements` edges) and resolves the rest with
+  `FindImplementationForInterfaceMember`. Those interfaces come from `AllInterfaces` and are already
+  constructed, so the definition/construction trap documented above does not apply here.
+
+Generic types are normalized with `OriginalDefinition` before asking whether an interface is ours -
+`IHandler<Widget>` is not in the map, `IHandler<T>` is.
+
+The store is filled from the parallel phase 2, hence a `ConcurrentDictionary`. The dead code analysis
+reports such members with a note rather than dropping them, and the fact is deliberately **not** pushed to
+the containing type: implementing `IDisposable` is not a use of the class, so a class whose only remaining
+trace is a `Dispose` method stays reportable.
+
+### Notifying types (INotifyPropertyChanged through an external base class)
+
+The store carries one type-level fact beside the member contracts: `NotifyingTypes`, every analyzed type
+with `INotifyPropertyChanged` anywhere in its interface set. The member-level route cannot express the
+common MVVM shape `MyViewModel : ObservableObject` (CommunityToolkit.Mvvm, Prism's `BindableBase`, ...):
+the implementation of `PropertyChanged` sits in the external base class, so the derived type has **no
+member of its own** to record a contract on, and from the graph alone it is indistinguishable from any
+other class. Only the symbol knows — `RecordIfNotifyingType` asks `AllInterfaces`, which includes the
+interfaces contributed by base classes, external or not. Without this, the dead code analysis rated the
+bindable properties of such view models with the highest confidence, which is exactly where a XAML
+`{Binding}` proves it wrong.
+
+The single-file parse (`ParseSourceAsync`) needed `System.ObjectModel.dll` added to its metadata
+references for this: `netstandard.dll` only *forwards* `INotifyPropertyChanged`, and a forward whose
+target assembly is missing leaves the type unresolved — it then silently misses from `AllInterfaces`.
+
+## Visibility on the code element
+
+`CodeElement.AccessLevel` carries what `ISymbol.DeclaredAccessibility` says, mapped in `HierarchyAnalyzer`
+where the elements are created (types and members in one place, property accessors in another - an accessor
+may narrow its property, `public int P { get; private set; }`).
+
+Unlike the external contracts, this belongs **on** the element rather than beside it: visibility is a
+first-class property that every language the tool imports has, several consumers can use it, and the
+importers can fill it later. `AccessLevel.Unknown` is the default and must always be read as "nobody told
+us", never as a value - a graph from doxygen or jdeps has no visibility today, and neither has a project
+file written before this existed.
+
+The type is called `AccessLevel`, not `Accessibility`: WPF drags a global `Accessibility` namespace into
+scope, so the natural name would force a full qualification in every file of the UI projects.
+
+Persisted in both formats - `SerializableCodeElement` (optional constructor parameter, so old project files
+keep loading) and the text serializer (`access=` written only when it is not Unknown, and an unparsable
+value falls back to Unknown rather than guessing).
+
+The dead code analysis uses it for the confidence of a finding, and reads it over the whole containment
+chain: a `public` method of an `internal` class is just as unreachable from another assembly, so it is the
+*most restrictive* container that decides.
+
+Two members were found only through this: a **static constructor** (`.cctor`) and a **finalizer** (the
+destructor arrives from the parser as an ordinary method named `Finalize` - the Roslyn symbol name). Both
+are run by the runtime, can never be referenced from code, and are effectively private, so they landed in
+the highest confidence band. The static constructor started out annotated as an entry point; both are now
+dropped from the result entirely - on a live type such a row is wrong in every case, and on a dead type
+the roll-up covers them.
diff --git a/Documentation/dead-code.md b/Documentation/dead-code.md
new file mode 100644
index 00000000..598997d0
--- /dev/null
+++ b/Documentation/dead-code.md
@@ -0,0 +1,345 @@
+# Dead Code
+
+[TOC]
+
+This guide explains the **Dead Code** analysis: what it reports, what it deliberately does not report, and
+how much you can trust the result.
+
+Available via *Analyzers → Dead Code*. The result is a sortable table:
+
+| Column  | Meaning                                                                     |
+| ------- | ---------------------------------------------------------------------------- |
+| Element | The fully qualified name of the unreferenced element.                        |
+| Kind    | Class, Interface, Method, Field, Property, ... — the kind of element.        |
+| Access  | The element's visibility, empty when the producer does not supply one.        |
+| Confidence | How much the finding can be trusted — coloured like the complexity metric. See below. |
+| Notes   | Anything worth knowing about the finding. **Empty means nothing speaks against deleting it.** |
+
+Sort by *Notes* to get the clean cases together, and use *Jump to code* or *Copy to explorer graph* from
+the context menu to check a finding.
+
+> **Two rows can carry the same name.** A full name is built from the plain symbol names, which carry
+> neither generic arity nor a parameter list. So `WpfCommand` and `WpfCommand<T>` read alike, and so do the
+> overloads `Foo(int)` and `Foo(string)`. They are separate elements in the graph — only the display
+> collides, and one of them being dead while the other is used looks like a wrong finding. *Jump to code*
+> resolves it: the source locations differ.
+
+On a large codebase the fastest way to make the result readable is the filter box, which understands the
+same expressions as the Advanced Search — including **exclusion** with a leading `-`. Whole groups of
+findings disappear at once:
+
+```
+-Strings. -Tests -ThirdParty
+```
+
+`-type:property` drops a whole element kind, and `-source:extern` works as well. Terms combine with spaces
+(AND) and `|` (OR); the exclusion belongs to the term it precedes.
+
+The *Notes* column carries two different kinds of remark, which is why it is not called something like
+"might still be used":
+
+- A **doubt** — `Entry point`, `Test code`, `Attributes: ...`. The reference may exist somewhere the parser
+  cannot see, so the finding needs a second look.
+- An **explanation** — `Implemented but never called: ...`, `Implements unused contract: ...`. Those are
+  the opposite of a doubt: the finding is well understood, and the note tells you what dies together with
+  it.
+
+## The rule
+
+An element is dead when **no relationship enters its subtree from the outside**.
+
+The subtree is the point. Two things follow from it, and both match how you would judge the code by hand:
+
+- A class is alive when one of its members is used, even if nothing ever names the class itself. Somebody
+  calls `Service.Run()`, so `Service` is not dead code — you cannot delete it.
+- A class cannot keep itself alive. If its methods only call each other, every one of those calls stays
+  inside the subtree and proves nothing. The whole class is dead.
+
+Because a dead element implies a dead subtree, **only the topmost dead element is reported**. If a class is
+dead you get one row for the class, not one row per method. If the class is alive but three of its methods
+are unused, you get those three rows.
+
+Namespaces and assemblies are never reported: nothing ever references them in the graph, so they would all
+look dead. Code from outside the solution (frameworks, NuGet packages) is out of scope — we see neither its
+callers nor its body.
+
+### One round, not a chain
+
+The analysis reports what nothing references **right now**. It does not chase the consequences: if the only
+caller of `Formatter` sits in the `Report` class you just got reported, `Formatter` is *not* also reported —
+it is referenced, by dead code, but referenced.
+
+That is a deliberate step back from an earlier cascading version, which kept re-running with the previous
+findings switched off. It worked, but it multiplied every false positive: one invisible `{Binding}` took
+seven further elements with it, and the deeper rounds were only as good as the rounds below them.
+
+**Delete a finding and run the analysis again.** You get the next layer, one honest round at a time, and
+every row stands on its own.
+
+### Code only the tests still use
+
+References are counted in two colours: those from test code, and those from everything else. An element
+with no reference at all is the obvious finding. An element that only *tests* reference is the same
+statement about the production code, and is reported with the note `Used only by tests`.
+
+Without this rule, analyzing the tests along with the production code would **hide** dead code. Exclude the
+test projects and the elements show up as unreferenced; include them and the tests hold them up. Both
+answers cannot be right, and this is the one that survives either setup.
+
+**Test code is decided per type:** a type is a test type when it, or anything inside it, carries a known
+test-framework attribute — the subtree, because xUnit has no class-level attribute (only the `[Fact]`
+methods carry one) and NUnit finds classes without `[TestFixture]` too. Attribute names are matched
+case-sensitively; a domain attribute that happens to be called `test` does not count.
+
+Per type and not per assembly (which it used to be), because one embedded test class poisoned its whole
+assembly in both directions: every reference leaving the assembly counted as a test reference, so code in
+*other* assemblies used from ordinary production code was falsely `Used only by tests` — and production
+code beside the embedded tests, used only by them, was never found, because the whole assembly was exempt.
+
+**Inside a test type the rule does not apply.** A fixture's own helper members and nested fakes are what
+the tests are made of. A helper *class* outside the fixtures carries no attribute, though, so it is
+production code to the analysis and shows up as used-only-by-tests. That is the accepted price of the type
+granularity, and the statement is true — the helper goes when the tests go — it is just noise while the
+helper is doing its job.
+
+The note names the tests that reference the element — what has to go with it. It can be empty: when the
+element is reached through a contract member (`ICommand.Execute` and friends) there is no edge whose caller
+we could name.
+
+> This needs the test projects to be part of the analysis. The default project exclusion filter is
+> `.*Tests`, which removes them — then there is no test code, and the rule finds nothing.
+
+### Generated code
+
+Code a tool wrote is **always** parsed and never excluded. That is not a convenience, it is a correctness
+requirement: generated code holds relationships nothing else does.
+
+- The markup compiler's `Connect` in `MainWindow.g.cs` is the **only** caller of every XAML event handler.
+- A CommunityToolkit `[ObservableProperty]` generates the only code that reads the backing field, and
+  `[RelayCommand]` the only code that calls the method behind it.
+
+Leave that out and you do not merely hide the generated members — you turn the hand-written code they
+reference into dead code. There used to be an *Include generated code* setting; it is gone, because no
+answer it could give was right.
+
+Instead every element a tool wrote is **marked** (`CodeElement.IsGenerated`) and its findings carry the
+note `Generated code`. In this repository that is 812 of 8473 elements and 83 of the findings — resource
+designer members, `IComponentConnector.Connect`, the fields behind `x:Name`.
+
+**The marking asks about every declaration, not any.** A WPF code-behind class is `partial`: half of it is
+`MainWindow.xaml.cs`, which you wrote, half is `MainWindow.g.cs`, which the markup compiler wrote — one
+element, two source locations. An element counts as generated only when *all* of its declarations sit in
+generated files, so your code-behind class stays yours while `Connect` and the `x:Name` fields, which
+exist nowhere else, are marked.
+
+Recognized the way Roslyn's own analyzers do it: the file name (`.g.cs`, `.g.i.cs`, `.designer.cs`,
+`.generated.cs`, `.AssemblyAttributes.cs`, `TemporaryGeneratedFile_*`) or an `<auto-generated>` comment
+before the first token. Source-generated documents are generated by definition.
+
+### Suppressed: serialized properties
+
+**A public property of a type carrying a serialization attribute** is not reported. The serializer reaches
+it by reflection, so "nothing references it" says nothing about it — and on such a type that would be the
+rule rather than the exception, filling the result with rows nobody can act on.
+
+Recognized attributes (the ones that mark the whole type): `[Serializable]`, `[DataContract]`,
+`[JsonObject]`, `[JsonConverter]`, `[XmlRoot]`, `[XmlType]`, `[ProtoContract]`, `[MessagePackObject]`. None
+of them is inherited in C#, so a derived DTO has to carry its own — and a plain DTO without any attribute
+(`System.Text.Json` needs none) is not covered.
+
+Two boundaries are deliberate:
+
+- **Only properties, and only public ones.** A private property, a method or a field on the same type is
+  reported as usual — the serializer resolves by public reflection and reaches none of them. (`[Serializable]`
+  with `BinaryFormatter` does serialize fields; that case is not covered.)
+- **Only the member.** If the whole class is dead, the class is reported — carrying a serialization
+  attribute is not a use of the type.
+
+What you lose on those types is the finding "this property is written but never read".
+
+> An earlier version dropped a **single property accessor** as well, so a setter nobody calls never showed
+> up and only a property dead as a whole was reported. It halved the output, but it answered a question
+> nobody asked — "is this property used at all" instead of "is anything reading it" — and it contradicted
+> the rest of the analysis, which reports and annotates rather than drops. Accessors are reported again.
+> They only exist in the graph when the parser option **Split property accessors** is on.
+
+### Which relationships count as a reference
+
+`Calls`, `Creates`, `Uses`, `Inherits`, `Invokes`, `UsesAttribute`, and `Implements` between two *types*
+(`class C : IFoo` names `IFoo` in C's declaration).
+
+`Containment` is the parent/child hierarchy, not a use. `Bundled` is an artificial edge the graph view
+creates. `Handles` points from the handler to the event and is the callback wiring, not a dependency — but
+nothing is lost: registering `x.Click += OnClick` also produces a method-group `Uses` edge that keeps
+`OnClick` alive.
+
+## Interfaces, overrides and abstract members
+
+`Implements` and `Overrides` between two *members* point from the implementation to the contract. Taken
+literally that gives two wrong answers: an implementation never has an incoming reference and would always
+look dead, while a contract member always looks used just because somebody implements it.
+
+So those edges are not counted as references. Instead **liveness is propagated the other way**:
+
+- A contract member that *is* called keeps every implementation alive — and the types holding them.
+  Calling `IService.Run()` is a call to `Service.Run()`, even if nothing else ever mentions `Service`.
+- A contract member that is *never* called dies together with its implementations. You get one row for the
+  contract (`Implemented but never called: ...`) and one for each implementation (`Implements unused
+  contract: ...`). That pair is one of the more valuable findings: an abstraction nobody uses.
+
+Contracts from **outside** the solution are the exception. We cannot see who calls `IDisposable.Dispose` or
+`object.ToString`, so an implementation of them is assumed to be alive and is not reported. That assumption
+deliberately stops at the member: **implementing `IDisposable` is not a use of the class.** A class whose
+only remaining trace is a `Dispose` method is still reported as dead.
+
+The graph itself cannot carry that fact. With *Include External Code* off — the default — the parser records
+no `Implements` / `Overrides` relationship for a contract outside the solution, because there is no element
+to point at. With it on, the edge is flattened to a `Uses` relationship on the containing *type*, which is
+indistinguishable from ordinary use of that type.
+
+So the parser records it **beside** the graph instead, from the symbols, the same way it does for source
+metrics. Those members are still listed — with `Implements external contract: ICommand.Execute` in the
+*Notes* column, so the judgement stays visible instead of rows disappearing silently.
+
+## Confidence
+
+Three levels, each from one stated rule, evaluated in this order. It is a summary of what is known, not a
+measurement:
+
+| Confidence | Rule |
+| ---------- | ------ |
+| **Low** (red) | The finding carries a note saying the caller may sit outside the graph — entry point, test code, attributes, an external contract. We already know we might be wrong. |
+| **High** (green) | No such note, and the element **or one of its containers** is `private` or `internal`. Nothing outside the analyzed code could reach it, so "nothing references it" and "nothing *can* reference it" are the same statement. |
+| **Medium** (orange) | Everything else: `public`, `protected`, or an unknown visibility. |
+
+The containment part matters more than it looks: a `public` method of an `internal` class cannot be called
+from another assembly either, so it still qualifies as high.
+
+**A `Used only by tests` finding is capped at medium.** The ladder measures whether a caller we cannot see
+could exist, and that question stays valid — a public element could still be used from an assembly outside
+the analysis. High is the one level such a finding must not reach, because high claims that nothing *can*
+reference the element while something demonstrably does. Whether a test alone justifies keeping it is a
+decision, not a measurement. Low still wins when one of the notes above applies.
+
+**One exception to high:** a `public` property on a type that implements `INotifyPropertyChanged` — a view
+model. A XAML `{Binding}` reaches exactly that, and bindings are the one XAML construct the analysis
+deliberately does not follow. The parser records every analyzed type with the interface anywhere in its
+interface set, no matter which class of the inheritance chain implements it — so a view model deriving from
+a base class outside the analyzed code (`ObservableObject`, `BindableBase`, ...) is covered too, although
+nothing in the graph itself says it is a view model. A project file saved before this existed has no
+recorded types, so the rule is simply off there until the solution is parsed anew — the same graceful
+degradation as for the other parser-side facts.
+
+Being confined does not help against this. A public property of an internal class cannot be referenced from
+another assembly, but the binding sits *inside* the assembly and is merely invisible — a different thing.
+Private, internal and protected properties stay high: the binding engine resolves by public reflection and
+cannot reach them.
+
+> **Known gap.** The rule keys on `INotifyPropertyChanged`, so a plain object bound inside a `DataTemplate`
+> is not covered. In this repository the `Mru` class (`Path`, `Command`, bound from an `ItemsSource`) is
+> exactly that case and still shows as high. Recognizing it would mean demoting *every* public property,
+> which costs real findings in non-WPF code.
+
+**Unknown visibility never reaches high.** Every importer except the C# parser leaves it unset, and so does
+a project file written before this existed. That is the honest answer rather than a penalty — without
+knowing the visibility we cannot claim that nothing outside could reference the element.
+
+The high bucket is deliberately small: it is the list you can work through without checking each entry by
+hand.
+
+> `InternalsVisibleTo` is not taken into account. A friend assembly inside the analysis shows its references
+> anyway; one outside it is the rare case this misses.
+
+## The notes
+
+The analysis can only see what the parser saw. Everything reached through reflection, dependency injection,
+serialization or a test runner therefore looks unreferenced. Those elements are not silently dropped — they
+are reported with a note, and you decide. (Two exceptions are dropped outright: the serialized property
+above, where the note would be on every row of a DTO, and static constructors and finalizers — no code can
+reference those, only the runtime calls them, so the row would be wrong on every live type.)
+
+**Doubts** — the reference may exist where the parser cannot look:
+
+| Note              | Meaning                                                                       |
+| ----------------- | ------------------------------------------------------------------------------ |
+| `Entry point`     | `Main`, or the synthetic `GlobalStatements` element for top-level statements. |
+| `Test code`       | The element or something below it carries a known test-framework attribute.    |
+| `Generated code`  | A tool wrote it, not a person. The finding is correct, it is just not for you — the next build writes it again. See [Generated code](#generated-code). |
+| `Attributes: ...` | The element carries attributes — often the sign that a framework drives it. Every attribute is listed, including the test ones that already produced `Test code`. Attributes that only talk to the compiler, debugger or analyzer (`[Obsolete]`, `[DebuggerDisplay]`, `[ExcludeFromCodeCoverage]`, ...) do not raise this note — they say nothing about a caller, and `[Obsolete]` outright argues for deletion. |
+
+**Explanations** — the finding is understood, and the note names what dies with it:
+
+| Note                                | Meaning                                                                     |
+| ----------------------------------- | ----------------------------------------------------------------------------- |
+| `Implemented but never called: ...` | A contract member that is implemented but never called through the contract.  |
+| `Implements unused contract: ...`   | Implements or overrides an internal contract member that is itself dead.      |
+| `Implements external contract: ...` | Implements or overrides something outside the analyzed code (`ICommand.Execute`, `object.GetHashCode`). The framework is the caller, so this is almost certainly alive. |
+| `Used only by tests: ...`           | Nothing in the production code references it — the listed tests are the only thing keeping it alive. See [Code only the tests still use](#code-only-the-tests-still-use). |
+
+Notes are collected over the whole subtree, because the evidence usually sits below what is reported: a
+test fixture is reported as a dead *class*, but the `[Test]` attributes are on its methods.
+
+## What XAML the analysis does see
+
+Half of XAML is compiled into C# and is therefore fully visible; the other half is not, and the split is
+sharp.
+
+The markup compiler writes a partial class per XAML file (`obj/.../MyView.g.cs`) and that file **is** part of
+the compilation — MSBuildWorkspace runs the markup compile pass during its design-time build, so this works
+even on a solution that was never built. The generated class contains a field per `x:Name`d element and a
+`Connect` method that wires the event handlers:
+
+```csharp
+this.CodeTree.ContextMenuOpening += new ContextMenuEventHandler(this.TreeView_ContextMenuOpening);
+```
+
+That is ordinary C#, so those references are found like any other. Everything declarative is compiled into
+**BAML** instead — a binary resource resolved by reflection at runtime, with no C# generated for it. The
+parser closes most of that gap by reading the XAML files themselves and adding the references that carry a
+fully qualified CLR name (see `ParserConfig.IncludeXamlReferences`).
+
+| In XAML                                                      | Found? |
+| ------------------------------------------------------------ | ------ |
+| `Click="Button_Click"`, anywhere incl. templates              | yes, generated C# |
+| `x:Name="CodeTree"` in the file's main name scope             | yes, generated field |
+| `x:Name` inside `DataTemplate` / `ControlTemplate` / `Style`  | no field is generated — but the element tag is read from the XAML |
+| `<local:MyControl/>` — the element tag                        | yes, read from the XAML — including the constructor it runs |
+| `{x:Static resx:Strings.Header}`, `{x:Type local:Foo}`        | yes, read from the XAML |
+| `{Binding SaveCommand}`                                       | **no** |
+| `{StaticResource key}`                                        | **no** |
+| `Source="Styles/Buttons.xaml"`, `StartupUri`                  | **no** |
+
+Prefixes are resolved through the `clr-namespace` xmlns declarations, so nothing is matched by guessing.
+`{Binding}` is deliberately left out: without evaluating the DataContext it is a bare member name, and
+matching that across the codebase would suppress far more than it explains.
+
+The name-scope rule is worth knowing even so. `MainWindow.xaml` in this repository has ten `x:Name`s and
+the generated file has nine fields — the missing one sits inside a `DataTemplate`. Before the XAML files
+were read, that control looked unused despite being used three times.
+
+A XAML file with no code-behind class (a resource dictionary) is represented by a synthetic class named
+after its path, so its references have a source. Nothing resolves the `Source` URIs of merged dictionaries,
+so those synthetic elements appear in the result themselves — six of them in this repository.
+
+## Limitations
+
+Read these before deleting anything.
+
+- **The rest of XAML.** Most of it is covered — see the section above for the exact split. What remains
+  invisible is `{Binding}`, `{StaticResource}` and the `Source` / `StartupUri` URIs of merged dictionaries.
+  Reading the XAML files removed 187 findings on this repository when it was introduced.
+- **Reflection, DI and serialization** are invisible for the same reason: the reference only exists at
+  runtime. What is handled explicitly are the two suppressed cases above — a single property accessor and
+  a public property of a type marked as a serialization target.
+- **External contracts are recognized, but only for C#.** The information comes from the Roslyn symbols, so
+  a graph produced by one of the importers (Java, C++, Dart, ...) does not have it, and a project file
+  written before this existed does not either — parse the solution again to get it.
+- **Public API.** Accessibility is not part of the code graph, so a library whose public API is consumed by
+  a different solution will report most of that API as dead.
+- **Only the analyzed scope.** The analysis is only as complete as the loaded graph. If the solution was
+  parsed with project exclusions, or the graph came from an import, the callers may simply be missing.
+- **Only one layer at a time.** Code that is kept alive solely by the code just reported does not show up
+  in the same run — see *One round, not a chain*. Delete and run again.
+- **Dead cycles are not found.** Two classes that only use each other and nothing else each have an
+  incoming reference, so neither is reported — and re-running does not help, because nothing ever breaks
+  the cycle. Finding those requires reachability from an explicit set of entry points.
diff --git a/README.md b/README.md
index 2a9481aa..e2c12b21 100644
--- a/README.md
+++ b/README.md
@@ -24,6 +24,7 @@ This desktop app helps you explore, understand, and manage large C# codebases, e
 - **Incremental Graph Exploration** – Build the exact graph you need to understand a codebase or solve a task. Map out dependencies step by step on demand (e.g., "show all incoming relationships"), and easily filter out unrelated code elements to keep the graph free of visual clutter.
 - **Sandbox Code Refactoring** – Experiment with structural changes and simulate cycle-breaking strategies safely, without touching your actual source code.
 - **Architectural Guardrails** – Define custom dependency rules and metric thresholds to actively validate and enforce a clean codebase.
+- **Dead Code Detection** – Find the types and members nothing references any more, with the cases that only look unused flagged instead of hidden.
 - **Multi-Format Exports** – Share your architecture by exporting diagrams to PlantUML, DGML, PNG, SVG, and more.
 - **Git History Hotspots** – Uncover hidden technical debt by running hotspot or change-coupling analyses directly on your Git repository history.
 - **Design Structure Matrix (DSM)** - Explore the System's dependencies at the type level.
@@ -234,6 +235,16 @@ All metrics are accessible via the Analyzer Ribbon, and the results are presente
 
 ![](Documentation/Images/metrics-example.png)
 
+## Find dead code
+
+C# Code Analyst can list code elements that nothing references anymore.
+
+This is a heuristic only. There are many situations, like Reflection, DI, and XAML Bindings, that are not recognized. Therefore, each finding gets a confidence level.
+
+You can read more about the rules and  the limits here: [Dead Code](Documentation/dead-code.md)
+
+The analysis is accessible via the Analyzer Ribbon, and the result is presented in a table on a separate tab.
+
 ## Other languages
 
 The tool is built for C# (has its own Roslyn-based parser), but you can also import Java, C++, Python and Dart via external tools.
@@ -274,6 +285,7 @@ Please keep these points in mind:
 - You can include external code by setting the "Include External Code" option. Only type dependencies are collected.
 - A method defining a  lambda expression only has "uses" relationships to types and methods inside the lambda.  This is because I cannot track where the lambda is actually called. I think that is a good compromise.
 - Primary constructors of records do not create the properties in the code graph.
+- XAML Bindings are not resolved.
 - Projects must be loadable by the **.NET SDK's MSBuild**. Legacy non-SDK .NET Framework projects — especially old-style WPF (`net472`) — may fail to load even though they build in Visual Studio. See [Supported projects and solutions](Documentation/supported-projects.md).
 
 ## Thank you
diff --git a/TestSuiteGenerated/SourceGenerated/SourceGenerated.csproj b/TestSuiteGenerated/SourceGenerated/SourceGenerated.csproj
new file mode 100644
index 00000000..237d6616
--- /dev/null
+++ b/TestSuiteGenerated/SourceGenerated/SourceGenerated.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+</Project>
diff --git a/TestSuiteGenerated/SourceGenerated/Validator.cs b/TestSuiteGenerated/SourceGenerated/Validator.cs
new file mode 100644
index 00000000..b3ed53b5
--- /dev/null
+++ b/TestSuiteGenerated/SourceGenerated/Validator.cs
@@ -0,0 +1,25 @@
+using System.Text.RegularExpressions;
+
+namespace SourceGenerated;
+
+/// <summary>
+///     Fixture for the source-generator path of the parser. [GeneratedRegex] ships with the .NET SDK, so
+///     this needs no package reference and no restore - the generator runs during the design-time build
+///     MSBuildWorkspace performs.
+///     <para>
+///         The point of the fixture is the partial shape: this class and NumberPattern() are declared
+///         here and completed by the generator, so each of them ends up with one hand-written and one
+///         generated declaration. Everything the generator adds beside them (its Regex subclass and its
+///         helpers) exists only in the generated file.
+///     </para>
+/// </summary>
+public partial class Validator
+{
+    [GeneratedRegex(@"^\d+$")]
+    private static partial Regex NumberPattern();
+
+    public bool IsNumber(string text)
+    {
+        return NumberPattern().IsMatch(text);
+    }
+}
diff --git a/TestSuiteGenerated/TestSuiteGenerated.sln b/TestSuiteGenerated/TestSuiteGenerated.sln
new file mode 100644
index 00000000..d03a1085
--- /dev/null
+++ b/TestSuiteGenerated/TestSuiteGenerated.sln
@@ -0,0 +1,19 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SourceGenerated", "SourceGenerated\SourceGenerated.csproj", "{2F9B4E1D-7C63-4A5B-9F2E-8D1A6C3B5E70}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2F9B4E1D-7C63-4A5B-9F2E-8D1A6C3B5E70}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2F9B4E1D-7C63-4A5B-9F2E-8D1A6C3B5E70}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2F9B4E1D-7C63-4A5B-9F2E-8D1A6C3B5E70}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2F9B4E1D-7C63-4A5B-9F2E-8D1A6C3B5E70}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal
diff --git a/Tests/Helper/TestCodeGraph.cs b/Tests/Helper/TestCodeGraph.cs
index b12d37e3..8cc4db4e 100644
--- a/Tests/Helper/TestCodeGraph.cs
+++ b/Tests/Helper/TestCodeGraph.cs
@@ -24,9 +24,10 @@ public CodeElement CreateAssembly(string id)
         return element;
     }
 
-    public CodeElement CreateClass(string id, CodeElement? parent = null, string? fullName = null)
+    public CodeElement CreateClass(string id, CodeElement? parent = null, string? fullName = null,
+        AccessLevel accessLevel = AccessLevel.Unknown)
     {
-        var element = new CodeElement(id, CodeElementType.Class, id, id, parent);
+        var element = new CodeElement(id, CodeElementType.Class, id, id, parent) { AccessLevel = accessLevel };
         Link(parent, element);
         return element;
     }
@@ -60,6 +61,14 @@ public CodeElement CreateInterface(string id, CodeElement? parent = null)
         return element;
     }
 
+    /// <summary>An interface from outside the solution (framework contract like IDisposable).</summary>
+    public CodeElement CreateExternalInterface(string id, CodeElement? parent = null)
+    {
+        var element = new CodeElement(id, CodeElementType.Interface, id, id, parent) { IsExternal = true };
+        Link(parent, element);
+        return element;
+    }
+
     public CodeElement CreateDelegate(string id, CodeElement? parent = null)
     {
         var element = new CodeElement(id, CodeElementType.Delegate, id, id, parent);
@@ -74,16 +83,26 @@ public CodeElement CreateEvent(string id, CodeElement? parent = null)
         return element;
     }
 
-    public CodeElement CreateProperty(string id, CodeElement? parent = null)
+    public CodeElement CreateProperty(string id, CodeElement? parent = null,
+        AccessLevel accessLevel = AccessLevel.Unknown)
+    {
+        var element = new CodeElement(id, CodeElementType.Property, id, id, parent) { AccessLevel = accessLevel };
+        Link(parent, element);
+        return element;
+    }
+
+    public CodeElement CreateMethod(string id, CodeElement? parent = null,
+        AccessLevel accessLevel = AccessLevel.Unknown)
     {
-        var element = new CodeElement(id, CodeElementType.Property, id, id, parent);
+        var element = new CodeElement(id, CodeElementType.Method, id, id, parent) { AccessLevel = accessLevel };
         Link(parent, element);
         return element;
     }
 
-    public CodeElement CreateMethod(string id, CodeElement? parent = null)
+    /// <summary>A method from outside the solution (member of a framework type).</summary>
+    public CodeElement CreateExternalMethod(string id, CodeElement? parent = null)
     {
-        var element = new CodeElement(id, CodeElementType.Method, id, id, parent);
+        var element = new CodeElement(id, CodeElementType.Method, id, id, parent) { IsExternal = true };
         Link(parent, element);
         return element;
     }
diff --git a/Tests/UnitTests/DeadCode/DeadCodeAnalysisTests.cs b/Tests/UnitTests/DeadCode/DeadCodeAnalysisTests.cs
new file mode 100644
index 00000000..d4622b3c
--- /dev/null
+++ b/Tests/UnitTests/DeadCode/DeadCodeAnalysisTests.cs
@@ -0,0 +1,464 @@
+using CodeParserTests.Helper;
+using CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+using CSharpCodeAnalyst.CodeGraph.Declarations;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+
+namespace CodeParserTests.UnitTests.DeadCode;
+
+[TestFixture]
+public class DeadCodeAnalysisTests
+{
+    [SetUp]
+    public void SetUp()
+    {
+        _graph = new TestCodeGraph();
+    }
+
+    private TestCodeGraph _graph = null!;
+
+    private void Rel(CodeElement source, CodeElement target, RelationshipType type)
+    {
+        source.Relationships.Add(new Relationship(source.Id, target.Id, type));
+    }
+
+    private string[] Reported()
+    {
+        return DeadCodeAnalysis.Calculate(_graph)
+            .Select(f => f.Element.FullName)
+            .ToArray();
+    }
+
+    private DeadCodeFinding FindingFor(CodeElement element)
+    {
+        return DeadCodeAnalysis.Calculate(_graph).Single(f => f.Element.Id == element.Id);
+    }
+
+    [Test]
+    public void Calculate_EmptyGraph_NoFindings()
+    {
+        Assert.That(DeadCodeAnalysis.Calculate(_graph), Is.Empty);
+    }
+
+    [Test]
+    public void Calculate_UnreferencedClass_Reported()
+    {
+        _graph.CreateClass("A");
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "A" }));
+    }
+
+    [Test]
+    public void Calculate_ClassUsedByAnotherClass_NotReported()
+    {
+        // B uses A, so only B itself has no incoming reference.
+        var a = _graph.CreateClass("A");
+        var b = _graph.CreateClass("B");
+        Rel(b, a, RelationshipType.Uses);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "B" }));
+    }
+
+    [Test]
+    public void Calculate_MethodCalledFromOutside_KeepsWholeClassAlive()
+    {
+        // Nothing names A, but B.M calls A.M -> the reference enters A's subtree from the outside.
+        var a = _graph.CreateClass("A");
+        var am = _graph.CreateMethod("A.M", a);
+        var b = _graph.CreateClass("B");
+        var bm = _graph.CreateMethod("B.M", b);
+        Rel(bm, am, RelationshipType.Calls);
+
+        // B is dead; B.M is inside it and rolled up.
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "B" }));
+    }
+
+    [Test]
+    public void Calculate_ClassWithOnlyInternalCalls_ReportedAsOneFinding()
+    {
+        // A.M1 -> A.M2 does not prove anything about A: the reference never leaves the subtree.
+        var a = _graph.CreateClass("A");
+        var m1 = _graph.CreateMethod("A.M1", a);
+        var m2 = _graph.CreateMethod("A.M2", a);
+        Rel(m1, m2, RelationshipType.Calls);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "A" }));
+    }
+
+    [Test]
+    public void Calculate_UnusedMemberOfLiveClass_Reported()
+    {
+        var a = _graph.CreateClass("A");
+        var used = _graph.CreateMethod("A.Used", a);
+        _graph.CreateMethod("A.Unused", a);
+        var b = _graph.CreateClass("B");
+        var bm = _graph.CreateMethod("B.M", b);
+        Rel(bm, used, RelationshipType.Calls);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "A.Unused", "B" }));
+    }
+
+    [Test]
+    public void Calculate_NestedDeadClass_OnlyOutermostReported()
+    {
+        var outer = _graph.CreateClass("Outer");
+        var inner = _graph.CreateClass("Outer.Inner", outer);
+        _graph.CreateMethod("Outer.Inner.M", inner);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "Outer" }));
+    }
+
+    [Test]
+    public void Calculate_ContainersAndExternalElements_NeverReported()
+    {
+        var assembly = _graph.CreateAssembly("Asm");
+        var ns = _graph.CreateNamespace("Asm.Ns", assembly);
+        _graph.CreateClass("Asm.Ns.A", ns);
+        _graph.CreateExternalClass("Ext");
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "Asm.Ns.A" }));
+    }
+
+    [Test]
+    public void Calculate_ContainmentAndHandles_AreNoReferences()
+    {
+        // Handles points handler -> event; it is the callback wiring, not a use of the handler.
+        var publisher = _graph.CreateClass("Publisher");
+        var evt = _graph.CreateEvent("Publisher.Changed", publisher);
+        var subscriber = _graph.CreateClass("Subscriber");
+        var handler = _graph.CreateMethod("Subscriber.OnChanged", subscriber);
+        Rel(handler, evt, RelationshipType.Handles);
+        Rel(publisher, subscriber, RelationshipType.Containment);
+
+        // The Handles edge enters Publisher's subtree and the Containment edge enters Subscriber's,
+        // yet neither is a reference - both classes stay dead.
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "Publisher", "Subscriber" }));
+    }
+
+    [Test]
+    public void Calculate_CalledThroughInterface_KeepsImplementationAndItsTypeAlive()
+    {
+        var contract = _graph.CreateInterface("IFoo");
+        var contractMember = _graph.CreateMethod("IFoo.Bar", contract);
+        var impl = _graph.CreateClass("C");
+        var implMember = _graph.CreateMethod("C.Bar", impl);
+        Rel(impl, contract, RelationshipType.Implements);
+        Rel(implMember, contractMember, RelationshipType.Implements);
+
+        var user = _graph.CreateClass("User");
+        var userMethod = _graph.CreateMethod("User.M", user);
+        Rel(userMethod, contractMember, RelationshipType.Calls);
+
+        // Nobody creates C, yet the call through IFoo.Bar reaches C.Bar - so neither is dead.
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "User" }));
+    }
+
+    [Test]
+    public void Calculate_OverrideChain_LivenessPropagatesTransitively()
+    {
+        var contract = _graph.CreateInterface("IFoo");
+        var contractMember = _graph.CreateMethod("IFoo.Bar", contract);
+        var middle = _graph.CreateClass("Base");
+        var middleMember = _graph.CreateMethod("Base.Bar", middle);
+        var leaf = _graph.CreateClass("Derived");
+        var leafMember = _graph.CreateMethod("Derived.Bar", leaf);
+
+        Rel(middle, contract, RelationshipType.Implements);
+        Rel(middleMember, contractMember, RelationshipType.Implements);
+        Rel(leaf, middle, RelationshipType.Inherits);
+        Rel(leafMember, middleMember, RelationshipType.Overrides);
+
+        var user = _graph.CreateClass("User");
+        Rel(user, contractMember, RelationshipType.Calls);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "User" }));
+    }
+
+    [Test]
+    public void Calculate_ContractImplementedButNeverCalled_ContractAndImplementationReported()
+    {
+        var contract = _graph.CreateInterface("IFoo");
+        var contractMember = _graph.CreateMethod("IFoo.Bar", contract);
+        var impl = _graph.CreateClass("C");
+        var implMember = _graph.CreateMethod("C.Bar", impl);
+        Rel(impl, contract, RelationshipType.Implements);
+        Rel(implMember, contractMember, RelationshipType.Implements);
+
+        // C is instantiated, so the class itself is alive - but nobody ever calls Bar.
+        var user = _graph.CreateClass("User");
+        Rel(user, impl, RelationshipType.Creates);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "C.Bar", "IFoo.Bar", "User" }));
+
+        var contractFinding = FindingFor(contractMember);
+        Assert.That(contractFinding.Hints.HasFlag(DeadCodeHint.ContractNeverCalled), Is.True);
+        Assert.That(contractFinding.RelatedMembers.Select(m => m.FullName), Is.EquivalentTo(new[] { "C.Bar" }));
+
+        var implFinding = FindingFor(implMember);
+        Assert.That(implFinding.Hints.HasFlag(DeadCodeHint.ImplementsDeadContract), Is.True);
+        Assert.That(implFinding.RelatedMembers.Select(m => m.FullName), Is.EquivalentTo(new[] { "IFoo.Bar" }));
+    }
+
+    [Test]
+    public void Calculate_ImplementsExternalContract_MemberAliveButClassStillDead()
+    {
+        // class C : IDisposable { public void Dispose() {} } - Dispose is called by code we cannot see,
+        // but implementing IDisposable is no use of C itself.
+        var external = _graph.CreateExternalInterface("IDisposable");
+        var externalMember = _graph.CreateExternalMethod("IDisposable.Dispose", external);
+        var impl = _graph.CreateClass("C");
+        var implMember = _graph.CreateMethod("C.Dispose", impl);
+        Rel(impl, external, RelationshipType.Implements);
+        Rel(implMember, externalMember, RelationshipType.Implements);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "C" }));
+    }
+
+    [Test]
+    public void Calculate_OverridesUnresolvedBaseMember_ReportedWithTheExternalContractHint()
+    {
+        // The parser falls back to the containing type when it cannot resolve the exact base member
+        // (generic base methods). We cannot tell who calls it - the member is still reported, but the
+        // note says why it is probably alive rather than dropping the row silently.
+        var baseClass = _graph.CreateClass("Base");
+        var derived = _graph.CreateClass("Derived");
+        var member = _graph.CreateMethod("Derived.M", derived);
+        Rel(derived, baseClass, RelationshipType.Inherits);
+        Rel(member, baseClass, RelationshipType.Overrides);
+
+        var user = _graph.CreateClass("User");
+        Rel(user, derived, RelationshipType.Creates);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "Derived.M", "User" }));
+
+        var finding = FindingFor(member);
+        Assert.Multiple(() =>
+        {
+            Assert.That(finding.Hints.HasFlag(DeadCodeHint.ImplementsExternalContract), Is.True);
+            Assert.That(finding.ExternalContract, Is.EqualTo("Base"));
+        });
+    }
+
+    [Test]
+    public void Calculate_ExternalContractFromTheStore_ReportedWithTheContractName()
+    {
+        // The usual case: the parser recorded the contract beside the graph because there is no element
+        // to point an edge at (IncludeExternals is off, so ICommand is not in the graph at all).
+        var live = _graph.CreateClass("Command");
+        var execute = _graph.CreateMethod("Command.Execute", live);
+        var user = _graph.CreateClass("User");
+        Rel(user, live, RelationshipType.Creates);
+
+        var store = new ExternalContractStore();
+        store.Add(execute.Id, "ICommand.Execute");
+
+        var findings = DeadCodeAnalysis.Calculate(_graph, store);
+        var finding = findings.Single(f => f.Element.Id == execute.Id);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(finding.Hints.HasFlag(DeadCodeHint.ImplementsExternalContract), Is.True);
+            Assert.That(finding.ExternalContract, Is.EqualTo("ICommand.Execute"));
+
+            // The class itself is untouched by the assumption - it is created, so it is not reported.
+            Assert.That(findings.Select(f => f.Element.FullName), Does.Not.Contain("Command"));
+        });
+    }
+
+    [Test]
+    public void Calculate_EntryPointAndTestCode_ReportedWithHint()
+    {
+        var program = _graph.CreateClass("Program");
+        _graph.CreateMethod("Main", program);
+
+        var fixture = _graph.CreateClass("MyTests");
+        var testMethod = _graph.CreateMethod("MyTests.ShouldWork", fixture);
+        testMethod.Attributes.Add("TestAttribute");
+
+        var service = _graph.CreateClass("Service");
+        service.Attributes.Add("ExportAttribute");
+
+        Assert.That(FindingFor(program).Hints, Is.EqualTo(DeadCodeHint.EntryPoint));
+        Assert.That(FindingFor(fixture).Hints, Is.EqualTo(DeadCodeHint.TestCode));
+        Assert.That(FindingFor(service).Hints, Is.EqualTo(DeadCodeHint.Attributed));
+        Assert.That(FindingFor(service).Attributes, Is.EquivalentTo(new[] { "ExportAttribute" }));
+    }
+
+    [Test]
+    public void Calculate_ToolingAttributes_RaiseNoDoubt()
+    {
+        // [Obsolete] and the debugger attributes talk to the compiler or debugger, not to a runtime
+        // that could call the element - they must not count as a caller doubt. The attributes are
+        // still collected on the finding.
+        var service = _graph.CreateClass("Service");
+        service.Attributes.Add("ObsoleteAttribute");
+        service.Attributes.Add("DebuggerDisplayAttribute");
+
+        var finding = FindingFor(service);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(finding.Hints, Is.EqualTo(DeadCodeHint.None));
+            Assert.That(finding.Attributes,
+                Is.EquivalentTo(new[] { "DebuggerDisplayAttribute", "ObsoleteAttribute" }));
+        });
+    }
+
+    [Test]
+    public void Calculate_StaticConstructorAndFinalizer_AreNeverReported()
+    {
+        // No code can reference either - the runtime calls them. On a live type the row would be wrong
+        // in every case, so it is dropped rather than annotated; on a dead type the roll-up covers them.
+        var cache = _graph.CreateClass("Cache");
+        _graph.CreateMethod(".cctor", cache);
+        _graph.CreateMethod("Finalize", cache);
+        var used = _graph.CreateMethod("Cache.Used", cache);
+
+        var user = _graph.CreateClass("User");
+        Rel(user, used, RelationshipType.Calls);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "User" }));
+    }
+
+    [Test]
+    public void Calculate_DeadClassWithStaticConstructor_IsReportedWithoutAnEntryPointHint()
+    {
+        // An unused type's static constructor never runs. It must not push the class finding down to
+        // the lowest confidence the way a real entry point would.
+        var cache = _graph.CreateClass("Cache");
+        _graph.CreateMethod(".cctor", cache);
+
+        Assert.That(FindingFor(cache).Hints, Is.EqualTo(DeadCodeHint.None));
+    }
+
+    [Test]
+    public void Calculate_UnusedPropertyAccessor_Reported()
+    {
+        var a = _graph.CreateClass("A");
+        var property = _graph.CreateProperty("A.Value", a);
+        var getter = _graph.CreatePropertyAccessor("A.get_Value", property);
+        _graph.CreatePropertyAccessor("A.set_Value", property);
+
+        var user = _graph.CreateClass("User");
+        Rel(user, getter, RelationshipType.Calls);
+
+        // The property is used, so it is alive - but nothing writes it, and that is a finding of its own.
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "A.set_Value", "User" }));
+    }
+
+    [Test]
+    public void Calculate_PropertyWithNoUsedAccessor_ReportedAsTheProperty()
+    {
+        var a = _graph.CreateClass("A");
+        var property = _graph.CreateProperty("A.Value", a);
+        _graph.CreatePropertyAccessor("A.get_Value", property);
+        _graph.CreatePropertyAccessor("A.set_Value", property);
+
+        var used = _graph.CreateMethod("A.Used", a);
+        var user = _graph.CreateClass("User");
+        Rel(user, used, RelationshipType.Calls);
+
+        // A property that is dead as a whole is one finding, not three - the accessors roll up into it.
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "A.Value", "User" }));
+    }
+
+    [Test]
+    public void Calculate_CodeOnlyUsedByDeadCode_NotReported()
+    {
+        // Deliberate: the analysis reports what nothing references right now and does not chase the
+        // consequences. Formatter is referenced - by dead code, but referenced. Delete Report and run the
+        // analysis again, and Formatter shows up. That keeps every finding standing on its own instead of
+        // stacking on the round below it.
+        var report = _graph.CreateClass("Report");
+        var print = _graph.CreateMethod("Report.Print", report);
+        var formatter = _graph.CreateClass("Formatter");
+        var format = _graph.CreateMethod("Formatter.Format", formatter);
+        Rel(print, format, RelationshipType.Calls);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "Report" }));
+    }
+
+    [Test]
+    public void Calculate_MutualReference_NotFound()
+    {
+        // The known limit: two elements that only reference each other keep each other alive. Finding
+        // those needs reachability from an explicit set of entry points.
+        var a = _graph.CreateClass("A");
+        var am = _graph.CreateMethod("A.M", a);
+        var b = _graph.CreateClass("B");
+        var bm = _graph.CreateMethod("B.M", b);
+        Rel(am, bm, RelationshipType.Calls);
+        Rel(bm, am, RelationshipType.Calls);
+
+        Assert.That(Reported(), Is.Empty);
+    }
+
+    /// <summary>
+    ///     A type a serializer drives, kept alive by a user so that the members are reported individually.
+    /// </summary>
+    private CodeElement CreateSerializableType(string attribute = "DataContractAttribute")
+    {
+        var type = _graph.CreateClass("Config");
+        type.Attributes.Add(attribute);
+
+        var user = _graph.CreateClass("User");
+        Rel(user, type, RelationshipType.Creates);
+        return type;
+    }
+
+    [Test]
+    public void Calculate_PublicPropertyOfASerializableType_NotReported()
+    {
+        // The serializer reads it by reflection. On such a type every property looks dead, so reporting
+        // them would only fill the result with rows nobody can act on.
+        var type = CreateSerializableType();
+        _graph.CreateProperty("Config.Title", type, AccessLevel.Public);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "User" }));
+    }
+
+    [Test]
+    public void Calculate_NonPublicPropertyOfASerializableType_Reported()
+    {
+        // Out of reach for the serializer, which resolves by public reflection.
+        var type = CreateSerializableType("SerializableAttribute");
+        _graph.CreateProperty("Config.Secret", type, AccessLevel.Private);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "Config.Secret", "User" }));
+    }
+
+    [Test]
+    public void Calculate_MethodOfASerializableType_Reported()
+    {
+        // The exception is about the serialized state, not about everything on the type.
+        var type = CreateSerializableType();
+        _graph.CreateMethod("Config.Validate", type, AccessLevel.Public);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "Config.Validate", "User" }));
+    }
+
+    [Test]
+    public void Calculate_PublicPropertyOfAnOrdinaryType_Reported()
+    {
+        // Without one of the serialization attributes there is nothing to suspect.
+        var type = _graph.CreateClass("Config");
+        _graph.CreateProperty("Config.Title", type, AccessLevel.Public);
+
+        var user = _graph.CreateClass("User");
+        Rel(user, type, RelationshipType.Creates);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "Config.Title", "User" }));
+    }
+
+    [Test]
+    public void Calculate_PropertyOfASerializableTypeWithNoUsedAccessor_NotReported()
+    {
+        // Here the accessor roll-up alone would not help: nothing touches the property at all, so without
+        // the serialization rule it would be reported as a dead property.
+        var type = CreateSerializableType();
+        var property = _graph.CreateProperty("Config.Title", type, AccessLevel.Public);
+        _graph.CreatePropertyAccessor("Config.get_Title", property);
+        _graph.CreatePropertyAccessor("Config.set_Title", property);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "User" }));
+    }
+}
diff --git a/Tests/UnitTests/DeadCode/DeadCodeConfidenceTests.cs b/Tests/UnitTests/DeadCode/DeadCodeConfidenceTests.cs
new file mode 100644
index 00000000..a8c76254
--- /dev/null
+++ b/Tests/UnitTests/DeadCode/DeadCodeConfidenceTests.cs
@@ -0,0 +1,199 @@
+using CodeParserTests.Helper;
+using CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+using CSharpCodeAnalyst.CodeGraph.Declarations;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+
+namespace CodeParserTests.UnitTests.DeadCode;
+
+/// <summary>
+///     The confidence of a finding follows three rules: a note about a caller outside the graph makes it
+///     low, a direct finding confined to the analyzed code makes it high, everything else is medium.
+/// </summary>
+[TestFixture]
+public class DeadCodeConfidenceTests
+{
+    [SetUp]
+    public void SetUp()
+    {
+        _graph = new TestCodeGraph();
+    }
+
+    private TestCodeGraph _graph = null!;
+
+    private void Rel(CodeElement source, CodeElement target, RelationshipType type)
+    {
+        source.Relationships.Add(new Relationship(source.Id, target.Id, type));
+    }
+
+    private DeadCodeConfidence ConfidenceOf(CodeElement element, ExternalContractStore? store = null)
+    {
+        return DeadCodeAnalysis.Calculate(_graph, store).Single(f => f.Element.Id == element.Id).Confidence;
+    }
+
+    /// <summary>A live class holding one used and one unused member - the unused one is the finding.</summary>
+    private CodeElement CreateUnusedMember(AccessLevel memberAccess, AccessLevel classAccess = AccessLevel.Public)
+    {
+        var type = _graph.CreateClass("Widget", accessLevel: classAccess);
+        var used = _graph.CreateMethod("Widget.Used", type, AccessLevel.Public);
+        var unused = _graph.CreateMethod("Widget.Unused", type, memberAccess);
+
+        var program = _graph.CreateClass("Program");
+        var main = _graph.CreateMethod("Main", program);
+        Rel(main, used, RelationshipType.Calls);
+
+        return unused;
+    }
+
+    [Test]
+    public void PrivateMember_IsHighConfidence()
+    {
+        // Nothing outside the type could call it, and nothing inside does.
+        Assert.That(ConfidenceOf(CreateUnusedMember(AccessLevel.Private)), Is.EqualTo(DeadCodeConfidence.High));
+    }
+
+    [Test]
+    public void InternalMember_IsHighConfidence()
+    {
+        Assert.That(ConfidenceOf(CreateUnusedMember(AccessLevel.Internal)), Is.EqualTo(DeadCodeConfidence.High));
+    }
+
+    [Test]
+    public void PublicMember_IsMediumConfidence()
+    {
+        // A caller could sit in code we never analyzed.
+        Assert.That(ConfidenceOf(CreateUnusedMember(AccessLevel.Public)), Is.EqualTo(DeadCodeConfidence.Medium));
+    }
+
+    [Test]
+    public void ProtectedMember_IsMediumConfidence()
+    {
+        // A derived class in another assembly could override or call it.
+        Assert.That(ConfidenceOf(CreateUnusedMember(AccessLevel.Protected)), Is.EqualTo(DeadCodeConfidence.Medium));
+    }
+
+    [Test]
+    public void UnknownVisibility_IsMediumConfidence()
+    {
+        // What every importer other than the C# parser produces. "No information" must not be read as
+        // "confined", so the finding cannot reach the top level.
+        Assert.That(ConfidenceOf(CreateUnusedMember(AccessLevel.Unknown)), Is.EqualTo(DeadCodeConfidence.Medium));
+    }
+
+    [Test]
+    public void PublicMemberOfAnInternalClass_IsHighConfidence()
+    {
+        // The effective reach is what counts: a public method of an internal class cannot be called from
+        // another assembly either.
+        var unused = CreateUnusedMember(AccessLevel.Public, AccessLevel.Internal);
+
+        Assert.That(ConfidenceOf(unused), Is.EqualTo(DeadCodeConfidence.High));
+    }
+
+    [Test]
+    public void NoteAboutACallerOutsideTheGraph_IsLowConfidence()
+    {
+        var type = _graph.CreateClass("Command", accessLevel: AccessLevel.Internal);
+        var used = _graph.CreateMethod("Command.Used", type, AccessLevel.Private);
+        var execute = _graph.CreateMethod("Command.Execute", type, AccessLevel.Private);
+
+        var program = _graph.CreateClass("Program");
+        var main = _graph.CreateMethod("Main", program);
+        Rel(main, used, RelationshipType.Calls);
+
+        var store = new ExternalContractStore();
+        store.Add(execute.Id, "ICommand.Execute");
+
+        // Private and internal would say "high", but we know the framework calls it - the note wins.
+        Assert.That(ConfidenceOf(execute, store), Is.EqualTo(DeadCodeConfidence.Low));
+    }
+
+    /// <summary>
+    ///     A view model with one used and one unused property. The recorded notifying type is what tells
+    ///     the analysis that a {Binding} may read the public properties. Where the interface is
+    ///     implemented - own code, an internal base, an external base like ObservableObject - makes no
+    ///     difference here; that distinction lives in the parser (see NotifyingTypeParseTests).
+    /// </summary>
+    private (CodeElement Unused, ExternalContractStore Store) CreateViewModel(AccessLevel propertyAccess,
+        AccessLevel typeAccess = AccessLevel.Internal)
+    {
+        var viewModel = _graph.CreateClass("MainViewModel", accessLevel: typeAccess);
+        var used = _graph.CreateMethod("MainViewModel.Used", viewModel, AccessLevel.Public);
+        var unused = _graph.CreateProperty("MainViewModel.Title", viewModel);
+        unused = Retype(unused, propertyAccess);
+
+        var program = _graph.CreateClass("Program");
+        var main = _graph.CreateMethod("Main", program);
+        Rel(main, used, RelationshipType.Calls);
+
+        var store = new ExternalContractStore();
+        store.AddNotifyingType(viewModel.Id);
+        return (unused, store);
+    }
+
+    /// <summary>TestCodeGraph has no accessibility overload for properties - replace the element.</summary>
+    private CodeElement Retype(CodeElement element, AccessLevel accessLevel)
+    {
+        var replacement = new CodeElement(element.Id, element.ElementType, element.Name, element.FullName,
+            element.Parent) { AccessLevel = accessLevel };
+        element.Parent?.Children.Remove(element);
+        element.Parent?.Children.Add(replacement);
+        _graph.Nodes[replacement.Id] = replacement;
+        return replacement;
+    }
+
+    [Test]
+    public void ObsoleteMember_StaysHighConfidence()
+    {
+        // [Obsolete] argues for deleting the element, not against it - it must not count as a doubt
+        // about a caller outside the graph.
+        var unused = CreateUnusedMember(AccessLevel.Private);
+        unused.Attributes.Add("Obsolete");
+
+        Assert.That(ConfidenceOf(unused), Is.EqualTo(DeadCodeConfidence.High));
+    }
+
+    [Test]
+    public void UnknownAttributeOnAMember_IsLowConfidence()
+    {
+        // Everything not on the tooling list keeps the doubt: a custom or framework attribute usually
+        // means some runtime finds the element by reflection.
+        var unused = CreateUnusedMember(AccessLevel.Private);
+        unused.Attributes.Add("Export");
+
+        Assert.That(ConfidenceOf(unused), Is.EqualTo(DeadCodeConfidence.Low));
+    }
+
+    [Test]
+    public void PublicPropertyOnANotifyingType_IsNotHighConfidence()
+    {
+        // A XAML {Binding} reaches exactly this and is invisible to the analysis.
+        var (unused, store) = CreateViewModel(AccessLevel.Public);
+
+        Assert.That(ConfidenceOf(unused, store), Is.EqualTo(DeadCodeConfidence.Medium));
+    }
+
+    [Test]
+    public void PrivatePropertyOnANotifyingType_StaysHighConfidence()
+    {
+        // The binding engine resolves by public reflection, so it can never reach this one.
+        var (unused, store) = CreateViewModel(AccessLevel.Private);
+
+        Assert.That(ConfidenceOf(unused, store), Is.EqualTo(DeadCodeConfidence.High));
+    }
+
+    [Test]
+    public void PublicPropertyOnAnOrdinaryType_StaysHighConfidence()
+    {
+        // Without the notification contract there is no reason to suspect a binding.
+        var type = _graph.CreateClass("Options", accessLevel: AccessLevel.Internal);
+        var used = _graph.CreateMethod("Options.Used", type, AccessLevel.Public);
+        var unused = Retype(_graph.CreateProperty("Options.Title", type), AccessLevel.Public);
+
+        var program = _graph.CreateClass("Program");
+        var main = _graph.CreateMethod("Main", program);
+        Rel(main, used, RelationshipType.Calls);
+
+        Assert.That(ConfidenceOf(unused), Is.EqualTo(DeadCodeConfidence.High));
+    }
+
+}
diff --git a/Tests/UnitTests/DeadCode/DeadCodeParseTests.cs b/Tests/UnitTests/DeadCode/DeadCodeParseTests.cs
new file mode 100644
index 00000000..f7c57547
--- /dev/null
+++ b/Tests/UnitTests/DeadCode/DeadCodeParseTests.cs
@@ -0,0 +1,100 @@
+using CodeParserTests.UnitTests.Parser;
+using CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+
+namespace CodeParserTests.UnitTests.DeadCode;
+
+/// <summary>
+///     End-to-end check of the dead code analysis against a real parse result: the synthetic graph tests
+///     pin the rules, this fixture proves the rules match what the parser actually produces.
+/// </summary>
+[TestFixture]
+public class DeadCodeParseTests : InMemoryParseTestBase
+{
+    protected override string Code => """
+                                      namespace Demo;
+
+                                      public interface IService
+                                      {
+                                          void Run();
+                                          void NeverCalled();
+                                      }
+
+                                      public class Service : IService
+                                      {
+                                          private readonly int _used = 1;
+                                          private readonly int _unused = 2;
+
+                                          public void Run() { Helper.Help(_used); }
+                                          public void NeverCalled() { }
+                                          private void PrivateUnused() { }
+                                      }
+
+                                      public static class Helper
+                                      {
+                                          public static void Help(int x) { }
+                                          public static void UnusedHelp() { }
+                                      }
+
+                                      public class DeadClass
+                                      {
+                                          public void A() { B(); }
+                                          private void B() { }
+                                      }
+
+                                      public class Program
+                                      {
+                                          public static void Main()
+                                          {
+                                              IService service = new Service();
+                                              service.Run();
+                                          }
+                                      }
+                                      """;
+
+    private string[] Reported()
+    {
+        return DeadCodeAnalysis.Calculate(Graph).Select(f => PathOf(f.Element)).ToArray();
+    }
+
+    [Test]
+    public void Calculate_ReportsExactlyTheUnreferencedElements()
+    {
+        // Service and Helper are reached from Main, IService.Run through the interface call.
+        // DeadClass only calls itself, Program is only the entry point holder.
+        Assert.That(Reported(), Is.EquivalentTo(new[]
+        {
+            "DeadClass",
+            "Program",
+            "Helper.UnusedHelp",
+            "IService.NeverCalled",
+            "Service.NeverCalled",
+            "Service.PrivateUnused",
+            "Service._unused"
+        }));
+    }
+
+    [Test]
+    public void Calculate_MainHolder_CarriesEntryPointHint()
+    {
+        var program = DeadCodeAnalysis.Calculate(Graph).Single(f => PathOf(f.Element) == "Program");
+
+        Assert.That(program.Hints.HasFlag(DeadCodeHint.EntryPoint), Is.True);
+    }
+
+    [Test]
+    public void Calculate_UncalledContract_LinksToItsImplementation()
+    {
+        var findings = DeadCodeAnalysis.Calculate(Graph);
+        var contract = findings.Single(f => PathOf(f.Element) == "IService.NeverCalled");
+        var implementation = findings.Single(f => PathOf(f.Element) == "Service.NeverCalled");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(contract.Hints.HasFlag(DeadCodeHint.ContractNeverCalled), Is.True);
+            Assert.That(contract.RelatedMembers.Select(PathOf), Is.EquivalentTo(new[] { "Service.NeverCalled" }));
+
+            Assert.That(implementation.Hints.HasFlag(DeadCodeHint.ImplementsDeadContract), Is.True);
+            Assert.That(implementation.RelatedMembers.Select(PathOf), Is.EquivalentTo(new[] { "IService.NeverCalled" }));
+        });
+    }
+}
diff --git a/Tests/UnitTests/DeadCode/DeadCodeTestOnlyTests.cs b/Tests/UnitTests/DeadCode/DeadCodeTestOnlyTests.cs
new file mode 100644
index 00000000..d66d18aa
--- /dev/null
+++ b/Tests/UnitTests/DeadCode/DeadCodeTestOnlyTests.cs
@@ -0,0 +1,277 @@
+using CodeParserTests.Helper;
+using CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+
+namespace CodeParserTests.UnitTests.DeadCode;
+
+/// <summary>
+///     Code that only the tests still use. The rule exists because without it, analyzing the tests along
+///     with the production code hides exactly these elements - they look referenced.
+/// </summary>
+[TestFixture]
+public class DeadCodeTestOnlyTests
+{
+    [SetUp]
+    public void SetUp()
+    {
+        _graph = new TestCodeGraph();
+        _production = _graph.CreateAssembly("Production");
+        _tests = _graph.CreateAssembly("Tests");
+    }
+
+    private TestCodeGraph _graph = null!;
+    private CodeElement _production = null!;
+    private CodeElement _tests = null!;
+
+    private void Rel(CodeElement source, CodeElement target, RelationshipType type)
+    {
+        source.Relationships.Add(new Relationship(source.Id, target.Id, type));
+    }
+
+    /// <summary>A test class - the attribute is what makes it a test type.</summary>
+    private CodeElement CreateTestClass(string id)
+    {
+        var element = _graph.CreateClass(id, _tests);
+        element.Attributes.Add("TestFixture");
+        return element;
+    }
+
+    private string[] Reported()
+    {
+        return DeadCodeAnalysis.Calculate(_graph).Select(f => f.Element.FullName).ToArray();
+    }
+
+    private DeadCodeFinding FindingFor(CodeElement element)
+    {
+        return DeadCodeAnalysis.Calculate(_graph).Single(f => f.Element.Id == element.Id);
+    }
+
+    [Test]
+    public void Calculate_ClassOnlyUsedByATest_IsReportedWithTheTestAsReference()
+    {
+        var helper = _graph.CreateClass("Helper", _production);
+        var test = CreateTestClass("HelperTests");
+        Rel(test, helper, RelationshipType.Uses);
+
+        var finding = FindingFor(helper);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(finding.Hints.HasFlag(DeadCodeHint.UsedOnlyByTests), Is.True);
+            Assert.That(finding.TestReferences.Select(m => m.FullName), Is.EqualTo(new[] { "HelperTests" }));
+        });
+    }
+
+    [Test]
+    public void Calculate_ClassUsedByProductionAndByATest_IsNotReported()
+    {
+        var helper = _graph.CreateClass("Helper", _production);
+        var caller = _graph.CreateClass("Caller", _production);
+        Rel(caller, helper, RelationshipType.Uses);
+        Rel(CreateTestClass("HelperTests"), helper, RelationshipType.Uses);
+
+        Assert.That(Reported(), Does.Not.Contain("Helper"));
+    }
+
+    /// <summary>
+    ///     The accepted price of the type granularity: a helper class outside the fixtures carries no
+    ///     attribute, so to the analysis it is production code that only tests use. The statement is
+    ///     true - the helper goes when the tests go - it is just noise when the helper is doing its job.
+    /// </summary>
+    [Test]
+    public void Calculate_TestHelperClassUsedByTests_IsReportedAsUsedOnlyByTests()
+    {
+        var helper = _graph.CreateClass("TestDataBuilder", _tests);
+        Rel(CreateTestClass("SomeTests"), helper, RelationshipType.Uses);
+
+        Assert.That(FindingFor(helper).Hints.HasFlag(DeadCodeHint.UsedOnlyByTests), Is.True);
+    }
+
+    /// <summary>
+    ///     Inside a fixture the rule stays off: the helper members and nested fakes are what the tests
+    ///     are made of. Only the fixture itself is reported, as unreferenced test code like always.
+    /// </summary>
+    [Test]
+    public void Calculate_HelpersInsideAFixture_AreNotReportedSeparately()
+    {
+        var fixture = CreateTestClass("SomeTests");
+        var test = _graph.CreateMethod("SomeTests.ShouldWork", fixture);
+        test.Attributes.Add("Test");
+
+        var helper = _graph.CreateMethod("SomeTests.CreateSut", fixture);
+        var fake = _graph.CreateClass("SomeTests.FakeService", fixture);
+        var fakeMethod = _graph.CreateMethod("SomeTests.FakeService.Run", fake);
+        Rel(test, helper, RelationshipType.Calls);
+        Rel(test, fakeMethod, RelationshipType.Calls);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "SomeTests" }));
+    }
+
+    /// <summary>
+    ///     xUnit has no class-level attribute - only the [Fact] methods carry one. The attributed member
+    ///     marks the class, so the references of its unattributed members are test references too.
+    /// </summary>
+    [Test]
+    public void Calculate_ClassWithOnlyMethodAttributes_IsATestTypeAsAWhole()
+    {
+        var fixture = _graph.CreateClass("FactTests", _tests);
+        var fact = _graph.CreateMethod("FactTests.ShouldWork", fixture);
+        fact.Attributes.Add("Fact");
+        var plain = _graph.CreateMethod("FactTests.Verify", fixture);
+
+        var helper = _graph.CreateClass("Helper", _production);
+        Rel(plain, helper, RelationshipType.Uses);
+
+        Assert.That(FindingFor(helper).Hints.HasFlag(DeadCodeHint.UsedOnlyByTests), Is.True);
+    }
+
+    /// <summary>
+    ///     The reason for the type granularity: with the whole assembly classified, one embedded test
+    ///     class made every reference leaving the assembly a test reference, and code in other
+    ///     assemblies used from ordinary production code was falsely used-only-by-tests.
+    /// </summary>
+    [Test]
+    public void Calculate_EmbeddedTestClass_DoesNotPoisonItsAssembly()
+    {
+        var caller = _graph.CreateClass("Caller", _production);
+        _graph.CreateClass("SmokeTests", _production).Attributes.Add("TestFixture");
+
+        var library = _graph.CreateAssembly("Library");
+        var helper = _graph.CreateClass("Helper", library);
+        Rel(caller, helper, RelationshipType.Uses);
+
+        Assert.That(Reported(), Does.Not.Contain("Helper"));
+    }
+
+    /// <summary>
+    ///     The other direction the assembly rule got wrong: production code beside the embedded tests,
+    ///     used only by them, was never found - the whole assembly was exempt.
+    /// </summary>
+    [Test]
+    public void Calculate_ProductionCodeOnlyUsedByAnEmbeddedTest_IsReported()
+    {
+        var service = _graph.CreateClass("Service", _production);
+        var smokeTests = _graph.CreateClass("SmokeTests", _production);
+        smokeTests.Attributes.Add("TestFixture");
+        Rel(smokeTests, service, RelationshipType.Uses);
+
+        Assert.That(FindingFor(service).Hints.HasFlag(DeadCodeHint.UsedOnlyByTests), Is.True);
+    }
+
+    /// <summary>
+    ///     Matching is case-sensitive: the framework attribute names are exact, and a domain attribute
+    ///     that happens to be called "test" must not turn its class into test code.
+    /// </summary>
+    [Test]
+    public void Calculate_LowercaseTestAttribute_DoesNotMarkTestCode()
+    {
+        var caller = _graph.CreateClass("AbTestRunner", _production);
+        caller.Attributes.Add("test");
+
+        var helper = _graph.CreateClass("Helper", _production);
+        Rel(caller, helper, RelationshipType.Uses);
+
+        Assert.That(Reported(), Does.Not.Contain("Helper"));
+    }
+
+    /// <summary>The test class itself is unreferenced as ever, and keeps saying so.</summary>
+    [Test]
+    public void Calculate_TestClassItself_IsStillReportedAsTestCode()
+    {
+        var test = CreateTestClass("SomeTests");
+
+        var finding = FindingFor(test);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(finding.Hints.HasFlag(DeadCodeHint.TestCode), Is.True);
+            Assert.That(finding.Hints.HasFlag(DeadCodeHint.UsedOnlyByTests), Is.False);
+            Assert.That(finding.Confidence, Is.EqualTo(DeadCodeConfidence.Low));
+        });
+    }
+
+    /// <summary>
+    ///     The cap: unreferenced and internal would be the highest confidence, but something demonstrably
+    ///     references this one - whether the test alone justifies keeping it is a decision, not a fact.
+    /// </summary>
+    [Test]
+    public void Calculate_InternalClassOnlyUsedByATest_IsCappedAtMedium()
+    {
+        var helper = _graph.CreateClass("Helper", _production, accessLevel: AccessLevel.Internal);
+        Rel(CreateTestClass("HelperTests"), helper, RelationshipType.Uses);
+
+        var unreferenced = _graph.CreateClass("Unused", _production, accessLevel: AccessLevel.Internal);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(FindingFor(helper).Confidence, Is.EqualTo(DeadCodeConfidence.Medium));
+
+            // Same visibility, nothing referencing it at all - the level the cap takes away.
+            Assert.That(FindingFor(unreferenced).Confidence, Is.EqualTo(DeadCodeConfidence.High));
+        });
+    }
+
+    /// <summary>
+    ///     Liveness travelling from a contract member to its implementations has to keep the colour.
+    ///     Production calling the contract keeps the implementation alive.
+    /// </summary>
+    [Test]
+    public void Calculate_ImplementationOfAContractProductionCalls_IsNotReported()
+    {
+        var contract = _graph.CreateInterface("IService", _production);
+        var contractMethod = _graph.CreateMethod("IService.Run", contract);
+
+        var service = _graph.CreateClass("Service", _production);
+        var implementation = _graph.CreateMethod("Service.Run", service);
+        Rel(implementation, contractMethod, RelationshipType.Implements);
+
+        var caller = _graph.CreateClass("Caller", _production);
+        Rel(caller, contractMethod, RelationshipType.Calls);
+
+        Assert.That(Reported(), Does.Not.Contain("Service.Run"));
+    }
+
+    /// <summary>
+    ///     ...and a test calling the contract does not. The hint is set although no caller can be named:
+    ///     liveness arriving through a contract member is not an edge.
+    /// </summary>
+    [Test]
+    public void Calculate_ImplementationOfAContractOnlyTestsCall_IsReported()
+    {
+        var contract = _graph.CreateInterface("IService", _production);
+        var contractMethod = _graph.CreateMethod("IService.Run", contract);
+
+        var service = _graph.CreateClass("Service", _production);
+        var implementation = _graph.CreateMethod("Service.Run", service);
+        Rel(implementation, contractMethod, RelationshipType.Implements);
+
+        // Production uses the type, so the finding stays on the method instead of being rolled up.
+        Rel(_graph.CreateClass("User", _production), service, RelationshipType.Uses);
+
+        Rel(CreateTestClass("ServiceTests"), contractMethod, RelationshipType.Calls);
+
+        var finding = FindingFor(implementation);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(finding.Hints.HasFlag(DeadCodeHint.UsedOnlyByTests), Is.True);
+            Assert.That(finding.TestReferences, Is.Empty);
+            Assert.That(finding.Confidence, Is.EqualTo(DeadCodeConfidence.Medium));
+        });
+    }
+
+    /// <summary>
+    ///     A graph without any test attribute has no test assembly, so nothing changes for it - this is
+    ///     what every importer-produced graph looks like.
+    /// </summary>
+    [Test]
+    public void Calculate_GraphWithoutTests_ReportsOnlyTheUnreferencedElements()
+    {
+        var used = _graph.CreateClass("Used", _production);
+        _graph.CreateClass("Unused", _production);
+        var caller = _graph.CreateClass("Caller", _production);
+        Rel(caller, used, RelationshipType.Uses);
+
+        Assert.That(Reported(), Is.EquivalentTo(new[] { "Unused", "Caller" }));
+    }
+}
diff --git a/Tests/UnitTests/DynamicDataGrid/TableCsvTests.cs b/Tests/UnitTests/DynamicDataGrid/TableCsvTests.cs
new file mode 100644
index 00000000..9d02a059
--- /dev/null
+++ b/Tests/UnitTests/DynamicDataGrid/TableCsvTests.cs
@@ -0,0 +1,76 @@
+using CSharpCodeAnalyst.AnalyzerSdk.DynamicDataGrid.Contracts.TabularData;
+
+namespace CodeParserTests.UnitTests.DynamicDataGrid;
+
+[TestFixture]
+public class TableCsvTests
+{
+    private static readonly TableColumnDefinition[] Columns =
+    [
+        new() { Header = "Name", PropertyName = nameof(Row.Name) },
+        new() { Header = "Count", PropertyName = nameof(Row.Count) },
+        new() { Header = "Note", PropertyName = nameof(Row.Note) }
+    ];
+
+    private static string[] Lines(string csv)
+    {
+        return csv.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+    }
+
+    [Test]
+    public void Build_WritesTheHeaderAndOneLinePerRow()
+    {
+        var csv = TableCsv.Build(Columns, [new Row("A", 1, null), new Row("B", 2, null)], ";");
+
+        Assert.That(Lines(csv), Is.EqualTo(new[] { "Name;Count;Note", "A;1;", "B;2;" }));
+    }
+
+    [Test]
+    public void Build_ValueContainingTheSeparator_IsQuoted()
+    {
+        var csv = TableCsv.Build(Columns, [new Row("A", 1, "used by X; and Y")], ";");
+
+        Assert.That(Lines(csv)[1], Is.EqualTo("A;1;\"used by X; and Y\""));
+    }
+
+    /// <summary>A comma separator must not quote a value that merely contains a semicolon, and vice versa.</summary>
+    [Test]
+    public void Build_QuotingFollowsTheChosenSeparator()
+    {
+        var csv = TableCsv.Build(Columns, [new Row("A", 1, "used by X; and Y")], ",");
+
+        Assert.That(Lines(csv)[1], Is.EqualTo("A,1,used by X; and Y"));
+    }
+
+    [Test]
+    public void Build_QuotesAndLineBreaks_AreEscaped()
+    {
+        var csv = TableCsv.Build(Columns, [new Row("A", 1, "say \"hi\"\nagain")], ";");
+
+        Assert.That(csv, Does.Contain("\"say \"\"hi\"\"\nagain\""));
+    }
+
+    /// <summary>A column bound to nothing (a button, an image) must not break the row.</summary>
+    [Test]
+    public void Build_ColumnWithoutAProperty_YieldsAnEmptyCell()
+    {
+        TableColumnDefinition[] columns =
+        [
+            new() { Header = "Name", PropertyName = nameof(Row.Name) },
+            new() { Header = "Action", PropertyName = string.Empty },
+            new() { Header = "Unknown", PropertyName = "DoesNotExist" }
+        ];
+
+        var csv = TableCsv.Build(columns, [new Row("A", 1, null)], ";");
+
+        Assert.That(Lines(csv), Is.EqualTo(new[] { "Name;Action;Unknown", "A;;" }));
+    }
+
+    [Test]
+    public void Build_WithoutRows_StillWritesTheHeader()
+    {
+        Assert.That(Lines(TableCsv.Build(Columns, [], ";")), Is.EqualTo(new[] { "Name;Count;Note" }));
+    }
+
+    private sealed record Row(string Name, int Count, string? Note);
+}
diff --git a/Tests/UnitTests/Parser/ExternalContractParseTests.cs b/Tests/UnitTests/Parser/ExternalContractParseTests.cs
new file mode 100644
index 00000000..bcac07f2
--- /dev/null
+++ b/Tests/UnitTests/Parser/ExternalContractParseTests.cs
@@ -0,0 +1,142 @@
+using CSharpCodeAnalyst.CodeGraph.Declarations;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+using CSharpCodeAnalyst.CodeParser.Parser.Config;
+
+namespace CodeParserTests.UnitTests.Parser;
+
+/// <summary>
+///     A member that implements or overrides something from outside the analyzed code has no incoming
+///     reference anywhere in the graph - the framework is the caller. The relationship model cannot carry
+///     the fact, so the parser records it in the <see cref="ExternalContractStore" /> beside the graph.
+///     This fixture pins both routes: the "override" keyword and an implicit interface implementation.
+/// </summary>
+[TestFixture]
+public class ExternalContractParseTests
+{
+    [OneTimeSetUp]
+    public async Task ParseCode()
+    {
+        const string code = """
+                            using System;
+                            using System.Collections;
+
+                            namespace Demo;
+
+                            public interface IOwn
+                            {
+                                void Handle();
+                            }
+
+                            public class Widget : IDisposable, IOwn
+                            {
+                                // Implicit implementation of a framework interface - no "override" keyword.
+                                public void Dispose() { }
+
+                                // Implementation of one of our own interfaces: a real Implements edge exists.
+                                public void Handle() { }
+
+                                // Overrides a framework member.
+                                public override string ToString() => "widget";
+
+                                // Neither. Nothing keeps this alive.
+                                public void Unused() { }
+
+                                // Overrides a framework member declared as a property.
+                                public override int GetHashCode() => 0;
+                            }
+
+                            public abstract class OwnBase
+                            {
+                                public abstract void Run();
+                            }
+
+                            public class OwnDerived : OwnBase
+                            {
+                                // Overrides one of ours: a real Overrides edge exists.
+                                public override void Run() { }
+                            }
+
+                            public class Sequence : IEnumerable
+                            {
+                                public IEnumerator GetEnumerator() => throw new NotImplementedException();
+                            }
+                            """;
+
+        var parser = new CSharpCodeAnalyst.CodeParser.Parser.Parser(
+            new ParserConfig(new ProjectExclusionRegExCollection(), false));
+        var result = await parser.ParseSourceAsync(code);
+
+        _graph = result.CodeGraph;
+        _contracts = result.ExternalContracts;
+    }
+
+    private CodeGraph _graph = null!;
+    private ExternalContractStore _contracts = null!;
+
+    private string? ContractOf(string path)
+    {
+        var element = _graph.Nodes.Values.Single(n => PathOf(n) == path);
+        return _contracts.TryGet(element.Id);
+    }
+
+    private static string PathOf(CodeElement element)
+    {
+        var parts = new List<string>();
+        var current = element;
+        while (current is not null && current.ElementType is not (CodeElementType.Namespace or CodeElementType.Assembly))
+        {
+            parts.Insert(0, current.Name);
+            current = current.Parent;
+        }
+
+        return string.Join(".", parts);
+    }
+
+    [Test]
+    public void ImplicitImplementationOfAFrameworkInterface_IsRecorded()
+    {
+        Assert.That(ContractOf("Widget.Dispose"), Is.EqualTo("IDisposable.Dispose"));
+    }
+
+    [Test]
+    public void OverrideOfAFrameworkMember_IsRecorded()
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(ContractOf("Widget.ToString"), Is.EqualTo("Object.ToString"));
+            Assert.That(ContractOf("Widget.GetHashCode"), Is.EqualTo("Object.GetHashCode"));
+        });
+    }
+
+    [Test]
+    public void ImplementationOfAFrameworkInterfaceOnAnotherType_IsRecorded()
+    {
+        Assert.That(ContractOf("Sequence.GetEnumerator"), Is.EqualTo("IEnumerable.GetEnumerator"));
+    }
+
+    [Test]
+    public void ImplementationOfOurOwnInterface_IsNotRecorded()
+    {
+        // The graph already has the Implements edge; the dead code analysis propagates liveness along it.
+        Assert.That(ContractOf("Widget.Handle"), Is.Null);
+    }
+
+    [Test]
+    public void OverrideOfOurOwnBaseClass_IsNotRecorded()
+    {
+        Assert.That(ContractOf("OwnDerived.Run"), Is.Null);
+    }
+
+    [Test]
+    public void OrdinaryMember_IsNotRecorded()
+    {
+        Assert.That(ContractOf("Widget.Unused"), Is.Null);
+    }
+
+    [Test]
+    public void TheTypeItself_IsNeverRecorded()
+    {
+        // Implementing IDisposable is not a use of the class - it must still be reportable as dead code.
+        Assert.That(ContractOf("Widget"), Is.Null);
+    }
+}
diff --git a/Tests/UnitTests/Parser/GeneratedCodeTests.cs b/Tests/UnitTests/Parser/GeneratedCodeTests.cs
new file mode 100644
index 00000000..0d0a2f12
--- /dev/null
+++ b/Tests/UnitTests/Parser/GeneratedCodeTests.cs
@@ -0,0 +1,99 @@
+using CSharpCodeAnalyst.CodeGraph.Graph;
+using CSharpCodeAnalyst.CodeParser.Parser;
+using CSharpCodeAnalyst.CodeParser.Parser.Config;
+
+namespace CodeParserTests.UnitTests.Parser;
+
+/// <summary>
+///     Generated code is always parsed - it holds relationships nothing else does - and marked instead, so
+///     a result can leave out what nobody can edit anyway.
+/// </summary>
+[TestFixture]
+public class GeneratedCodeTests
+{
+    private const string Code = """
+                                namespace Demo;
+
+                                public class Widget
+                                {
+                                    public void Run() { }
+                                }
+                                """;
+
+    private static async Task<CodeElement> ParseWidget(string code, string documentPath)
+    {
+        var parser = new CSharpCodeAnalyst.CodeParser.Parser.Parser(
+            new ParserConfig(new ProjectExclusionRegExCollection(), false));
+        var result = await parser.ParseSourceAsync(code, documentPath);
+
+        return result.CodeGraph.Nodes.Values.Single(n => n.Name == "Widget");
+    }
+
+    [Test]
+    public async Task Parse_HandWrittenFile_IsNotMarked()
+    {
+        Assert.That((await ParseWidget(Code, "Widget.cs")).IsGenerated, Is.False);
+    }
+
+    [TestCase("Widget.g.cs")]
+    [TestCase("Widget.g.i.cs")]
+    [TestCase("Widget.Designer.cs")]
+    [TestCase("Widget.generated.cs")]
+    [TestCase("TemporaryGeneratedFile_Widget.cs")]
+    public async Task Parse_GeneratedFileName_IsMarked(string documentPath)
+    {
+        Assert.That((await ParseWidget(Code, documentPath)).IsGenerated, Is.True);
+    }
+
+    [Test]
+    public async Task Parse_AutoGeneratedHeader_IsMarked()
+    {
+        // What catches the files the name list does not - the AssemblyInfo under obj, and anything a tool
+        // writes under its own name.
+        var code = "// <auto-generated />" + Environment.NewLine + Code;
+
+        Assert.That((await ParseWidget(code, "Widget.cs")).IsGenerated, Is.True);
+    }
+
+    [Test]
+    public async Task Parse_AutoGeneratedCommentBelowTheFirstToken_IsNotMarked()
+    {
+        // Otherwise a file merely talking about generated code would count.
+        var code = Code + Environment.NewLine + "// <auto-generated> is what a tool would write here.";
+
+        Assert.That((await ParseWidget(code, "Widget.cs")).IsGenerated, Is.False);
+    }
+
+    /// <summary>
+    ///     The partial case, which is why the rule asks about *every* declaration: a WPF code-behind class
+    ///     lives in MainWindow.xaml.cs and MainWindow.g.cs at once. Only what exists nowhere but the
+    ///     generated file is generated.
+    /// </summary>
+    [Test]
+    public void IsGeneratedElement_DecidesOverAllDeclarations()
+    {
+        var generatedFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { @"C:\p\MainWindow.g.cs" };
+
+        var partialType = Element(@"C:\p\MainWindow.xaml.cs", @"C:\p\MainWindow.g.cs");
+        var generatedOnly = Element(@"C:\p\MainWindow.g.cs");
+        var handWritten = Element(@"C:\p\MainWindow.xaml.cs");
+        var withoutLocation = Element();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(GeneratedCode.IsGeneratedElement(partialType, generatedFiles), Is.False);
+            Assert.That(GeneratedCode.IsGeneratedElement(generatedOnly, generatedFiles), Is.True);
+            Assert.That(GeneratedCode.IsGeneratedElement(handWritten, generatedFiles), Is.False);
+
+            // An assembly or a namespace has no declaration of its own.
+            Assert.That(GeneratedCode.IsGeneratedElement(withoutLocation, generatedFiles), Is.False);
+        });
+    }
+
+    private static CodeElement Element(params string[] files)
+    {
+        var element = new CodeElement("id", CodeElementType.Class, "MainWindow", "MainWindow", null);
+        element.SourceLocations.AddRange(files.Select(file => new SourceLocation(file, 1, 1)));
+        return element;
+    }
+}
diff --git a/Tests/UnitTests/Parser/NotifyingTypeParseTests.cs b/Tests/UnitTests/Parser/NotifyingTypeParseTests.cs
new file mode 100644
index 00000000..d6959cf8
--- /dev/null
+++ b/Tests/UnitTests/Parser/NotifyingTypeParseTests.cs
@@ -0,0 +1,92 @@
+using CSharpCodeAnalyst.CodeGraph.Declarations;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+using CSharpCodeAnalyst.CodeParser.Parser.Config;
+
+namespace CodeParserTests.UnitTests.Parser;
+
+/// <summary>
+///     A XAML {Binding} reads the public properties of any type implementing INotifyPropertyChanged, so
+///     the parser records those types beside the graph (<see cref="ExternalContractStore.NotifyingTypes" />).
+///     The case that forces the type-level set is the external base class: a view model deriving from
+///     ObservableObject or BindableBase has no PropertyChanged member of its own, so neither the graph nor
+///     the member-level contracts can tell it apart from an ordinary class.
+/// </summary>
+[TestFixture]
+public class NotifyingTypeParseTests
+{
+    [OneTimeSetUp]
+    public async Task ParseCode()
+    {
+        const string code = """
+                            using System.Collections.ObjectModel;
+                            using System.ComponentModel;
+
+                            namespace Demo;
+
+                            public class DirectViewModel : INotifyPropertyChanged
+                            {
+                                public event PropertyChangedEventHandler? PropertyChanged;
+                                public string? Title { get; set; }
+                            }
+
+                            public class DerivedViewModel : DirectViewModel
+                            {
+                                public string? Caption { get; set; }
+                            }
+
+                            // The implementation sits in a base class outside the analyzed code.
+                            public class ExternalBaseViewModel : ObservableCollection<int>
+                            {
+                                public string? Header { get; set; }
+                            }
+
+                            public class Ordinary
+                            {
+                                public string? Name { get; set; }
+                            }
+                            """;
+
+        var parser = new CSharpCodeAnalyst.CodeParser.Parser.Parser(
+            new ParserConfig(new ProjectExclusionRegExCollection(), false));
+        var result = await parser.ParseSourceAsync(code);
+
+        _graph = result.CodeGraph;
+        _contracts = result.ExternalContracts;
+    }
+
+    private CodeGraph _graph = null!;
+    private ExternalContractStore _contracts = null!;
+
+    private bool IsNotifying(string typeName)
+    {
+        var element = _graph.Nodes.Values.Single(n =>
+            n.ElementType == CodeElementType.Class && n.Name == typeName);
+        return _contracts.NotifyingTypes.Contains(element.Id);
+    }
+
+    [Test]
+    public void DirectImplementation_IsRecorded()
+    {
+        Assert.That(IsNotifying("DirectViewModel"), Is.True);
+    }
+
+    [Test]
+    public void DerivedFromAnInternalImplementer_IsRecorded()
+    {
+        Assert.That(IsNotifying("DerivedViewModel"), Is.True);
+    }
+
+    [Test]
+    public void DerivedFromAnExternalImplementer_IsRecorded()
+    {
+        // The reason the set exists: no PropertyChanged member in the graph, no internal base to spread
+        // from - only the symbol knows.
+        Assert.That(IsNotifying("ExternalBaseViewModel"), Is.True);
+    }
+
+    [Test]
+    public void OrdinaryType_IsNotRecorded()
+    {
+        Assert.That(IsNotifying("Ordinary"), Is.False);
+    }
+}
diff --git a/Tests/UnitTests/Parser/RuntimeInvokedMemberParseTests.cs b/Tests/UnitTests/Parser/RuntimeInvokedMemberParseTests.cs
new file mode 100644
index 00000000..5c7d98d6
--- /dev/null
+++ b/Tests/UnitTests/Parser/RuntimeInvokedMemberParseTests.cs
@@ -0,0 +1,69 @@
+using CSharpCodeAnalyst.CodeGraph.Algorithms.DeadCode;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+using CSharpCodeAnalyst.CodeParser.Parser.Config;
+
+namespace CodeParserTests.UnitTests.Parser;
+
+/// <summary>
+///     A destructor and a static constructor reach the graph as ordinary methods named "Finalize" and
+///     ".cctor" - the Roslyn symbol names. The dead code analysis relies on exactly these names to drop
+///     them: no code can reference either, the runtime calls them.
+/// </summary>
+[TestFixture]
+public class RuntimeInvokedMemberParseTests
+{
+    [OneTimeSetUp]
+    public async Task ParseCode()
+    {
+        const string code = """
+                            namespace Demo;
+
+                            public class Widget
+                            {
+                                static Widget() { }
+
+                                ~Widget() { }
+
+                                public void Used() { }
+                            }
+
+                            public class User
+                            {
+                                public void Run(Widget widget)
+                                {
+                                    widget.Used();
+                                }
+                            }
+                            """;
+
+        var parser = new CSharpCodeAnalyst.CodeParser.Parser.Parser(
+            new ParserConfig(new ProjectExclusionRegExCollection(), false));
+        var result = await parser.ParseSourceAsync(code);
+        _graph = result.CodeGraph;
+    }
+
+    private CodeGraph _graph = null!;
+
+    [Test]
+    public void DestructorAndStaticConstructor_CarryTheRoslynSymbolNames()
+    {
+        var methods = _graph.Nodes.Values
+            .Where(n => n is { ElementType: CodeElementType.Method, Parent.Name: "Widget" })
+            .Select(n => n.Name)
+            .ToList();
+
+        Assert.That(methods, Is.SupersetOf(new[] { ".cctor", "Finalize" }));
+    }
+
+    [Test]
+    public void DeadCodeAnalysis_DoesNotReportThem()
+    {
+        var reported = DeadCodeAnalysis.Calculate(_graph).Select(f => f.Element.Name).ToList();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(reported, Does.Not.Contain(".cctor"));
+            Assert.That(reported, Does.Not.Contain("Finalize"));
+        });
+    }
+}
diff --git a/Tests/UnitTests/Parser/SourceGeneratorFixtureTests.cs b/Tests/UnitTests/Parser/SourceGeneratorFixtureTests.cs
new file mode 100644
index 00000000..e6e03e76
--- /dev/null
+++ b/Tests/UnitTests/Parser/SourceGeneratorFixtureTests.cs
@@ -0,0 +1,121 @@
+using CSharpCodeAnalyst.CodeGraph.Graph;
+using CSharpCodeAnalyst.CodeParser.Parser;
+using CSharpCodeAnalyst.CodeParser.Parser.Config;
+
+namespace CodeParserTests.UnitTests.Parser;
+
+/// <summary>
+///     The source-generator path of the parser, against a real generator.
+///     <para>
+///         This is the one half of the generated-code handling the in-memory tests cannot reach:
+///         <c>GetSourceGeneratedDocumentsAsync</c> needs a real MSBuild project, and the documents it
+///         returns are not on disk. The fixture uses <c>[GeneratedRegex]</c>, which ships with the SDK -
+///         no package reference, and no restore or build of the fixture is required, because the design
+///         time build MSBuildWorkspace performs runs the generator itself.
+///     </para>
+///     <para>
+///         Assertions stay off the generated type names (<c>NumberPattern_0</c>, <c>Utilities</c>): those
+///         are SDK implementation details and change with the version. What is asserted is the shape - who
+///         is marked, who is not, and that the generated code carries its relationships.
+///     </para>
+/// </summary>
+[TestFixture]
+public class SourceGeneratorFixtureTests
+{
+    [OneTimeSetUp]
+    public async Task FixtureSetup()
+    {
+        // Another fixture may have registered it already, which is harmless.
+        try
+        {
+            Initializer.InitializeMsBuildLocator();
+        }
+        catch
+        {
+            // already registered
+        }
+
+        var parser = new CSharpCodeAnalyst.CodeParser.Parser.Parser(
+            new ParserConfig(new ProjectExclusionRegExCollection(), false));
+        _graph = (await parser.ParseAsync(@"..\..\..\..\TestSuiteGenerated\TestSuiteGenerated.sln")).CodeGraph;
+    }
+
+    private CodeGraph _graph = null!;
+
+    private CodeElement Element(string name)
+    {
+        return _graph.Nodes.Values.Single(n => n.FullName.EndsWith("." + name, StringComparison.Ordinal));
+    }
+
+    private static bool IsHandWritten(CodeElement element)
+    {
+        return element.SourceLocations.Any(l => l.File is not null && l.File.EndsWith("Validator.cs",
+            StringComparison.OrdinalIgnoreCase));
+    }
+
+    [Test]
+    public void Parse_GeneratorOutput_ProducesElements()
+    {
+        // Without this the whole path is silently dead and every assertion below would pass vacuously.
+        Assert.That(_graph.Nodes.Values.Count(n => n.IsGenerated), Is.GreaterThan(0));
+    }
+
+    [Test]
+    public void Parse_PartialTypeCompletedByTheGenerator_IsNotMarked()
+    {
+        var validator = Element("Validator");
+
+        Assert.Multiple(() =>
+        {
+            // One declaration here, one in the generator output - so half of it is the user's.
+            Assert.That(validator.SourceLocations, Has.Count.EqualTo(2));
+            Assert.That(IsHandWritten(validator), Is.True);
+            Assert.That(validator.IsGenerated, Is.False);
+        });
+    }
+
+    [Test]
+    public void Parse_PartialMethodImplementedByTheGenerator_IsNotMarked()
+    {
+        // The signature is the user's, the body is the generator's - the same rule one level down.
+        var method = Element("Validator.NumberPattern");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(method.SourceLocations, Has.Count.EqualTo(2));
+            Assert.That(method.IsGenerated, Is.False);
+        });
+    }
+
+    [Test]
+    public void Parse_NothingHandWritten_IsMarked()
+    {
+        var marked = _graph.Nodes.Values.Where(n => n.IsGenerated).Where(IsHandWritten).ToList();
+
+        Assert.That(marked, Is.Empty,
+            "An element with a declaration in Validator.cs must never be marked as generated.");
+    }
+
+    [Test]
+    public void Parse_GeneratedCode_CarriesItsRelationships()
+    {
+        // The reason generated code is never excluded: its edges are the only ones some elements have.
+        var isNumber = Element("Validator.IsNumber");
+        var numberPattern = Element("Validator.NumberPattern");
+
+        var callsIntoTheGenerator = isNumber.Relationships
+            .Any(r => r.TargetId == numberPattern.Id && r.Type == RelationshipType.Calls);
+
+        // The generated Regex subclass is instantiated somewhere in the generator output.
+        var edgesInsideTheGeneratedCode = _graph.Nodes.Values
+            .Where(n => n.IsGenerated)
+            .SelectMany(n => n.Relationships)
+            .Count();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(callsIntoTheGenerator, Is.True);
+            Assert.That(edgesInsideTheGeneratedCode, Is.GreaterThan(0));
+        });
+    }
+}
diff --git a/Tests/UnitTests/Search/SearchExpressionTests.cs b/Tests/UnitTests/Search/SearchExpressionTests.cs
new file mode 100644
index 00000000..7104888c
--- /dev/null
+++ b/Tests/UnitTests/Search/SearchExpressionTests.cs
@@ -0,0 +1,276 @@
+using CSharpCodeAnalyst.AnalyzerSdk.Search;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+
+namespace CodeParserTests.UnitTests.Search;
+
+/// <summary>
+///     Pins the search grammar reachable through <see cref="SearchExpressionFactory" />: AND (space),
+///     OR (pipe), negation (leading minus) and the "type:" / "source:" terms. The same expression feeds
+///     the tree, the graph search, the Advanced Search and every analyzer table, so the behaviour is
+///     shared by all of them.
+/// </summary>
+[TestFixture]
+public class SearchExpressionTests
+{
+    private static CodeElement Element(string fullName, string? name = null,
+        CodeElementType type = CodeElementType.Class, bool isExternal = false, bool isGenerated = false)
+    {
+        return new CodeElement(fullName, type, name ?? fullName, fullName, null)
+        {
+            IsExternal = isExternal,
+            IsGenerated = isGenerated
+        };
+    }
+
+    private static bool Matches(string search, CodeElement? element,
+        SearchExpressionFactory.TextSearchField field = SearchExpressionFactory.TextSearchField.FullName)
+    {
+        return SearchExpressionFactory.CreateSearchExpression(search, field).Evaluate(element);
+    }
+
+    [Test]
+    public void Term_MatchesSubstringOfTheFullName()
+    {
+        var element = Element("App.Resources.Strings.Close_Button");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("resources", element), Is.True);
+            Assert.That(Matches("missing", element), Is.False);
+        });
+    }
+
+    [Test]
+    public void LowerCaseTerm_IsCaseInsensitive()
+    {
+        Assert.That(Matches("strings", Element("App.Resources.Strings.Close")), Is.True);
+    }
+
+    [Test]
+    public void Space_MeansAnd()
+    {
+        var element = Element("App.Resources.Strings.Close");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("resources close", element), Is.True);
+            Assert.That(Matches("resources missing", element), Is.False);
+        });
+    }
+
+    [Test]
+    public void Pipe_MeansOr()
+    {
+        var element = Element("App.Views.MainWindow");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("missing | views", element), Is.True);
+            Assert.That(Matches("missing | absent", element), Is.False);
+        });
+    }
+
+    [Test]
+    public void Or_BindsLessThanAnd()
+    {
+        // "views window | absent" reads as "(views AND window) OR absent".
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("views window | absent", Element("App.Views.MainWindow")), Is.True);
+            Assert.That(Matches("views absent | dialog", Element("App.Other.Dialog")), Is.True);
+            Assert.That(Matches("views absent | missing", Element("App.Views.MainWindow")), Is.False);
+        });
+    }
+
+    [Test]
+    public void MinusPrefix_ExcludesTheTerm()
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("-resources", Element("App.Resources.Strings.Close")), Is.False);
+            Assert.That(Matches("-resources", Element("App.Views.MainWindow")), Is.True);
+        });
+    }
+
+    [Test]
+    public void Negation_CombinesWithAPositiveTerm()
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("rules -tooltip", Element("App.Strings.Rules_Clear")), Is.True);
+            Assert.That(Matches("rules -tooltip", Element("App.Strings.Rules_Clear_Tooltip")), Is.False);
+        });
+    }
+
+    [Test]
+    public void SeveralNegations_ExcludeAll()
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("-tests -dsmsuite", Element("App.Views.MainWindow")), Is.True);
+            Assert.That(Matches("-tests -dsmsuite", Element("Tests.UnitTests.Foo")), Is.False);
+            Assert.That(Matches("-tests -dsmsuite", Element("DsmSuite.Viewer.Bar")), Is.False);
+        });
+    }
+
+    [Test]
+    public void Negation_BelongsToItsOwnOrGroup()
+    {
+        // "views -window | dialog" reads as "((NOT views) AND window) OR dialog" - the negation does not
+        // reach across the pipe.
+        Assert.That(Matches("views -window | dialog", Element("App.Other.Dialog")), Is.True);
+    }
+
+    [Test]
+    public void Negation_AppliesToATypeTerm()
+    {
+        var property = Element("App.Strings.Close", type: CodeElementType.Property);
+        var method = Element("App.Service.Run", type: CodeElementType.Method);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("-type:property", property), Is.False);
+            Assert.That(Matches("-type:property", method), Is.True);
+        });
+    }
+
+    [Test]
+    public void Negation_AppliesToASourceTerm()
+    {
+        var external = Element("System.String", isExternal: true);
+        var internalElement = Element("App.Service");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("-source:extern", external), Is.False);
+            Assert.That(Matches("-source:extern", internalElement), Is.True);
+        });
+    }
+
+    [Test]
+    public void SourceGenerated_SelectsWhatAToolWrote()
+    {
+        var generated = Element("App.MainWindow.Connect", type: CodeElementType.Method, isGenerated: true);
+        var handWritten = Element("App.MainWindow.OnClick", type: CodeElementType.Method);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("source:generated", generated), Is.True);
+            Assert.That(Matches("source:generated", handWritten), Is.False);
+
+            // The useful direction: drop the rows nobody can act on.
+            Assert.That(Matches("-source:generated", generated), Is.False);
+            Assert.That(Matches("-source:generated", handWritten), Is.True);
+        });
+    }
+
+    /// <summary>The three source terms are independent - generated code is internal code, not a third kind.</summary>
+    [Test]
+    public void SourceGenerated_IsIndependentOfInternAndExtern()
+    {
+        var generated = Element("App.MainWindow.Connect", type: CodeElementType.Method, isGenerated: true);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("source:intern", generated), Is.True);
+            Assert.That(Matches("source:extern", generated), Is.False);
+
+            // Combined with AND, which is how it is typed in the search box.
+            Assert.That(Matches("source:intern -source:generated", generated), Is.False);
+        });
+    }
+
+    [Test]
+    public void Negation_AppliesToAPascalCaseTerm()
+    {
+        // An upper case letter switches the term to the ReSharper style regex ("DDG" -> DynamicDataGrid).
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("DDG", Element("App.Grids.DynamicDataGrid")), Is.True);
+            Assert.That(Matches("-DDG", Element("App.Grids.DynamicDataGrid")), Is.False);
+            Assert.That(Matches("-DDG", Element("App.Views.MainWindow")), Is.True);
+        });
+    }
+
+    [Test]
+    public void NegationDisabled_TreatsTheMinusAsPartOfTheTerm()
+    {
+        // The tree turns negation off: it expands and highlights every ancestor of a match, so an
+        // excluding search would unfold the whole tree. The '-' then searches literally and finds nothing
+        // instead of matching everything.
+        var element = Element("App.Resources.Strings.Close");
+
+        var withNegation = SearchExpressionFactory.CreateSearchExpression("-resources");
+        var withoutNegation = SearchExpressionFactory.CreateSearchExpression("-resources",
+            SearchExpressionFactory.TextSearchField.FullName, false);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(withNegation.Evaluate(element), Is.False);
+            Assert.That(withoutNegation.Evaluate(element), Is.False);
+            Assert.That(withoutNegation.Evaluate(Element("App.Views.MainWindow")), Is.False);
+        });
+    }
+
+    [Test]
+    public void NegationDisabled_LeavesPositiveTermsUntouched()
+    {
+        var expression = SearchExpressionFactory.CreateSearchExpression("resources close",
+            SearchExpressionFactory.TextSearchField.FullName, false);
+
+        Assert.That(expression.Evaluate(Element("App.Resources.Strings.Close")), Is.True);
+    }
+
+    [Test]
+    public void LoneMinus_IsALiteralTerm()
+    {
+        // Nothing to negate. It must not become an empty term, which would match everything and turn the
+        // expression into "match nothing".
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("-", Element("App.My-Package.Widget")), Is.True);
+            Assert.That(Matches("-", Element("App.Views.MainWindow")), Is.False);
+        });
+    }
+
+    [Test]
+    public void MinusInsideATerm_IsNotANegation()
+    {
+        Assert.That(Matches("my-package", Element("App.My-Package.Widget")), Is.True);
+    }
+
+    [Test]
+    public void NullElement_NeverMatches_NotEvenANegation()
+    {
+        // The tree has a virtual root without a code element. It answers "no" to every term, and an
+        // exclusion must not turn that into a match.
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("anything", null), Is.False);
+            Assert.That(Matches("-anything", null), Is.False);
+            Assert.That(Matches("-type:property", null), Is.False);
+        });
+    }
+
+    [Test]
+    public void NameField_SearchesTheNameInsteadOfTheFullName()
+    {
+        var element = Element("App.Resources.Strings", "Strings");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Matches("resources", element, SearchExpressionFactory.TextSearchField.Name), Is.False);
+            Assert.That(Matches("strings", element, SearchExpressionFactory.TextSearchField.Name), Is.True);
+            Assert.That(Matches("-resources", element, SearchExpressionFactory.TextSearchField.Name), Is.True);
+        });
+    }
+
+    [Test]
+    public void EmptySearch_MatchesNothing()
+    {
+        // Documents today's behaviour: an empty text yields no OR group at all, and an OR over nothing is
+        // false. Every caller short-circuits on empty input before building an expression, so this never
+        // shows up as "the filter hid everything".
+        Assert.That(Matches("", Element("App.Views.MainWindow")), Is.False);
+    }
+}
diff --git a/Tests/UnitTests/Xaml/XamlFileLocatorTests.cs b/Tests/UnitTests/Xaml/XamlFileLocatorTests.cs
new file mode 100644
index 00000000..11e067d1
--- /dev/null
+++ b/Tests/UnitTests/Xaml/XamlFileLocatorTests.cs
@@ -0,0 +1,132 @@
+using CSharpCodeAnalyst.CodeParser.Parser;
+using CSharpCodeAnalyst.CodeParser.Xaml;
+
+namespace CodeParserTests.UnitTests.Xaml;
+
+[TestFixture]
+public class XamlFileLocatorTests
+{
+    [OneTimeSetUp]
+    public void FixtureSetup()
+    {
+        // Evaluating a project file needs MSBuild. Another fixture may have registered it already, which
+        // is harmless.
+        try
+        {
+            Initializer.InitializeMsBuildLocator();
+        }
+        catch
+        {
+            // already registered
+        }
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _directory = Path.Combine(Path.GetTempPath(), "XamlLocatorTests", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(_directory);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        if (Directory.Exists(_directory))
+        {
+            Directory.Delete(_directory, true);
+        }
+    }
+
+    private string _directory = null!;
+
+    private void Write(string relativePath, string content)
+    {
+        var path = Path.Combine(_directory, relativePath);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        File.WriteAllText(path, content);
+    }
+
+    private string[] Locate(string? projectFileName)
+    {
+        using var locator = new XamlFileLocator();
+        return locator.Locate(projectFileName is null ? null : Path.Combine(_directory, projectFileName), _directory)
+            .Select(file => Path.GetRelativePath(_directory, file))
+            .OrderBy(file => file, StringComparer.Ordinal)
+            .ToArray();
+    }
+
+    /// <summary>The whole point of asking MSBuild: a file on disk that the project does not contain.</summary>
+    [Test]
+    public void Locate_FileRemovedFromTheProject_IsNotReturned()
+    {
+        Write("App.csproj", """
+                            <Project Sdk="Microsoft.NET.Sdk">
+                              <PropertyGroup>
+                                <TargetFramework>net10.0-windows</TargetFramework>
+                                <UseWPF>true</UseWPF>
+                              </PropertyGroup>
+                              <ItemGroup>
+                                <Page Remove="Old\Excluded.xaml" />
+                              </ItemGroup>
+                            </Project>
+                            """);
+        Write("Included.xaml", "<ResourceDictionary />");
+        Write(Path.Combine("Old", "Excluded.xaml"), "<ResourceDictionary />");
+
+        Assert.That(Locate("App.csproj"), Is.EqualTo(new[] { "Included.xaml" }));
+    }
+
+    /// <summary>
+    ///     The SDK contributes a couple of dozen PropertyPageSchema items pointing into the dotnet
+    ///     installation. They are XAML files, they are evaluated items, and they are none of our business.
+    /// </summary>
+    [Test]
+    public void Locate_SdkOwnedXamlItems_AreNotReturned()
+    {
+        Write("App.csproj", """
+                            <Project Sdk="Microsoft.NET.Sdk">
+                              <PropertyGroup>
+                                <TargetFramework>net10.0-windows</TargetFramework>
+                                <UseWPF>true</UseWPF>
+                              </PropertyGroup>
+                            </Project>
+                            """);
+        Write("Included.xaml", "<ResourceDictionary />");
+
+        Assert.That(Locate("App.csproj"), Is.EqualTo(new[] { "Included.xaml" }));
+    }
+
+    /// <summary>Without a project file - and for one that cannot be evaluated - only the scan is left.</summary>
+    [Test]
+    public void Locate_WithoutAnEvaluableProject_FallsBackToTheDirectoryScan()
+    {
+        Write("Broken.csproj", "<Project Sdk=\"Microsoft.NET.Sdk\"><NotClosed>");
+        Write("Included.xaml", "<ResourceDictionary />");
+        Write(Path.Combine("Old", "Excluded.xaml"), "<ResourceDictionary />");
+
+        var expected = new[] { "Included.xaml", Path.Combine("Old", "Excluded.xaml") };
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Locate(null), Is.EqualTo(expected));
+            Assert.That(Locate("Broken.csproj"), Is.EqualTo(expected));
+        });
+    }
+
+    [Test]
+    public void EnumerateDirectory_SkipsGeneratedOutputDirectories()
+    {
+        Write("MainWindow.xaml", "<ResourceDictionary />");
+        Write(Path.Combine("obj", "Copy.xaml"), "<ResourceDictionary />");
+        Write(Path.Combine("bin", "Copy.xaml"), "<ResourceDictionary />");
+
+        Assert.That(XamlFileLocator.EnumerateDirectory(_directory).Select(Path.GetFileName),
+            Is.EqualTo(new[] { "MainWindow.xaml" }));
+    }
+
+    [Test]
+    public void EnumerateDirectory_MissingDirectory_IsEmpty()
+    {
+        Assert.That(XamlFileLocator.EnumerateDirectory(Path.Combine(_directory, "does-not-exist")), Is.Empty);
+    }
+}
diff --git a/Tests/UnitTests/Xaml/XamlGraphLinkerTests.cs b/Tests/UnitTests/Xaml/XamlGraphLinkerTests.cs
new file mode 100644
index 00000000..f98a5f47
--- /dev/null
+++ b/Tests/UnitTests/Xaml/XamlGraphLinkerTests.cs
@@ -0,0 +1,255 @@
+using CodeParserTests.Helper;
+using CSharpCodeAnalyst.CodeGraph.Graph;
+using CSharpCodeAnalyst.CodeParser.Xaml;
+
+namespace CodeParserTests.UnitTests.Xaml;
+
+[TestFixture]
+public class XamlGraphLinkerTests
+{
+    [SetUp]
+    public void SetUp()
+    {
+        _graph = new TestCodeGraph();
+        _directory = Path.Combine(Path.GetTempPath(), "XamlLinkerTests", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(_directory);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        if (Directory.Exists(_directory))
+        {
+            Directory.Delete(_directory, true);
+        }
+    }
+
+    private TestCodeGraph _graph = null!;
+    private string _directory = null!;
+
+    /// <summary>
+    ///     Builds "Assembly &gt; Namespace &gt; Type" the way the parser does: the namespace element carries
+    ///     the whole dotted namespace, so the CLR name of the type is "App.Views.MyControl". The linker
+    ///     resolves through the element names, so the ids stay short here.
+    /// </summary>
+    private CodeElement CreateType(CodeElement assembly, string namespaceName, string typeName)
+    {
+        var ns = assembly.Children.FirstOrDefault(c => c.Name == namespaceName)
+                 ?? _graph.CreateNamespace(namespaceName, assembly);
+        return _graph.CreateClass(typeName, ns);
+    }
+
+    private void WriteXaml(string relativePath, string content)
+    {
+        var path = Path.Combine(_directory, relativePath);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        File.WriteAllText(path, content);
+    }
+
+    /// <summary>
+    ///     Which files belong to a project is <see cref="XamlFileLocator" />'s job; here everything written
+    ///     into the temporary directory is simply passed in.
+    /// </summary>
+    private XamlProject Project(CodeElement assembly)
+    {
+        return new XamlProject(assembly, _directory, XamlFileLocator.EnumerateDirectory(_directory));
+    }
+
+    private static string[] EdgesFrom(CodeElement source, CodeGraph graph)
+    {
+        return source.Relationships
+            .Where(r => r.HasAttribute(RelationshipAttribute.IsXamlReference))
+            .Select(r => graph.Nodes[r.TargetId].FullName)
+            .ToArray();
+    }
+
+    [Test]
+    public void Link_ElementTag_ConnectsCodeBehindToTheUsedType()
+    {
+        var assembly = _graph.CreateAssembly("App");
+        var view = CreateType(assembly, "App.Views", "MainWindow");
+        var control = CreateType(assembly, "App.Controls", "MyGrid");
+
+        WriteXaml("MainWindow.xaml", """
+                                     <Window x:Class="App.Views.MainWindow"
+                                             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                             xmlns:c="clr-namespace:App.Controls">
+                                         <c:MyGrid />
+                                     </Window>
+                                     """);
+
+        var added = XamlGraphLinker.Link(_graph, [Project(assembly)]);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(added, Is.EqualTo(1));
+            Assert.That(EdgesFrom(view, _graph), Is.EqualTo(new[] { "MyGrid" }));
+        });
+    }
+
+    [Test]
+    public void Link_ObjectElement_AlsoConnectsToTheConstructor()
+    {
+        // Without this edge the constructor has no incoming reference at all, and everything only it
+        // calls dies with it once the analysis cascades.
+        var assembly = _graph.CreateAssembly("App");
+        var view = CreateType(assembly, "App.Views", "MainWindow");
+        var control = CreateType(assembly, "App.Controls", "MyGrid");
+        var constructor = _graph.CreateMethod(".ctor", control);
+
+        WriteXaml("MainWindow.xaml", """
+                                     <Window x:Class="App.Views.MainWindow"
+                                             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                             xmlns:c="clr-namespace:App.Controls">
+                                         <c:MyGrid />
+                                     </Window>
+                                     """);
+
+        XamlGraphLinker.Link(_graph, [Project(assembly)]);
+
+        Assert.That(EdgesFrom(view, _graph), Is.EquivalentTo(new[] { "MyGrid", constructor.FullName }));
+    }
+
+    [Test]
+    public void Link_XType_DoesNotConnectToTheConstructor()
+    {
+        // {x:Type} only names the type; nothing is created.
+        var assembly = _graph.CreateAssembly("App");
+        var view = CreateType(assembly, "App.Views", "MainWindow");
+        var control = CreateType(assembly, "App.Controls", "MyGrid");
+        _graph.CreateMethod(".ctor", control);
+
+        WriteXaml("MainWindow.xaml", """
+                                     <Window x:Class="App.Views.MainWindow"
+                                             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                             xmlns:c="clr-namespace:App.Controls">
+                                         <Style TargetType="{x:Type c:MyGrid}" />
+                                     </Window>
+                                     """);
+
+        XamlGraphLinker.Link(_graph, [Project(assembly)]);
+
+        Assert.That(EdgesFrom(view, _graph), Is.EquivalentTo(new[] { "MyGrid" }));
+    }
+
+    [Test]
+    public void Link_XStatic_ConnectsToTheMemberNotOnlyTheType()
+    {
+        var assembly = _graph.CreateAssembly("App");
+        var view = CreateType(assembly, "App.Views", "MainWindow");
+        var strings = CreateType(assembly, "App.Resources", "Strings");
+        var caption = _graph.CreateProperty("Caption", strings);
+
+        WriteXaml("MainWindow.xaml", """
+                                     <Window x:Class="App.Views.MainWindow"
+                                             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                             xmlns:res="clr-namespace:App.Resources">
+                                         <TextBlock Text="{x:Static res:Strings.Caption}" />
+                                     </Window>
+                                     """);
+
+        XamlGraphLinker.Link(_graph, [Project(assembly)]);
+
+        Assert.That(EdgesFrom(view, _graph), Is.EqualTo(new[] { caption.FullName }));
+    }
+
+    [Test]
+    public void Link_ResourceDictionary_GetsASyntheticClassNamedAfterTheFile()
+    {
+        var assembly = _graph.CreateAssembly("App");
+        var converter = CreateType(assembly, "App.Converters", "BoolToBrush");
+
+        WriteXaml(Path.Combine("Styles", "ButtonStyles.xaml"), """
+                                                               <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                                                                   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                                                                   xmlns:conv="clr-namespace:App.Converters">
+                                                                   <conv:BoolToBrush x:Key="B" />
+                                                               </ResourceDictionary>
+                                                               """);
+
+        XamlGraphLinker.Link(_graph, [Project(assembly)]);
+
+        var synthetic = assembly.Children.Single(c => c.Name == "Styles.ButtonStyles");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(_graph.Nodes.ContainsKey(synthetic.Id), Is.True);
+            Assert.That(synthetic.SourceLocations.Single().File, Does.EndWith("ButtonStyles.xaml"));
+            Assert.That(EdgesFrom(synthetic, _graph), Is.EqualTo(new[] { "BoolToBrush" }));
+        });
+    }
+
+    [Test]
+    public void Link_FileWithoutAnyClrReference_CreatesNoSyntheticClass()
+    {
+        var assembly = _graph.CreateAssembly("App");
+
+        WriteXaml("Empty.xaml", """
+                                <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" />
+                                """);
+
+        var added = XamlGraphLinker.Link(_graph, [Project(assembly)]);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(added, Is.Zero);
+            Assert.That(assembly.Children, Is.Empty);
+        });
+    }
+
+    [Test]
+    public void Link_AssemblyQualifiedReference_ResolvesIntoTheOtherAssembly()
+    {
+        var app = _graph.CreateAssembly("App");
+        var view = CreateType(app, "App.Views", "MainWindow");
+
+        var library = _graph.CreateAssembly("Sdk");
+        var widget = CreateType(library, "Sdk.Controls", "Widget");
+
+        WriteXaml("MainWindow.xaml", """
+                                     <Window x:Class="App.Views.MainWindow"
+                                             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                             xmlns:sdk="clr-namespace:Sdk.Controls;assembly=Sdk">
+                                         <sdk:Widget />
+                                     </Window>
+                                     """);
+
+        XamlGraphLinker.Link(_graph, [Project(app)]);
+
+        Assert.That(EdgesFrom(view, _graph), Is.EqualTo(new[] { "Widget" }));
+    }
+
+    [Test]
+    public void Link_SameTypeUsedTwice_YieldsOneRelationshipWithBothLocations()
+    {
+        var assembly = _graph.CreateAssembly("App");
+        var view = CreateType(assembly, "App.Views", "MainWindow");
+        var control = CreateType(assembly, "App.Controls", "MyGrid");
+
+        WriteXaml("MainWindow.xaml", """
+                                     <Window x:Class="App.Views.MainWindow"
+                                             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                             xmlns:c="clr-namespace:App.Controls">
+                                         <c:MyGrid />
+                                         <c:MyGrid />
+                                     </Window>
+                                     """);
+
+        XamlGraphLinker.Link(_graph, [Project(assembly)]);
+
+        var relationship = view.Relationships.Single();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(relationship.Type, Is.EqualTo(RelationshipType.Uses));
+            Assert.That(relationship.SourceLocations, Has.Count.EqualTo(2));
+        });
+    }
+}
diff --git a/Tests/UnitTests/Xaml/XamlReferenceExtractorTests.cs b/Tests/UnitTests/Xaml/XamlReferenceExtractorTests.cs
new file mode 100644
index 00000000..d4bd4ffe
--- /dev/null
+++ b/Tests/UnitTests/Xaml/XamlReferenceExtractorTests.cs
@@ -0,0 +1,264 @@
+using CSharpCodeAnalyst.CodeParser.Xaml;
+
+namespace CodeParserTests.UnitTests.Xaml;
+
+[TestFixture]
+public class XamlReferenceExtractorTests
+{
+    private static string[] TypeRefs(string xaml)
+    {
+        return XamlReferenceExtractor.Extract(xaml).References
+            .Where(r => r.MemberName is null)
+            .Select(r => r.TypeFullName)
+            .Distinct()
+            .ToArray();
+    }
+
+    private static string[] MemberRefs(string xaml)
+    {
+        return XamlReferenceExtractor.Extract(xaml).References
+            .Where(r => r.MemberName is not null)
+            .Select(r => $"{r.TypeFullName}.{r.MemberName}")
+            .Distinct()
+            .ToArray();
+    }
+
+    [Test]
+    public void Extract_ElementTag_IsResolvedThroughTheXmlnsPrefix()
+    {
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:grid="clr-namespace:App.Shared.DynamicDataGrid">
+                                <grid:DynamicDataGrid />
+                            </Window>
+                            """;
+
+        Assert.That(TypeRefs(xaml), Is.EqualTo(new[] { "App.Shared.DynamicDataGrid.DynamicDataGrid" }));
+    }
+
+    [Test]
+    public void Extract_ElementTagInsideDataTemplate_IsFoundToo()
+    {
+        // The case that started this: a named control inside a template gets no generated field, so the
+        // element tag is the only trace of the type.
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:grid="clr-namespace:App.Grids">
+                                <Window.Resources>
+                                    <DataTemplate x:Key="T">
+                                        <grid:DynamicDataGrid x:Name="_dynamicDataGrid" />
+                                    </DataTemplate>
+                                </Window.Resources>
+                            </Window>
+                            """;
+
+        Assert.That(TypeRefs(xaml), Is.EqualTo(new[] { "App.Grids.DynamicDataGrid" }));
+    }
+
+    [Test]
+    public void Extract_XStatic_YieldsTypeAndMember()
+    {
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:res="clr-namespace:App.Resources">
+                                <TextBlock Text="{x:Static res:Strings.Close_Button}" />
+                            </Window>
+                            """;
+
+        Assert.That(MemberRefs(xaml), Is.EqualTo(new[] { "App.Resources.Strings.Close_Button" }));
+    }
+
+    [Test]
+    public void Extract_NestedMarkupExtension_IsFound()
+    {
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:res="clr-namespace:App.Resources">
+                                <TextBlock Text="{Binding Name, FallbackValue={x:Static res:Strings.Fallback}}" />
+                            </Window>
+                            """;
+
+        Assert.That(MemberRefs(xaml), Is.EqualTo(new[] { "App.Resources.Strings.Fallback" }));
+    }
+
+    [Test]
+    public void Extract_ObjectElement_IsMarkedAsInstantiation()
+    {
+        // XAML creates the object here, so the constructor runs - the linker needs to know.
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:local="clr-namespace:App.Views">
+                                <local:MyControl />
+                            </Window>
+                            """;
+
+        Assert.That(XamlReferenceExtractor.Extract(xaml).References.Single().IsInstantiation, Is.True);
+    }
+
+    [Test]
+    public void Extract_PropertyElementSyntaxAndXType_AreNoInstantiation()
+    {
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:local="clr-namespace:App.Views">
+                                <Style TargetType="{x:Type local:Other}" />
+                                <local:MyControl.Items />
+                            </Window>
+                            """;
+
+        Assert.That(XamlReferenceExtractor.Extract(xaml).References.Select(r => r.IsInstantiation),
+            Is.All.False);
+    }
+
+    [Test]
+    public void Extract_XType_YieldsTypeOnly()
+    {
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:local="clr-namespace:App.Views">
+                                <Style TargetType="{x:Type local:MyControl}" />
+                            </Window>
+                            """;
+
+        Assert.That(TypeRefs(xaml), Is.EqualTo(new[] { "App.Views.MyControl" }));
+    }
+
+    [Test]
+    public void Extract_PropertyElementSyntax_ReferencesTheTypeNotTheProperty()
+    {
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:local="clr-namespace:App.Views">
+                                <local:MyControl.Items>
+                                    <sys:String xmlns:sys="clr-namespace:System;assembly=mscorlib">x</sys:String>
+                                </local:MyControl.Items>
+                            </Window>
+                            """;
+
+        Assert.That(TypeRefs(xaml), Does.Contain("App.Views.MyControl"));
+    }
+
+    [Test]
+    public void Extract_AssemblyQualifiedXmlns_KeepsTheAssemblyName()
+    {
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:other="clr-namespace:Other.Lib;assembly=Other">
+                                <other:Widget />
+                            </Window>
+                            """;
+
+        var reference = XamlReferenceExtractor.Extract(xaml).References.Single();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(reference.TypeFullName, Is.EqualTo("Other.Lib.Widget"));
+            Assert.That(reference.AssemblyName, Is.EqualTo("Other"));
+        });
+    }
+
+    [Test]
+    public void Extract_FrameworkNamespaces_AreIgnored()
+    {
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+                                <Button x:Name="Go" Click="OnGo" Content="Go" />
+                            </Window>
+                            """;
+
+        Assert.That(XamlReferenceExtractor.Extract(xaml).References, Is.Empty);
+    }
+
+    [Test]
+    public void Extract_BindingPath_IsNotCollected()
+    {
+        // Deliberate: without the DataContext this is a bare name, and matching it by name would
+        // suppress far more than it explains.
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+                                <TextBlock Text="{Binding BoundOnlyInXaml}" />
+                            </Window>
+                            """;
+
+        Assert.That(XamlReferenceExtractor.Extract(xaml).References, Is.Empty);
+    }
+
+    [Test]
+    public void Extract_CodeBehindClass_IsTakenFromXClass()
+    {
+        const string xaml = """
+                            <Window x:Class="App.Views.MainWindow"
+                                    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" />
+                            """;
+
+        Assert.That(XamlReferenceExtractor.Extract(xaml).CodeBehindClass, Is.EqualTo("App.Views.MainWindow"));
+    }
+
+    [Test]
+    public void Extract_ResourceDictionaryWithoutCodeBehind_HasNoClass()
+    {
+        const string xaml = """
+                            <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                                                xmlns:conv="clr-namespace:App.Converters">
+                                <conv:BoolToBrush x:Key="B" />
+                            </ResourceDictionary>
+                            """;
+
+        var result = XamlReferenceExtractor.Extract(xaml);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.CodeBehindClass, Is.Null);
+            Assert.That(result.References.Select(r => r.TypeFullName),
+                Is.EqualTo(new[] { "App.Converters.BoolToBrush" }));
+        });
+    }
+
+    [Test]
+    public void Extract_MalformedXaml_ReturnsNothingInsteadOfThrowing()
+    {
+        Assert.That(XamlReferenceExtractor.Extract("<Window").References, Is.Empty);
+    }
+
+    [Test]
+    public void Extract_AliasedXamlPrefix_IsResolvedNotAssumed()
+    {
+        // The "x" prefix is only a convention. Here the XAML language namespace is bound to "xaml".
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:xaml="http://schemas.microsoft.com/winfx/2006/xaml"
+                                    xmlns:res="clr-namespace:App.Resources">
+                                <TextBlock Text="{xaml:Static res:Strings.Caption}" />
+                            </Window>
+                            """;
+
+        Assert.That(MemberRefs(xaml), Is.EqualTo(new[] { "App.Resources.Strings.Caption" }));
+    }
+
+    [Test]
+    public void Extract_ForeignPrefixNamedX_IsNotMistakenForXaml()
+    {
+        const string xaml = """
+                            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                                    xmlns:x="clr-namespace:App.NotXaml"
+                                    xmlns:res="clr-namespace:App.Resources">
+                                <TextBlock Text="{x:Static res:Strings.Caption}" />
+                            </Window>
+                            """;
+
+        Assert.That(MemberRefs(xaml), Is.Empty);
+    }
+}