com.wallstop-studios.dxmessaging 2.1.3 → 2.1.5

package/Samples~/Mini Combat/Walkthrough.md

@@ -141,7 +141,7 @@ Settings changes are **global events**—they don't target anyone specifically.
 
 ### The Code Flow
 
-1. **[Boot.cs](./Boot.cs)** calls: `MessageHub.Publish(new VideoSettingsChanged())`
+1. **[Boot.cs](./Boot.cs)** calls: `var settings = new VideoSettingsChanged(); settings.Emit();`
 1. **[UIOverlay.cs](./UIOverlay.cs)** receives it through its registered handler
 1. **UIOverlay** rebuilds the UI with new settings
 
@@ -179,7 +179,7 @@ We want to heal **one specific player**, not all players in the scene.
 ### The Code Flow
 
 1. **[Boot.cs](./Boot.cs)** finds the Player Component reference
-1. **[Boot.cs](./Boot.cs)** calls: `MessageHub.Publish(new Heal(amount), targetComponent)`
+1. **[Boot.cs](./Boot.cs)** calls: `var heal = new Heal(amount); heal.EmitComponentTargeted(targetComponent);`
 1. **Only the targeted [Player.cs](./Player.cs)** receives it through its handler
 1. **Player** increases its HP
 
@@ -249,7 +249,7 @@ The Enemy doesn't know (or care) who needs to know about the damage. It just ann
 
 ```csharp
 // Player.cs registers like this:
-token.RegisterComponent<Heal>(this, OnHeal);
+token.RegisterComponentTargeted<Heal>(this, OnHeal);
 ```
 
 #### Reasoning:
@@ -388,7 +388,7 @@ token.RegisterBroadcastWithoutSource<TookDamage>(OnTookDamage);
 ### For Advanced Developers
 
 1. **Source-filtered broadcasts exist**: Use `RegisterGameObjectBroadcast` for efficiency
-1. **Message order can be controlled**: See InterceptorsAndOrdering.md
+1. **Message order can be controlled**: See the Interceptors & Ordering documentation
 1. **Performance considerations**: Targeted > Broadcast in terms of overhead
 1. **Consider message granularity**: Too many message types = harder maintenance
 
@@ -407,10 +407,10 @@ Try modifying the sample:
 
 ### Learn More
 
-- **[Message Types Documentation](../../Docs/MessageTypes.md)** - Complete message type reference
-- **[Targeting and Context Guide](../../Docs/TargetingAndContext.md)** - Deep dive into targeting
-- **[Patterns Guide](../../Docs/Patterns.md)** - Common messaging patterns
-- **[Performance Guide](../../Docs/Performance.md)** - Optimization tips
+- **[Message Types Documentation](../../docs/concepts/message-types.md)** - Complete message type reference
+- **[Targeting and Context Guide](../../docs/concepts/targeting-and-context.md)** - Deep dive into targeting
+- **[Patterns Guide](../../docs/guides/patterns.md)** - Common messaging patterns
+- **[Performance Guide](../../docs/architecture/performance.md)** - Optimization tips
 
 ---
 
@@ -418,13 +418,13 @@ Try modifying the sample:
 
 | Want to... | Use... | Example |
 |------------|--------|---------|
-| Send to everyone | Untargeted | `MessageHub.Publish(new GamePaused())` |
-| Send to specific Component | Targeted | `MessageHub.Publish(new Heal(10), playerComponent)` |
+| Send to everyone | Untargeted | `var paused = new GamePaused(); paused.Emit();` |
+| Send to specific Component | Targeted | `var heal = new Heal(10); heal.EmitComponentTargeted(playerComponent);` |
 | Announce an event | Broadcast | `this.EmitBroadcast(new Exploded())` |
 | Listen to everything | `RegisterBroadcastWithoutSource` | `token.RegisterBroadcastWithoutSource<Damage>(OnDamage)` |
 | Listen to specific source | `RegisterComponentBroadcast` | `token.RegisterComponentBroadcast<Fire>(weapon, OnFire)` |
