From e1ced4deab57eabc4b7ca904e2b76649d88c397b Mon Sep 17 00:00:00 2001
From: Benjamin Michaelis <git@relay.benjamin.michaelis.net>
Date: Sun, 17 May 2026 08:50:04 -0700
Subject: [PATCH 1/3] Extract hard-coded routes into centralized constants
 (issue #747)

- Add Constants/RouteConstants.cs with StaticPages string constants,
  NonContentRoutes HashSet, and SeoMetadata dictionary for sitemap config
- Add src/constants/routes.js mirroring the C# constants for the frontend,
  exporting ROUTES, NON_CONTENT_ROUTES, NAVIGATION_LINKS, and isContentPagePath
- Refactor useSiteShell.js isContentPage to use NON_CONTENT_ROUTES.some()
  with Array path matching as suggested in issue #747, with percentComplete
  as a secondary check
- Refactor SidebarPanel.vue to import NAVIGATION_LINKS from routes.js,
  removing the inline hard-coded navLinks definition
- Refactor SitemapXmlHelpers.cs to use RouteConstants.SeoMetadata.RouteConfig
  dictionary lookups instead of switch expressions
- Update HomeController.cs Route attributes to reference RouteConstants.StaticPages
  string constants instead of hard-coded string literals
---
 .../Constants/RouteConstants.cs               | 76 +++++++++++++++++++
 .../Controllers/HomeController.cs             | 11 +--
 .../Helpers/SitemapXmlHelpers.cs              | 29 +++----
 .../src/components/SidebarPanel.vue           | 28 +------
 .../src/composables/useSiteShell.js           | 17 ++++-
 EssentialCSharp.Web/src/constants/routes.js   | 74 ++++++++++++++++++
 6 files changed, 189 insertions(+), 46 deletions(-)
 create mode 100644 EssentialCSharp.Web/Constants/RouteConstants.cs
 create mode 100644 EssentialCSharp.Web/src/constants/routes.js

diff --git a/EssentialCSharp.Web/Constants/RouteConstants.cs b/EssentialCSharp.Web/Constants/RouteConstants.cs
new file mode 100644
index 00000000..3a96d828
--- /dev/null
+++ b/EssentialCSharp.Web/Constants/RouteConstants.cs
@@ -0,0 +1,76 @@
+namespace EssentialCSharp.Web.Constants;
+
+/// <summary>
+/// Centralized definition of application routes and their metadata.
+/// This constant provides a single source of truth for route paths,
+/// making it easier to maintain and update routes across the application.
+/// </summary>
+public static class RouteConstants
+{
+    /// <summary>
+    /// Static page routes that are not content pages (e.g., informational, utility pages).
+    /// Content pages are dynamically loaded from sitemap.json.
+    /// </summary>
+    public static class StaticPages
+    {
+        public const string Home = "/home";
+        public const string About = "/about";
+        public const string Guidelines = "/guidelines";
+        public const string Announcements = "/announcements";
+        public const string TermsOfService = "/termsofservice";
+    }
+
+    /// <summary>
+    /// Set of non-content route paths. Use this to determine if a requested path
+    /// is a static page (non-content) or a content page (from sitemap).
+    /// </summary>
+    public static readonly HashSet<string> NonContentRoutes = new(StringComparer.OrdinalIgnoreCase)
+    {
+        StaticPages.Home,
+        StaticPages.About,
+        StaticPages.Guidelines,
+        StaticPages.Announcements,
+        StaticPages.TermsOfService
+    };
+
+    /// <summary>
+    /// SEO metadata for routes used in sitemap generation.
+    /// Maps route paths to their change frequency and priority values.
+    /// </summary>
+    public static class SeoMetadata
+    {
+        public enum ChangeFrequency
+        {
+            Always,
+            Hourly,
+            Daily,
+            Weekly,
+            Monthly,
+            Yearly,
+            Never
+        }
+
+        /// <summary>
+        /// Maps route paths to (ChangeFrequency, Priority) tuples for sitemap.xml generation.
+        /// Priority is a decimal value between 0.0 and 1.0 (0.5 is the default).
+        /// </summary>
+        public static readonly Dictionary<string, (ChangeFrequency, decimal)> RouteConfig =
+            new(StringComparer.OrdinalIgnoreCase)
+            {
+                { StaticPages.Home, (ChangeFrequency.Monthly, 0.5m) },
+                { StaticPages.About, (ChangeFrequency.Monthly, 0.5m) },
+                { StaticPages.Guidelines, (ChangeFrequency.Monthly, 0.9m) },
+                { StaticPages.Announcements, (ChangeFrequency.Monthly, 0.5m) },
+                { StaticPages.TermsOfService, (ChangeFrequency.Yearly, 0.2m) }
+            };
+    }
+
+    /// <summary>
+    /// Determines if the given path represents a content page (from sitemap)
+    /// versus a static page (non-content).
+    /// </summary>
+    public static bool IsContentPage(string path)
+    {
+        return !NonContentRoutes.Contains(path);
+    }
+}
diff --git a/EssentialCSharp.Web/Controllers/HomeController.cs b/EssentialCSharp.Web/Controllers/HomeController.cs
index de471129..0ef2e717 100644
--- a/EssentialCSharp.Web/Controllers/HomeController.cs
+++ b/EssentialCSharp.Web/Controllers/HomeController.cs
@@ -1,4 +1,5 @@
 using DotnetSitemapGenerator;
+using EssentialCSharp.Web.Constants;
 using EssentialCSharp.Web.Extensions;
 using EssentialCSharp.Web.Helpers;
 using EssentialCSharp.Web.Models;
@@ -48,7 +49,7 @@ public IActionResult Index()
         }
     }
 
-    [Route("/TermsOfService",
+    [Route(RouteConstants.StaticPages.TermsOfService,
        Name = "TermsOfService")]
     public IActionResult TermsOfService()
     {
@@ -56,27 +57,27 @@ public IActionResult TermsOfService()
         return View();
     }
 
-    [Route("/Announcements", Name = "Announcements")]
+    [Route(RouteConstants.StaticPages.Announcements, Name = "Announcements")]
     public IActionResult Announcements()
     {
         ViewBag.PageTitle = "Announcements";
         return View();
     }
 
-    [Route("/about", Name = "about")]
+    [Route(RouteConstants.StaticPages.About, Name = "about")]
     public IActionResult About()
     {
         ViewBag.PageTitle = "About";
         return View();
     }
 
-    [Route("/home", Name = "home")]
+    [Route(RouteConstants.StaticPages.Home, Name = "home")]
     public IActionResult Home()
     {
         return View();
     }
 
-    [Route("/guidelines", Name = "guidelines")]
+    [Route(RouteConstants.StaticPages.Guidelines, Name = "guidelines")]
     public IActionResult Guidelines()
     {
         ViewBag.PageTitle = "Coding Guidelines";
diff --git a/EssentialCSharp.Web/Helpers/SitemapXmlHelpers.cs b/EssentialCSharp.Web/Helpers/SitemapXmlHelpers.cs
index 5db73953..001a163a 100644
--- a/EssentialCSharp.Web/Helpers/SitemapXmlHelpers.cs
+++ b/EssentialCSharp.Web/Helpers/SitemapXmlHelpers.cs
@@ -1,4 +1,5 @@
 using DotnetSitemapGenerator;
+using EssentialCSharp.Web.Constants;
 using EssentialCSharp.Web.Services;
 
 namespace EssentialCSharp.Web.Helpers;
@@ -74,26 +75,26 @@ private static bool IsSitemapRoute(string route) =>
 
     private static ChangeFrequency GetChangeFrequencyForRoute(string route)
     {
-        return route.ToLowerInvariant() switch
+        var normalizedRoute = route.TrimStart('/').ToLowerInvariant();
+        
+        if (RouteConstants.SeoMetadata.RouteConfig.TryGetValue(normalizedRoute, out var config))
         {
-            "/termsofservice" => ChangeFrequency.Yearly,
-            "/announcements" => ChangeFrequency.Monthly,
-            "/guidelines" => ChangeFrequency.Monthly,
-            _ => ChangeFrequency.Monthly
-        };
+            return (ChangeFrequency)(int)config.Item1;
+        }
+        
+        return ChangeFrequency.Monthly;
     }
 
     private static decimal GetPriorityForRoute(string route)
     {
-        return route.ToLowerInvariant() switch
+        var normalizedRoute = route.TrimStart('/').ToLowerInvariant();
+        
+        if (RouteConstants.SeoMetadata.RouteConfig.TryGetValue(normalizedRoute, out var config))
         {
-            "/home" => 0.5M,
-            "/about" => 0.5M,
-            "/announcements" => 0.5M,
-            "/guidelines" => 0.9M,
-            "/termsofservice" => 0.2M,
-            _ => 0.5M
-        };
+            return config.Item2;
+        }
+        
+        return 0.5M;
     }
 
 }