-| Receive targeted messages | `RegisterComponent` | `token.RegisterComponent<Heal>(this, OnHeal)` |
+| Receive targeted messages | `RegisterComponentTargeted` | `token.RegisterComponentTargeted<Heal>(this, OnHeal)` |
 
 ---
 
-**Remember**: Keep Player, Enemy, and UIOverlay GameObjects each with a `MessagingComponent` attached, and enable diagnostics to see the magic happen!
+**Remember**: Keep Player, Enemy, and UIOverlay GameObjects each with a `MessagingComponent` attached, and enable diagnostics to observe message traffic.

package/Samples~/UI Buttons + Inspector/README.md

@@ -14,7 +14,7 @@
 
 ---
 
-## The Power Move
+## Comparison
 
 ### Before DxMessaging:
 
@@ -45,7 +45,7 @@ public class PlayButton : MonoBehaviour {
 }
 ```
 
-###### GameManager, Audio, and Analytics listen independently. Zero coupling.
+###### GameManager, Audio, and Analytics listen independently without direct references.
 
 ## Import & Run (30 Seconds)
 
@@ -55,10 +55,10 @@ public class PlayButton : MonoBehaviour {
 2. **Find DxMessaging** → Scroll to **Samples**
 3. **"UI Buttons + Inspector"** → Click **Import**
 4. **Navigate to** Assets/Samples/.../UI Buttons + Inspector/
-5. **Open the scene** → **Press Play** 🎮
+5. **Open the scene** → **Press Play**
 6. **Click the buttons** → Watch Console logs
 
-**Done!** You're seeing DxMessaging in action.
+You are now seeing DxMessaging in action.
 
 ## Click-To-Message: The Quick Path
 
@@ -140,7 +140,7 @@ Add your own partial struct next to it, then emit it from `UIButtonEmitter` usin
 
 ### If you extend `MessagingObserver` or create your own scripts deriving from `MessageAwareComponent`:
 
-### The Golden Rules (Follow These to Avoid Pain)
+### Important Guidelines
 
 1. **ALWAYS call `base.RegisterMessageHandlers()` FIRST** in your override:
 
@@ -202,8 +202,8 @@ public class MyObserver : MessageAwareComponent {
 
 ## Next Steps
 
-- Quick tour: [Getting Started guide](../../Docs/GettingStarted.md)
-- Patterns and recipes: [Common Patterns](../../Docs/Patterns.md)
+- Quick tour: [Getting Started guide](../../docs/getting-started/getting-started.md)
+- Patterns and recipes: [Common Patterns](../../docs/guides/patterns.md)
 - Explore another sample: [Mini Combat sample](../Mini%20Combat/README.md)
 
-You now have an easy, inspector-first way to publish and observe messages. Build up from here by swapping in your own message types and listeners.
+You now have an inspector-first way to publish and observe messages. Build on this by using your own message types and listeners.

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/DocsSnippetCompilationTests.cs

@@ -17,11 +17,48 @@ public sealed class DocsSnippetCompilationTests
         "CS8803", // top-level statements mixed with declarations (visual guide style snippets)
     };
 
+    // Compiled regex patterns for API signature detection
+    private static readonly System.Text.RegularExpressions.Regex MethodSignatureStartRegex = new(
+        @"^\w+(?:<[^>]+>)?\s+\w+(?:<[^>]+>)?\s*\($",
+        System.Text.RegularExpressions.RegexOptions.Compiled
+    );
+
+    private static readonly System.Text.RegularExpressions.Regex DocumentationStyleMethodCallRegex =
+        new(
+            @"\(\s*[A-Z]\w*\s+\w+\s*\)[\s;]*$",
+            System.Text.RegularExpressions.RegexOptions.Compiled
+        );
+
+    private static readonly System.Text.RegularExpressions.Regex GenericMethodCallRegex = new(
+        @"<T>\s*\(",
+        System.Text.RegularExpressions.RegexOptions.Compiled
+    );
+
+    private static readonly System.Text.RegularExpressions.Regex HandlerParameterRegex = new(
+        @",\s*handler\s*,",
+        System.Text.RegularExpressions.RegexOptions.Compiled
+    );
+
+    private static readonly System.Text.RegularExpressions.Regex ApiReferenceUnityTypeRegex = new(
+        @"\(\s*(GameObject|Component|InstanceId)\s+\w+\s*,",
+        System.Text.RegularExpressions.RegexOptions.Compiled
+    );
+
+    private static readonly System.Text.RegularExpressions.Regex ApiReferenceHandlerPriorityRegex =
+        new(
+            @",\s*handler\s*,\s*(int|bool|string)\s+\w+\s*=",
+            System.Text.RegularExpressions.RegexOptions.Compiled
+        );
+
+    // Constants for signature detection thresholds
+    private const double ApiSignatureRatioThreshold = 0.30;
+    private const int MinimumApiSignatureLinesForDetection = 2;
+
     [Test]
     public void QuickStartStep1Compiles()
     {
         string docsRoot = ResolveDocsRoot();
-        string quickStartPath = Path.Combine(docsRoot, "QuickStart.md");
+        string quickStartPath = Path.Combine(docsRoot, "getting-started", "quick-start.md");
         Assert.That(File.Exists(quickStartPath), Is.True, $"Unable to locate {quickStartPath}.");
 
         string snippet = ExtractFirstCodeBlock(quickStartPath, "csharp");
@@ -146,8 +183,8 @@ using UnityEngine;
         string currentDirectoryPath = TestContext.CurrentContext.TestDirectory;
         while (!string.IsNullOrEmpty(currentDirectoryPath))
         {
-            string docsDirectory = Path.Combine(currentDirectoryPath, "Docs");
-            string candidate = Path.Combine(docsDirectory, "QuickStart.md");
+            string docsDirectory = Path.Combine(currentDirectoryPath, "docs");
+            string candidate = Path.Combine(docsDirectory, "getting-started", "quick-start.md");
             if (File.Exists(candidate))
             {
                 return docsDirectory;
@@ -164,7 +201,156 @@ using UnityEngine;
         }
 
         throw new FileNotFoundException(
-            "Unable to locate Docs/QuickStart.md from the current test directory."
+            "Unable to locate docs/getting-started/quick-start.md from the current test directory."
+        );
+    }
+
+    [TestCase("", true, TestName = "Empty snippet should be skipped")]
+    [TestCase("   ", true, TestName = "Whitespace-only snippet should be skipped")]
+    [TestCase(
+        "var x = 1;\nConsole.WriteLine(x);",
+        false,
+        TestName = "Regular compilable code should not be skipped"
+    )]
+    [TestCase(
+        "public class MyClass { }",
+        false,
+        TestName = "Simple class declaration should not be skipped"
+    )]
+    [TestCase(
+        "// Comment only\nvar x = 1;",
+        false,
+        TestName = "Code with comments should not be skipped"
+    )]
+    [TestCase(
+        "MessageRegistrationHandle RegisterUntargeted<T>(Action<T> handler, int priority = 0)",
+        true,
+        TestName = "Single line method signature with default parameter should be skipped"
+    )]
+    [TestCase(
+        "void Process(string name = null)",
+        true,
+        TestName = "Method with null default should be skipped"
+    )]
+    [TestCase(
+        "bool IsEnabled(bool flag = false)",
+        true,
+        TestName = "Method with false default should be skipped"
+    )]
+    [TestCase(
+        "void Toggle(bool active = true)",
+        true,
+        TestName = "Method with true default should be skipped"
+    )]
+    [TestCase(
+        "MessageRegistrationHandle RegisterUntargeted<T>(\n    Action<T> handler,\n    int priority = 0)",
+        true,
+        TestName = "Multi-line signature with default params should be skipped"
+    )]
+    [TestCase(
+        "Do something...\nthen continue",
+        true,
+        TestName = "Snippet with ellipsis should be skipped"
+    )]
+    [TestCase(
+        "public void Method() { ... }",
+        true,
+        TestName = "Method with ellipsis body should be skipped"
+    )]
+    [TestCase(
+        "MessageRegistrationHandle RegisterUntargeted<T>(\n    Action<T> handler,\n    int priority = 0\n)",
+        true,
+        TestName = "Multi-line signature with closing paren on own line should be skipped"
+    )]
+    [TestCase(
+        "    // GameObject target\n    MessageRegistrationHandle RegisterGameObjectTargeted<T>(\n        GameObject target,\n        Action<T> handler,\n        int priority = 0\n    )",
+        true,
+        TestName = "Indented multi-line signature with comments should be skipped"
+    )]
+    [TestCase(
+        "// Emit to specific target (by InstanceId)\nmessage.EmitTargeted(InstanceId target);",
+        true,
+        TestName = "Method call with parameter type documentation should be skipped"
+    )]
+    [TestCase(
+        "Action RegisterUntargetedInterceptor<T>(\n    UntargetedInterceptor<T> interceptor,\n    int priority = 0\n)",
+        true,
+        TestName = "Interceptor signature should be skipped"
+    )]
+    [TestCase(
+        "token.RegisterUntargeted<T>(Action<T> handler, int priority = 0)",
+        true,
+        TestName = "Method call with generic type parameter and Action handler should be skipped"
+    )]
+    [TestCase(
+        "token.RegisterUntargeted<T>(FastHandler<T> handler, int priority = 0)",
+        true,
+        TestName = "Method call with FastHandler parameter should be skipped"
+    )]
+    [TestCase(
+        "token.RegisterGameObjectTargeted<T>(GameObject go, handler, int priority = 0)",
+        true,
+        TestName = "Method call with handler parameter name should be skipped"
+    )]
+    [TestCase(
+        "token.RegisterTargetedWithoutTargeting<T>(FastHandlerWithContext<T> handler, int priority = 0)",
+        true,
+        TestName = "Method call with FastHandlerWithContext should be skipped"
+    )]
+    [TestCase(
+        "bus.RegisterUntargetedInterceptor<T>(UntargetedInterceptor<T> interceptor, int priority = 0)",
+        true,
+        TestName = "Bus interceptor registration with generic type should be skipped"
+    )]
+    [TestCase(
+        "token.RegisterTargeted<T>(InstanceId id, handler, int priority = 0)",
+        true,
+        TestName = "Method with InstanceId parameter and handler should be skipped"
+    )]
+    [TestCase(
+        "token.RegisterBroadcast<T>(InstanceId id, handler, int priority = 0)",
+        true,
+        TestName = "Broadcast registration with InstanceId and handler should be skipped"
+    )]
+    [TestCase("int x = 0;", false, TestName = "Assignment with zero should not be skipped")]
+    [TestCase("var priority = 0;", false, TestName = "Variable assignment should not be skipped")]
+    [TestCase(
+        "int priority = 0;\nConsole.WriteLine(priority);",
+        false,
+        TestName = "Variable assignment with usage should not be skipped"
+    )]
+    [TestCase(
+        "bool isEnabled = false;\nif (isEnabled) { DoSomething(); }",
+        false,
+        TestName = "Boolean assignment with conditional should not be skipped"
+    )]
+    [TestCase(
+        "string name = null;\nname = GetName();",
+        false,
+        TestName = "Null assignment with reassignment should not be skipped"
+    )]
+    [TestCase(
+        "public void Process()\n{\n    int count = 0;\n}",
+        false,
+        TestName = "Method with local variable initialization should not be skipped"
+    )]
+    [TestCase(
+        "Action<int> handler = x => Console.WriteLine(x);",
+        false,
+        TestName = "Lambda assignment should not be skipped"
+    )]
+    [TestCase(
+        "var result = Calculate(value, 0);",
+        false,
+        TestName = "Method call with zero argument should not be skipped"
+    )]
+    public void ShouldSkipSnippetDetectsApiSignatures(string snippet, bool expectedSkip)
+    {
+        bool actualSkip = ShouldSkipSnippet(snippet);
+        Assert.That(
+            actualSkip,
+            Is.EqualTo(expectedSkip),
+            $"Expected ShouldSkipSnippet to return {expectedSkip} for snippet: '{snippet.Replace("\n", "\\n")}'"
         );
     }
 
@@ -188,6 +374,171 @@ using UnityEngine;
             }
         }
 
+        if (IsApiSignatureDocumentation(snippet))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Detects whether a code snippet represents API signature documentation rather than
+    /// compilable sample code. API signatures in documentation (e.g., method signatures
+    /// with default parameters shown for reference) are not meant to be compiled.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// API signature snippets need special handling because documentation often shows
+    /// method signatures like <c>RegisterUntargeted&lt;T&gt;(Action&lt;T&gt; handler, int priority = 0)</c>
+    /// for reference. These are informational and not valid standalone C# code.
+    /// </para>
+    /// <para>
+    /// Detection heuristics:
+    /// <list type="bullet">
+    /// <item><description>Default parameter patterns on same line: <c>= 0)</c>, <c>= null)</c>, <c>= false)</c>, <c>= true)</c> and their comma variants</description></item>
+    /// <item><description>Default parameter patterns at end of line: <c>= 0</c>, <c>= null</c>, <c>= false</c>, <c>= true</c> for multi-line signatures</description></item>
+    /// <item><description>Method signature start patterns: return type followed by method name and opening paren</description></item>
+    /// <item><description>Partial signature patterns: lines ending in comma with parameter type keywords (Action&lt;&gt;, Func&lt;&gt;, int, bool, string, GameObject, Component, InstanceId, FastHandler)</description></item>
+    /// <item><description>Isolated closing parens: lines that are just <c>)</c> or <c>);</c></description></item>
+    /// <item><description>Documentation-style method calls: <c>method(TypeName param);</c> showing parameter types as placeholders</description></item>
+    /// <item><description>Generic method calls with type parameters: <c>method&lt;T&gt;(Action&lt;T&gt; handler, ...)</c> with generic handler types</description></item>
+    /// <item><description>API reference parameter lines: <c>(GameObject go, handler, int priority = 0)</c> with type-name pairs and handler placeholders</description></item>
+    /// </list>
+    /// </para>
+    /// <para>
+    /// Ratio threshold logic: A snippet is considered an API signature if:
+    /// <list type="bullet">
+    /// <item><description>At least 30% of non-empty lines match signature patterns, OR</description></item>
+    /// <item><description>Two or more lines match signature patterns (handles multi-line signatures)</description></item>
+    /// </list>
+    /// </para>
+    /// </remarks>
+    /// <param name="snippet">The code snippet to analyze.</param>
+    /// <returns>True if the snippet appears to be API signature documentation; otherwise false.</returns>
+    private static bool IsApiSignatureDocumentation(string snippet)
+    {
+        string[] lines = snippet.Split('\n');
+        int signatureLineCount = 0;
+        int totalNonEmptyLines = 0;
+
+        foreach (string rawLine in lines)
+        {
+            string line = rawLine.Trim();
+            if (string.IsNullOrEmpty(line))
+            {
+                continue;
+            }
+
+            totalNonEmptyLines++;
+
+            // Default parameters on same line as closing paren or comma
+            bool hasDefaultParameterSameLine =
+                line.Contains("= 0)")
+                || line.Contains("= null)")
+                || line.Contains("= false)")
+                || line.Contains("= true)")
+                || line.Contains("= 0,")
+                || line.Contains("= null,")
+                || line.Contains("= false,")
+                || line.Contains("= true,");
+
+            // Default parameters on their own line (multi-line signatures)
+            bool hasDefaultParameterEndOfLine =
+                line.EndsWith("= 0")
+                || line.EndsWith("= null")
+                || line.EndsWith("= false")
+                || line.EndsWith("= true");
+
+            // Method signature that starts with return type + method name pattern
+            // e.g., "MessageRegistrationHandle RegisterUntargeted<T>("
+            bool isMethodSignatureStart =
+                !line.StartsWith("//")
+                && !line.StartsWith("/*")
+                && !line.StartsWith("var ")
+                && !line.Contains(" = ")
+                && line.EndsWith("(")
+                && MethodSignatureStartRegex.IsMatch(line);
+
+            bool isPartialSignature =
+                line.EndsWith(",")
+                && !line.StartsWith("//")
+                && (
+                    line.Contains("Action<")
+                    || line.Contains("Func<")
+                    || line.Contains("int ")
+                    || line.Contains("bool ")
+                    || line.Contains("string ")
+                    || line.Contains("GameObject ")
+                    || line.Contains("Component ")
+                    || line.Contains("InstanceId ")
+                    || line.Contains("FastHandler")
+                );
+
+            // Isolated closing paren (multi-line signature endings)
+            bool isIsolatedClosingParen = line == ")" || line == ");";
+
+            // Method calls with type+parameter documentation style
+            // e.g., "message.EmitTargeted(InstanceId target);"
+            bool isDocumentationStyleMethodCall =
+                !line.StartsWith("//")
+                && !line.StartsWith("/*")
+                && (line.EndsWith(");") || line.EndsWith(")"))
+                && line.Contains("(")
+                && DocumentationStyleMethodCallRegex.IsMatch(line);
+
+            // Generic method calls with <T>( pattern that are API reference style
+            // e.g., "token.RegisterUntargeted<T>(Action<T> handler, int priority = 0)"
+            bool isGenericMethodCallWithTypeParams =
+                !line.StartsWith("//")
+                && !line.StartsWith("/*")
+                && GenericMethodCallRegex.IsMatch(line)
+                && (
+                    line.Contains("Action<T>")
+                    || line.Contains("FastHandler")
+                    || line.Contains("Interceptor<T>")
+                    || line.Contains("FastHandlerWithContext")
+                    || HandlerParameterRegex.IsMatch(line)
+                );
+
+            // API reference lines with parameter declarations showing type and name
+            // e.g., "(GameObject go, handler, int priority = 0)" or "(InstanceId id, handler,"
+            bool isApiReferenceParameterLine =
+                !line.StartsWith("//")
+                && !line.StartsWith("/*")
+                && line.Contains("(")
+                && (
+                    ApiReferenceUnityTypeRegex.IsMatch(line)
+                    || ApiReferenceHandlerPriorityRegex.IsMatch(line)
+                );
+
+            if (
+                hasDefaultParameterSameLine
+                || hasDefaultParameterEndOfLine
+                || isMethodSignatureStart
+                || isPartialSignature
+                || isIsolatedClosingParen
+                || isDocumentationStyleMethodCall
+                || isGenericMethodCallWithTypeParams
+                || isApiReferenceParameterLine
+            )
+            {
+                signatureLineCount++;
+            }
+        }
+
+        if (signatureLineCount > 0 && totalNonEmptyLines > 0)
+        {
+            double ratio = (double)signatureLineCount / totalNonEmptyLines;
+            if (
+                ratio >= ApiSignatureRatioThreshold
+                || signatureLineCount >= MinimumApiSignatureLinesForDetection
+            )
+            {
+                return true;
+            }
+        }
+
         return false;
     }
 }

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/WallstopStudios.DxMessaging.SourceGenerators.Tests.csproj

@@ -6,9 +6,9 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageReference Include="NUnit" Version="4.4.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="5.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
     <PackageReference Include="coverlet.collector" Version="6.0.4">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

package/Tests/Runtime/Benchmarks/BenchmarkSession.cs

@@ -98,7 +98,7 @@ namespace DxMessaging.Tests.Runtime.Benchmarks
             + "- Run PlayMode tests locally in your Unity project that references this package.\n"
             + "- The benchmark test writes an OS-specific section below with a markdown table.\n"
             + "- CI runs skip writing to avoid noisy diffs.\n\n"
-            + "See also: `Docs/DesignAndArchitecture.md#performance-optimizations` for design details.\n";
+            + "See also: `docs/architecture/design-and-architecture.md#performance-optimizations` for design details.\n";
 
         internal static string GetOperatingSystemSection()
         {
@@ -208,12 +208,15 @@ namespace DxMessaging.Tests.Runtime.Benchmarks
 
         internal static string TryFindPerformanceDocPath()
         {
-            return TryFindDocPath(Path.Combine("Docs", "Performance.md"), PerformanceHeader);
+            return TryFindDocPath(
+                Path.Combine("docs", "architecture", "performance.md"),
+                PerformanceHeader
+            );
         }
 
         internal static string TryFindComparisonsDocPath()
         {
-            return TryFindDocPath(Path.Combine("Docs", "Comparisons.md"));
+            return TryFindDocPath(Path.Combine("docs", "architecture", "comparisons.md"));
         }
 
         internal static string TryFindReadmePath()