diff --git a/EssentialCSharp.Web/src/components/SidebarPanel.vue b/EssentialCSharp.Web/src/components/SidebarPanel.vue
index 22e5f173..7ea3e3db 100644
--- a/EssentialCSharp.Web/src/components/SidebarPanel.vue
+++ b/EssentialCSharp.Web/src/components/SidebarPanel.vue
@@ -1,35 +1,11 @@
 <script setup>
 import { inject } from "vue";
 import TocTree from "./TocTree.vue";
+import { NAVIGATION_LINKS } from "../constants/routes.js";
 
 const shell = inject("shell");
 const currentPath = window.location.pathname.toLowerCase();
-const navLinks = [
-    {
-        href: "/home",
-        iconClass: "fas fa-home me-2",
-        label: "Home",
-        activePaths: ["/", "/home"]
-    },
-    {
-        href: "/about",
-        iconClass: "fas fa-book me-2",
-        label: "About",
-        activePaths: ["/about"]
-    },
-    {
-        href: "/guidelines",
-        iconClass: "fas fa-code me-2",
-        label: "Guidelines",
-        activePaths: ["/guidelines"]
-    },
-    {
-        href: "/announcements",
-        iconClass: "fas fa-bullhorn me-2",
-        label: "Announcements",
-        activePaths: ["/announcements"]
-    }
-];
+const navLinks = NAVIGATION_LINKS;
 
 function isActivePath(paths) {
     return paths.includes(currentPath);
diff --git a/EssentialCSharp.Web/src/composables/useSiteShell.js b/EssentialCSharp.Web/src/composables/useSiteShell.js
index 206b6e44..9f9adc86 100644
--- a/EssentialCSharp.Web/src/composables/useSiteShell.js
+++ b/EssentialCSharp.Web/src/composables/useSiteShell.js
@@ -1,5 +1,6 @@
 import { computed, nextTick, onMounted, onUnmounted, reactive, ref, watch } from "vue";
 import { useWindowSize } from "./useWindowSize.js";
+import { NON_CONTENT_ROUTES } from "../constants/routes.js";
 
 const SMALL_SCREEN_SIZE = 768;
 
@@ -71,7 +72,21 @@ export function useSiteShell() {
     const smallScreen = computed(() => (windowWidth.value || 0) < SMALL_SCREEN_SIZE);
     const currentPage = findCurrentPage([], tocData) ?? [];
     const chapterParentPage = currentPage.find((parent) => parent.level === 0) ?? null;
-    const isContentPage = computed(() => percentComplete.value !== null);
+    
+    /**
+     * Determines if the current page is a content page (from sitemap) or a static page.
+     * Checks against the NON_CONTENT_ROUTES array and falls back to percentComplete check
+     * for additional verification.
+     */
+    const isContentPage = computed(() => {
+        const currentPath = window.location.pathname.toLowerCase();
+        const isStaticPage = NON_CONTENT_ROUTES.some(route => 
+            currentPath === route.toLowerCase() || 
+            currentPath.startsWith(route.toLowerCase() + '/')
+        );
+        
+        return !isStaticPage && percentComplete.value !== null;
+    });
 
     for (const item of currentPage) {
         expandedTocs.add(item.key);
diff --git a/EssentialCSharp.Web/src/constants/routes.js b/EssentialCSharp.Web/src/constants/routes.js
new file mode 100644
index 00000000..23dd336b
--- /dev/null
+++ b/EssentialCSharp.Web/src/constants/routes.js
@@ -0,0 +1,74 @@
+/**
+ * Centralized route constants for the frontend.
+ * Mirrors the backend RouteConstants to ensure consistency across frontend and backend.
+ * Update these whenever routes are added, removed, or changed.
+ */
+
+export const ROUTES = {
+    HOME: '/home',
+    ABOUT: '/about',
+    GUIDELINES: '/guidelines',
+    ANNOUNCEMENTS: '/announcements',
+    TERMS_OF_SERVICE: '/termsofservice'
+};
+
+/**
+ * Array of non-content route paths.
+ * Use with Array.includes() to determine if a path is a static page vs. a content page.
+ */
+export const NON_CONTENT_ROUTES = [
+    ROUTES.HOME,
+    ROUTES.ABOUT,
+    ROUTES.GUIDELINES,
+    ROUTES.ANNOUNCEMENTS,
+    ROUTES.TERMS_OF_SERVICE
+];
+
+/**
+ * Navigation link definitions for the sidebar.
+ * Each link includes href, label, icon class, and active path matching patterns.
+ */
+export const NAVIGATION_LINKS = [
+    {
+        href: ROUTES.HOME,
+        label: 'Home',
+        iconClass: 'fas fa-home me-2',
+        activePaths: ['/', ROUTES.HOME],
+        key: 'home'
+    },
+    {
+        href: ROUTES.ABOUT,
+        label: 'About',
+        iconClass: 'fas fa-book me-2',
+        activePaths: [ROUTES.ABOUT],
+        key: 'about'
+    },
+    {
+        href: ROUTES.GUIDELINES,
+        label: 'Guidelines',
+        iconClass: 'fas fa-code me-2',
+        activePaths: [ROUTES.GUIDELINES],
+        key: 'guidelines'
+    },
+    {
+        href: ROUTES.ANNOUNCEMENTS,
+        label: 'Announcements',
+        iconClass: 'fas fa-bullhorn me-2',
+        activePaths: [ROUTES.ANNOUNCEMENTS],
+        key: 'announcements'
+    }
+];
+
+/**
+ * Determines if the given path is a content page (from sitemap)
+ * versus a static page (non-content).
+ * @param {string} path - The path to check
+ * @returns {boolean} - True if path is a content page, false if static page
+ */
+export function isContentPagePath(path) {
+    const normalizedPath = path.toLowerCase();
+    return !NON_CONTENT_ROUTES.some(route => 
+        normalizedPath === route.toLowerCase() || 
+        normalizedPath.startsWith(route.toLowerCase() + '/')
+    );
+}

From a414c0bf1c490ffa262e5be9345e2cc3ddf948fd Mon Sep 17 00:00:00 2001
From: Benjamin Michaelis <git@relay.benjamin.michaelis.net>
Date: Sun, 17 May 2026 22:07:47 -0700
Subject: [PATCH 2/3] Fix bugs found in critic review of route constants

- Use DotnetSitemapGenerator.ChangeFrequency directly in RouteConfig,
  eliminating the fragile local enum and the (ChangeFrequency)(int) cast
- Use FrozenSet<string> and FrozenDictionary for NonContentRoutes and
  RouteConfig to make collections truly immutable
- Remove TrimStart('/') from GetChangeFrequencyForRoute and
  GetPriorityForRoute so dictionary keys ('/home', etc.) actually match
- Use isContentPagePath() from routes.js in useSiteShell.js instead of
  duplicating the same inline logic
- Document why TERMS_OF_SERVICE is excluded from NAVIGATION_LINKS
- Add per-route SEO metadata tests to SitemapXmlHelpersTests
---
 .../SitemapXmlHelpersTests.cs                 | 66 +++++++++++++++++++
 .../Constants/RouteConstants.cs               | 59 ++++++-----------
 .../Helpers/SitemapXmlHelpers.cs              | 16 ++---
 .../src/composables/useSiteShell.js           | 14 ++--
 EssentialCSharp.Web/src/constants/routes.js   |  2 +
 5 files changed, 99 insertions(+), 58 deletions(-)

diff --git a/EssentialCSharp.Web.Tests/SitemapXmlHelpersTests.cs b/EssentialCSharp.Web.Tests/SitemapXmlHelpersTests.cs
index b47b49bf..86cc4818 100644
--- a/EssentialCSharp.Web.Tests/SitemapXmlHelpersTests.cs
+++ b/EssentialCSharp.Web.Tests/SitemapXmlHelpersTests.cs
@@ -246,6 +246,72 @@ public async Task GenerateSitemapXml_DoesNotSetLastModifiedDateWhenSiteMappingDa
         await Assert.That(siteMappingNode.LastModificationDate).IsNull();
     }
 
+    [Test]
+    public async Task GenerateSitemapXml_GuidelinesRoute_HasHighPriority()
+    {
+        // Arrange
+        var siteMappings = new List<SiteMapping>();
+        var baseUrl = "https://test.example.com/";
+
+        // Act
+        var routeConfigurationService = Factory.Services.GetRequiredService<IRouteConfigurationService>();
+        SitemapXmlHelpers.GenerateSitemapXml(
+            siteMappings,
+            routeConfigurationService,
+            baseUrl,
+            out var nodes);
+
+        // Assert — /guidelines should have priority 0.9 (higher than default 0.5)
+        var guidelinesNode = nodes.FirstOrDefault(n => n.Url.Contains("/guidelines", StringComparison.OrdinalIgnoreCase));
+        await Assert.That(guidelinesNode).IsNotNull();
+        await Assert.That(guidelinesNode!.Priority).IsEqualTo(0.9M);
+        await Assert.That(guidelinesNode.ChangeFrequency).IsEqualTo(ChangeFrequency.Monthly);
+    }
+
+    [Test]
+    public async Task GenerateSitemapXml_TermsOfServiceRoute_HasYearlyFrequencyAndLowPriority()
+    {
+        // Arrange
+        var siteMappings = new List<SiteMapping>();
+        var baseUrl = "https://test.example.com/";
+
+        // Act
+        var routeConfigurationService = Factory.Services.GetRequiredService<IRouteConfigurationService>();
+        SitemapXmlHelpers.GenerateSitemapXml(
+            siteMappings,
+            routeConfigurationService,
+            baseUrl,
+            out var nodes);
+
+        // Assert — /termsofservice changes rarely (Yearly) and has low priority (0.2)
+        var tosNode = nodes.FirstOrDefault(n => n.Url.Contains("/termsofservice", StringComparison.OrdinalIgnoreCase));
+        await Assert.That(tosNode).IsNotNull();
+        await Assert.That(tosNode!.Priority).IsEqualTo(0.2M);
+        await Assert.That(tosNode.ChangeFrequency).IsEqualTo(ChangeFrequency.Yearly);
+    }
+
+    [Test]
+    public async Task GenerateSitemapXml_UnknownRoute_UsesDefaultSeoValues()
+    {
+        // Arrange
+        var siteMappings = new List<SiteMapping> { CreateSiteMapping(1, 1, true, "test-page-unknown-route") };
+        var baseUrl = "https://test.example.com/";
+
+        // Act
+        var routeConfigurationService = Factory.Services.GetRequiredService<IRouteConfigurationService>();
+        SitemapXmlHelpers.GenerateSitemapXml(
+            siteMappings,
+            routeConfigurationService,
+            baseUrl,
+            out var nodes);
+
+        // Assert — content pages without specific config get default SEO values
+        var contentNode = nodes.FirstOrDefault(n => n.Url.Contains("test-page-unknown-route", StringComparison.OrdinalIgnoreCase));
+        await Assert.That(contentNode).IsNotNull();
+        await Assert.That(contentNode!.Priority).IsEqualTo(0.5M);
+        await Assert.That(contentNode.ChangeFrequency).IsEqualTo(ChangeFrequency.Monthly);
+    }
+
     private static SiteMapping CreateSiteMapping(
         int chapterNumber,
         int pageNumber,
diff --git a/EssentialCSharp.Web/Constants/RouteConstants.cs b/EssentialCSharp.Web/Constants/RouteConstants.cs
index 3a96d828..c3b09086 100644
--- a/EssentialCSharp.Web/Constants/RouteConstants.cs
+++ b/EssentialCSharp.Web/Constants/RouteConstants.cs
@@ -1,15 +1,18 @@
+using System.Collections.Frozen;
+using DotnetSitemapGenerator;
+
 namespace EssentialCSharp.Web.Constants;
 
 /// <summary>
 /// Centralized definition of application routes and their metadata.
-/// This constant provides a single source of truth for route paths,
-/// making it easier to maintain and update routes across the application.
+/// This is the single source of truth for static page route paths.
+/// Update these whenever a static page is added, removed, or renamed.
 /// </summary>
 public static class RouteConstants
 {
     /// <summary>
     /// Static page routes that are not content pages (e.g., informational, utility pages).
-    /// Content pages are dynamically loaded from sitemap.json.
+    /// Content pages are dynamically discovered from sitemap.json.
     /// </summary>
     public static class StaticPages
     {
@@ -21,56 +24,36 @@ public static class StaticPages
     }
 
     /// <summary>
-    /// Set of non-content route paths. Use this to determine if a requested path
-    /// is a static page (non-content) or a content page (from sitemap).
+    /// Immutable set of non-content route paths. Use to determine if a requested path
+    /// is a static page (non-content) rather than a content page (from sitemap).
     /// </summary>
-    public static readonly HashSet<string> NonContentRoutes = new(StringComparer.OrdinalIgnoreCase)
+    public static readonly FrozenSet<string> NonContentRoutes = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
     {
         StaticPages.Home,
         StaticPages.About,
         StaticPages.Guidelines,
         StaticPages.Announcements,
         StaticPages.TermsOfService
-    };
+    }.ToFrozenSet();
 
     /// <summary>
-    /// SEO metadata for routes used in sitemap generation.
-    /// Maps route paths to their change frequency and priority values.
+    /// SEO metadata for static routes used in sitemap.xml generation.
     /// </summary>
     public static class SeoMetadata
     {
-        public enum ChangeFrequency
-        {
-            Always,
-            Hourly,
-            Daily,
-            Weekly,
-            Monthly,
-            Yearly,
-            Never
-        }
-
         /// <summary>
-        /// Maps route paths to (ChangeFrequency, Priority) tuples for sitemap.xml generation.
-        /// Priority is a decimal value between 0.0 and 1.0 (0.5 is the default).
+        /// Immutable map of route paths to (ChangeFrequency, Priority) tuples.
+        /// Keys include the leading slash (e.g. "/home") to match how ASP.NET Core
+        /// exposes routes. Priority is 0.0–1.0; 0.5 is the sitemap default.
         /// </summary>
-        public static readonly Dictionary<string, (ChangeFrequency, decimal)> RouteConfig =
-            new(StringComparer.OrdinalIgnoreCase)
+        public static readonly FrozenDictionary<string, (ChangeFrequency Frequency, decimal Priority)> RouteConfig =
+            new Dictionary<string, (ChangeFrequency, decimal)>(StringComparer.OrdinalIgnoreCase)
             {
-                { StaticPages.Home, (ChangeFrequency.Monthly, 0.5m) },
-                { StaticPages.About, (ChangeFrequency.Monthly, 0.5m) },
-                { StaticPages.Guidelines, (ChangeFrequency.Monthly, 0.9m) },
+                { StaticPages.Home,          (ChangeFrequency.Monthly, 0.5m) },
+                { StaticPages.About,         (ChangeFrequency.Monthly, 0.5m) },
+                { StaticPages.Guidelines,    (ChangeFrequency.Monthly, 0.9m) },
                 { StaticPages.Announcements, (ChangeFrequency.Monthly, 0.5m) },
-                { StaticPages.TermsOfService, (ChangeFrequency.Yearly, 0.2m) }
-            };
-    }
-
-    /// <summary>
-    /// Determines if the given path represents a content page (from sitemap)
-    /// versus a static page (non-content).
-    /// </summary>
-    public static bool IsContentPage(string path)
-    {
-        return !NonContentRoutes.Contains(path);
+                { StaticPages.TermsOfService,(ChangeFrequency.Yearly,  0.2m) }
+            }.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);
     }
 }
diff --git a/EssentialCSharp.Web/Helpers/SitemapXmlHelpers.cs b/EssentialCSharp.Web/Helpers/SitemapXmlHelpers.cs
index 001a163a..52353453 100644
--- a/EssentialCSharp.Web/Helpers/SitemapXmlHelpers.cs
+++ b/EssentialCSharp.Web/Helpers/SitemapXmlHelpers.cs
@@ -75,25 +75,21 @@ private static bool IsSitemapRoute(string route) =>
 
     private static ChangeFrequency GetChangeFrequencyForRoute(string route)
     {
-        var normalizedRoute = route.TrimStart('/').ToLowerInvariant();
-        
-        if (RouteConstants.SeoMetadata.RouteConfig.TryGetValue(normalizedRoute, out var config))
+        if (RouteConstants.SeoMetadata.RouteConfig.TryGetValue(route, out var config))
         {
-            return (ChangeFrequency)(int)config.Item1;
+            return config.Frequency;
         }
-        
+
         return ChangeFrequency.Monthly;
     }
 
     private static decimal GetPriorityForRoute(string route)
     {
-        var normalizedRoute = route.TrimStart('/').ToLowerInvariant();
-        
-        if (RouteConstants.SeoMetadata.RouteConfig.TryGetValue(normalizedRoute, out var config))
+        if (RouteConstants.SeoMetadata.RouteConfig.TryGetValue(route, out var config))
         {
-            return config.Item2;
+            return config.Priority;
         }
-        
+
         return 0.5M;
     }
 
diff --git a/EssentialCSharp.Web/src/composables/useSiteShell.js b/EssentialCSharp.Web/src/composables/useSiteShell.js
index 9f9adc86..752c897b 100644
--- a/EssentialCSharp.Web/src/composables/useSiteShell.js
+++ b/EssentialCSharp.Web/src/composables/useSiteShell.js
@@ -1,6 +1,6 @@
 import { computed, nextTick, onMounted, onUnmounted, reactive, ref, watch } from "vue";
 import { useWindowSize } from "./useWindowSize.js";
-import { NON_CONTENT_ROUTES } from "../constants/routes.js";
+import { isContentPagePath } from "../constants/routes.js";
 
 const SMALL_SCREEN_SIZE = 768;
 
@@ -75,17 +75,11 @@ export function useSiteShell() {
     
     /**
      * Determines if the current page is a content page (from sitemap) or a static page.
-     * Checks against the NON_CONTENT_ROUTES array and falls back to percentComplete check
-     * for additional verification.
+     * Checks against the NON_CONTENT_ROUTES array via isContentPagePath and falls back
+     * to percentComplete check for additional verification that content data is loaded.
      */
     const isContentPage = computed(() => {
-        const currentPath = window.location.pathname.toLowerCase();
-        const isStaticPage = NON_CONTENT_ROUTES.some(route => 
-            currentPath === route.toLowerCase() || 
-            currentPath.startsWith(route.toLowerCase() + '/')
-        );
-        
-        return !isStaticPage && percentComplete.value !== null;
+        return isContentPagePath(window.location.pathname) && percentComplete.value !== null;
     });
 
     for (const item of currentPage) {
diff --git a/EssentialCSharp.Web/src/constants/routes.js b/EssentialCSharp.Web/src/constants/routes.js
index 23dd336b..aceb4df9 100644
--- a/EssentialCSharp.Web/src/constants/routes.js
+++ b/EssentialCSharp.Web/src/constants/routes.js
@@ -27,6 +27,8 @@ export const NON_CONTENT_ROUTES = [
 /**
  * Navigation link definitions for the sidebar.
  * Each link includes href, label, icon class, and active path matching patterns.
+ * Note: ROUTES.TERMS_OF_SERVICE is intentionally excluded from this list —
+ * it is a legal page linked in the footer, not a primary navigation destination.
  */
 export const NAVIGATION_LINKS = [
     {

From cbe21bb35414e141c540e4320042fc7588df9897 Mon Sep 17 00:00:00 2001
From: Benjamin Michaelis <git@relay.benjamin.michaelis.net>
Date: Sun, 17 May 2026 22:11:02 -0700
Subject: [PATCH 3/3] Make FrozenSet comparer explicit for NonContentRoutes

Pass StringComparer.OrdinalIgnoreCase explicitly to ToFrozenSet() to
guarantee case-insensitive lookup, rather than relying on comparer
propagation from the source HashSet.
---
 EssentialCSharp.Web/Constants/RouteConstants.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/EssentialCSharp.Web/Constants/RouteConstants.cs b/EssentialCSharp.Web/Constants/RouteConstants.cs
index c3b09086..0e06d8c6 100644
--- a/EssentialCSharp.Web/Constants/RouteConstants.cs
+++ b/EssentialCSharp.Web/Constants/RouteConstants.cs
@@ -34,7 +34,7 @@ public static class StaticPages
         StaticPages.Guidelines,
         StaticPages.Announcements,
         StaticPages.TermsOfService
-    }.ToFrozenSet();
+    }.ToFrozenSet(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
     /// SEO metadata for static routes used in sitemap.xml generation.