diff --git a/GenHub/GenHub.Core/Constants/ContentConstants.cs b/GenHub/GenHub.Core/Constants/ContentConstants.cs
index 0bc3c907c..96d6a6db0 100644
--- a/GenHub/GenHub.Core/Constants/ContentConstants.cs
+++ b/GenHub/GenHub.Core/Constants/ContentConstants.cs
@@ -94,4 +94,31 @@ public static class ContentConstants
     /// Maximum allowed size for the content catalog in bytes (10 MB).
     /// </summary>
     public const long MaxCatalogSizeBytes = 10 * ConversionConstants.BytesPerMegabyte;
+
+    /// <summary>
+    /// Shared resolver/display metadata key for map player counts.
+    /// Builtin and catalog publishers should set this so download cards can render a consistent badge.
+    /// </summary>
+    public const string PlayerCountMetadataKey = "playerCount";
+
+    /// <summary>
+    /// Shared resolver/display metadata key for content categories (AOA, Compstomp, ModDB category, etc.).
+    /// </summary>
+    public const string CategoryMetadataKey = "category";
+
+    /// <summary>
+    /// Display metadata key for a comma-separated list of included/required content names
+    /// (e.g. catalog ContentBundle dependencies resolved to friendly titles).
+    /// </summary>
+    public const string IncludesSummaryMetadataKey = "includesSummary";
+
+    /// <summary>
+    /// Number of recent releases and addons to eagerly preload extended details for.
+    /// </summary>
+    public const int PreloadRecentItemsLimit = 5;
+
+    /// <summary>
+    /// Maximum concurrent background requests when preloading recent item details.
+    /// </summary>
+    public const int PreloadConcurrencyLimit = 3;
 }
\ No newline at end of file
diff --git a/GenHub/GenHub.Core/Constants/DirectoryNames.cs b/GenHub/GenHub.Core/Constants/DirectoryNames.cs
index 47097cc18..19b341d80 100644
--- a/GenHub/GenHub.Core/Constants/DirectoryNames.cs
+++ b/GenHub/GenHub.Core/Constants/DirectoryNames.cs
@@ -59,4 +59,14 @@ public static class DirectoryNames
     /// Directory for storing tool workspaces.
     /// </summary>
     public const string ToolWorkspaces = "ToolWorkspaces";
+
+    /// <summary>
+    /// Directory for persistent Playwright browser profiles (cookies/storage for bot-protected sites).
+    /// </summary>
+    public const string BrowserProfiles = "BrowserProfiles";
+
+    /// <summary>
+    /// Directory for the app-owned Playwright Chromium runtime (not the system Chrome/Edge install).
+    /// </summary>
+    public const string BrowserRuntime = "BrowserRuntime";
 }
diff --git a/GenHub/GenHub.Core/Constants/ModDBConstants.cs b/GenHub/GenHub.Core/Constants/ModDBConstants.cs
index 2deed935c..f8b9c8d3d 100644
--- a/GenHub/GenHub.Core/Constants/ModDBConstants.cs
+++ b/GenHub/GenHub.Core/Constants/ModDBConstants.cs
@@ -72,6 +72,12 @@ public static class ModDBConstants
     /// <summary>ModDB website URL.</summary>
     public const string PublisherWebsite = BaseUrl;
 
+    /// <summary>
+    /// On-disk Playwright browser profile name used to persist the Cloudflare clearance cookie so
+    /// the user only solves the bot challenge once per session (and across restarts until expiry).
+    /// </summary>
+    public const string BrowserProfileName = "moddb";
+
     /// <summary>Short description for publisher card display.</summary>
     public const string ShortDescription = "Community mods, maps, and content from ModDB";
 
@@ -184,6 +190,29 @@ public static class ModDBConstants
     /// <summary>Value for filter parameter when enabled.</summary>
     public const string FilterEnabledValue = "t";
 
+    // ===== Sort Values =====
+
+    /// <summary>Sort: Date descending (newest first).</summary>
+    public const string SortDateDesc = "date-desc";
+
+    /// <summary>Sort: Date ascending (oldest first).</summary>
+    public const string SortDateAsc = "date-asc";
+
+    /// <summary>Sort: Visits / Popularity descending.</summary>
+    public const string SortVisitDesc = "visit-desc";
+
+    /// <summary>Sort: Rating descending.</summary>
+    public const string SortRatingDesc = "rating-desc";
+
+    /// <summary>Sort: Name ascending (A-Z).</summary>
+    public const string SortNameAsc = "name-asc";
+
+    /// <summary>Sort: Name descending (Z-A).</summary>
+    public const string SortNameDesc = "name-desc";
+
+    /// <summary>Default sort value for ModDB searches and listings (newest first).</summary>
+    public const string DefaultSort = SortDateDesc;
+
     // ===== Category Values =====
 
     // Downloads Section - Releases
@@ -356,6 +385,34 @@ public static class ModDBConstants
     /// <summary>Metadata key for original category.</summary>
     public const string OriginalCategoryMetadataKey = "moddbCategory";
 
+    /// <summary>Metadata key for identifying if content is a mod.</summary>
+    public const string IsModMetadataKey = "IsMod";
+
+    /// <summary>Metadata key for parent mod URL.</summary>
+    public const string ParentModUrlMetadataKey = "ParentModUrl";
+
+    // ===== Playwright / Scraping Constants =====
+
+    /// <summary>Default timeout for page navigation (ms).</summary>
+    public const int DefaultGotoTimeout = 30000;
+
+    /// <summary>
+    /// Default timeout for waiting for a selector (ms). ModDB sits behind Cloudflare; the headed
+    /// browser persistent profile usually receives the clearance cookie after verification, but 15 s gives a safe margin
+    /// for manual challenge solves before the scraper parses whatever it has.
+    /// </summary>
+    public const int DefaultSelectorTimeout = 15000;
+
+    /// <summary>
+    /// How long (ms) the listing scrape waits for the user to solve a Cloudflare challenge in the
+    /// visible browser before giving up. Long enough for a manual "I am not a robot" click; the
+    /// page stays open after the deadline so the user can finish and retry.
+    /// </summary>
+    public const int VerificationWaitTimeoutMs = 120000;
+
+    /// <summary>Selector for content items in listing pages (Fallback).</summary>
+    public const string DefaultListItemSelector = "div.row.rowcontent, div.table tr";
+
     // ===== Error Messages =====
 
     /// <summary>Error message for invalid URL.</summary>
diff --git a/GenHub/GenHub.Core/Constants/ModDBParserConstants.cs b/GenHub/GenHub.Core/Constants/ModDBParserConstants.cs
index 55ab7fa3c..4f61403a9 100644
--- a/GenHub/GenHub.Core/Constants/ModDBParserConstants.cs
+++ b/GenHub/GenHub.Core/Constants/ModDBParserConstants.cs
@@ -17,6 +17,9 @@ public static class ModDBParserConstants
     /// <summary>Selector for developer/publisher links.</summary>
     public const string DeveloperSelector = "a[href*='/members/'], a[href*='/company/']";
 
+    /// <summary>Selector for the profile/mod info box that carries the real developer name.</summary>
+    public const string DeveloperProfileSelector = "#modsinfo a[href*='/members/'], #modsinfo a[href*='/company/'], .sidecolumn a[href*='/members/'], .sidecolumn a[href*='/company/']";
+
     /// <summary>Selector for release date.</summary>
     public const string ReleaseDateSelector = "time[datetime], .date, .released";
 
@@ -59,7 +62,7 @@ public static class ModDBParserConstants
     public const string FileMetadataValueSelector = "td:last-child";
 
     /// <summary>Selector for the main download button on file pages.</summary>
-    public const string MainDownloadButtonSelector = "a.download, a.downloadarea, .downloadbutton a, a[href*='/downloads/start/']";
+    public const string MainDownloadButtonSelector = "a.download, a.downloadarea, .downloadbutton a, a[href*='/downloads/start/'], a[href*='/addons/start/']";
 
     /// <summary>Selector for download size on the button.</summary>
     public const string DownloadSizeSelector = ".download .size, .downloadbutton .size";
@@ -87,10 +90,13 @@ public static class ModDBParserConstants
     // ===== Description/Summary Selectors =====
 
     /// <summary>Selector for full description content.</summary>
-    public const string FullDescriptionSelector = "#articlebrowse, .summary .content, .description .content, .modtext";
+    public const string FullDescriptionSelector = "#downloaddescription, #downloadsummary, #articlebrowse .articlebody, .articlebody, #modsummary, .modtext, #profile .description, #description, #articlebrowse, .summary .content, .description .content";
+
+    /// <summary>Selector for the file-page body copy (not the breadcrumb .summary trail).</summary>
+    public const string FileDescriptionSelector = "#downloaddescription, #downloadsummary";
 
-    /// <summary>Selector for truncated summary.</summary>
-    public const string SummarySelector = ".summary p, .description p";
+    /// <summary>Selector for summary or description container.</summary>
+    public const string SummarySelector = ".description, .rubric, p[itemprop='description']";
 
     // ===== Legacy File Selectors =====
 
@@ -98,28 +104,31 @@ public static class ModDBParserConstants
     public const string FilesTableSelector = "table.filelist, .table.files, #files";
 
     /// <summary>Selector for individual file rows.</summary>
-    public const string FileRowSelector = "tr.file, .row.file, .file";
+    public const string FileRowSelector = "tr.file, .row.file, .file, .row.rowcontent";
 
     /// <summary>Selector for file name.</summary>
-    public const string FileNameSelector = "h5, h4, .name, .title";
+    public const string FileNameSelector = "h4 a, h5 a, h3 a, .heading a, .title a, a.title, .name a, h5, h4, .name, .title";
 
     /// <summary>Selector for file version.</summary>
     public const string FileVersionSelector = ".version, .ver";
 
     /// <summary>Selector for file size.</summary>
-    public const string FileSizeSelector = ".size, .filesize";
+    public const string FileSizeSelector = ".size, .filesize, .filesizes, span.size";
+
+    /// <summary>Selector for file subheading or metadata row.</summary>
+    public const string FileSubheadingSelector = ".subheading, span.subheading, .meta, .details, .info, p.summary, .summary";
 
     /// <summary>Selector for file upload date.</summary>
-    public const string FileDateSelector = "time[datetime], .date, .uploaded";
+    public const string FileDateSelector = "time[datetime], .date, .uploaded, time";
 
     /// <summary>Selector for file category.</summary>
-    public const string FileCategorySelector = ".category, .type";
+    public const string FileCategorySelector = ".category, .type, span.category";
 
     /// <summary>Selector for file uploader.</summary>
-    public const string FileUploaderSelector = ".uploader, .author, a[href*='/members/']";
+    public const string FileUploaderSelector = ".uploader, .author, a[href*='/members/'], a[href*='/company/']";
 
     /// <summary>Selector for file download link (robust).</summary>
-    public const string FileDownloadSelector = "a.button.download, a[href*='/downloads/start/'], .download a";
+    public const string FileDownloadSelector = "a.button, a.buttonlarge, a.download, a.btn, a[href*='/downloads/start/'], a[href*='/addons/start/'], a[href*='/downloads/'], a[href*='/addons/'], .download a, .actions a";
 
     /// <summary>Selector for file MD5 hash.</summary>
     public const string FileMd5Selector = ".md5, .hash";
@@ -130,22 +139,41 @@ public static class ModDBParserConstants
     // ===== Videos Section Selectors =====
 
     /// <summary>Selector for embedded video iframes.</summary>
-    public const string VideoSelector = "iframe[src*='youtube'], iframe[src*='vimeo'], iframe[src*='youtu.be']";
+    public const string VideoSelector = "iframe[src*='youtube'], iframe[src*='youtube-nocookie'], iframe[src*='youtu.be'], iframe[src*='vimeo'], iframe[src*='dailymotion'], iframe[src*='moddb.com/media/iframe'], iframe[src*='moddb.com/media/embed'], iframe[src*='moddb.com/videos/iframe'], iframe[src*='moddb.com/videos/embed']";
+
+    /// <summary>Selector for video gallery containers and items.</summary>
+    public const string VideoGallerySelector = "#videobox, #videosbrowse, #mediabrowse, .mediarow, .mediabox";
+
+    /// <summary>Selector for video links.</summary>
+    public const string VideoLinkSelector = "a[href*='/videos/'], a[href*='youtube.com/watch'], a[href*='youtu.be/'], a[href*='vimeo.com/']";
 
     /// <summary>Selector for video thumbnails.</summary>
-    public const string VideoThumbnailSelector = ".thumbnail img, .preview img";
+    public const string VideoThumbnailSelector = ".thumbnail img, .preview img, img";
 
     /// <summary>Selector for video titles.</summary>
-    public const string VideoTitleSelector = ".title, h3, h4";
+    public const string VideoTitleSelector = ".title, h3, h4, h5, .caption";
+
+    /// <summary>Selector for recommendation and related content sections.</summary>
+    public const string RecommendationsSelector = "#recommendations, .recommendations, #related, .related, #similar, .similar, #fansalsoviewed, .fansalsoviewed, .youmayalso, [class*='recommend'], [id*='recommend'], [class*='similar'], [id*='similar']";
 
     // ===== Images Section Selectors =====
 
     /// <summary>Selector for image gallery container.</summary>
-    public const string ImageGallerySelector = ".mediarow, .screenshot, .imagebox, .gallery";
+    public const string ImageGallerySelector = "#imagebox, #mediaimage, #imagebrowse, #mediabrowse, .mediarow";
+
+    /// <summary>
+    /// Selector for gallery images only. Deliberately excludes a blanket
+    /// <c>img[src*='media.moddb.com']</c> match, which previously pulled game icons, member
+    /// avatars, and file-page chrome into the Media tab.
+    /// </summary>
+    public const string GalleryImageSelector = "#imagebox img, #mediaimage img, #imagebrowse img, #mediabrowse img, .mediarow img, .media .holder img, #downloadsummary img, #downloaddescription img, .preview img, a[href*='/mods/'][href*='/images/'] img";
 
     /// <summary>Selector for individual images.</summary>
     public const string ImageSelector = "img";
 
+    /// <summary>Sidebar/profile containers whose images are icons and avatars, not gallery media.</summary>
+    public const string ImageSidebarSelector = "#modsinfo, #downloadsprofilemenu, #profile, .sidecolumn, aside";
+
     /// <summary>Selector for image thumbnails.</summary>
     public const string ImageThumbnailSelector = ".thumbnail img, .thumb img";
 
@@ -197,20 +225,24 @@ public static class ModDBParserConstants
 
     // ===== Comments Section Selectors =====
 
-    /// <summary>Selector for comments container.</summary>
-    public const string CommentsSelector = ".comment, .post, .comments";
+    /// <summary>Selector for comments container. Do not use #commentform — that is the composer.</summary>
+    public const string CommentsSelector = "#commentsbrowse";
 
-    /// <summary>Selector for individual comment rows.</summary>
-    public const string CommentRowSelector = ".comment, .post";
+    /// <summary>
+    /// Selector for posted comment rows. Requires the exact <c>rowcomment</c> class so the
+    /// composer rows (<c>rowcommentguest</c>, <c>rowcommentsummary</c>, <c>rowcommentemail</c>)
+    /// and <c>#commentform</c> are not treated as comments.
+    /// </summary>
+    public const string CommentRowSelector = ".row.rowcomment, .rowcomment";
 
     /// <summary>Selector for comment authors.</summary>
-    public const string CommentAuthorSelector = ".author, .username, a[href*='/members/']";
+    public const string CommentAuthorSelector = ".author, .username, .heading a, a[href*='/members/']";
 
-    /// <summary>Selector for comment content.</summary>
-    public const string CommentContentSelector = ".content, .body, .text";
+    /// <summary>Selector for comment content. Avoids bare <c>p</c> which matches login chrome and CSS blobs.</summary>
+    public const string CommentContentSelector = ":scope > .commentbody, .commentbody, p.comment";
 
     /// <summary>Selector for comment dates.</summary>
-    public const string CommentDateSelector = "time[datetime], .date";
+    public const string CommentDateSelector = "time[datetime], time, .date, .datetime, span.subheading";
 
     /// <summary>Selector for comment karma/votes.</summary>
     public const string CommentKarmaSelector = ".karma, .votes, .goodkarma, .badkarma";
@@ -245,4 +277,100 @@ public static class ModDBParserConstants
 
     /// <summary>Pattern for games URLs.</summary>
     public const string GamesUrlPattern = "/games/";
+
+    // ===== Mod Detail Page Selectors =====
+
+    /// <summary>Selector for the downloads section on mod pages.</summary>
+    public const string DownloadsSectionSelector = "#downloads, .downloads, .files";
+
+    /// <summary>Selector for the addons section on mod pages.</summary>
+    public const string AddonsSectionSelector = "#addons, .addons";
+
+    /// <summary>Selector for the tabs/navigation on mod pages.</summary>
+    public const string TabsSelector = ".tabs, .navigation, nav";
+
+    /// <summary>Selector for individual tab links.</summary>
+    public const string TabLinkSelector = "a[href*='/downloads'], a[href*='/addons']";
+
+    // ===== Metadata Keys (Internal/Normalized) =====
+
+    /// <summary>Metadata key for filename.</summary>
+    public const string MetadataFilename = "filename";
+
+    /// <summary>Alternative metadata key for filename.</summary>
+    public const string MetadataFileNameAlt = "file name";
+
+    /// <summary>Alternative metadata key for file.</summary>
+    public const string MetadataFileAlt = "file";
+
+    /// <summary>Metadata key for size.</summary>
+    public const string MetadataSize = "size";
+
+    /// <summary>Alternative metadata key for size.</summary>
+    public const string MetadataFileSizeAlt = "file size";
+
+    /// <summary>Metadata key for uploader.</summary>
+    public const string MetadataUploader = "uploader";
+
+    /// <summary>Alternative metadata key for uploaded by.</summary>
+    public const string MetadataUploadedBy = "uploaded by";
+
+    /// <summary>Alternative metadata key for author.</summary>
+    public const string MetadataAuthor = "author";
+
+    /// <summary>Metadata key for category.</summary>
+    public const string MetadataCategory = "category";
+
+    /// <summary>Alternative metadata key for file category.</summary>
+    public const string MetadataFileCategory = "file category";
+
+    /// <summary>Alternative metadata key for type.</summary>
+    public const string MetadataType = "type";
+
+    /// <summary>Metadata key for MD5 hash.</summary>
+    public const string MetadataMd5Hash = "md5 hash";
+
+    /// <summary>Metadata key for MD5 hash (alternative).</summary>
+    public const string MetadataMd5HashAlt = "md5hash";
+
+    /// <summary>Alternative metadata key for MD5 checksum.</summary>
+    public const string MetadataMd5Checksum = "md5 checksum";
+
+    /// <summary>Alternative metadata key for MD5.</summary>
+    public const string MetadataMd5 = "md5";
+
+    /// <summary>Alternative metadata key for hash.</summary>
+    public const string MetadataHash = "hash";
+
+    /// <summary>Alternative metadata key for checksum.</summary>
+    public const string MetadataChecksum = "checksum";
+
+    /// <summary>Metadata key for total downloads.</summary>
+    public const string MetadataTotalDownloads = "total downloads";
+
+    /// <summary>Alternative metadata key for download count.</summary>
+    public const string MetadataDownloadCount = "download count";
+
+    /// <summary>Metadata key for added date.</summary>
+    public const string MetadataAdded = "added";
+
+    /// <summary>Metadata key for updated date.</summary>
+    public const string MetadataUpdated = "updated";
+
+    // ===== Additional Selectors =====
+
+    /// <summary>Selector for fallback titles (h1, h2, etc).</summary>
+    public const string FallbackTitleSelector = "h2 a, h1 a, h2, h1";
+
+    /// <summary>Selector for file detail page title heading outside the global headerbox.</summary>
+    public const string FilePageTitleSelector = ".midcolumn h2, .columncenter h2, #downloadsfiles h2, #downloadsinfo h2, #downloads h2, .heading h2, .title h2, h2.title, .midcolumn h3, .heading h3";
+
+    /// <summary>Selector for file detail page preview images.</summary>
+    public const string FilePreviewImagesSelector = "#downloadmedia img, #downloadsmedia img, #preview img, #media img, .mediagallery img, .imagebox img, #imagebox img, #downloaddescription img, #downloadsummary img, a[href*='/images/'] img, .previewholder img, .media .holder img";
+
+    /// <summary>Selector for file description container elements.</summary>
+    public const string FileDescriptionContainerSelector = "#downloaddescription, #downloadsummary, #description, .description, .articlebody, #profiletotal";
+
+    /// <summary>Regex pattern for extracting parent mod path.</summary>
+    public const string ParentModPathRegex = @"(/mods/[^/]+)/(?:downloads|addons)/";
 }
diff --git a/GenHub/GenHub.Core/Helpers/HtmlTextHelper.cs b/GenHub/GenHub.Core/Helpers/HtmlTextHelper.cs
new file mode 100644
index 000000000..b19f11d94
--- /dev/null
+++ b/GenHub/GenHub.Core/Helpers/HtmlTextHelper.cs
@@ -0,0 +1,145 @@
+using System;
+using System.Net;
+using System.Text.RegularExpressions;
+
+namespace GenHub.Core.Helpers;
+
+/// <summary>
+/// Provides high-performance utilities for stripping HTML tags, decoding HTML entities,
+/// and normalizing text descriptions for display across the application.
+/// </summary>
+public static partial class HtmlTextHelper
+{
+    /// <summary>
+    /// Converts an HTML snippet or formatted description into clean, normalized plain text:
+    /// - Replaces &lt;br&gt; and block element closures (&lt;/p&gt;, &lt;/div&gt;, etc.) with line breaks.
+    /// - Strips all remaining HTML tags.
+    /// - Decodes HTML entities (e.g., &amp;amp;, &amp;quot;, &amp;gt;, &amp;nbsp;).
+    /// - Normalizes whitespace and excessive blank lines.
+    /// - Uses the platform newline format.
+    /// </summary>
+    /// <param name="html">The raw HTML or formatted text string to normalize.</param>
+    /// <returns>Normalized plain text, or empty string if input is null or whitespace.</returns>
+    public static string NormalizeHtml(string? html)
+    {
+        if (string.IsNullOrWhiteSpace(html))
+        {
+            return string.Empty;
+        }
+
+        // 0. Remove script and style elements along with their contents
+        var text = ScriptTagRegex().Replace(html, string.Empty);
+        text = StyleTagRegex().Replace(text, string.Empty);
+
+        // 1. Convert <br> tags to newline
+        text = BrTagRegex().Replace(text, "\n");
+
+        // 2. Convert paragraph closing tags to double newline for paragraph separation
+        text = ParagraphCloseTagRegex().Replace(text, "\n\n");
+
+        // 3. Convert other block-level closing tags and <hr> tags to newline
+        text = BlockCloseTagRegex().Replace(text, "\n");
+
+        // 4. Strip all remaining HTML/XML tags
+        text = HtmlTagRegex().Replace(text, string.Empty);
+
+        // 5. Decode HTML entities (&nbsp;, &gt;, &quot;, &#39;, numeric entities, etc.)
+        text = WebUtility.HtmlDecode(text);
+
+        // 6. Normalize non-breaking spaces and line endings
+        text = text.Replace('\u00A0', ' ')
+                   .Replace("\r\n", "\n")
+                   .Replace('\r', '\n');
+
+        // 7. Clean trailing whitespace on lines and collapse excess blank lines
+        text = TrailingWhitespaceBeforeNewlineRegex().Replace(text, "\n");
+        text = ExcessBlankLinesRegex().Replace(text, "\n\n");
+
+        // 8. Trim and unify with environment newline
+        text = text.Trim();
+        text = text.Replace("\n", Environment.NewLine);
+
+        return text;
+    }
+
+    /// <summary>
+    /// Converts an HTML snippet or multi-line text into a single-line summary without HTML tags,
+    /// collapsing all whitespace runs into a single space, and optionally truncating with an ellipsis.
+    /// </summary>
+    /// <param name="htmlOrText">The input HTML or text string.</param>
+    /// <param name="maxLength">Optional maximum character length including ellipsis.</param>
+    /// <returns>A single-line plain text summary.</returns>
+    public static string CleanToSingleLine(string? htmlOrText, int? maxLength = null)
+    {
+        if (string.IsNullOrWhiteSpace(htmlOrText))
+        {
+            return string.Empty;
+        }
+
+        // Strip HTML if tags exist, decode entities, and normalize
+        var text = NormalizeHtml(htmlOrText);
+
+        // Collapse all newlines, tabs, and multiple spaces into a single space
+        text = MultiWhitespaceRegex().Replace(text, " ").Trim();
+
+        if (maxLength.HasValue && maxLength.Value > 0 && text.Length > maxLength.Value)
+        {
+            return TruncateWithEllipsis(text, maxLength.Value);
+        }
+
+        return text;
+    }
+
+    /// <summary>
+    /// Truncates a string to a specified maximum length and appends an ellipsis ("...") if truncated.
+    /// </summary>
+    /// <param name="text">The text to truncate.</param>
+    /// <param name="maxLength">The maximum allowed length (including the ellipsis).</param>
+    /// <returns>The truncated text with an ellipsis if it exceeded maxLength, or the original text.</returns>
+    public static string TruncateWithEllipsis(string? text, int maxLength)
+    {
+        if (string.IsNullOrWhiteSpace(text) || maxLength <= 0)
+        {
+            return string.Empty;
+        }
+
+        if (text.Length <= maxLength)
+        {
+            return text;
+        }
+
+        if (maxLength <= 3)
+        {
+            return text[..maxLength];
+        }
+
+        return string.Concat(text.AsSpan(0, maxLength - 3), "...");
+    }
+
+    [GeneratedRegex(@"<script\b[^>]*>[\s\S]*?</script>", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+    private static partial Regex ScriptTagRegex();
+
+    [GeneratedRegex(@"<style\b[^>]*>[\s\S]*?</style>", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+    private static partial Regex StyleTagRegex();
+
+    [GeneratedRegex(@"<br\s*/?>", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+    private static partial Regex BrTagRegex();
+
+    [GeneratedRegex(@"</p\s*>", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+    private static partial Regex ParagraphCloseTagRegex();
+
+    [GeneratedRegex(@"</?(?:div|li|h[1-6]|tr|section|article|blockquote|header|footer|hr)\b[^>]*>", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+    private static partial Regex BlockCloseTagRegex();
+
+    [GeneratedRegex(@"</?[A-Za-z][^>]*>", RegexOptions.CultureInvariant)]
+    private static partial Regex HtmlTagRegex();
+
+    [GeneratedRegex(@"[ \t]+\n", RegexOptions.CultureInvariant)]
+    private static partial Regex TrailingWhitespaceBeforeNewlineRegex();
+
+    [GeneratedRegex(@"(?:\n){3,}", RegexOptions.CultureInvariant)]
+    private static partial Regex ExcessBlankLinesRegex();
+
+    [GeneratedRegex(@"\s+", RegexOptions.CultureInvariant)]
+    private static partial Regex MultiWhitespaceRegex();
+}
diff --git a/GenHub/GenHub.Core/Interfaces/Parsers/IWebPageParser.cs b/GenHub/GenHub.Core/Interfaces/Parsers/IWebPageParser.cs
index 136018297..2d75645fe 100644
--- a/GenHub/GenHub.Core/Interfaces/Parsers/IWebPageParser.cs
+++ b/GenHub/GenHub.Core/Interfaces/Parsers/IWebPageParser.cs
@@ -1,3 +1,8 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using GenHub.Core.Models.Parsers;
 
 namespace GenHub.Core.Interfaces.Parsers;
@@ -36,4 +41,56 @@ public interface IWebPageParser
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>A parsed web page with all extracted content sections.</returns>
     Task<ParsedWebPage> ParseAsync(string url, string html, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Parses a specific file or item detail page.
+    /// Default implementation delegates to <see cref="ParseAsync(string, CancellationToken)"/>.
+    /// </summary>
+    /// <param name="url">The detail page URL.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A parsed web page containing the detailed file information.</returns>
+    Task<ParsedWebPage> ParseFileDetailAsync(string url, CancellationToken cancellationToken = default)
+        => ParseAsync(url, cancellationToken);
+
+    /// <summary>
+    /// Parses multiple file or item detail pages in a batch.
+    /// Default implementation delegates to <see cref="ParseFileDetailAsync(string, CancellationToken)"/>.
+    /// </summary>
+    /// <param name="urls">The detail page URLs to parse.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A dictionary mapping each URL to its parsed web page result.</returns>
+    async Task<IReadOnlyDictionary<string, ParsedWebPage>> ParseFileDetailsManyAsync(
+        IReadOnlyList<string> urls,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(urls);
+        var results = new Dictionary<string, ParsedWebPage>(StringComparer.OrdinalIgnoreCase);
+        foreach (var url in urls.Distinct(StringComparer.OrdinalIgnoreCase))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            try
+            {
+                var page = await ParseFileDetailAsync(url, cancellationToken);
+                results[url] = page;
+            }
+            catch (HttpRequestException)
+            {
+                // soft failure per url in batch
+            }
+            catch (IOException)
+            {
+                // soft failure per url in batch
+            }
+            catch (InvalidOperationException)
+            {
+                // soft failure per url in batch
+            }
+            catch (FormatException)
+            {
+                // soft failure per url in batch
+            }
+        }
+
+        return results;
+    }
 }
diff --git a/GenHub/GenHub.Core/Interfaces/Tools/IPlaywrightService.cs b/GenHub/GenHub.Core/Interfaces/Tools/IPlaywrightService.cs
index f2007576a..df73f9827 100644
--- a/GenHub/GenHub.Core/Interfaces/Tools/IPlaywrightService.cs
+++ b/GenHub/GenHub.Core/Interfaces/Tools/IPlaywrightService.cs
@@ -6,6 +6,7 @@
 using GenHub.Core.Models.Results;
 using Microsoft.Playwright;
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -25,6 +26,31 @@ public interface IPlaywrightService
     /// <returns>A new IPage instance.</returns>
     Task<IPage> CreatePageAsync(BrowserNewContextOptions? options = null, CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Creates a page in a persistent, headed browser context whose cookies and storage survive
+    /// across calls. Use this for bot-protected sites (e.g. ModDB's Cloudflare): the user solves
+    /// the challenge once, the resulting clearance cookie is persisted to disk, and subsequent
+    /// pages in the same session (and across app restarts, until the cookie expires) load without
+    /// another challenge. A real browser window is shown while the challenge is pending.
+    /// </summary>
+    /// <param name="profileName">The on-disk profile name (scoped under the app data browser-profile root).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A new <see cref="IPage"/> in the persistent context.</returns>
+    Task<IPage> CreatePersistentPageAsync(string profileName, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Closes a page from <see cref="CreatePersistentPageAsync"/> and shuts down the headed Chromium
+    /// window when no active pages remain. Prefer this over <c>page.CloseAsync</c> alone so
+    /// callers do not leave an about:blank window open after a successful ModDB scrape.
+    /// </summary>
+    /// <param name="page">The persistent-context page to close.</param>
+    /// <param name="keepOpen">
+    /// When <see langword="true"/>, leaves the page open (e.g. so the user can finish a Cloudflare
+    /// challenge) without closing the browser.
+    /// </param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    Task ClosePersistentPageAsync(IPage page, bool keepOpen = false);
+
     /// <summary>
     /// Fetches HTML content from a URL using Playwright.
     /// </summary>
@@ -41,6 +67,35 @@ public interface IPlaywrightService
     /// <returns>A parsed AngleSharp IDocument.</returns>
     Task<IDocument> FetchAndParseAsync(string url, CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Fetches and parses a web page in a persistent, headed browser context whose cookies survive
+    /// across calls. Use this for bot-protected URLs (e.g. ModDB) so the Cloudflare clearance cookie
+    /// obtained from a single manual challenge solve is reused.
+    /// </summary>
+    /// <param name="profileName">The on-disk profile name (scoped under the app data browser-profile root).</param>
+    /// <param name="url">The URL to fetch and parse.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A parsed AngleSharp IDocument.</returns>
+    Task<IDocument> FetchAndParsePersistentAsync(string profileName, string url, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Fetches and parses multiple URLs in one persistent headed page — open once, navigate each
+    /// URL in order, then close. Use this for ModDB section sweeps so Chromium does not spawn a
+    /// new window per section (and so concurrent NewPage/Close races cannot tear down the context
+    /// mid-navigation).
+    /// </summary>
+    /// <param name="profileName">The on-disk profile name (scoped under the app data browser-profile root).</param>
+    /// <param name="urls">URLs to fetch in order. Duplicates are fetched once; order of first occurrence is kept.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>
+    /// A map of URL → parsed document for every URL that loaded successfully. Failed URLs are omitted;
+    /// callers should treat a missing key as a soft failure for that section.
+    /// </returns>
+    Task<IReadOnlyDictionary<string, IDocument>> FetchAndParsePersistentManyAsync(
+        string profileName,
+        IReadOnlyList<string> urls,
+        CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Downloads a file using Playwright to handle complex scenarios (like anti-bot protections).
     /// </summary>
@@ -48,4 +103,27 @@ public interface IPlaywrightService
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>A DownloadResult indicating success or failure.</returns>
     Task<DownloadResult> DownloadFileAsync(DownloadConfiguration configuration, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Executes an operation within a scoped persistent browser context session.
+    /// The persistent browser window stays open for the duration of the operation and closes
+    /// immediately when the operation completes, avoiding multiple window launches and idle delays.
+    /// </summary>
+    /// <typeparam name="T">The return type of the operation.</typeparam>
+    /// <param name="profileName">The on-disk profile name.</param>
+    /// <param name="operation">The asynchronous operation to execute.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The result of the operation.</returns>
+    Task<T> ExecuteInPersistentContextAsync<T>(
+        string profileName,
+        Func<Task<T>> operation,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Asynchronously pre-warms the Playwright driver runtime in the background so subsequent
+    /// browser operations launch with minimal latency.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A task representing the background warmup operation.</returns>
+    Task WarmupAsync(CancellationToken cancellationToken = default);
 }
diff --git a/GenHub/GenHub.Core/Models/ModDB/MapDetails.cs b/GenHub/GenHub.Core/Models/ModDB/MapDetails.cs
index 347634147..979071455 100644
--- a/GenHub/GenHub.Core/Models/ModDB/MapDetails.cs
+++ b/GenHub/GenHub.Core/Models/ModDB/MapDetails.cs
@@ -37,4 +37,4 @@ public record MapDetails(
     string? FileType = null,
     float? Rating = null,
     string? RefererUrl = null,
-    List<GenHub.Core.Models.Parsers.File>? AdditionalFiles = null);
+    List<DownloadableFile>? AdditionalFiles = null);
diff --git a/GenHub/GenHub.Core/Models/ModDB/ModDBCategoryMapper.cs b/GenHub/GenHub.Core/Models/ModDB/ModDBCategoryMapper.cs
index cf2fc5920..c0f1e9a1f 100644
--- a/GenHub/GenHub.Core/Models/ModDB/ModDBCategoryMapper.cs
+++ b/GenHub/GenHub.Core/Models/ModDB/ModDBCategoryMapper.cs
@@ -19,8 +19,8 @@ public static ContentType MapCategory(string? categoryCode)
             // Releases (Mods)
             "2" => ContentType.Mod,  // Full Version
             "3" => ContentType.Mod,  // Demo
-            "4" => ContentType.Patch, // Patch
-            "28" => ContentType.Patch, // Script
+            "4" => ContentType.Mod,  // Patch (mod release/update)
+            "28" => ContentType.Mod, // Script (mod script/release)
             "29" => ContentType.Addon, // Trainer
 
             // Media
@@ -60,11 +60,11 @@ public static ContentType MapCategory(string? categoryCode)
             "131" => ContentType.Addon, // Model Pack
 
             // Addons - Skins
-            "112" => ContentType.Skin, // Player Skin
-            "133" => ContentType.Skin, // Prop Skin
-            "113" => ContentType.Skin, // Vehicle Skin
-            "114" => ContentType.Skin, // Weapon Skin
-            "134" => ContentType.Skin, // Skin Pack
+            "112" => ContentType.Addon, // Player Skin
+            "133" => ContentType.Addon, // Prop Skin
+            "113" => ContentType.Addon, // Vehicle Skin
+            "114" => ContentType.Addon, // Weapon Skin
+            "134" => ContentType.Addon, // Skin Pack
 
             // Addons - Audio
             "117" => ContentType.Addon, // Music
@@ -75,8 +75,8 @@ public static ContentType MapCategory(string? categoryCode)
             // Addons - Graphics
             "124" => ContentType.Addon, // Decal
             "136" => ContentType.Addon, // Effects GFX
-            "125" => ContentType.Skin, // GUI
-            "126" => ContentType.Skin, // HUD
+            "125" => ContentType.Addon, // GUI
+            "126" => ContentType.Addon, // HUD
             "128" => ContentType.Addon, // Sprite
             "129" => ContentType.Addon, // Texture
 
@@ -103,10 +103,15 @@ public static ContentType MapCategoryByName(string? categoryName)
         {
             var s when s.Contains("full version") => ContentType.Mod,
             var s when s.Contains("demo") => ContentType.Mod,
-            var s when s.Contains("patch") => ContentType.Patch,
-            var s when s.Contains("script") => ContentType.Patch,
+            var s when s.Contains("patch") => ContentType.Mod,
+            var s when s.Contains("script") => ContentType.Mod,
             var s when s.Contains("trainer") => ContentType.Addon,
 
+            var s when s.Contains("tool") => ContentType.ModdingTool,
+            var s when s.Contains("sdk") => ContentType.ModdingTool,
+            var s when s.Contains("ide") => ContentType.ModdingTool,
+            var s when s.Contains("source code") => ContentType.ModdingTool,
+
             var s when s.Contains("trailer") => ContentType.Video,
             var s when s.Contains("movie") => ContentType.Video,
             var s when s.Contains("video") => ContentType.Video,
@@ -116,17 +121,12 @@ var s when s.Contains("singleplayer map") => ContentType.Map,
             var s when s.Contains("map") => ContentType.Map,
             var s when s.Contains("prefab") => ContentType.Map,
 
-            var s when s.Contains("skin") => ContentType.Skin,
-            var s when s.Contains("gui") => ContentType.Skin,
-            var s when s.Contains("hud") => ContentType.Skin,
+            var s when s.Contains("skin") => ContentType.Addon,
+            var s when s.Contains("gui") => ContentType.Addon,
+            var s when s.Contains("hud") => ContentType.Addon,
 
             var s when s.Contains("language") => ContentType.LanguagePack,
 
-            var s when s.Contains("tool") => ContentType.ModdingTool,
-            var s when s.Contains("sdk") => ContentType.ModdingTool,
-            var s when s.Contains("ide") => ContentType.ModdingTool,
-            var s when s.Contains("source code") => ContentType.ModdingTool,
-
             _ => ContentType.Addon,
         };
     }
diff --git a/GenHub/GenHub.Core/Models/ModDB/ModDBFilter.cs b/GenHub/GenHub.Core/Models/ModDB/ModDBFilter.cs
index a977a5f08..88232974f 100644
--- a/GenHub/GenHub.Core/Models/ModDB/ModDBFilter.cs
+++ b/GenHub/GenHub.Core/Models/ModDB/ModDBFilter.cs
@@ -1,3 +1,7 @@
+using System;
+using System.Collections.Generic;
+using GenHub.Core.Constants;
+
 namespace GenHub.Core.Models.ModDB;
 
 /// <summary>
@@ -21,7 +25,7 @@ public class ModDBFilter
     public string? Licence { get; set; }
 
     /// <summary>Gets or sets the sort parameter.</summary>
-    public string? Sort { get; set; }
+    public string? Sort { get; set; } = ModDBConstants.DefaultSort;
 
     /// <summary>Gets or sets the page number (1-based).</summary>
     public int Page { get; set; } = 1;
diff --git a/GenHub/GenHub.Core/Models/Parsers/Comment.cs b/GenHub/GenHub.Core/Models/Parsers/Comment.cs
index 645e1fd5a..dd1532318 100644
--- a/GenHub/GenHub.Core/Models/Parsers/Comment.cs
+++ b/GenHub/GenHub.Core/Models/Parsers/Comment.cs
@@ -1,3 +1,6 @@
+using System;
+using System.Collections.Generic;
+
 namespace GenHub.Core.Models.Parsers;
 
 /// <summary>
@@ -8,9 +11,13 @@ namespace GenHub.Core.Models.Parsers;
 /// <param name="Date">The comment date (optional).</param>
 /// <param name="Karma">The karma/vote score (optional).</param>
 /// <param name="IsCreator">Whether the comment is from the content creator (optional).</param>
+/// <param name="IndentLevel">Indentation depth level for reply threads (optional).</param>
+/// <param name="Replies">Child replies to this comment (optional).</param>
 public record Comment(
     string? Author = null,
     string? Content = null,
     DateTime? Date = null,
     int? Karma = null,
-    bool? IsCreator = null) : ContentSection(SectionType.Comment, "Comment");
+    bool? IsCreator = null,
+    int IndentLevel = 0,
+    IReadOnlyList<Comment>? Replies = null) : ContentSection(SectionType.Comment, "Comment");
diff --git a/GenHub/GenHub.Core/Models/Parsers/DownloadableFile.cs b/GenHub/GenHub.Core/Models/Parsers/DownloadableFile.cs
new file mode 100644
index 000000000..0df14e67a
--- /dev/null
+++ b/GenHub/GenHub.Core/Models/Parsers/DownloadableFile.cs
@@ -0,0 +1,42 @@
+namespace GenHub.Core.Models.Parsers;
+
+/// <summary>
+/// Represents a downloadable file extracted from a web page.
+/// </summary>
+/// <param name="Name">The file name.</param>
+/// <param name="Version">The file version (optional).</param>
+/// <param name="SizeBytes">File size in bytes (optional).</param>
+/// <param name="SizeDisplay">Human-readable file size (optional).</param>
+/// <param name="UploadDate">The upload date (optional).</param>
+/// <param name="Category">The file category (optional).</param>
+/// <param name="Uploader">The uploader name (optional).</param>
+/// <param name="DownloadUrl">The download URL (optional).</param>
+/// <param name="Md5Hash">The MD5 hash of the file (optional).</param>
+/// <param name="CommentCount">Number of comments (optional).</param>
+/// <param name="ThumbnailUrl">The thumbnail image URL (optional).</param>
+/// <param name="DownloadCount">Number of downloads (optional).</param>
+/// <param name="FileSectionType">The file section type (Downloads or Addons).</param>
+/// <param name="ReleaseDate">The release date (optional, may differ from upload date).</param>
+/// <param name="DetailsUrl">The web page details URL (optional).</param>
+/// <param name="Description">The full description or release notes (optional).</param>
+/// <param name="PreviewImages">List of preview image URLs (optional).</param>
+/// <param name="Filename">The actual file archive name (optional).</param>
+public record DownloadableFile(
+    string Name,
+    string? Version = null,
+    long? SizeBytes = null,
+    string? SizeDisplay = null,
+    DateTime? UploadDate = null,
+    string? Category = null,
+    string? Uploader = null,
+    string? DownloadUrl = null,
+    string? Md5Hash = null,
+    int? CommentCount = null,
+    string? ThumbnailUrl = null,
+    int? DownloadCount = null,
+    FileSectionType FileSectionType = FileSectionType.Downloads,
+    DateTime? ReleaseDate = null,
+    string? DetailsUrl = null,
+    string? Description = null,
+    System.Collections.Generic.IReadOnlyList<string>? PreviewImages = null,
+    string? Filename = null) : ContentSection(SectionType.File, Name);
diff --git a/GenHub/GenHub.Core/Models/Parsers/FileSectionType.cs b/GenHub/GenHub.Core/Models/Parsers/FileSectionType.cs
new file mode 100644
index 000000000..9fddb1afb
--- /dev/null
+++ b/GenHub/GenHub.Core/Models/Parsers/FileSectionType.cs
@@ -0,0 +1,13 @@
+namespace GenHub.Core.Models.Parsers;
+
+/// <summary>
+/// Represents the type of file section, distinguishing between main releases and addon files.
+/// </summary>
+public enum FileSectionType
+{
+    /// <summary>Files from the main releases/downloads section.</summary>
+    Downloads,
+
+    /// <summary>Files from the addons section.</summary>
+    Addons,
+}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/ModDB/ModDBCategoryMapperTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/ModDB/ModDBCategoryMapperTests.cs
new file mode 100644
index 000000000..73e18587f
--- /dev/null
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/ModDB/ModDBCategoryMapperTests.cs
@@ -0,0 +1,63 @@
+using GenHub.Core.Models.Enums;
+using GenHub.Core.Models.ModDB;
+using Xunit;
+using ContentType = GenHub.Core.Models.Enums.ContentType;
+
+namespace GenHub.Tests.Core.Features.Content.ModDB;
+
+/// <summary>
+/// Unit tests for <see cref="ModDBCategoryMapper"/>.
+/// </summary>
+public class ModDBCategoryMapperTests
+{
+    /// <summary>
+    /// Verifies that MapCategory maps ModDB category codes correctly, especially mapping patches and scripts to Mod.
+    /// </summary>
+    /// <param name="categoryCode">The category code to map.</param>
+    /// <param name="expected">The expected content type.</param>
+    [Theory]
+    [InlineData("2", ContentType.Mod)]
+    [InlineData("3", ContentType.Mod)]
+    [InlineData("4", ContentType.Mod)]
+    [InlineData("28", ContentType.Mod)]
+    [InlineData("29", ContentType.Addon)]
+    [InlineData("7", ContentType.Video)]
+    [InlineData("8", ContentType.Video)]
+    [InlineData("101", ContentType.Map)]
+    [InlineData("102", ContentType.Map)]
+    [InlineData("112", ContentType.Addon)]
+    [InlineData("125", ContentType.Addon)]
+    [InlineData("126", ContentType.Addon)]
+    [InlineData("20", ContentType.ModdingTool)]
+    [InlineData("30", ContentType.LanguagePack)]
+    public void MapCategory_MapsCategoryCodesCorrectly(string categoryCode, ContentType expected)
+    {
+        var result = ModDBCategoryMapper.MapCategory(categoryCode);
+        Assert.Equal(expected, result);
+    }
+
+    /// <summary>
+    /// Verifies that MapCategoryByName maps category names correctly, mapping patch and script names to Mod.
+    /// </summary>
+    /// <param name="categoryName">The category name to map.</param>
+    /// <param name="expected">The expected content type.</param>
+    [Theory]
+    [InlineData("Full Version", ContentType.Mod)]
+    [InlineData("Demo", ContentType.Mod)]
+    [InlineData("Patch", ContentType.Mod)]
+    [InlineData("v1.01 Patch", ContentType.Mod)]
+    [InlineData("Script", ContentType.Mod)]
+    [InlineData("Multiplayer Map", ContentType.Map)]
+    [InlineData("Singleplayer Map", ContentType.Map)]
+    [InlineData("Player Skin", ContentType.Addon)]
+    [InlineData("GUI", ContentType.Addon)]
+    [InlineData("HUD", ContentType.Addon)]
+    [InlineData("Mapping Tool", ContentType.ModdingTool)]
+    [InlineData("Language Pack", ContentType.LanguagePack)]
+    [InlineData("Trailer", ContentType.Video)]
+    public void MapCategoryByName_MapsNamesCorrectly(string categoryName, ContentType expected)
+    {
+        var result = ModDBCategoryMapper.MapCategoryByName(categoryName);
+        Assert.Equal(expected, result);
+    }
+}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/Parsers/ModDBPageParserTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/Parsers/ModDBPageParserTests.cs
new file mode 100644
index 000000000..a630b8b5c
--- /dev/null
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/Parsers/ModDBPageParserTests.cs
@@ -0,0 +1,1691 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using AngleSharp;
+using AngleSharp.Dom;
+using GenHub.Core.Constants;
+using GenHub.Core.Interfaces.Tools;
+using GenHub.Core.Models.Parsers;
+using GenHub.Features.Content.Services.Parsers;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+
+namespace GenHub.Tests.Core.Features.Content.Parsers;
+
+/// <summary>
+/// Regression tests for the current ModDB detail markup and Cloudflare-aware section loading.
+/// </summary>
+public sealed class ModDBPageParserTests
+{
+    /// <summary>
+    /// Verifies the current game-addon detail page maps its metadata and /addons/start route into
+    /// a usable file rather than returning an empty download URL.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_CurrentAddonDetailMarkup_ExtractsArchiveNameAndAddonStartUrlAsync()
+    {
+        // Arrange
+        var playwright = CreatePlaywrightMock();
+        var pageUrl = "https://www.moddb.com/games/cc-generals-zero-hour/addons/lemuria-2026-fixes";
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div id="downloadsinfo">
+                <div class="row clear"><h5>Filename</h5><span class="summary">Lemuria_2026_Fixes.rar</span></div>
+                <div class="row clear"><h5>Category</h5><a>Singleplayer Map</a></div>
+                <div class="row clear"><h5>Uploader</h5><a>BagaturKhan</a></div>
+                <div class="row clear"><h5>Added</h5><time>Jan 2nd, 2026</time></div>
+                <div class="row clear"><h5>Size</h5><span class="summary">1.07mb (1,125,450 bytes)</span></div>
+                <div class="row clear"><a class="button buttonlarge" href="/addons/start/302328">Download Now</a></div>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var file = Assert.Single(parsed.Sections.OfType<DownloadableFile>());
+        Assert.Equal("Lemuria_2026_Fixes.rar", file.Name);
+        Assert.Equal("https://www.moddb.com/addons/start/302328", file.DownloadUrl);
+        Assert.Equal("Singleplayer Map", file.Category);
+        Assert.Equal(1_125_450, file.SizeBytes);
+    }
+
+    /// <summary>
+    /// Game-scoped FileDetail URLs (from the ModDB downloads listing) have no parent /mods/ page
+    /// to sweep, so the detail view must still populate Community from comments on the file page
+    /// itself instead of leaving only a single Releases row.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_GameFileDetail_ExtractsOnPageCommentsWithoutParentSweepAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/games/cc-generals-zero-hour/downloads/genbigeditbig-editor";
+        var playwright = CreatePlaywrightMock();
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div id="downloadsinfo">
+                <div class="row clear"><h5>Filename</h5><span class="summary">GenBigEdit.zip</span></div>
+                <div class="row clear"><h5>Size</h5><span class="summary">174.33mb (182,801,143 bytes)</span></div>
+                <div class="row clear"><a class="button buttonlarge" href="/downloads/start/310120">Download Now</a></div>
+              </div>
+              <div id="commentsbrowse">
+                <div class="row rowcomment" id="comment501">
+                  <div class="heading"><a href="/members/mah_boi">mah_boi</a> <span class="subheading">May 30 2026</span></div>
+                  <div class="commentbody">Please, provide us the source code of this program.</div>
+                </div>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        Assert.Equal(PageType.FileDetail, parsed.PageType);
+        var file = Assert.Single(parsed.Sections.OfType<DownloadableFile>());
+        Assert.Equal("GenBigEdit.zip", file.Name);
+        Assert.Equal("https://www.moddb.com/downloads/start/310120", file.DownloadUrl);
+
+        var comment = Assert.Single(parsed.Sections.OfType<Comment>());
+        Assert.Equal("mah_boi", comment.Author);
+        Assert.Equal("Please, provide us the source code of this program.", comment.Content);
+
+        // Must not attempt a parent-mod section sweep for /games/... FileDetail URLs (fetches only the single URL).
+        playwright.Verify(
+            service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.Is<IReadOnlyList<string>>(urls => urls.Count == 1 && urls[0] == pageUrl),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    /// <summary>
+    /// Verifies an addons-list row retains its ModDB category so a map does not become a generic
+    /// add-on later in the resolver and manifest pipeline.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_AddonsListRow_ExtractsSingleplayerMapCategoryAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/games/cc-generals-zero-hour/addons";
+        var playwright = CreatePlaywrightMock();
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div class="row rowcontent">
+                <h4>Lemuria 2026</h4>
+                <span class="category">Singleplayer Map</span>
+                <span class="size">1.07 MB</span>
+                <a href="/addons/start/302328">Download</a>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var file = Assert.Single(parsed.Sections.OfType<DownloadableFile>());
+        Assert.Equal("Singleplayer Map", file.Category);
+        Assert.Equal(FileSectionType.Addons, file.FileSectionType);
+        Assert.Equal("https://www.moddb.com/addons/start/302328", file.DownloadUrl);
+    }
+
+    /// <summary>
+    /// Verifies that rich ModDB sections use the verified persistent Chromium profile instead of
+    /// a separate headless browser that loses Cloudflare clearance.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_ModDetail_UsesPersistentProfileForDownloadsAndAddonsAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/example-mod";
+        var documents = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase)
+        {
+            [pageUrl] = await CreateDocumentAsync("<html><body><h1>Example Mod</h1></body></html>"),
+            [pageUrl + "/downloads"] = await CreateDocumentAsync("""
+                <div class="row file"><h4>Example Release</h4><span class="size">4 MB</span><a href="/downloads/start/100">Download</a></div>
+                """),
+            [pageUrl + "/addons"] = await CreateDocumentAsync("""
+                <div class="row file"><h4>Example Addon</h4><span class="size">2 MB</span><a href="/addons/start/200">Download</a></div>
+                """),
+            [pageUrl + "/videos"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [pageUrl + "/images"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [pageUrl + "/reviews"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [pageUrl + "/articles"] = await CreateDocumentAsync("<html><body></body></html>"),
+        };
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .Returns((string _, IReadOnlyList<string> urls, CancellationToken _) =>
+            {
+                var result = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase);
+                foreach (var url in urls)
+                {
+                    if (documents.TryGetValue(url, out var d))
+                    {
+                        result[url] = d;
+                    }
+                }
+
+                return Task.FromResult<IReadOnlyDictionary<string, IDocument>>(result);
+            });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var files = parsed.Sections.OfType<DownloadableFile>().ToList();
+        Assert.Contains(files, file => file.Name == "Example Release" && file.DownloadUrl == "https://www.moddb.com/downloads/start/100");
+        Assert.Contains(files, file => file.Name == "Example Addon" && file.DownloadUrl == "https://www.moddb.com/addons/start/200");
+        playwright.Verify(
+            service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.Is<IReadOnlyList<string>>(urls =>
+                    urls.Contains(pageUrl) && urls.Contains(pageUrl + "/downloads") && urls.Contains(pageUrl + "/addons")),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        playwright.Verify(service => service.FetchAndParseAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()), Times.Never);
+    }
+
+    /// <summary>
+    /// Verifies the file-only acquisition path resolves a FileDetail download without fetching the
+    /// parent mod's downloads/addons/videos/images/reviews/articles sections (the seven-page sweep
+    /// that previously fired on every card download).
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseFileDetailAsync_FetchesOnlyFileDetailPageAndSkipsSectionSweepAsync()
+    {
+        // Arrange: the FileDetail page already carries a real (non-guest) icon, so the parent-mod
+        // icon fallback fetch is skipped too — exactly one fetch total.
+        const string pageUrl = "https://www.moddb.com/mods/genspeed/downloads/genspeed-v25";
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentAsync(
+                ModDBConstants.BrowserProfileName,
+                pageUrl,
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(await CreateDocumentAsync("""
+                <html><body>
+                  <h1><a>GenSpeed v2.5</a></h1>
+                  <div class="sidecolumn"><div class="profilebox"><img class="icon" src="https://static.moddb.com/mods/genspeed/icon.png" /></div></div>
+                  <div id="downloadsinfo">
+                    <div class="row clear"><h5>Filename</h5><span class="summary">GenSpeed-v2.5.zip</span></div>
+                    <div class="row clear"><h5>Size</h5><span class="summary">65.04mb (68,197,650 bytes)</span></div>
+                    <div class="row clear"><a href="/downloads/start/311183">Download Now</a></div>
+                  </div>
+                </body></html>
+                """));
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseFileDetailAsync(pageUrl);
+
+        // Assert: exactly one DownloadableFile, no section sweep, icon from the FileDetail page.
+        var file = Assert.Single(parsed.Sections.OfType<DownloadableFile>());
+        Assert.Equal("GenSpeed v2.5", file.Name);
+        Assert.Equal("GenSpeed-v2.5.zip", file.Filename);
+        Assert.Equal("https://www.moddb.com/downloads/start/311183", file.DownloadUrl);
+        Assert.Equal(68_197_650, file.SizeBytes);
+        Assert.Equal("https://static.moddb.com/mods/genspeed/icon.png", parsed.Context.IconUrl);
+
+        playwright.Verify(
+            service => service.FetchAndParsePersistentAsync(
+                ModDBConstants.BrowserProfileName,
+                It.Is<string>(url => url != pageUrl),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    /// <summary>
+    /// Verifies that ParseFileDetailAsync performs only a single page fetch for file details without
+    /// secondary parent mod fetches or section sweeps.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseFileDetailAsync_WithGuestIcon_FetchesOnlyFileDetailPageAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/genspeed/downloads/genspeed-v25";
+        var fetchedUrls = new List<string>();
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()))
+            .Returns((string _, string url, CancellationToken _) =>
+            {
+                fetchedUrls.Add(url);
+                return Task.FromResult(CreateDocumentAsync("""
+                    <html><body>
+                      <h1><a>GenSpeed v2.5</a></h1>
+                      <div class="sidecolumn"><img class="icon" src="https://static.moddb.com/html/cutoff/images/guest/guest4.png" /></div>
+                      <div id="downloadsinfo">
+                        <div class="row clear"><h5>Filename</h5><span class="summary">GenSpeed-v2.5.zip</span></div>
+                        <div class="row clear"><a href="/downloads/start/311183">Download Now</a></div>
+                      </div>
+                    </body></html>
+                    """).GetAwaiter().GetResult());
+            });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseFileDetailAsync(pageUrl);
+
+        // Assert: exactly one fetch (FileDetail), never parent mod or section pages.
+        Assert.Equal(new[] { pageUrl }, fetchedUrls);
+        Assert.Contains(parsed.Sections.OfType<DownloadableFile>(), f => f.Filename == "GenSpeed-v2.5.zip");
+    }
+
+    /// <summary>
+    /// Verifies that comment parsing creates nested reply threads with correct author attribution
+    /// and cleans out ModDB action text like 'Reply Good karma Bad karma+1 vote'.
+    /// </summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_NestedComments_ParsesThreadHierarchyAndCleansActionTextAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/example-mod/comments";
+        var playwright = CreatePlaywrightMock();
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div id="commentsbrowse">
+                <div class="row rowcomment" id="comment101">
+                  <div class="heading"><a href="/members/scorpionwins">Scorpionwins</a> <span class="subheading">Jul 31 2026</span></div>
+                  <div class="commentbody">
+                    How to activate additional weapons?
+                    <div class="actions">Reply Good karma Bad karma+1 vote</div>
+                  </div>
+                  <div class="children">
+                    <div class="row rowcomment" id="comment102">
+                      <div class="heading"><a href="/members/bagaturkhan">BagaturKhan</a> <span class="subheading">Jul 31 2026</span></div>
+                      <div class="commentbody">
+                        If you are talking about stolen tech, train your infiltrator.
+                        <div class="actions">Reply Good karma Bad karma+1 vote</div>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var topLevelComments = parsed.Sections.OfType<Comment>().ToList();
+        var parentComment = Assert.Single(topLevelComments);
+        Assert.Equal("Scorpionwins", parentComment.Author);
+        Assert.Equal("How to activate additional weapons?", parentComment.Content);
+        Assert.Equal(0, parentComment.IndentLevel);
+
+        var reply = Assert.Single(parentComment.Replies!);
+        Assert.Equal("BagaturKhan", reply.Author);
+        Assert.Equal("If you are talking about stolen tech, train your infiltrator.", reply.Content);
+        Assert.Equal(1, reply.IndentLevel);
+    }
+
+    /// <summary>
+    /// Verifies reply markup nested inside <c>.commentbody</c> does not inflate the parent content
+    /// into a huge whitespace block (the layout bug seen in the Community tab).
+    /// </summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_NestedCommentsInsideCommentBody_DoesNotPolluteParentContentAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/example-mod/comments";
+        var playwright = CreatePlaywrightMock();
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div id="commentsbrowse">
+                <div class="row rowcomment" id="comment201">
+                  <div class="heading"><a href="/members/scorpionwins">Scorpionwins</a> <span class="subheading">Jul 31 2026</span></div>
+                  <div class="commentbody">
+
+
+                    How to activate additional weapons?
+                    <div class="actions">Reply Good karma Bad karma+1 vote</div>
+                    <div class="children">
+                      <div class="row rowcomment" id="comment202">
+                        <div class="heading"><a href="/members/bagaturkhan">BagaturKhan</a> <span class="subheading">Jul 31 2026</span></div>
+                        <div class="commentbody">
+                          Train your infiltrator.
+                          <div class="actions">Reply</div>
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var parentComment = Assert.Single(parsed.Sections.OfType<Comment>());
+        Assert.Equal("How to activate additional weapons?", parentComment.Content);
+        Assert.DoesNotContain("BagaturKhan", parentComment.Content);
+        Assert.DoesNotContain("infiltrator", parentComment.Content, StringComparison.OrdinalIgnoreCase);
+
+        var reply = Assert.Single(parentComment.Replies!);
+        Assert.Equal("BagaturKhan", reply.Author);
+        Assert.Equal("Train your infiltrator.", reply.Content);
+    }
+
+    /// <summary>
+    /// Verifies rating widgets without author/body are not surfaced as empty Community review cards.
+    /// </summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_BareRatingWidget_IsNotTreatedAsReviewAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/example-mod/reviews";
+        var playwright = CreatePlaywrightMock();
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div class="rating"><span class="score">9.0</span><span class="helpful">people found this helpful</span></div>
+              <div class="review">
+                <a href="/members/alice">Alice</a>
+                <div class="content">Solid patch for ROTR.</div>
+                <span class="score">8.5</span>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var review = Assert.Single(parsed.Sections.OfType<Review>());
+        Assert.Equal("Alice", review.Author);
+        Assert.Equal("Solid patch for ROTR.", review.Content);
+    }
+
+    /// <summary>
+    /// The live ModDB composer (<c>#commentform</c> plus guest/email rows and injected CSS) must
+    /// not appear as Community comments.
+    /// </summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_CommentComposer_IsNotTreatedAsCommentsAsync()
+    {
+        const string pageUrl = "https://www.moddb.com/mods/cc-generals-undone/downloads/cc-generals-undone";
+        var playwright = CreatePlaywrightMock();
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <h1>C&amp;C Generals Undone file</h1>
+              <h2>C&amp;C Generals Undone</h2>
+              <div id="downloadsinfo">
+                <div class="row clear"><h5>Filename</h5><span class="summary">GeneralsUndone_v1.0.zip</span></div>
+                <div class="row clear"><a class="button buttonlarge" href="/downloads/start/313719">Download Now</a></div>
+              </div>
+              <div class="normalbox formbox" id="commentform">
+                <div id="commentform" class="body">
+                  <div class="row rowcommentguest clear">
+                    <p>Your comment will be anonymous unless you join the community.
+                    <style>span.ffbcbbfaadacfformouter span { display: none; }</style></p>
+                  </div>
+                  <div class="row rowcommentsummary clear" id="commentsummary"><textarea></textarea></div>
+                  <div class="row rowcommentemail clear" id="commentemail"><input /></div>
+                </div>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        Assert.Empty(parsed.Sections.OfType<Comment>());
+    }
+
+    /// <summary>
+    /// File-page chrome (game icon, developer avatar, download title art) must not appear in Media.
+    /// </summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_FileDetailChromeImages_AreNotGalleryMediaAsync()
+    {
+        const string pageUrl = "https://www.moddb.com/mods/cc-generals-undone/downloads/cc-generals-undone";
+        var playwright = CreatePlaywrightMock();
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <h2>C&amp;C Generals Undone</h2>
+              <div id="downloadsinfo">
+                <div class="row clear"><h5>Filename</h5><span class="summary">GeneralsUndone_v1.0.zip</span></div>
+                <div class="row clear"><a href="/downloads/start/313719">Download Now</a></div>
+              </div>
+              <a class="thickbox" href="https://media.moddb.com/images/downloads/1/314/313719/Title.png">
+                <img alt="C&amp;C Generals Undone" src="https://media.moddb.com/cache/images/downloads/1/314/313719/thumb_620x2000/Title.png" />
+              </a>
+              <div id="modsinfo">
+                <a href="https://www.moddb.com/games/cc-generals-zero-hour">
+                  <img alt="C&amp;C: Generals Zero Hour" src="https://media.moddb.com/images/games/1/1/184/icon.gif" />
+                </a>
+                <a href="https://www.moddb.com/mods/cc-generals-undone">
+                  <img alt="C&amp;C Generals Undone" src="https://media.moddb.com/cache/images/mods/1/73/72174/crop_120x90/Screenshot.png" />
+                </a>
+                <a href="https://www.moddb.com/company/whiteskull9044">
+                  <img alt="WhiteSkull#9044" src="https://media.moddb.com/cache/images/groups/1/49/48231/crop_120x90/Screenshot.png" />
+                </a>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        Assert.Empty(parsed.Sections.OfType<Image>());
+    }
+
+    /// <summary>
+    /// The images tab should yield unique gallery shots, not share icons or duplicate featured thumbs.
+    /// </summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_ImagesPage_ExtractsUniqueGalleryShotsAsync()
+    {
+        const string pageUrl = "https://www.moddb.com/mods/cc-generals-undone/images";
+        var playwright = CreatePlaywrightMock();
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div id="imagebox">
+                <a href="/mods/cc-generals-undone/images/icbm-powtruck#imagebox">
+                  <img alt="View media" src="https://media.moddb.com/cache/images/mods/1/73/72174/crop_120x90/ICBM_POWTruck.png" />
+                </a>
+                <a href="/mods/cc-generals-undone/images/spectre#imagebox">
+                  <img alt="View media" src="https://media.moddb.com/cache/images/mods/1/73/72174/crop_120x90/Spectre.png" />
+                </a>
+                <div class="media"><div class="holder">
+                  <img alt="ICBM POWTruck" src="https://media.moddb.com/cache/images/mods/1/73/72174/thumb_620x2000/ICBM_POWTruck.png" />
+                </div></div>
+                <a href="https://www.facebook.com/share"><img alt="Share on Facebook" src="data:image/png;base64,aaaa" /></a>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        var images = parsed.Sections.OfType<Image>().ToList();
+        Assert.Equal(2, images.Count);
+        Assert.Contains(images, image => image.Title.Contains("ICBM", StringComparison.OrdinalIgnoreCase));
+        Assert.Contains(images, image => image.Title.Contains("Spectre", StringComparison.OrdinalIgnoreCase));
+        Assert.DoesNotContain(images, image => image.Title.Contains("Share", StringComparison.OrdinalIgnoreCase));
+        Assert.DoesNotContain(images, image => image.ThumbnailUrl?.StartsWith("data:", StringComparison.OrdinalIgnoreCase) == true);
+        Assert.All(images, image => Assert.DoesNotContain("crop_", image.ThumbnailUrl ?? string.Empty));
+        Assert.All(images, image => Assert.DoesNotContain("/cache/", image.ThumbnailUrl ?? string.Empty));
+    }
+
+    /// <summary>
+    /// Image titles with CamelCase or raw filenames should be formatted with clean spaces.
+    /// </summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_ImageTitles_FormatsCamelCaseAndFilenamesAsync()
+    {
+        const string pageUrl = "https://www.moddb.com/mods/test-mod/images";
+        var playwright = CreatePlaywrightMock();
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div id="imagebox">
+                <a href="/mods/test-mod/images/shot1">
+                  <img alt="LifeOfBRRRRTTT" src="https://media.moddb.com/cache/images/mods/1/73/72174/crop_120x90/LifeOfBRRRRTTT.png" />
+                </a>
+                <a href="/mods/test-mod/images/shot2">
+                  <img alt="BASSBASSBASSASS" src="https://media.moddb.com/cache/images/mods/1/73/72174/crop_120x90/BASSBASSBASSASS.png" />
+                </a>
+              </div>
+            </body></html>
+            """);
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        var images = parsed.Sections.OfType<Image>().ToList();
+        Assert.Equal(2, images.Count);
+        Assert.Equal("Life Of BRRRRTTT", images[0].Title);
+        Assert.Equal("BASSBASSBASSASS", images[1].Title);
+        Assert.Equal("https://media.moddb.com/images/mods/1/73/72174/LifeOfBRRRRTTT.png", images[0].ThumbnailUrl);
+        Assert.Equal("https://media.moddb.com/images/mods/1/73/72174/LifeOfBRRRRTTT.png", images[0].FullSizeUrl);
+    }
+
+    /// <summary>
+    /// FileDetail filename plus the parent downloads listing of the same start URL must collapse
+    /// to one release, keeping the human listing name.
+    /// </summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_FileDetailAndParentDownloads_DedupesSameBinaryAsync()
+    {
+        const string pageUrl = "https://www.moddb.com/mods/cc-generals-undone/downloads/cc-generals-undone";
+        const string parentUrl = "https://www.moddb.com/mods/cc-generals-undone";
+        var documents = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase)
+        {
+            [pageUrl] = await CreateDocumentAsync("""
+                <html><body>
+                  <h1>C&amp;C Generals Undone file</h1>
+                  <h2>C&amp;C Generals Undone</h2>
+                  <a href="/members/register">register</a>
+                  <div id="modsinfo"><a href="/company/whiteskull9044">WhiteSkull#9044</a></div>
+                  <span class="summary">Games : C&amp;C: Generals Zero Hour : Mods : C&amp;C Generals Undone : Files</span>
+                  <p id="downloadsummary">This is the first version of Undone, and I know it's still very much in development.</p>
+                  <div id="downloadsinfo">
+                    <div class="row clear"><h5>Filename</h5><span class="summary">GeneralsUndone_v1.0.zip</span></div>
+                    <div class="row clear"><a href="/downloads/start/313719">Download Now</a></div>
+                  </div>
+                </body></html>
+                """),
+            [parentUrl] = await CreateDocumentAsync("<html><body><h2>C&amp;C Generals Undone</h2></body></html>"),
+            [parentUrl + "/downloads"] = await CreateDocumentAsync("""
+                <div class="row rowcontent">
+                  <h4>C&amp;C Generals Undone</h4>
+                  <span class="size">289.6 MB</span>
+                  <a href="/mods/cc-generals-undone/downloads/cc-generals-undone" class="button download">Download</a>
+                </div>
+                <div class="row rowcontent">
+                  <h4>Generals Undone v1.01 Patch</h4>
+                  <span class="size">1 MB</span>
+                  <a href="/downloads/start/314093">Download</a>
+                </div>
+                """),
+            [parentUrl + "/addons"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/videos"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/images"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/reviews"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/articles"] = await CreateDocumentAsync("<html><body></body></html>"),
+        };
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .Returns((string _, IReadOnlyList<string> urls, CancellationToken _) =>
+            {
+                var result = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase);
+                foreach (var url in urls)
+                {
+                    if (documents.TryGetValue(url, out var doc))
+                    {
+                        result[url] = doc;
+                    }
+                }
+
+                return Task.FromResult<IReadOnlyDictionary<string, IDocument>>(result);
+            });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        var files = parsed.Sections.OfType<DownloadableFile>().ToList();
+        Assert.Equal(2, files.Count);
+        Assert.Contains(files, file => file.Name == "C&C Generals Undone" && file.DownloadUrl == "https://www.moddb.com/downloads/start/313719");
+        Assert.Contains(files, file => file.Name == "Generals Undone v1.01 Patch");
+        Assert.DoesNotContain(files, file => file.Name == "GeneralsUndone_v1.0.zip");
+        Assert.Equal("C&C Generals Undone", parsed.Context.Title);
+        Assert.Equal("WhiteSkull#9044", parsed.Context.Developer);
+        Assert.Contains("first version of Undone", parsed.Context.Description, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain("Games :", parsed.Context.Description, StringComparison.Ordinal);
+    }
+
+    /// <summary>
+    /// Verifies that ParseFileDetailAsync correctly parses metadata when ModDB uses alternative label names
+    /// such as "File Name", "File Size", "Uploaded By", "MD5 Checksum", and "Total Downloads".
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseFileDetailAsync_WithAlternativeLabels_ParsesMd5ChecksumTotalDownloadsAndUploaderAsync()
+    {
+        const string pageUrl = "https://www.moddb.com/mods/cc-generals-undone/downloads/generals-undone-v101-patch";
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentAsync(
+                ModDBConstants.BrowserProfileName,
+                pageUrl,
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(await CreateDocumentAsync("""
+                <html><body>
+                  <div id="downloadsinfo">
+                    <div class="row clear"><h5>File Name</h5><span class="summary">GeneralsUndone_v1.01.csf</span></div>
+                    <div class="row clear"><h5>Category</h5><span class="summary">Patch</span></div>
+                    <div class="row clear"><h5>Uploaded By</h5><span class="summary">WhiteSkull#9044</span></div>
+                    <div class="row clear"><h5>File Size</h5><span class="summary">289.6mb (303,663,235 bytes)</span></div>
+                    <div class="row clear"><h5>MD5 Checksum</h5><span class="summary">6e5b1fd58fc7a58cf21af86933116942</span></div>
+                    <div class="row clear"><h5>Total Downloads</h5><span class="summary">185</span></div>
+                    <div class="row clear"><a class="button buttonlarge" href="/downloads/start/313720">Download Now</a></div>
+                  </div>
+                </body></html>
+                """));
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        var parsed = await parser.ParseFileDetailAsync(pageUrl);
+
+        var file = Assert.Single(parsed.Sections.OfType<DownloadableFile>());
+        Assert.Equal("GeneralsUndone_v1.01.csf", file.Filename);
+        Assert.Equal("Patch", file.Category);
+        Assert.Equal("WhiteSkull#9044", file.Uploader);
+        Assert.Equal(303_663_235, file.SizeBytes);
+        Assert.Equal("6e5b1fd58fc7a58cf21af86933116942", file.Md5Hash);
+        Assert.Equal(185, file.DownloadCount);
+        Assert.Equal("https://www.moddb.com/downloads/start/313720", file.DownloadUrl);
+    }
+
+    /// <summary>
+    /// Verifies that ModDB download listing rows with subheading metadata (size in subheading, button class)
+    /// extract size, category, uploader, details URL, and download URL correctly.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_ModernModDBDownloadsListing_ExtractsSubheadingSizeAndLinksAsync()
+    {
+        const string pageUrl = "https://www.moddb.com/mods/cc-generals-undone/downloads/cc-generals-undone";
+        const string parentUrl = "https://www.moddb.com/mods/cc-generals-undone";
+        var documents = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase)
+        {
+            [pageUrl] = await CreateDocumentAsync("""
+                <html><body>
+                  <h1>C&amp;C Generals Undone file</h1>
+                  <h2>C&amp;C Generals Undone</h2>
+                  <div id="modsinfo"><a href="/company/whiteskull9044">WhiteSkull#9044</a></div>
+                  <p id="downloadsummary">First release of Undone.</p>
+                  <div id="downloadsinfo">
+                    <div class="row clear"><h5>Filename</h5><span class="summary">GeneralsUndone_v1.0.zip</span></div>
+                    <div class="row clear"><h5>Category</h5><span class="summary">Full Version</span></div>
+                    <div class="row clear"><h5>Size</h5><span class="summary">289.6mb (303,663,235 bytes)</span></div>
+                    <div class="row clear"><h5>MD5 Hash</h5><span class="summary">6e5b3fcf30fc7a58ef21af869551bb942</span></div>
+                    <div class="row clear"><a class="button buttonlarge" href="/downloads/start/313719">Download Now</a></div>
+                  </div>
+                </body></html>
+                """),
+            [parentUrl] = await CreateDocumentAsync("<html><body><h2>C&amp;C Generals Undone</h2></body></html>"),
+            [parentUrl + "/downloads"] = await CreateDocumentAsync("""
+                <div class="row rowcontent clear">
+                  <div class="heading">
+                    <h4><a href="/mods/cc-generals-undone/downloads/cc-generals-undone">C&amp;C Generals Undone</a></h4>
+                    <span class="subheading"><time datetime="2026-08-02T12:00:00+00:00">Aug 2nd, 2026</time> - Full Version, 289.6mb</span>
+                  </div>
+                  <div class="actions">
+                    <a href="/mods/cc-generals-undone/downloads/cc-generals-undone" class="button">Download</a>
+                  </div>
+                </div>
+                <div class="row rowcontent clear">
+                  <div class="heading">
+                    <h4><a href="/mods/cc-generals-undone/downloads/generals-undone-v101-patch">Generals Undone v1.01 Patch</a></h4>
+                    <span class="subheading"><time datetime="2026-08-07T12:00:00+00:00">Aug 7th, 2026</time> - Patch, 1 MB</span>
+                  </div>
+                  <div class="actions">
+                    <a href="/mods/cc-generals-undone/downloads/generals-undone-v101-patch" class="button">Download</a>
+                  </div>
+                </div>
+                """),
+            [parentUrl + "/addons"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/videos"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/images"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/reviews"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/articles"] = await CreateDocumentAsync("<html><body></body></html>"),
+        };
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .Returns((string _, IReadOnlyList<string> urls, CancellationToken _) =>
+            {
+                var result = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase);
+                foreach (var url in urls)
+                {
+                    if (documents.TryGetValue(url, out var doc))
+                    {
+                        result[url] = doc;
+                    }
+                }
+
+                return Task.FromResult<IReadOnlyDictionary<string, IDocument>>(result);
+            });
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        var files = parsed.Sections.OfType<DownloadableFile>().ToList();
+        Assert.Equal(2, files.Count);
+
+        var mainRelease = Assert.Single(files, f => f.Name == "C&C Generals Undone");
+        Assert.Equal("GeneralsUndone_v1.0.zip", mainRelease.Filename);
+        Assert.Equal("https://www.moddb.com/downloads/start/313719", mainRelease.DownloadUrl);
+        Assert.Equal("https://www.moddb.com/mods/cc-generals-undone/downloads/cc-generals-undone", mainRelease.DetailsUrl);
+        Assert.Equal("Full Version", mainRelease.Category);
+        Assert.Equal(303_663_235, mainRelease.SizeBytes);
+        Assert.Equal("6e5b3fcf30fc7a58ef21af869551bb942", mainRelease.Md5Hash);
+
+        var patchRelease = Assert.Single(files, f => f.Name == "Generals Undone v1.01 Patch");
+        Assert.Equal("https://www.moddb.com/mods/cc-generals-undone/downloads/generals-undone-v101-patch", patchRelease.DetailsUrl);
+        Assert.Equal("Patch", patchRelease.Category);
+        Assert.Equal(1048576, patchRelease.SizeBytes);
+        Assert.Equal("1 MB", patchRelease.SizeDisplay);
+    }
+
+    /// <summary>
+    /// Verifies that embedded YouTube iframes on mod pages have their title, thumbnail, platform,
+    /// and normalized embed URL properly extracted.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_WithYouTubeIframe_ExtractsTitlePlatformThumbnailAndEmbedUrlAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/korean-war-2";
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div class="headerbox"><h1>Korean War 2</h1></div>
+              <div class="video-container">
+                <iframe src="https://www.youtube.com/embed/fW_O3G_Z4qg" title="Korean War 2 Official Trailer" frameborder="0" allowfullscreen></iframe>
+              </div>
+              <div class="row">
+                <h3>Gameplay Teaser</h3>
+                <iframe src="https://www.youtube-nocookie.com/embed/dQw4w9WgXcQ?rel=0"></iframe>
+              </div>
+            </body></html>
+            """);
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var videos = parsed.Sections.OfType<Video>().ToList();
+        Assert.Equal(2, videos.Count);
+
+        var trailer = Assert.Single(videos, v => v.Title == "Korean War 2 Official Trailer");
+        Assert.Equal("YouTube", trailer.Platform);
+        Assert.Equal("https://img.youtube.com/vi/fW_O3G_Z4qg/hqdefault.jpg", trailer.ThumbnailUrl);
+        Assert.Equal("https://www.youtube.com/embed/fW_O3G_Z4qg", trailer.EmbedUrl);
+
+        var teaser = Assert.Single(videos, v => v.Title == "Gameplay Teaser");
+        Assert.Equal("YouTube", teaser.Platform);
+        Assert.Equal("https://img.youtube.com/vi/dQw4w9WgXcQ/hqdefault.jpg", teaser.ThumbnailUrl);
+        Assert.Equal("https://www.youtube.com/embed/dQw4w9WgXcQ", teaser.EmbedUrl);
+    }
+
+    /// <summary>
+    /// Verifies that ModDB /videos gallery cards are extracted from the videos section with titles,
+    /// thumbnails, platforms, and page links.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_WithVideosSectionListing_ExtractsGalleryVideosAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/korean-war-2/downloads/korean-war-2-v020";
+        const string parentUrl = "https://www.moddb.com/mods/korean-war-2";
+        var documents = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase)
+        {
+            [pageUrl] = await CreateDocumentAsync("""
+                <html><body>
+                  <div id="downloadsinfo">
+                    <div class="row clear"><h5>Filename</h5><span class="summary">KoreanWar2V020.zip</span></div>
+                    <div class="row clear"><h5>Size</h5><span class="summary">360mb</span></div>
+                    <div class="row clear"><a class="button buttonlarge" href="/downloads/start/309442">Download Now</a></div>
+                  </div>
+                </body></html>
+                """),
+            [parentUrl] = await CreateDocumentAsync("""
+                <html><body>
+                  <h1>Korean War 2</h1>
+                  <div class="sidecolumn"><div class="avatar"><img src="https://media.moddb.com/images/members/1/1/icon.jpg" /></div></div>
+                </body></html>
+                """),
+            [parentUrl + "/videos"] = await CreateDocumentAsync("""
+                <html><body>
+                  <div id="mediabrowse" class="table">
+                    <div class="row mediarow rowcontent">
+                      <div class="holder">
+                        <a href="/mods/korean-war-2/videos/iran-safir-mrl-ingame" title="Iran Safir MRL Ingame">
+                          <img src="https://media.moddb.com/cache/images/videos/1/12/11543/crop_120x90/preview.png" alt="Iran Safir MRL Ingame" />
+                          <span class="playbutton"></span>
+                        </a>
+                        <span class="title"><a href="/mods/korean-war-2/videos/iran-safir-mrl-ingame">Iran Safir MRL Ingame</a></span>
+                      </div>
+                    </div>
+                    <div class="row mediarow rowcontent">
+                      <div class="holder">
+                        <a href="/mods/korean-war-2/videos/iran-tabas-air-defense" title="Iran Tabas Air Defense System">
+                          <img src="https://media.moddb.com/cache/images/videos/1/12/11544/crop_120x90/preview2.png" alt="Iran Tabas Air Defense System" />
+                        </a>
+                        <span class="title"><a href="/mods/korean-war-2/videos/iran-tabas-air-defense">Iran Tabas Air Defense System</a></span>
+                      </div>
+                    </div>
+                  </div>
+                </body></html>
+                """),
+        };
+
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .Returns((string _, IReadOnlyList<string> urls, CancellationToken _) =>
+            {
+                var result = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase);
+                foreach (var url in urls)
+                {
+                    if (documents.TryGetValue(url, out var doc))
+                    {
+                        result[url] = doc;
+                    }
+                }
+
+                return Task.FromResult<IReadOnlyDictionary<string, IDocument>>(result);
+            });
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var videos = parsed.Sections.OfType<Video>().ToList();
+        Assert.Equal(2, videos.Count);
+
+        var video1 = Assert.Single(videos, v => v.Title == "Iran Safir MRL Ingame");
+        Assert.Equal("ModDB", video1.Platform);
+        Assert.Equal("https://www.moddb.com/mods/korean-war-2/videos/iran-safir-mrl-ingame", video1.EmbedUrl);
+        Assert.Equal("https://media.moddb.com/cache/images/videos/1/12/11543/crop_120x90/preview.png", video1.ThumbnailUrl);
+
+        var video2 = Assert.Single(videos, v => v.Title == "Iran Tabas Air Defense System");
+        Assert.Equal("ModDB", video2.Platform);
+        Assert.Equal("https://www.moddb.com/mods/korean-war-2/videos/iran-tabas-air-defense", video2.EmbedUrl);
+        Assert.Equal("https://media.moddb.com/cache/images/videos/1/12/11544/crop_120x90/preview2.png", video2.ThumbnailUrl);
+    }
+
+    /// <summary>
+    /// Verifies that video cards linking to /videos/ are not duplicated into the static image gallery.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_WithMediaBrowseContainingImagesAndVideos_SeparatesImagesAndVideosAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/test-mod";
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <h1>Test Mod</h1>
+              <div id="mediabrowse">
+                <div class="row mediarow">
+                  <div class="holder">
+                    <a href="/mods/test-mod/images/screenshot-1" title="Ingame Base Screenshot">
+                      <img src="https://media.moddb.com/images/mods/1/1/base.png" alt="Ingame Base Screenshot" />
+                    </a>
+                  </div>
+                  <div class="holder">
+                    <a href="/mods/test-mod/videos/trailer-1" title="Ingame Trailer Video">
+                      <img src="https://media.moddb.com/cache/images/videos/1/1/trailer.png" alt="Ingame Trailer Video" />
+                    </a>
+                  </div>
+                </div>
+              </div>
+            </body></html>
+            """);
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var images = parsed.Sections.OfType<Image>().ToList();
+        var videos = parsed.Sections.OfType<Video>().ToList();
+
+        var image = Assert.Single(images);
+        Assert.Equal("Ingame Base Screenshot", image.Title);
+
+        var video = Assert.Single(videos);
+        Assert.Equal("Ingame Trailer Video", video.Title);
+        Assert.Equal("https://www.moddb.com/mods/test-mod/videos/trailer-1", video.EmbedUrl);
+        Assert.Equal("https://media.moddb.com/cache/images/videos/1/1/trailer.png", video.ThumbnailUrl);
+    }
+
+    /// <summary>
+    /// Verifies that non-video iframes (like download widgets) and recommendation boxes
+    /// ("You may also like...") are not parsed into the Videos collection.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_WithDownloadWidgetAndRecommendations_IgnoresNonVideoWidgetsAndRecommendationsAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/zhe/downloads/patch-1";
+        const string parentUrl = "https://www.moddb.com/mods/zhe";
+        var documents = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase)
+        {
+            [pageUrl] = await CreateDocumentAsync("""
+                <html><body>
+                  <div id="downloadsinfo">
+                    <div class="row clear"><h5>Filename</h5><span class="summary">ZHE_Patch.zip</span></div>
+                    <div class="row clear"><h5>Size</h5><span class="summary">500kb</span></div>
+                    <div class="row clear"><a class="button buttonlarge" href="/downloads/start/313875">Download Now</a></div>
+                  </div>
+                  <div class="video-container">
+                    <iframe src="https://www.moddb.com/mods/zhe/downloads/zhe-installer/widget" width="468" height="60"></iframe>
+                  </div>
+                  <div id="mediaimage">
+                    <img src="https://media.moddb.com/cache/images/downloads/1/314/313875/crop_120x90/Final.jpg" alt="Final Preview" />
+                  </div>
+                </body></html>
+                """),
+            [parentUrl] = await CreateDocumentAsync("""
+                <html><body>
+                  <h1>ZHE</h1>
+                  <div class="sidecolumn">
+                    <div class="avatar"><img src="https://static.moddb.com/html/cutoff/images/default/error_50x50.png" /></div>
+                  </div>
+                </body></html>
+                """),
+            [parentUrl + "/videos"] = await CreateDocumentAsync("""
+                <html><body>
+                  <div id="mediabrowse">
+                    <div class="holder">
+                      <a href="/mods/zhe/videos/real-trailer" title="Real Mod Trailer">
+                        <img src="https://media.moddb.com/cache/images/videos/1/1/trailer.jpg" alt="Real Mod Trailer" />
+                      </a>
+                      <span class="title"><a href="/mods/zhe/videos/real-trailer">Real Mod Trailer</a></span>
+                    </div>
+                  </div>
+                  <div id="recommendations">
+                    <h3>You may also like...</h3>
+                    <div class="holder">
+                      <a href="/mods/other-mod/videos/other-trailer" title="You may also like...">
+                        <img src="https://media.moddb.com/cache/images/videos/2/2/other.jpg" alt="You may also like..." />
+                      </a>
+                    </div>
+                  </div>
+                </body></html>
+                """),
+        };
+
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .Returns((string _, IReadOnlyList<string> urls, CancellationToken _) =>
+            {
+                var result = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase);
+                foreach (var url in urls)
+                {
+                    if (documents.TryGetValue(url, out var doc))
+                    {
+                        result[url] = doc;
+                    }
+                }
+
+                return Task.FromResult<IReadOnlyDictionary<string, IDocument>>(result);
+            });
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var videos = parsed.Sections.OfType<Video>().ToList();
+        var images = parsed.Sections.OfType<Image>().ToList();
+
+        // Only the 1 real trailer should be extracted, NOT the download widget or recommendation box
+        var video = Assert.Single(videos);
+        Assert.Equal("Real Mod Trailer", video.Title);
+        Assert.Equal("https://www.moddb.com/mods/zhe/videos/real-trailer", video.EmbedUrl);
+        Assert.Equal("https://media.moddb.com/cache/images/videos/1/1/trailer.jpg", video.ThumbnailUrl);
+
+        // Preview image from file detail page should be extracted into Images
+        var image = Assert.Single(images);
+        Assert.Equal("Final Preview", image.Title);
+        Assert.Equal("https://media.moddb.com/images/downloads/1/314/313875/Final.jpg", image.ThumbnailUrl);
+        Assert.Equal("https://media.moddb.com/images/downloads/1/314/313875/Final.jpg", image.FullSizeUrl);
+
+        // Error placeholder icon must be ignored
+        Assert.Null(parsed.Context.IconUrl);
+    }
+
+    /// <summary>
+    /// Verifies that ParseFileDetailAsync extracts the file-specific heading rather than
+    /// the parent mod title inside the .headerbox container.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseFileDetailAsync_WithHeaderBox_ExtractsSpecificFileHeadingNotParentModNameAsync()
+    {
+        const string pageUrl = "https://www.moddb.com/mods/cc-generals-undone/downloads/generalsundone-v101-patch";
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentAsync(
+                ModDBConstants.BrowserProfileName,
+                pageUrl,
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(await CreateDocumentAsync("""
+                <html>
+                  <head>
+                    <title>Generals Undone v1.01 Patch file - C&amp;C Generals Undone mod for C&amp;C: Generals Zero Hour - ModDB</title>
+                  </head>
+                  <body>
+                    <div class="headerbox">
+                      <h1><a href="/mods/cc-generals-undone">C&amp;C Generals Undone</a></h1>
+                      <h2>C&amp;C: Generals Zero Hour mod | Released Aug 1, 2026</h2>
+                    </div>
+                    <div class="midcolumn">
+                      <div class="heading">
+                        <h2>Generals Undone v1.01 Patch</h2>
+                      </div>
+                      <div id="downloadsinfo">
+                        <div class="row clear"><h5>Filename</h5><span class="summary">GeneralsUndone_v1.01_Patch.1.zip</span></div>
+                        <div class="row clear"><h5>Category</h5><span class="summary">Patch</span></div>
+                        <div class="row clear"><h5>Uploader</h5><span class="summary">WhiteSkull#9044</span></div>
+                        <div class="row clear"><h5>Size</h5><span class="summary">188.3kb (192,819 bytes)</span></div>
+                        <div class="row clear"><h5>MD5 Hash</h5><span class="summary">5350e475319f2eaed0ab92d445b7099a</span></div>
+                        <div class="row clear"><a class="button buttonlarge" href="/downloads/start/314093">Download Now</a></div>
+                      </div>
+                      <div id="downloaddescription">
+                        <p>This is a patched .csf file that contains the entries for the USA supply truck.</p>
+                        <p>To Install:</p>
+                        <p>1. Extract the .zip folder</p>
+                      </div>
+                      <div id="downloadsmedia">
+                        <a href="https://media.moddb.com/images/downloads/1/314/314093/preview_full.png">
+                          <img src="https://media.moddb.com/cache/images/downloads/1/314/314093/crop_120x90/preview.png" />
+                        </a>
+                      </div>
+                    </div>
+                  </body>
+                </html>
+                """));
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        var parsed = await parser.ParseFileDetailAsync(pageUrl);
+
+        var file = Assert.Single(parsed.Sections.OfType<DownloadableFile>());
+        Assert.Equal("Generals Undone v1.01 Patch", file.Name);
+        Assert.Equal("GeneralsUndone_v1.01_Patch.1.zip", file.Filename);
+        Assert.Equal("Patch", file.Category);
+        Assert.Equal("5350e475319f2eaed0ab92d445b7099a", file.Md5Hash);
+        Assert.Equal(192_819, file.SizeBytes);
+        Assert.NotNull(file.Description);
+        Assert.Contains("This is a patched .csf file", file.Description, StringComparison.Ordinal);
+        Assert.Contains("To Install:", file.Description, StringComparison.Ordinal);
+        Assert.NotNull(file.PreviewImages);
+        Assert.Contains("https://media.moddb.com/images/downloads/1/314/314093/preview_full.png", file.PreviewImages);
+    }
+
+    /// <summary>
+    /// Verifies that DeduplicateDownloadableFiles keeps distinct release files separate when they have
+    /// different details/download URLs rather than collapsing them.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_WithMultipleDistinctReleases_KeepsBothReleasesSeparateAsync()
+    {
+        const string pageUrl = "https://www.moddb.com/mods/cc-generals-undone/downloads/cc-generals-undone";
+        const string parentUrl = "https://www.moddb.com/mods/cc-generals-undone";
+        var documents = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase)
+        {
+            [pageUrl] = await CreateDocumentAsync("""
+                <html>
+                  <head><title>C&amp;C Generals Undone file - ModDB</title></head>
+                  <body>
+                    <div class="headerbox">
+                      <h1><a href="/mods/cc-generals-undone">C&amp;C Generals Undone</a></h1>
+                    </div>
+                    <div class="midcolumn">
+                      <h2>C&amp;C Generals Undone</h2>
+                      <div id="downloadsinfo">
+                        <div class="row clear"><h5>Filename</h5><span class="summary">GeneralsUndone_v1.0.zip</span></div>
+                        <div class="row clear"><h5>Category</h5><span class="summary">Full Version</span></div>
+                        <div class="row clear"><h5>Size</h5><span class="summary">289.6mb (303,663,235 bytes)</span></div>
+                        <div class="row clear"><a class="button buttonlarge" href="/downloads/start/313719">Download Now</a></div>
+                      </div>
+                      <div id="downloaddescription">
+                        <p>This is the first version of Undone.</p>
+                      </div>
+                    </div>
+                  </body>
+                </html>
+                """),
+            [parentUrl] = await CreateDocumentAsync("<html><body><h2>C&amp;C Generals Undone</h2></body></html>"),
+            [parentUrl + "/downloads"] = await CreateDocumentAsync("""
+                <div class="row rowcontent clear">
+                  <div class="heading">
+                    <h4><a href="/mods/cc-generals-undone/downloads/cc-generals-undone">C&amp;C Generals Undone</a></h4>
+                    <span class="subheading"><time datetime="2026-08-02T12:00:00+00:00">Aug 2nd, 2026</time> - Full Version, 289.6mb</span>
+                  </div>
+                  <div class="actions">
+                    <a href="/mods/cc-generals-undone/downloads/cc-generals-undone" class="button">Download</a>
+                  </div>
+                </div>
+                <div class="row rowcontent clear">
+                  <div class="heading">
+                    <h4><a href="/mods/cc-generals-undone/downloads/generalsundone-v101-patch">Generals Undone v1.01 Patch</a></h4>
+                    <span class="subheading"><time datetime="2026-08-07T12:00:00+00:00">Aug 7th, 2026</time> - Patch, 188.3kb</span>
+                  </div>
+                  <div class="actions">
+                    <a href="/mods/cc-generals-undone/downloads/generalsundone-v101-patch" class="button">Download</a>
+                  </div>
+                </div>
+                """),
+            [parentUrl + "/addons"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/videos"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/images"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/reviews"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [parentUrl + "/articles"] = await CreateDocumentAsync("<html><body></body></html>"),
+        };
+
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .Returns((string _, IReadOnlyList<string> urls, CancellationToken _) =>
+            {
+                var result = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase);
+                foreach (var url in urls)
+                {
+                    if (documents.TryGetValue(url, out var doc))
+                    {
+                        result[url] = doc;
+                    }
+                }
+
+                return Task.FromResult<IReadOnlyDictionary<string, IDocument>>(result);
+            });
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        var releases = parsed.Sections.OfType<DownloadableFile>().ToList();
+        Assert.Equal(2, releases.Count);
+
+        var patch = Assert.Single(releases, r => r.DetailsUrl?.Contains("generalsundone-v101-patch", StringComparison.OrdinalIgnoreCase) == true);
+        Assert.Equal("Generals Undone v1.01 Patch", patch.Name);
+        Assert.Equal("Patch", patch.Category);
+
+        var full = Assert.Single(releases, r => r.DetailsUrl?.EndsWith("cc-generals-undone", StringComparison.OrdinalIgnoreCase) == true);
+        Assert.Equal("C&C Generals Undone", full.Name);
+        Assert.Equal("Full Version", full.Category);
+        Assert.Equal("GeneralsUndone_v1.0.zip", full.Filename);
+        Assert.Contains("This is the first version of Undone.", full.Description, StringComparison.Ordinal);
+    }
+
+    /// <summary>
+    /// Gets test data for size parsing formats.
+    /// </summary>
+    public static TheoryData<string, long> SizeTestData => new()
+    {
+        { "188.3kb (192,819 bytes)", 192819L },
+        { "188.3kb", 192819L },
+        { "9,72 MB", (long)(9.72 * 1024 * 1024) },
+        { "1.07mb (1,125,450 bytes)", 1125450L },
+        { "289.6 MB", (long)(289.6 * 1024 * 1024) },
+    };
+
+    /// <summary>
+    /// Tests that ParseFileDetail handles various size formats correctly.
+    /// </summary>
+    /// <param name="sizeString">The raw size string to test.</param>
+    /// <param name="expectedBytes">The expected parsed size in bytes.</param>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Theory]
+    [MemberData(nameof(SizeTestData))]
+    public async Task ParseFileDetail_WithVariousSizeFormats_CorrectlyParsesSizeBytesAsync(string sizeString, long expectedBytes)
+    {
+        // Arrange
+        var playwright = CreatePlaywrightMock();
+        var pageUrl = "https://www.moddb.com/mods/test-mod/downloads/test-file";
+        var doc = await CreateDocumentAsync($"""
+            <html><body>
+              <div id="downloadsinfo">
+                <div class="row clear"><h5>Filename</h5><span class="summary">test_file.zip</span></div>
+                <div class="row clear"><h5>Size</h5><span class="summary">{sizeString}</span></div>
+                <div class="row clear"><a class="button buttonlarge" href="/downloads/start/12345">Download Now</a></div>
+              </div>
+            </body></html>
+            """);
+
+        playwright
+            .Setup(service => service.FetchAndParsePersistentAsync(
+                ModDBConstants.BrowserProfileName,
+                pageUrl,
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(doc);
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseFileDetailAsync(pageUrl);
+
+        // Assert
+        Assert.NotNull(parsed);
+        var file = Assert.Single(parsed.Sections.OfType<DownloadableFile>());
+        Assert.NotNull(file.SizeBytes);
+
+        // Allow within 1% tolerance for floating-point calculations where byte count was not explicit
+        if (sizeString.Contains("bytes", StringComparison.OrdinalIgnoreCase))
+        {
+            Assert.Equal(expectedBytes, file.SizeBytes.Value);
+        }
+        else
+        {
+            var diff = Math.Abs(file.SizeBytes.Value - expectedBytes);
+            Assert.True(diff < expectedBytes * 0.05, $"Parsed size {file.SizeBytes.Value} was not within tolerance of {expectedBytes}");
+        }
+    }
+
+    /// <summary>
+    /// Verifies that ParseFileDetailsManyAsync requests all URLs via FetchAndParsePersistentManyAsync
+    /// and parses each document returned into a ParsedWebPage.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseFileDetailsManyAsync_MultipleUrls_CallsFetchAndParsePersistentManyAsyncAndParsesAllAsync()
+    {
+        // Arrange
+        const string url1 = "https://www.moddb.com/games/cc-generals-zero-hour/addons/addon1";
+        const string url2 = "https://www.moddb.com/games/cc-generals-zero-hour/downloads/release1";
+
+        var doc1 = await CreateDocumentAsync("""
+            <html><body>
+              <div id="downloadsinfo">
+                <div class="row clear"><h5>Filename</h5><span class="summary">addon1.zip</span></div>
+                <div class="row clear"><a class="button buttonlarge" href="/addons/start/101">Download</a></div>
+              </div>
+            </body></html>
+            """);
+
+        var doc2 = await CreateDocumentAsync("""
+            <html><body>
+              <div id="downloadsinfo">
+                <div class="row clear"><h5>Filename</h5><span class="summary">release1.zip</span></div>
+                <div class="row clear"><a class="button buttonlarge" href="/downloads/start/202">Download</a></div>
+              </div>
+            </body></html>
+            """);
+
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.Is<IReadOnlyList<string>>(urls => urls.Contains(url1) && urls.Contains(url2)),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase)
+            {
+                [url1] = doc1,
+                [url2] = doc2,
+            });
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var results = await parser.ParseFileDetailsManyAsync([url1, url2]);
+
+        // Assert
+        Assert.Equal(2, results.Count);
+        Assert.True(results.TryGetValue(url1, out var page1));
+        var file1 = Assert.Single(page1!.Sections.OfType<DownloadableFile>());
+        Assert.Equal("addon1.zip", file1.Name);
+        Assert.Equal("https://www.moddb.com/addons/start/101", file1.DownloadUrl);
+
+        Assert.True(results.TryGetValue(url2, out var page2));
+        var file2 = Assert.Single(page2!.Sections.OfType<DownloadableFile>());
+        Assert.Equal("release1.zip", file2.Name);
+        Assert.Equal("https://www.moddb.com/downloads/start/202", file2.DownloadUrl);
+    }
+
+    /// <summary>
+    /// Protocol-relative media URLs (starting with //media.moddb.com) should normalize to https:// without duplicating base domain.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_ProtocolRelativeMediaUrls_NormalizesToHttpsSchemeAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/test-mod/images";
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div id="imagebox">
+                <a href="/mods/test-mod/images/shot1">
+                  <img alt="Screenshot One" src="//media.moddb.com/cache/images/mods/1/73/72174/crop_120x90/ScreenshotOne.png" />
+                </a>
+              </div>
+            </body></html>
+            """);
+
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var image = Assert.Single(parsed.Sections.OfType<Image>());
+        Assert.Equal("Screenshot One", image.Title);
+        Assert.Equal("https://media.moddb.com/images/mods/1/73/72174/ScreenshotOne.png", image.ThumbnailUrl);
+        Assert.Equal("https://media.moddb.com/images/mods/1/73/72174/ScreenshotOne.png", image.FullSizeUrl);
+        Assert.DoesNotContain("www.moddb.com//", image.ThumbnailUrl);
+    }
+
+    /// <summary>
+    /// Pagination links, RSS feeds, and navigation controls on video pages must be excluded from extracted videos.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_VideosPage_ExcludesPaginationAndRssLinksAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/test-mod/videos";
+        var doc = await CreateDocumentAsync("""
+            <html><body>
+              <div id="videosbrowse">
+                <div class="row mediarow">
+                  <div class="holder">
+                    <a href="/mods/test-mod/videos/gameplay-trailer" title="Gameplay Trailer">
+                      <img src="//media.moddb.com/cache/images/videos/1/1/trailer.png" alt="Gameplay Trailer" />
+                    </a>
+                  </div>
+                </div>
+                <div class="pagination">
+                  <a href="/mods/test-mod/videos/page/2#videosbrowse">Next Media</a>
+                  <a href="/mods/test-mod/videos/rss/feed">RSS</a>
+                  <a class="prev" href="/mods/test-mod/videos/page/1">Previous</a>
+                </div>
+              </div>
+            </body></html>
+            """);
+
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase) { [pageUrl] = doc });
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var videos = parsed.Sections.OfType<Video>().ToList();
+        var video = Assert.Single(videos);
+        Assert.Equal("Gameplay Trailer", video.Title);
+        Assert.Equal("https://media.moddb.com/cache/images/videos/1/1/trailer.png", video.ThumbnailUrl);
+        Assert.DoesNotContain(videos, v => v.Title.Contains("Next", StringComparison.OrdinalIgnoreCase));
+        Assert.DoesNotContain(videos, v => v.Title.Contains("RSS", StringComparison.OrdinalIgnoreCase));
+        Assert.DoesNotContain(videos, v => v.Title.Contains("Previous", StringComparison.OrdinalIgnoreCase));
+    }
+
+    /// <summary>
+    /// Verifies that when a mod has both releases and addons, ParseAsync enriches both top releases and top addons
+    /// in the same session without dropping releases when addons have newer timestamps.
+    /// </summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Fact]
+    public async Task ParseAsync_ModWithReleasesAndAddons_EnrichesBothTopReleasesAndAddonsInSingleSessionAsync()
+    {
+        // Arrange
+        const string pageUrl = "https://www.moddb.com/mods/rich-mod";
+        const string release1Url = "https://www.moddb.com/mods/rich-mod/downloads/release-1";
+        const string addon1Url = "https://www.moddb.com/mods/rich-mod/addons/addon-1";
+
+        var documents = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase)
+        {
+            [pageUrl] = await CreateDocumentAsync("<html><body><h1>Rich Mod</h1></body></html>"),
+            [pageUrl + "/downloads"] = await CreateDocumentAsync("""
+                <div class="row file">
+                  <h4><a href="/mods/rich-mod/downloads/release-1">Release 1</a></h4>
+                  <span class="size">500 MB</span>
+                  <time datetime="2024-01-01">Jan 1 2024</time>
+                  <a href="/downloads/start/1001">Download</a>
+                </div>
+                """),
+            [pageUrl + "/addons"] = await CreateDocumentAsync("""
+                <div class="row file">
+                  <h4><a href="/mods/rich-mod/addons/addon-1">Addon 1</a></h4>
+                  <span class="size">10 MB</span>
+                  <time datetime="2026-06-01">Jun 1 2026</time>
+                  <a href="/addons/start/2001">Download</a>
+                </div>
+                """),
+            [pageUrl + "/videos"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [pageUrl + "/images"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [pageUrl + "/reviews"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [pageUrl + "/articles"] = await CreateDocumentAsync("<html><body></body></html>"),
+            [release1Url] = await CreateDocumentAsync("""
+                <html><body>
+                  <h1><a>Release 1</a></h1>
+                  <div id="downloadsinfo">
+                    <div class="row clear"><h5>Filename</h5><span class="summary">release_1.zip</span></div>
+                    <div class="row clear"><h5>MD5 Hash</h5><span class="summary">hash_release_1</span></div>
+                    <div class="row clear"><h5>Size</h5><span class="summary">500mb (524,288,000 bytes)</span></div>
+                    <div class="row clear"><a class="button" href="/downloads/start/1001">Download Now</a></div>
+                  </div>
+                  <div id="downloadsummary">Full release v1 description</div>
+                </body></html>
+                """),
+            [addon1Url] = await CreateDocumentAsync("""
+                <html><body>
+                  <h1><a>Addon 1</a></h1>
+                  <div id="downloadsinfo">
+                    <div class="row clear"><h5>Filename</h5><span class="summary">addon_1.zip</span></div>
+                    <div class="row clear"><h5>MD5 Hash</h5><span class="summary">hash_addon_1</span></div>
+                    <div class="row clear"><h5>Size</h5><span class="summary">10mb (10,485,760 bytes)</span></div>
+                    <div class="row clear"><a class="button" href="/addons/start/2001">Download Now</a></div>
+                  </div>
+                  <div id="downloadsummary">Addon 1 map pack description</div>
+                </body></html>
+                """),
+        };
+
+        var playwright = CreatePlaywrightMock();
+        playwright
+            .Setup(service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<CancellationToken>()))
+            .Returns((string _, IReadOnlyList<string> urls, CancellationToken _) =>
+            {
+                var result = new Dictionary<string, IDocument>(StringComparer.OrdinalIgnoreCase);
+                foreach (var url in urls)
+                {
+                    if (documents.TryGetValue(url, out var doc))
+                    {
+                        result[url] = doc;
+                    }
+                }
+
+                return Task.FromResult<IReadOnlyDictionary<string, IDocument>>(result);
+            });
+
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var parsed = await parser.ParseAsync(pageUrl);
+
+        // Assert
+        var files = parsed.Sections.OfType<DownloadableFile>().ToList();
+        var release = Assert.Single(files, f => f.FileSectionType == FileSectionType.Downloads);
+        Assert.Equal("Release 1", release.Name);
+        Assert.Equal("release_1.zip", release.Filename);
+        Assert.Equal("hash_release_1", release.Md5Hash);
+        Assert.Equal("Full release v1 description", release.Description);
+
+        var addon = Assert.Single(files, f => f.FileSectionType == FileSectionType.Addons);
+        Assert.Equal("Addon 1", addon.Name);
+        Assert.Equal("addon_1.zip", addon.Filename);
+        Assert.Equal("hash_addon_1", addon.Md5Hash);
+        Assert.Equal("Addon 1 map pack description", addon.Description);
+
+        // Verify both the release and addon detail URLs were fetched during enrichment
+        playwright.Verify(
+            service => service.FetchAndParsePersistentManyAsync(
+                ModDBConstants.BrowserProfileName,
+                It.Is<IReadOnlyList<string>>(urls => urls.Contains(release1Url) && urls.Contains(addon1Url)),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    /// <summary>
+    /// Verifies CanParse accepts valid ModDB HTTP(S) domains and rejects invalid or attacker origins.
+    /// </summary>
+    /// <param name="url">The URL to test.</param>
+    /// <param name="expected">The expected parseability result.</param>
+    [Theory]
+    [InlineData("https://www.moddb.com/mods/test-mod", true)]
+    [InlineData("http://moddb.com/mods/test-mod", true)]
+    [InlineData("https://media.moddb.com/downloads/test.zip", true)]
+    [InlineData("https://localhost/?source=moddb.com", false)]
+    [InlineData("https://moddb.com.attacker.example/mods/test", false)]
+    [InlineData("https://attacker-moddb.com/mods/test", false)]
+    [InlineData("not-a-valid-url", false)]
+    [InlineData("ftp://www.moddb.com/mods/test", false)]
+    public void CanParse_ValidatesSchemeAndHostCorrectly(string url, bool expected)
+    {
+        // Arrange
+        var playwright = new Mock<IPlaywrightService>();
+        var parser = new ModDBPageParser(playwright.Object, new Mock<ILogger<ModDBPageParser>>().Object);
+
+        // Act
+        var result = parser.CanParse(url);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    private static async Task<IDocument> CreateDocumentAsync(string html)
+    {
+        var browsingContext = BrowsingContext.New(Configuration.Default);
+        return await browsingContext.OpenAsync(request => request.Content(html));
+    }
+
+    private static Mock<IPlaywrightService> CreatePlaywrightMock()
+    {
+        var playwright = new Mock<IPlaywrightService>(MockBehavior.Strict);
+        playwright
+            .Setup(service => service.ExecuteInPersistentContextAsync(
+                It.IsAny<string>(),
+                It.IsAny<Func<Task<ParsedWebPage>>>(),
+                It.IsAny<CancellationToken>()))
+            .Returns((string _, Func<Task<ParsedWebPage>> op, CancellationToken _) => op());
+        return playwright;
+    }
+}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/Tools/ManagedChromiumRuntimeTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/Tools/ManagedChromiumRuntimeTests.cs
new file mode 100644
index 000000000..2f430b8ec
--- /dev/null
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/Tools/ManagedChromiumRuntimeTests.cs
@@ -0,0 +1,168 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using GenHub.Core.Models.Common;
+using GenHub.Features.Content.Services.Tools;
+using Microsoft.Extensions.Logging;
+using Microsoft.Playwright;
+using Moq;
+using Xunit;
+
+namespace GenHub.Tests.Core.Features.Content.Tools;
+
+/// <summary>
+/// Tests the app-owned Playwright Chromium runtime and request-header propagation.
+/// </summary>
+public sealed class ManagedChromiumRuntimeTests : IDisposable
+{
+    private readonly string _runtimeDirectory = Path.Combine(Path.GetTempPath(), "GenHubTests", Guid.NewGuid().ToString("N"));
+    private readonly string? _originalBrowserPath = Environment.GetEnvironmentVariable(ManagedChromiumRuntime.BrowserPathEnvironmentVariable);
+
+    /// <summary>
+    /// Verifies a pre-provisioned app-owned Chromium executable does not trigger another install.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task EnsureInstalledAsync_ExistingManagedExecutable_DoesNotRunInstallerAsync()
+    {
+        // Arrange
+        var executablePath = Path.Combine(_runtimeDirectory, "chromium.exe");
+        Directory.CreateDirectory(_runtimeDirectory);
+        await File.WriteAllTextAsync(executablePath, "browser");
+        var installerCalls = 0;
+        var consentCalls = 0;
+        var chromium = new Mock<IBrowserType>(MockBehavior.Strict);
+        chromium.SetupGet(browser => browser.ExecutablePath).Returns(executablePath);
+        var runtime = new ManagedChromiumRuntime(
+            _runtimeDirectory,
+            _ =>
+            {
+                installerCalls++;
+                return 0;
+            },
+            _ =>
+            {
+                consentCalls++;
+                return Task.FromResult(true);
+            },
+            new Mock<ILogger>().Object);
+
+        // Act
+        await runtime.EnsureInstalledAsync(chromium.Object, default);
+
+        // Assert
+        Assert.Equal(0, installerCalls);
+        Assert.Equal(0, consentCalls);
+        Assert.Equal(_runtimeDirectory, Environment.GetEnvironmentVariable(ManagedChromiumRuntime.BrowserPathEnvironmentVariable));
+    }
+
+    /// <summary>
+    /// Verifies a clean app profile asks for consent, then invokes Playwright's Chromium installer
+    /// exactly once and accepts the executable it produces, without consulting a system browser.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task EnsureInstalledAsync_MissingManagedExecutable_InstallsChromiumOnceAsync()
+    {
+        // Arrange
+        var executablePath = Path.Combine(_runtimeDirectory, "chromium.exe");
+        IReadOnlyList<string>? installerArguments = null;
+        string? consentPath = null;
+        var chromium = new Mock<IBrowserType>(MockBehavior.Strict);
+        chromium.SetupGet(browser => browser.ExecutablePath).Returns(executablePath);
+        var runtime = new ManagedChromiumRuntime(
+            _runtimeDirectory,
+            arguments =>
+            {
+                installerArguments = arguments;
+                Directory.CreateDirectory(_runtimeDirectory);
+                File.WriteAllText(executablePath, "browser");
+                return 0;
+            },
+            path =>
+            {
+                consentPath = path;
+                return Task.FromResult(true);
+            },
+            new Mock<ILogger>().Object);
+
+        // Act
+        await runtime.EnsureInstalledAsync(chromium.Object, default);
+
+        // Assert
+        Assert.Equal(_runtimeDirectory, consentPath);
+        Assert.Equal(["install", "chromium"], installerArguments);
+        Assert.True(File.Exists(executablePath));
+        Assert.Equal(_runtimeDirectory, Environment.GetEnvironmentVariable(ManagedChromiumRuntime.BrowserPathEnvironmentVariable));
+    }
+
+    /// <summary>
+    /// Verifies declining the install consent dialog cancels provisioning without downloading.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous test.</returns>
+    [Fact]
+    public async Task EnsureInstalledAsync_ConsentDeclined_ThrowsWithoutInstallingAsync()
+    {
+        // Arrange
+        var executablePath = Path.Combine(_runtimeDirectory, "chromium.exe");
+        var installerCalls = 0;
+        var chromium = new Mock<IBrowserType>(MockBehavior.Strict);
+        chromium.SetupGet(browser => browser.ExecutablePath).Returns(executablePath);
+        var runtime = new ManagedChromiumRuntime(
+            _runtimeDirectory,
+            _ =>
+            {
+                installerCalls++;
+                return 0;
+            },
+            _ => Task.FromResult(false),
+            new Mock<ILogger>().Object);
+
+        // Act
+        var ex = await Assert.ThrowsAsync<OperationCanceledException>(
+            () => runtime.EnsureInstalledAsync(chromium.Object, default));
+
+        // Assert
+        Assert.Contains("cancelled", ex.Message, StringComparison.OrdinalIgnoreCase);
+        Assert.Equal(0, installerCalls);
+        Assert.False(File.Exists(executablePath));
+    }
+
+    /// <summary>
+    /// Verifies browser downloads retain ModDB's referer and other safe request headers while
+    /// excluding headers Chromium must own itself.
+    /// </summary>
+    [Fact]
+    public void BuildSafeDownloadHeaders_PreservesRefererAndFiltersUnsafeHeaders()
+    {
+        // Arrange
+        var download = new DownloadConfiguration { UserAgent = "GenHub Test Agent" };
+        download.Headers["Referer"] = "https://www.moddb.com/mods/example";
+        download.Headers["Accept"] = "application/octet-stream";
+        download.Headers["Host"] = "should-not-be-forwarded";
+        download.Headers["Content-Length"] = "123";
+
+        // Act
+        var headers = PlaywrightService.BuildSafeDownloadHeaders(download);
+
+        // Assert
+        Assert.Equal("https://www.moddb.com/mods/example", headers["Referer"]);
+        Assert.Equal("application/octet-stream", headers["Accept"]);
+        Assert.Equal("GenHub Test Agent", headers["User-Agent"]);
+        Assert.DoesNotContain("Host", headers.Keys, StringComparer.OrdinalIgnoreCase);
+        Assert.DoesNotContain("Content-Length", headers.Keys, StringComparer.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// Deletes the temporary runtime directory and restores the process environment.
+    /// </summary>
+    public void Dispose()
+    {
+        Environment.SetEnvironmentVariable(ManagedChromiumRuntime.BrowserPathEnvironmentVariable, _originalBrowserPath);
+        if (Directory.Exists(_runtimeDirectory))
+        {
+            Directory.Delete(_runtimeDirectory, recursive: true);
+        }
+    }
+}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Helpers/HtmlTextHelperTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Helpers/HtmlTextHelperTests.cs
new file mode 100644
index 000000000..574b95262
--- /dev/null
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Helpers/HtmlTextHelperTests.cs
@@ -0,0 +1,147 @@
+using System;
+using GenHub.Core.Helpers;
+using Xunit;
+
+namespace GenHub.Tests.Core.Helpers;
+
+/// <summary>
+/// Unit tests for <see cref="HtmlTextHelper"/>.
+/// </summary>
+public sealed class HtmlTextHelperTests
+{
+    /// <summary>
+    /// Verifies that NormalizeHtml returns an empty string when input is null or whitespace.
+    /// </summary>
+    /// <param name="input">The test input string.</param>
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("   ")]
+    [InlineData("\r\n\t")]
+    public void NormalizeHtml_NullOrWhitespace_ReturnsEmptyString(string? input)
+    {
+        var result = HtmlTextHelper.NormalizeHtml(input);
+        Assert.Equal(string.Empty, result);
+    }
+
+    /// <summary>
+    /// Verifies that NormalizeHtml converts paragraph tags into paragraphs separated by newlines.
+    /// </summary>
+    [Fact]
+    public void NormalizeHtml_ParagraphTags_ConvertsToParagraphsAndStripsTags()
+    {
+        var html = "<p>First paragraph.</p><p>Second paragraph.</p>";
+        var result = HtmlTextHelper.NormalizeHtml(html);
+
+        var expected = $"First paragraph.{Environment.NewLine}{Environment.NewLine}Second paragraph.";
+        Assert.Equal(expected, result);
+    }
+
+    /// <summary>
+    /// Verifies that NormalizeHtml converts break tags to line breaks.
+    /// </summary>
+    [Fact]
+    public void NormalizeHtml_BreakTags_ConvertsToNewlines()
+    {
+        var html = "Line 1<br>Line 2<br/>Line 3<br />Line 4";
+        var result = HtmlTextHelper.NormalizeHtml(html);
+
+        var expected = $"Line 1{Environment.NewLine}Line 2{Environment.NewLine}Line 3{Environment.NewLine}Line 4";
+        Assert.Equal(expected, result);
+    }
+
+    /// <summary>
+    /// Verifies that NormalizeHtml strips inline HTML formatting tags.
+    /// </summary>
+    [Fact]
+    public void NormalizeHtml_InlineTags_StripsTagsCleanly()
+    {
+        var html = "<b>Bold</b> <i>Italic</i> <a href=\"https://example.com\">Link</a> <span class=\"highlight\">Text</span>";
+        var result = HtmlTextHelper.NormalizeHtml(html);
+
+        Assert.Equal("Bold Italic Link Text", result);
+    }
+
+    /// <summary>
+    /// Verifies that NormalizeHtml decodes HTML entities into appropriate characters.
+    /// </summary>
+    [Fact]
+    public void NormalizeHtml_HtmlEntities_DecodesCorrectly()
+    {
+        var html = "&quot;Hello &amp; Welcome&#39;s &lt;World&gt;&quot; &nbsp; &#8211;";
+        var result = HtmlTextHelper.NormalizeHtml(html);
+
+        Assert.Equal("\"Hello & Welcome's <World>\"   –", result);
+    }
+
+    /// <summary>
+    /// Verifies that NormalizeHtml strips paragraph tags from CNC Labs description snippets.
+    /// </summary>
+    [Fact]
+    public void NormalizeHtml_CncLabsDescriptionWithPTags_ResolvesCleanly()
+    {
+        var html = "<p>The Ships and Boats War map is a game map that takes place almost</p>";
+        var result = HtmlTextHelper.NormalizeHtml(html);
+
+        Assert.Equal("The Ships and Boats War map is a game map that takes place almost", result);
+    }
+
+    /// <summary>
+    /// Verifies that NormalizeHtml collapses runs of excess blank lines to a double newline.
+    /// </summary>
+    [Fact]
+    public void NormalizeHtml_ExcessBlankLines_CollapsedToDoubleNewline()
+    {
+        var html = "First paragraph\n\n\n\n\nSecond paragraph";
+        var result = HtmlTextHelper.NormalizeHtml(html);
+
+        var expected = $"First paragraph{Environment.NewLine}{Environment.NewLine}Second paragraph";
+        Assert.Equal(expected, result);
+    }
+
+    /// <summary>
+    /// Verifies that CleanToSingleLine collapses multiple whitespace characters and newlines into a single space.
+    /// </summary>
+    [Fact]
+    public void CleanToSingleLine_WithHtmlAndNewlines_CollapsesWhitespace()
+    {
+        var html = "<p>First line</p>\n\n<p>Second   line\twith   spaces</p>";
+        var result = HtmlTextHelper.CleanToSingleLine(html);
+
+        Assert.Equal("First line Second line with spaces", result);
+    }
+
+    /// <summary>
+    /// Verifies that CleanToSingleLine truncates strings exceeding maximum length and appends an ellipsis.
+    /// </summary>
+    [Fact]
+    public void CleanToSingleLine_WithMaxLength_TruncatesWithEllipsis()
+    {
+        var html = "<p>The Ships and Boats War map is a game map that takes place almost</p>";
+        var result = HtmlTextHelper.CleanToSingleLine(html, 30);
+
+        Assert.Equal(30, result.Length);
+        Assert.EndsWith("...", result, StringComparison.Ordinal);
+        Assert.Equal("The Ships and Boats War map...", result);
+    }
+
+    /// <summary>
+    /// Verifies that TruncateWithEllipsis handles various length inputs and edge cases.
+    /// </summary>
+    /// <param name="input">The test input string.</param>
+    /// <param name="maxLength">The maximum allowed length.</param>
+    /// <param name="expected">The expected truncated output.</param>
+    [Theory]
+    [InlineData(null, 10, "")]
+    [InlineData("", 10, "")]
+    [InlineData("Short text", 20, "Short text")]
+    [InlineData("ExactLengthText", 15, "ExactLengthText")]
+    [InlineData("A very long string exceeding limit", 10, "A very ...")]
+    [InlineData("Abcdef", 3, "Abc")]
+    [InlineData("Abcdef", 2, "Ab")]
+    public void TruncateWithEllipsis_VariousInputs_BehavesCorrectly(string? input, int maxLength, string expected)
+    {
+        var result = HtmlTextHelper.TruncateWithEllipsis(input, maxLength);
+        Assert.Equal(expected, result);
+    }
+}
diff --git a/GenHub/GenHub/Features/Content/Services/Parsers/ModDBPageParser.cs b/GenHub/GenHub/Features/Content/Services/Parsers/ModDBPageParser.cs
new file mode 100644
index 000000000..b435fbd30
--- /dev/null
+++ b/GenHub/GenHub/Features/Content/Services/Parsers/ModDBPageParser.cs
@@ -0,0 +1,3253 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using AngleSharp;
+using AngleSharp.Dom;
+using GenHub.Core.Constants;
+using GenHub.Core.Interfaces.Parsers;
+using GenHub.Core.Interfaces.Tools;
+using GenHub.Core.Models.Parsers;
+using Microsoft.Extensions.Logging;
+using IDocument = AngleSharp.Dom.IDocument;
+
+namespace GenHub.Features.Content.Services.Parsers;
+
+/// <summary>
+/// Parser for ModDB pages that extracts rich content including files, videos, images, articles, reviews, and comments.
+/// </summary>
+public partial class ModDBPageParser(IPlaywrightService playwrightService, ILogger<ModDBPageParser> logger) : IWebPageParser
+{
+    [GeneratedRegex(ModDBParserConstants.ParentModPathRegex, RegexOptions.IgnoreCase, "en-US")]
+    private static partial Regex MyRegex();
+
+    [GeneratedRegex(@"/(?:crop|thumb)_[^/]+/", RegexOptions.IgnoreCase, "en-US")]
+    private static partial Regex ModDBImageCropRegex();
+
+    [GeneratedRegex(@"(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", RegexOptions.None, "en-US")]
+    private static partial Regex CamelCaseSplitRegex();
+
+    [GeneratedRegex(@"(?:\b|\()(\d+(?:[.,]\d+)?\s*(?:GB|MB|KB|B|bytes|byte|gigabytes|megabytes|kilobytes)(?:\s*\([^)]+\))?)", RegexOptions.IgnoreCase, "en-US")]
+    private static partial Regex FileSizeRegex();
+
+    [GeneratedRegex(@"(?:\(|\b)(\d[\d,\s]*)\s*bytes", RegexOptions.IgnoreCase, "en-US")]
+    private static partial Regex ExactBytesRegex();
+
+    [GeneratedRegex(@"(\d+(?:[.,]\d+)?)\s*([a-zA-Z]+)", RegexOptions.IgnoreCase, "en-US")]
+    private static partial Regex NumericSizeWithUnitRegex();
+
+    [GeneratedRegex(@"(?:(?:v|embed|shorts|vi)/|(?:\?|&)v=|youtu\.be/)([a-zA-Z0-9_-]{11})", RegexOptions.IgnoreCase, "en-US")]
+    private static partial Regex YouTubeVideoIdRegex();
+
+    [GeneratedRegex(@"vimeo\.com/(?:video/)?(\d+)", RegexOptions.IgnoreCase, "en-US")]
+    private static partial Regex VimeoVideoIdRegex();
+
+    [GeneratedRegex(@"^(?<title>.+?)\s+(?:file|addon|patch|demo|mod)\s+-", RegexOptions.IgnoreCase, "en-US")]
+    private static partial Regex ModDBPageTitleRegex();
+
+    /// <summary>
+    /// Extracts parent mod URL from a FileDetail page URL.
+    /// Example: /mods/mod-name/downloads/file-name -> /mods/mod-name.
+    /// </summary>
+    private static string? ExtractParentModUrl(string url)
+    {
+        // Remove query string and fragment
+        var cleanUrl = url.Split('?')[0].Split('#')[0];
+
+        // Match pattern: /mods/mod-name/downloads/file-name or /mods/mod-name/addons/file-name
+        var match = MyRegex().Match(cleanUrl);
+
+        if (match.Success)
+        {
+            var parentPath = match.Groups[1].Value;
+
+            // Ensure it's a full URL
+            if (!parentPath.StartsWith("http", StringComparison.OrdinalIgnoreCase))
+            {
+                return ModDBConstants.BaseUrl.TrimEnd('/') + parentPath;
+            }
+
+            return parentPath;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Merges primary and fallback global contexts, taking fallback values when primary is missing.
+    /// </summary>
+    private static GlobalContext MergeContext(GlobalContext primary, GlobalContext fallback)
+    {
+        return new GlobalContext(
+            Title: string.IsNullOrWhiteSpace(primary.Title) || primary.Title == "Unknown" ? fallback.Title : primary.Title,
+            Developer: string.IsNullOrWhiteSpace(primary.Developer) ? fallback.Developer : primary.Developer,
+            ReleaseDate: primary.ReleaseDate ?? fallback.ReleaseDate,
+            GameName: string.IsNullOrWhiteSpace(primary.GameName) ? fallback.GameName : primary.GameName,
+            IconUrl: string.IsNullOrWhiteSpace(primary.IconUrl) ? fallback.IconUrl : primary.IconUrl,
+            Description: string.IsNullOrWhiteSpace(primary.Description) ? fallback.Description : primary.Description);
+    }
+
+    /// <summary>
+    /// Detects the page type based on URL patterns and DOM structure.
+    /// </summary>
+    private static PageType DetectPageType(string url, IDocument document)
+    {
+        // Check for file detail page
+        if (document.QuerySelector(ModDBParserConstants.DownloadsInfoSelector) != null)
+        {
+            return PageType.FileDetail;
+        }
+
+        // Addons listings are row tables. A mod's /images tab is a gallery (#imagebox), not a list.
+        if (url.Contains("/addons", StringComparison.OrdinalIgnoreCase))
+        {
+            return PageType.List;
+        }
+
+        if (url.Contains("/images", StringComparison.OrdinalIgnoreCase) &&
+            document.QuerySelector(ModDBParserConstants.ImageGallerySelector) == null)
+        {
+            return PageType.List;
+        }
+
+        // Check for summary/news pages
+        if (document.QuerySelector(ModDBParserConstants.ArticlesBrowseSelector) != null)
+        {
+            return PageType.Summary;
+        }
+
+        // Default to detail page
+        return PageType.Detail;
+    }
+
+    /// <summary>
+    /// Extracts content sections from summary/news pages.
+    /// </summary>
+    private static List<ContentSection> ExtractSummarySections(IDocument document)
+    {
+        var sections = new List<ContentSection>();
+
+        // Extract articles
+        sections.AddRange(ExtractArticles(document));
+
+        return sections;
+    }
+
+    /// <summary>
+    /// Extracts a file from a row element.
+    /// </summary>
+    /// <param name="row">The row element containing file information.</param>
+    /// <param name="sectionType">The type of file section (Release or Addon).</param>
+    private static DownloadableFile? ExtractFileFromRow(IElement row, FileSectionType sectionType = FileSectionType.Downloads)
+    {
+        var nameEl = row.QuerySelector(ModDBParserConstants.FileNameSelector);
+        var name = nameEl?.TextContent?.Trim();
+        if (string.IsNullOrEmpty(name))
+        {
+            return null;
+        }
+
+        var (sizeBytes, sizeText) = ExtractRowFileSize(row);
+        var (uploadDate, releaseDate) = ExtractRowDates(row);
+        var category = ExtractRowCategory(row);
+        var uploader = ExtractRowUploader(row);
+        var (downloadUrl, detailsUrl) = ExtractRowUrls(row, nameEl);
+        var thumbnailUrl = ExtractRowThumbnail(row);
+        var summary = ExtractRowSummary(row);
+        var commentCount = ExtractRowCommentCount(row);
+
+        return new DownloadableFile(
+            Name: name,
+            SizeBytes: sizeBytes,
+            SizeDisplay: sizeText,
+            UploadDate: uploadDate,
+            Category: category,
+            Uploader: uploader,
+            DownloadUrl: downloadUrl,
+            CommentCount: commentCount,
+            ThumbnailUrl: thumbnailUrl,
+            FileSectionType: sectionType,
+            ReleaseDate: releaseDate,
+            DetailsUrl: detailsUrl,
+            Description: summary);
+    }
+
+    private static (long? SizeBytes, string? SizeText) ExtractRowFileSize(IElement row)
+    {
+        var sizeEl = row.QuerySelector(ModDBParserConstants.FileSizeSelector);
+        var sizeText = sizeEl?.TextContent?.Trim();
+        long? sizeBytes = null;
+        if (!string.IsNullOrEmpty(sizeText))
+        {
+            sizeBytes = ParseFileSize(sizeText);
+        }
+
+        if (sizeBytes == null || string.IsNullOrEmpty(sizeText))
+        {
+            var subHeadingEl = row.QuerySelector(ModDBParserConstants.FileSubheadingSelector);
+            var textToSearch = subHeadingEl?.TextContent ?? row.TextContent;
+            if (!string.IsNullOrWhiteSpace(textToSearch))
+            {
+                var sizeMatch = FileSizeRegex().Match(textToSearch);
+                if (sizeMatch.Success)
+                {
+                    sizeText = sizeMatch.Groups[1].Value.Trim();
+                    sizeBytes = ParseFileSize(sizeText);
+                }
+            }
+        }
+
+        return (sizeBytes, sizeText);
+    }
+
+    private static (DateTime? UploadDate, DateTime? ReleaseDate) ExtractRowDates(IElement row)
+    {
+        var dateEl = row.QuerySelector(ModDBParserConstants.FileDateSelector);
+        DateTime? uploadDate = null;
+        DateTime? releaseDate = null;
+        if (dateEl != null)
+        {
+            var dateStr = dateEl.GetAttribute("datetime") ?? dateEl.GetAttribute("title") ?? dateEl.TextContent?.Trim();
+            if (!string.IsNullOrEmpty(dateStr))
+            {
+                if (DateTime.TryParse(dateStr, out var standardDate))
+                {
+                    uploadDate = standardDate;
+                    releaseDate = standardDate;
+                }
+                else
+                {
+                    var modDBDate = ParseModDBDate(dateStr);
+                    if (modDBDate.HasValue)
+                    {
+                        uploadDate = modDBDate;
+                        releaseDate = modDBDate;
+                    }
+                }
+            }
+        }
+
+        return (uploadDate, releaseDate);
+    }
+
+    private static string? ExtractRowCategory(IElement row)
+    {
+        var category = row.QuerySelector(ModDBParserConstants.FileCategorySelector)?.TextContent?.Trim();
+        if (string.IsNullOrEmpty(category))
+        {
+            var subHeadingEl = row.QuerySelector(ModDBParserConstants.FileSubheadingSelector);
+            var subHeadingText = subHeadingEl?.TextContent?.Trim();
+            if (!string.IsNullOrEmpty(subHeadingText))
+            {
+                var categoryKeywords = new[] { "Full Version", "Patch", "Demo", "Tool", "Addon", "Map", "Skin" };
+                foreach (var keyword in categoryKeywords)
+                {
+                    if (subHeadingText.Contains(keyword, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return keyword;
+                    }
+                }
+            }
+        }
+
+        return category;
+    }
+
+    private static string? ExtractRowUploader(IElement row)
+    {
+        var uploaderEl = row.QuerySelector(ModDBParserConstants.FileUploaderSelector);
+        var uploader = uploaderEl?.TextContent?.Trim();
+        return IsJunkDeveloperName(uploader) ? null : uploader;
+    }
+
+    private static (string? DownloadUrl, string? DetailsUrl) ExtractRowUrls(IElement row, IElement? nameEl)
+    {
+        string? downloadUrl = null;
+        string? detailsUrl = null;
+
+        var titleLinkEl = row.QuerySelector("h4 a, h5 a, h3 a, .heading a, .title a, a.title, .name a, a[href*='/downloads/'], a[href*='/addons/']")
+            ?? (string.Equals(nameEl?.TagName, "A", StringComparison.OrdinalIgnoreCase) ? nameEl : nameEl?.QuerySelector("a"));
+        var titleHref = titleLinkEl?.GetAttribute("href");
+        if (!string.IsNullOrEmpty(titleHref))
+        {
+            titleHref = ToAbsoluteUrl(titleHref);
+            if (!IsDirectDownloadUrl(titleHref))
+            {
+                detailsUrl = titleHref;
+            }
+            else
+            {
+                downloadUrl = titleHref;
+            }
+        }
+
+        var linkEl = row.QuerySelector(ModDBParserConstants.FileDownloadSelector);
+        var buttonHref = linkEl?.GetAttribute("href");
+        if (!string.IsNullOrEmpty(buttonHref))
+        {
+            if (!buttonHref.StartsWith("http", StringComparison.OrdinalIgnoreCase))
+            {
+                buttonHref = ModDBConstants.BaseUrl.TrimEnd('/') + "/" + buttonHref.TrimStart('/');
+            }
+
+            if (IsDirectDownloadUrl(buttonHref))
+            {
+                downloadUrl = buttonHref;
+            }
+            else if (string.IsNullOrEmpty(detailsUrl))
+            {
+                detailsUrl = buttonHref;
+            }
+        }
+
+        downloadUrl ??= detailsUrl;
+        return (downloadUrl, detailsUrl);
+    }
+
+    private static string? ExtractRowThumbnail(IElement row)
+    {
+        var imgEl = row.QuerySelector("img");
+        var thumbnailUrl = imgEl?.GetAttribute("src") ?? imgEl?.GetAttribute("data-src");
+        if (!string.IsNullOrEmpty(thumbnailUrl))
+        {
+            return (thumbnailUrl.Contains("blank.gif", StringComparison.OrdinalIgnoreCase) ||
+                    thumbnailUrl.Contains("clear.gif", StringComparison.OrdinalIgnoreCase))
+                ? null
+                : ToAbsoluteUrl(thumbnailUrl);
+        }
+
+        return null;
+    }
+
+    private static string? ExtractRowSummary(IElement row)
+    {
+        var summaryEl = row.QuerySelector("p.summary, .summary, p, div.summary");
+        var summary = summaryEl?.TextContent?.Trim();
+        return IsBreadcrumbOrLocationText(summary) ? null : summary;
+    }
+
+    private static int? ExtractRowCommentCount(IElement row)
+    {
+        var commentCountEl = row.QuerySelector(ModDBParserConstants.FileCommentCountSelector);
+        if (commentCountEl != null)
+        {
+            var countText = commentCountEl.TextContent?.Trim();
+            if (!string.IsNullOrEmpty(countText) && int.TryParse(countText, out var count))
+            {
+                return count;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Extracts metadata from the sidebar profile section.
+    /// </summary>
+    private static ProfileMeta ExtractProfileMeta(IDocument document)
+    {
+        var sidebar = document.QuerySelector(ModDBParserConstants.ProfileSidebarSelector);
+        if (sidebar == null)
+        {
+            return new ProfileMeta(null, null, null, null, null, null);
+        }
+
+        string? name = null; // Often the page title, but sometimes in sidebar
+        long? sizeBytes = null;
+        string? sizeDisplay = null;
+        DateTime? releaseDate = null;
+        string? developer = null;
+        string? md5Hash = null;
+
+        var rows = sidebar.QuerySelectorAll(ModDBParserConstants.ProfileRowSelector);
+        foreach (var row in rows)
+        {
+            var labelEl = row.QuerySelector(ModDBParserConstants.ProfileLabelSelector);
+            var contentEl = row.QuerySelector(ModDBParserConstants.ProfileContentSelector);
+
+            if (labelEl == null || contentEl == null)
+            {
+                continue;
+            }
+
+            var label = labelEl.TextContent?.Trim().ToLowerInvariant().Replace(":", string.Empty);
+            var content = contentEl.TextContent?.Trim();
+
+            if (string.IsNullOrEmpty(label) || string.IsNullOrEmpty(content))
+            {
+                continue;
+            }
+
+            switch (label)
+            {
+                case "filename":
+                case "file":
+                    name = content;
+                    break;
+                case "size":
+                    sizeDisplay = content;
+
+                    // Sometimes format is "134mb (140,505,749 bytes)"
+                    // Try to parse the bytes part first if available
+                    if (content.Contains("bytes") && content.Contains('(') && content.Contains(')'))
+                    {
+                         var bytesPart = content.Split('(').Last().Replace("bytes)", string.Empty).Replace(",", string.Empty).Trim();
+                         if (long.TryParse(bytesPart, out var bytesVal))
+                         {
+                             sizeBytes = bytesVal;
+                         }
+                    }
+
+                    sizeBytes ??= ParseFileSize(content);
+
+                    break;
+                case "uploader":
+                case "author":
+                    developer = content;
+                    break;
+                case "added":
+                case "date":
+                case "release date":
+                    if (DateTime.TryParse(content, out var dt))
+                    {
+                         releaseDate = dt;
+                    }
+
+                    break;
+                case "md5 hash":
+                case "md5":
+                    md5Hash = content;
+                    break;
+                default:
+                    // Ignore other metadata labels
+                    break;
+            }
+        }
+
+        return new ProfileMeta(name, sizeBytes, sizeDisplay, releaseDate, developer, md5Hash);
+    }
+
+    /// <summary>
+    /// Extracts videos from the document, including embedded iframes, HTML5 video elements,
+    /// and video gallery cards (e.g., from the /videos tab or media widgets).
+    /// </summary>
+    private static List<Video> ExtractVideos(IDocument document)
+    {
+        var videos = new List<Video>();
+        videos.AddRange(ExtractIFrameVideos(document));
+        videos.AddRange(ExtractHtml5Videos(document));
+        videos.AddRange(ExtractGalleryCardVideos(document));
+        return DeduplicateVideoList(videos);
+    }
+
+    private static List<Video> ExtractIFrameVideos(IDocument document)
+    {
+        var videos = new List<Video>();
+        var videoElements = document.QuerySelectorAll(ModDBParserConstants.VideoSelector);
+        foreach (var videoEl in videoElements)
+        {
+            var src = videoEl.GetAttribute("src")
+                ?? videoEl.GetAttribute("data-src")
+                ?? videoEl.GetAttribute("data-video");
+
+            if (string.IsNullOrWhiteSpace(src))
+            {
+                continue;
+            }
+
+            if (src.StartsWith("//", StringComparison.Ordinal))
+            {
+                src = "https:" + src;
+            }
+
+            if (IsNonVideoIframe(src))
+            {
+                continue;
+            }
+
+            var title = ResolveIFrameVideoTitle(videoEl);
+            if (!IsUsableVideoTitle(title))
+            {
+                continue;
+            }
+
+            var (platform, thumbnailUrl, embedUrl) = ResolveVideoPlatformDetails(src, videoEl);
+
+            if (!embedUrl.StartsWith("http", StringComparison.OrdinalIgnoreCase))
+            {
+                embedUrl = ToAbsoluteUrl(embedUrl);
+            }
+
+            videos.Add(new Video(
+                Title: title,
+                ThumbnailUrl: thumbnailUrl,
+                EmbedUrl: embedUrl,
+                Platform: platform));
+        }
+
+        return videos;
+    }
+
+    private static (string Platform, string? ThumbnailUrl, string EmbedUrl) ResolveVideoPlatformDetails(string src, IElement videoEl)
+    {
+        string? thumbnailUrl = null;
+        var platform = "Unknown";
+        var embedUrl = src;
+
+        var ytMatch = YouTubeVideoIdRegex().Match(src);
+        if (ytMatch.Success)
+        {
+            var videoId = ytMatch.Groups[1].Value;
+            platform = "YouTube";
+            thumbnailUrl = $"https://img.youtube.com/vi/{videoId}/hqdefault.jpg";
+            embedUrl = $"https://www.youtube.com/embed/{videoId}";
+        }
+        else
+        {
+            var vimeoMatch = VimeoVideoIdRegex().Match(src);
+            if (vimeoMatch.Success)
+            {
+                var videoId = vimeoMatch.Groups[1].Value;
+                platform = "Vimeo";
+                embedUrl = $"https://player.vimeo.com/video/{videoId}";
+            }
+            else if (src.Contains("dailymotion", StringComparison.OrdinalIgnoreCase))
+            {
+                platform = "Dailymotion";
+            }
+            else if (src.Contains("moddb.com", StringComparison.OrdinalIgnoreCase))
+            {
+                platform = "ModDB";
+            }
+        }
+
+        if (string.IsNullOrWhiteSpace(thumbnailUrl))
+        {
+            var container = videoEl.Closest(".video, .media, .mediabox, .holder, .row, .embed, figure, .video-container");
+            var thumbEl = container?.QuerySelector(ModDBParserConstants.VideoThumbnailSelector);
+            var rawThumb = thumbEl?.GetAttribute("src") ?? thumbEl?.GetAttribute("data-src");
+            if (!string.IsNullOrWhiteSpace(rawThumb))
+            {
+                thumbnailUrl = ToAbsoluteUrl(rawThumb);
+            }
+        }
+
+        return (platform, thumbnailUrl, embedUrl);
+    }
+
+    private static List<Video> ExtractHtml5Videos(IDocument document)
+    {
+        var videos = new List<Video>();
+        var html5VideoElements = document.QuerySelectorAll("video");
+        foreach (var videoEl in html5VideoElements)
+        {
+            var src = videoEl.GetAttribute("src")
+                ?? videoEl.QuerySelector("source")?.GetAttribute("src");
+
+            if (string.IsNullOrWhiteSpace(src))
+            {
+                continue;
+            }
+
+            var poster = videoEl.GetAttribute("poster");
+            var thumbnailUrl = !string.IsNullOrWhiteSpace(poster) ? ToAbsoluteUrl(poster) : null;
+            var title = ResolveIFrameVideoTitle(videoEl);
+            if (!IsUsableVideoTitle(title))
+            {
+                continue;
+            }
+
+            videos.Add(new Video(
+                Title: title,
+                ThumbnailUrl: thumbnailUrl,
+                EmbedUrl: ToAbsoluteUrl(src),
+                Platform: "ModDB"));
+        }
+
+        return videos;
+    }
+
+    private static List<Video> ExtractGalleryCardVideos(IDocument document)
+    {
+        var videos = new List<Video>();
+        var videoLinks = document.QuerySelectorAll(ModDBParserConstants.VideoLinkSelector);
+        foreach (var linkEl in videoLinks)
+        {
+            var href = linkEl.GetAttribute("href");
+            if (string.IsNullOrWhiteSpace(href))
+            {
+                continue;
+            }
+
+            if (IsNavigationOrPaginationLink(href, linkEl))
+            {
+                continue;
+            }
+
+            if (IsInRecommendationsOrAds(linkEl))
+            {
+                continue;
+            }
+
+            var absoluteHref = ToAbsoluteUrl(href);
+            var (video, isVideo) = ExtractVideoFromGalleryLink(linkEl, absoluteHref);
+            if (isVideo && video != null)
+            {
+                videos.Add(video);
+            }
+        }
+
+        return videos;
+    }
+
+    private static bool IsNonVideoIframe(string src)
+    {
+        if (string.IsNullOrWhiteSpace(src))
+        {
+            return true;
+        }
+
+        if (src.Contains("/widget", StringComparison.OrdinalIgnoreCase) ||
+            src.Contains("/widgets/", StringComparison.OrdinalIgnoreCase) ||
+            src.Contains("doubleclick", StringComparison.OrdinalIgnoreCase) ||
+            src.Contains("googlesyndication", StringComparison.OrdinalIgnoreCase) ||
+            src.Contains("adnxs", StringComparison.OrdinalIgnoreCase) ||
+            src.Contains("amazon-adsystem", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        if (src.Contains("moddb.com", StringComparison.OrdinalIgnoreCase) &&
+            !src.Contains("/media/iframe/", StringComparison.OrdinalIgnoreCase) &&
+            !src.Contains("/media/embed/", StringComparison.OrdinalIgnoreCase) &&
+            !src.Contains("/videos/iframe/", StringComparison.OrdinalIgnoreCase) &&
+            !src.Contains("/videos/embed/", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    private static bool IsInRecommendationsOrAds(IElement el)
+    {
+        return el.Closest(ModDBParserConstants.RecommendationsSelector) != null ||
+               el.Closest("aside, #sidecolumn, .sidecolumn") != null;
+    }
+
+    private static string ResolveIFrameVideoTitle(IElement element)
+    {
+        var title = element.GetAttribute("title");
+        if (IsUsableVideoTitle(title))
+        {
+            return FormatVideoTitle(title!);
+        }
+
+        var ariaLabel = element.GetAttribute("aria-label");
+        if (IsUsableVideoTitle(ariaLabel))
+        {
+            return FormatVideoTitle(ariaLabel!);
+        }
+
+        var container = element.Closest(".video, .media, .mediabox, .holder, .row, .embed, figure, .video-container, [class*='video'], [class*='media']");
+        var containerTitleEl = container?.QuerySelector(".title, .caption, figcaption, h1, h2, h3, h4, h5, strong");
+        var containerTitle = containerTitleEl?.TextContent?.Trim();
+        if (IsUsableVideoTitle(containerTitle))
+        {
+            return FormatVideoTitle(containerTitle!);
+        }
+
+        var prev = element.PreviousElementSibling;
+        if (prev != null && (prev.TagName.StartsWith('H') || prev.ClassList.Contains("title") || prev.ClassList.Contains("caption")))
+        {
+            var prevTitle = prev.TextContent?.Trim();
+            if (IsUsableVideoTitle(prevTitle))
+            {
+                return FormatVideoTitle(prevTitle!);
+            }
+        }
+
+        var next = element.NextElementSibling;
+        if (next != null && (next.ClassList.Contains("title") || next.ClassList.Contains("caption") || next.TagName.Equals("FIGCAPTION", StringComparison.OrdinalIgnoreCase)))
+        {
+            var nextTitle = next.TextContent?.Trim();
+            if (IsUsableVideoTitle(nextTitle))
+            {
+                return FormatVideoTitle(nextTitle!);
+            }
+        }
+
+        return "Video";
+    }
+
+    private static bool IsUsableVideoTitle(string? title)
+    {
+        if (string.IsNullOrWhiteSpace(title))
+        {
+            return false;
+        }
+
+        var clean = title.Trim();
+        return !clean.Equals("Video", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("YouTube video player", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("YouTube player", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("Play", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("View media", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("Image", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("Next Media", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("Previous Media", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("Next", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("Previous", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("Prev", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("RSS", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("RSS Feed", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("Feed", StringComparison.OrdinalIgnoreCase) &&
+               !clean.Equals("Subscribe", StringComparison.OrdinalIgnoreCase) &&
+               !clean.StartsWith("You may also like", StringComparison.OrdinalIgnoreCase) &&
+               !clean.StartsWith("Recommended", StringComparison.OrdinalIgnoreCase) &&
+               !clean.StartsWith("Related", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string FormatVideoTitle(string title)
+    {
+        if (string.IsNullOrWhiteSpace(title))
+        {
+            return "Video";
+        }
+
+        var formatted = title.Trim('*', ' ', '\t', '\r', '\n').Replace('_', ' ').Replace('-', ' ');
+
+        if (!formatted.Contains(' '))
+        {
+            formatted = CamelCaseSplitRegex().Replace(formatted, " ");
+        }
+
+        formatted = Regex.Replace(formatted, @"\s+", " ").Trim();
+
+        return string.IsNullOrWhiteSpace(formatted) ? "Video" : formatted;
+    }
+
+    private static (Video? Video, bool IsVideo) ExtractVideoFromGalleryLink(IElement linkEl, string absoluteHref)
+    {
+        if (absoluteHref.Contains("/widget", StringComparison.OrdinalIgnoreCase) ||
+            absoluteHref.Contains("/downloads/", StringComparison.OrdinalIgnoreCase) ||
+            absoluteHref.Contains("/addons/", StringComparison.OrdinalIgnoreCase))
+        {
+            return (null, false);
+        }
+
+        if (IsNavigationOrPaginationLink(absoluteHref, linkEl))
+        {
+            return (null, false);
+        }
+
+        var container = linkEl.Closest(".holder, .mediabox, .mediarow, .row, .rowcontent, .media, .videobox") ?? linkEl;
+
+        var img = linkEl.QuerySelector("img")
+            ?? container.QuerySelector("img");
+
+        var rawThumb = img?.GetAttribute("src") ?? img?.GetAttribute("data-src");
+        string? thumbnailUrl = null;
+        if (!string.IsNullOrWhiteSpace(rawThumb))
+        {
+            thumbnailUrl = ToAbsoluteUrl(rawThumb);
+        }
+
+        var platform = "ModDB";
+        var embedUrl = absoluteHref;
+
+        var ytMatch = YouTubeVideoIdRegex().Match(absoluteHref);
+        if (!ytMatch.Success && thumbnailUrl != null)
+        {
+            ytMatch = YouTubeVideoIdRegex().Match(thumbnailUrl);
+        }
+
+        if (ytMatch.Success)
+        {
+            var videoId = ytMatch.Groups[1].Value;
+            platform = "YouTube";
+            thumbnailUrl = $"https://img.youtube.com/vi/{videoId}/hqdefault.jpg";
+            embedUrl = $"https://www.youtube.com/embed/{videoId}";
+        }
+        else
+        {
+            var vimeoMatch = VimeoVideoIdRegex().Match(absoluteHref);
+            if (vimeoMatch.Success)
+            {
+                var videoId = vimeoMatch.Groups[1].Value;
+                platform = "Vimeo";
+                embedUrl = $"https://player.vimeo.com/video/{videoId}";
+            }
+        }
+
+        var title = ResolveGalleryVideoTitle(linkEl, container, img, absoluteHref);
+        if (!IsUsableVideoTitle(title))
+        {
+            return (null, false);
+        }
+
+        if (string.IsNullOrWhiteSpace(thumbnailUrl) && platform == "ModDB")
+        {
+            return (null, false);
+        }
+
+        return (new Video(
+            Title: title,
+            ThumbnailUrl: thumbnailUrl,
+            EmbedUrl: embedUrl,
+            Platform: platform), true);
+    }
+
+    private static string ResolveGalleryVideoTitle(IElement linkEl, IElement container, IElement? img, string absoluteHref)
+    {
+        var linkTitle = linkEl.GetAttribute("title");
+        if (IsUsableVideoTitle(linkTitle))
+        {
+            return FormatVideoTitle(linkTitle!);
+        }
+
+        var imgAlt = img?.GetAttribute("alt") ?? img?.GetAttribute("title");
+        if (IsUsableVideoTitle(imgAlt))
+        {
+            return FormatVideoTitle(imgAlt!);
+        }
+
+        var containerTitleEl = container.QuerySelector(".title a, .title, h4 a, h4, h3 a, h3, h5, .caption");
+        var containerTitle = containerTitleEl?.TextContent?.Trim();
+        if (IsUsableVideoTitle(containerTitle))
+        {
+            return FormatVideoTitle(containerTitle!);
+        }
+
+        var slug = GalleryImageKey(absoluteHref);
+        var dot = slug.LastIndexOf('.');
+        if (dot > 0)
+        {
+            slug = slug[..dot];
+        }
+
+        if (IsUsableVideoTitle(slug))
+        {
+            return FormatVideoTitle(slug);
+        }
+
+        return "Video";
+    }
+
+    private static bool IsNavigationOrPaginationLink(string href, IElement linkEl)
+    {
+        if (string.IsNullOrWhiteSpace(href))
+        {
+            return true;
+        }
+
+        var cleanHref = href.Split('?')[0].Split('#')[0].TrimEnd('/');
+        if (cleanHref.EndsWith("/videos", StringComparison.OrdinalIgnoreCase) ||
+            cleanHref.EndsWith("/media", StringComparison.OrdinalIgnoreCase) ||
+            cleanHref.EndsWith("/images", StringComparison.OrdinalIgnoreCase) ||
+            cleanHref.EndsWith("/downloads", StringComparison.OrdinalIgnoreCase) ||
+            cleanHref.EndsWith("/addons", StringComparison.OrdinalIgnoreCase) ||
+            cleanHref.EndsWith("/reviews", StringComparison.OrdinalIgnoreCase) ||
+            cleanHref.EndsWith("/articles", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        if (cleanHref.Contains("/page/", StringComparison.OrdinalIgnoreCase) ||
+            cleanHref.Contains("/rss", StringComparison.OrdinalIgnoreCase) ||
+            cleanHref.Contains("/feed", StringComparison.OrdinalIgnoreCase) ||
+            cleanHref.EndsWith(".xml", StringComparison.OrdinalIgnoreCase) ||
+            href.Contains("?page=", StringComparison.OrdinalIgnoreCase) ||
+            href.Contains("&page=", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        var text = linkEl.TextContent?.Trim();
+        if (!string.IsNullOrEmpty(text) &&
+            (text.Equals("Next Media", StringComparison.OrdinalIgnoreCase) ||
+             text.Equals("Previous Media", StringComparison.OrdinalIgnoreCase) ||
+             text.Equals("Next", StringComparison.OrdinalIgnoreCase) ||
+             text.Equals("Previous", StringComparison.OrdinalIgnoreCase) ||
+             text.Equals("Prev", StringComparison.OrdinalIgnoreCase) ||
+             text.Equals("RSS", StringComparison.OrdinalIgnoreCase) ||
+             text.Equals("RSS Feed", StringComparison.OrdinalIgnoreCase) ||
+             text.Equals("Feed", StringComparison.OrdinalIgnoreCase) ||
+             text.Equals("Subscribe", StringComparison.OrdinalIgnoreCase)))
+        {
+            return true;
+        }
+
+        var inNav = linkEl.Closest("nav, .tabs, .navigation, .pagination, .pages, .heading, #nav, .feed, .rss, .subheading, .actions") != null;
+        return inNav;
+    }
+
+    /// <summary>
+    /// Extracts gallery images from the document. Game icons, member avatars, file-page chrome,
+    /// and social-share glyphs are excluded — those previously flooded the Media tab.
+    /// </summary>
+    private static List<Image> ExtractImages(IDocument document)
+    {
+        var images = new List<Image>();
+        var seenKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        var elements = document.QuerySelectorAll(ModDBParserConstants.GalleryImageSelector);
+        foreach (var img in elements)
+        {
+            var src = img.GetAttribute("src") ?? img.GetAttribute("data-src");
+            if (!IsUsableModGalleryImage(src, img))
+            {
+                continue;
+            }
+
+            var thumbnailUrl = ToAbsoluteUrl(src!);
+            var key = GalleryImageKey(thumbnailUrl);
+            if (!seenKeys.Add(key))
+            {
+                continue;
+            }
+
+            var parentAnchor = img.Closest("a");
+            var anchorHref = parentAnchor?.GetAttribute("href");
+            var fullSizeUrl = GetFullSizeModDBImageSource(thumbnailUrl);
+
+            if (!string.IsNullOrWhiteSpace(anchorHref))
+            {
+                var absoluteHref = ToAbsoluteUrl(anchorHref);
+                if (absoluteHref.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) ||
+                    absoluteHref.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ||
+                    absoluteHref.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase) ||
+                    absoluteHref.EndsWith(".webp", StringComparison.OrdinalIgnoreCase))
+                {
+                    fullSizeUrl = absoluteHref;
+                }
+            }
+
+            var title = ResolveGalleryImageTitle(img, thumbnailUrl, anchorHref);
+
+            images.Add(new Image(
+                Title: title,
+                ThumbnailUrl: fullSizeUrl,
+                FullSizeUrl: fullSizeUrl,
+                Description: title));
+        }
+
+        return images;
+    }
+
+    private static bool IsUsableModGalleryImage(string? src, IElement img)
+    {
+        if (IsDisallowedImageSrc(src))
+        {
+            return false;
+        }
+
+        var alt = img.GetAttribute("alt") ?? string.Empty;
+        if (IsDisallowedAltText(alt))
+        {
+            return false;
+        }
+
+        var inSidebar = img.Closest(ModDBParserConstants.ImageSidebarSelector) != null;
+        var inGallery = img.Closest(ModDBParserConstants.ImageGallerySelector) != null;
+        if (inSidebar && !inGallery)
+        {
+            return false;
+        }
+
+        var href = img.Closest("a")?.GetAttribute("href") ?? string.Empty;
+        if (IsDisallowedVideoLink(href))
+        {
+            return false;
+        }
+
+        var isModImagePage = href.Contains("/mods/", StringComparison.OrdinalIgnoreCase) &&
+                             (href.Contains("/images/", StringComparison.OrdinalIgnoreCase) ||
+                              href.Contains("/downloads/", StringComparison.OrdinalIgnoreCase) ||
+                              href.Contains("/addons/", StringComparison.OrdinalIgnoreCase));
+        var isModMediaFile = src != null && (src.Contains("/images/mods/", StringComparison.OrdinalIgnoreCase) ||
+                             src.Contains("/cache/images/mods/", StringComparison.OrdinalIgnoreCase) ||
+                             src.Contains("/images/downloads/", StringComparison.OrdinalIgnoreCase) ||
+                             src.Contains("/cache/images/downloads/", StringComparison.OrdinalIgnoreCase));
+
+        return inGallery || isModImagePage || isModMediaFile;
+    }
+
+    private static bool IsDisallowedImageSrc(string? src)
+    {
+        if (string.IsNullOrWhiteSpace(src))
+        {
+            return true;
+        }
+
+        var disallowedTokens = new[]
+        {
+            "data:", "clear.gif", "blank.gif", "/avatar/", "/button",
+            "/guest/", "/default/error", "error_50x50", "/images/games/",
+            "/images/groups/", "/images/members/", "/cache/images/games/",
+            "/cache/images/groups/", "/cache/images/members/", "icon.gif",
+        };
+
+        foreach (var token in disallowedTokens)
+        {
+            if (src.Contains(token, StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static bool IsDisallowedAltText(string alt)
+    {
+        return alt.Contains("Share on", StringComparison.OrdinalIgnoreCase) ||
+               alt.Equals("Post", StringComparison.OrdinalIgnoreCase) ||
+               alt.Contains("Email a friend", StringComparison.OrdinalIgnoreCase) ||
+               alt.Contains("Tweeeeeet", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static bool IsDisallowedVideoLink(string href)
+    {
+        return href.Contains("/videos/", StringComparison.OrdinalIgnoreCase) ||
+               href.Contains("youtube.com", StringComparison.OrdinalIgnoreCase) ||
+               href.Contains("youtu.be", StringComparison.OrdinalIgnoreCase) ||
+               href.Contains("vimeo.com", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string GalleryImageKey(string url)
+    {
+        var path = url.Split('?')[0].Split('#')[0];
+        var slash = path.LastIndexOf('/');
+        return slash >= 0 ? path[(slash + 1)..] : path;
+    }
+
+    /// <summary>
+    /// Converts a ModDB cached/cropped thumbnail image source to a high-resolution full-size image source.
+    /// </summary>
+    private static string GetFullSizeModDBImageSource(string imageSource)
+    {
+        if (string.IsNullOrWhiteSpace(imageSource))
+        {
+            return imageSource;
+        }
+
+        var result = imageSource;
+        if (result.Contains("/cache/images/", StringComparison.OrdinalIgnoreCase))
+        {
+            result = result.Replace("/cache/images/", "/images/", StringComparison.OrdinalIgnoreCase);
+        }
+
+        result = ModDBImageCropRegex().Replace(result, "/");
+        return result;
+    }
+
+    private static string ResolveGalleryImageTitle(IElement img, string thumbnailUrl, string? anchorHref)
+    {
+        string? rawTitle = null;
+
+        var imgAlt = img.GetAttribute("alt") ?? img.GetAttribute("title");
+        if (!string.IsNullOrWhiteSpace(imgAlt) &&
+            !imgAlt.Equals("View media", StringComparison.OrdinalIgnoreCase) &&
+            !imgAlt.Equals("Image", StringComparison.OrdinalIgnoreCase) &&
+            !imgAlt.StartsWith("Share on", StringComparison.OrdinalIgnoreCase))
+        {
+            rawTitle = imgAlt.Trim();
+        }
+
+        if (string.IsNullOrWhiteSpace(rawTitle))
+        {
+            var parentAnchor = img.Closest("a");
+            if (parentAnchor != null)
+            {
+                var anchorTitle = parentAnchor.GetAttribute("title");
+                if (!string.IsNullOrWhiteSpace(anchorTitle) &&
+                    !anchorTitle.Equals("View media", StringComparison.OrdinalIgnoreCase) &&
+                    !anchorTitle.Equals("Image", StringComparison.OrdinalIgnoreCase))
+                {
+                    rawTitle = anchorTitle.Trim();
+                }
+            }
+        }
+
+        if (string.IsNullOrWhiteSpace(rawTitle))
+        {
+            var container = img.Closest(".imagebox, .mediabox, .mediarow, .holder");
+            var titleEl = container?.QuerySelector(".title, .caption");
+            var containerTitle = titleEl?.TextContent?.Trim();
+            if (!string.IsNullOrWhiteSpace(containerTitle) &&
+                !containerTitle.Equals("View media", StringComparison.OrdinalIgnoreCase) &&
+                !containerTitle.Equals("Image", StringComparison.OrdinalIgnoreCase))
+            {
+                rawTitle = containerTitle;
+            }
+        }
+
+        if (string.IsNullOrWhiteSpace(rawTitle))
+        {
+            var fileName = GalleryImageKey(thumbnailUrl);
+            var dot = fileName.LastIndexOf('.');
+            if (dot > 0)
+            {
+                fileName = fileName[..dot];
+            }
+
+            if (!string.IsNullOrWhiteSpace(fileName) &&
+                !fileName.Equals("image", StringComparison.OrdinalIgnoreCase))
+            {
+                rawTitle = fileName;
+            }
+        }
+
+        if (string.IsNullOrWhiteSpace(rawTitle) && !string.IsNullOrWhiteSpace(anchorHref))
+        {
+            var slug = GalleryImageKey(anchorHref.Split('#')[0]);
+            if (!string.IsNullOrWhiteSpace(slug))
+            {
+                rawTitle = slug;
+            }
+        }
+
+        if (string.IsNullOrWhiteSpace(rawTitle))
+        {
+            return "Image";
+        }
+
+        return FormatImageTitle(rawTitle);
+    }
+
+    private static string FormatImageTitle(string title)
+    {
+        if (string.IsNullOrWhiteSpace(title))
+        {
+            return "Image";
+        }
+
+        var formatted = title.Trim('*', ' ', '\t', '\r', '\n').Replace('_', ' ').Replace('-', ' ');
+
+        if (!formatted.Contains(' '))
+        {
+            formatted = CamelCaseSplitRegex().Replace(formatted, " ");
+        }
+
+        formatted = Regex.Replace(formatted, @"\s+", " ").Trim();
+
+        return string.IsNullOrWhiteSpace(formatted) ? "Image" : formatted;
+    }
+
+    private static string ToAbsoluteUrl(string url)
+    {
+        if (string.IsNullOrWhiteSpace(url))
+        {
+            return string.Empty;
+        }
+
+        if (url.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
+            url.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+        {
+            return url;
+        }
+
+        if (url.StartsWith("//", StringComparison.Ordinal))
+        {
+            return "https:" + url;
+        }
+
+        if (url.StartsWith('/'))
+        {
+            return ModDBConstants.BaseUrl.TrimEnd('/') + url;
+        }
+
+        return ModDBConstants.BaseUrl.TrimEnd('/') + "/" + url;
+    }
+
+    /// <summary>
+    /// Extracts an image from a row element.
+    /// </summary>
+    private static Image? ExtractImageFromRow(IElement row)
+    {
+        var img = row.QuerySelector(ModDBParserConstants.ImageSelector);
+        if (img == null)
+        {
+            return null;
+        }
+
+        var src = img.GetAttribute("src");
+        if (string.IsNullOrEmpty(src))
+        {
+            return null;
+        }
+
+        var absUrl = ToAbsoluteUrl(src);
+        var fullSizeUrl = GetFullSizeModDBImageSource(absUrl);
+        var alt = img.GetAttribute("alt");
+        var title = !string.IsNullOrWhiteSpace(alt) ? FormatImageTitle(alt) : "Image";
+
+        return new Image(
+            Title: title,
+            ThumbnailUrl: fullSizeUrl,
+            FullSizeUrl: fullSizeUrl,
+            Description: alt);
+    }
+
+    /// <summary>
+    /// Extracts articles from the document.
+    /// </summary>
+    private static List<Article> ExtractArticles(IDocument document)
+    {
+        var articles = new List<Article>();
+
+        var articleRows = document.QuerySelectorAll(ModDBParserConstants.ArticlesSelector);
+        foreach (var row in articleRows)
+        {
+            var titleEl = row.QuerySelector(ModDBParserConstants.ArticleTitleSelector);
+            var title = titleEl?.TextContent?.Trim();
+            if (string.IsNullOrEmpty(title))
+            {
+                continue;
+            }
+
+            var authorEl = row.QuerySelector(ModDBParserConstants.ArticleAuthorSelector);
+            var author = authorEl?.TextContent?.Trim();
+
+            var dateEl = row.QuerySelector(ModDBParserConstants.ArticleDateSelector);
+            DateTime? publishDate = null;
+            if (dateEl != null)
+            {
+                var dateStr = dateEl.GetAttribute("datetime") ?? dateEl.TextContent?.Trim();
+                if (!string.IsNullOrEmpty(dateStr) && DateTime.TryParse(dateStr, out var parsedDate))
+                {
+                    publishDate = parsedDate;
+                }
+            }
+
+            var contentEl = row.QuerySelector(ModDBParserConstants.ArticleContentSelector);
+            var content = contentEl?.TextContent?.Trim();
+
+            var linkEl = row.QuerySelector(ModDBParserConstants.ArticleLinkSelector);
+            var url = linkEl?.GetAttribute("href");
+            if (!string.IsNullOrEmpty(url) && !url.StartsWith("http", StringComparison.OrdinalIgnoreCase))
+            {
+                url = "https:" + url;
+            }
+
+            articles.Add(new Article(
+                Title: title,
+                Author: author,
+                PublishDate: publishDate,
+                Content: content,
+                Url: url));
+        }
+
+        return articles;
+    }
+
+    /// <summary>
+    /// Extracts reviews from the document.
+    /// </summary>
+    private static List<Review> ExtractReviews(IDocument document)
+    {
+        var reviews = new List<Review>();
+
+        var reviewRows = document.QuerySelectorAll(ModDBParserConstants.ReviewsSelector);
+        foreach (var row in reviewRows)
+        {
+            var authorEl = row.QuerySelector(ModDBParserConstants.ReviewAuthorSelector);
+            var author = authorEl?.TextContent?.Trim();
+
+            var ratingEl = row.QuerySelector(ModDBParserConstants.ReviewRatingSelector);
+            float? rating = null;
+            if (ratingEl != null)
+            {
+                var ratingText = ratingEl.TextContent?.Trim();
+                if (!string.IsNullOrEmpty(ratingText) && float.TryParse(ratingText, NumberStyles.Float, CultureInfo.InvariantCulture, out var parsedRating))
+                {
+                    rating = parsedRating;
+                }
+            }
+
+            var contentEl = row.QuerySelector(ModDBParserConstants.ReviewContentSelector);
+            var content = contentEl?.TextContent?.Trim();
+
+            var dateEl = row.QuerySelector(ModDBParserConstants.ReviewDateSelector);
+            DateTime? date = null;
+            if (dateEl != null)
+            {
+                var dateStr = dateEl.GetAttribute("datetime") ?? dateEl.TextContent?.Trim();
+                if (!string.IsNullOrEmpty(dateStr) && DateTime.TryParse(dateStr, out var parsedDate))
+                {
+                    date = parsedDate;
+                }
+            }
+
+            var helpfulEl = row.QuerySelector(ModDBParserConstants.ReviewHelpfulSelector);
+            int? helpfulVotes = null;
+            if (helpfulEl != null)
+            {
+                var votesText = helpfulEl.TextContent?.Trim();
+                if (!string.IsNullOrEmpty(votesText) && int.TryParse(votesText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var votes))
+                {
+                    helpfulVotes = votes;
+                }
+                else if (!string.IsNullOrEmpty(votesText))
+                {
+                    // "12 people found this helpful" — take the leading integer when present.
+                    var digits = new string(votesText.TakeWhile(char.IsDigit).ToArray());
+                    if (int.TryParse(digits, NumberStyles.Integer, CultureInfo.InvariantCulture, out votes))
+                    {
+                        helpfulVotes = votes;
+                    }
+                }
+            }
+
+            // Broad selectors also match bare rating widgets; skip shells with no review body.
+            if (string.IsNullOrWhiteSpace(author) && string.IsNullOrWhiteSpace(content))
+            {
+                continue;
+            }
+
+            reviews.Add(new Review(
+                Author: author,
+                Rating: rating,
+                Content: content,
+                Date: date,
+                HelpfulVotes: helpfulVotes));
+        }
+
+        return reviews;
+    }
+
+    /// <summary>
+    /// Extracts comments from the document with hierarchical thread structure.
+    /// Only posted threads inside <c>#commentsbrowse</c> are considered — the composer
+    /// (<c>#commentform</c>, guest/email rows, injected CSS) is not a comment.
+    /// </summary>
+    private static List<Comment> ExtractComments(IDocument document)
+    {
+        var comments = new List<Comment>();
+
+        var browse = document.QuerySelector(ModDBParserConstants.CommentsSelector);
+        if (browse == null)
+        {
+            return comments;
+        }
+
+        var allCommentRows = browse.QuerySelectorAll(ModDBParserConstants.CommentRowSelector);
+        var seenRows = new HashSet<IElement>();
+        var rootRows = new List<IElement>();
+
+        foreach (var row in allCommentRows)
+        {
+            if (!seenRows.Add(row))
+            {
+                continue;
+            }
+
+            // Nested replies live under .children / another .rowcomment. Do not treat
+            // #commentsbrowse (id starts with "comment") as a nesting ancestor.
+            var isNested = row.Ancestors<IElement>().Any(a =>
+                a.ClassList.Contains("children") ||
+                a.ClassList.Contains("rowcomment") ||
+                (a.Id?.StartsWith("comment", StringComparison.OrdinalIgnoreCase) == true &&
+                 !a.Id.StartsWith("comments", StringComparison.OrdinalIgnoreCase)));
+
+            if (!isNested)
+            {
+                rootRows.Add(row);
+            }
+        }
+
+        foreach (var rootRow in rootRows)
+        {
+            var comment = ParseCommentElement(rootRow, indentLevel: 0);
+            if (comment != null)
+            {
+                comments.Add(comment);
+            }
+        }
+
+        return comments;
+    }
+
+    private static Comment? ParseCommentElement(IElement row, int indentLevel)
+    {
+        if (row.ClassList.Contains("rowcommentguest") ||
+            row.ClassList.Contains("rowcommentsummary") ||
+            row.ClassList.Contains("rowcommentemail"))
+        {
+            return null;
+        }
+
+        var author = ExtractCommentAuthor(row);
+        var content = ExtractCommentContent(row);
+
+        if (string.IsNullOrWhiteSpace(author) && string.IsNullOrWhiteSpace(content))
+        {
+            return null;
+        }
+
+        var date = ExtractCommentDate(row);
+        var karma = ExtractCommentKarma(row);
+        var isCreator = row.QuerySelector(ModDBParserConstants.CommentCreatorSelector) != null;
+        var childReplies = ExtractChildReplies(row, indentLevel);
+
+        return new Comment(
+            Author: author ?? "Anonymous",
+            Content: content,
+            Date: date,
+            Karma: karma,
+            IsCreator: isCreator,
+            IndentLevel: indentLevel,
+            Replies: childReplies.Count > 0 ? childReplies : null);
+    }
+
+    private static string? ExtractCommentAuthor(IElement row)
+    {
+        var authorEl = row.QuerySelector(ModDBParserConstants.CommentAuthorSelector)
+            ?? row.QuerySelector(".username")
+            ?? row.QuerySelector("a[href*='/members/']:not([href*='/register']):not([href*='/login'])");
+        var author = authorEl?.TextContent?.Trim();
+        return IsJunkDeveloperName(author) ? null : author;
+    }
+
+    private static string? ExtractCommentContent(IElement row)
+    {
+        var contentEl = row.QuerySelector(":scope > .commentbody")
+            ?? row.QuerySelector(".commentbody")
+            ?? row.QuerySelector(ModDBParserConstants.CommentContentSelector)
+            ?? row.QuerySelector("p.comment");
+
+        string? content = null;
+        if (contentEl != null)
+        {
+            content = ExtractCleanCommentBody(contentEl);
+        }
+        else
+        {
+            var pEl = row.QuerySelector(":scope > p") ?? row.QuerySelector("p");
+            if (pEl != null)
+            {
+                content = ExtractCleanCommentBody(pEl);
+            }
+        }
+
+        return IsJunkCommentContent(content) ? null : content;
+    }
+
+    private static DateTime? ExtractCommentDate(IElement row)
+    {
+        var dateEl = row.QuerySelector(ModDBParserConstants.CommentDateSelector);
+        if (dateEl != null)
+        {
+            var dateStr = dateEl.GetAttribute("datetime") ?? dateEl.TextContent?.Trim();
+            if (!string.IsNullOrEmpty(dateStr))
+            {
+                return DateTime.TryParse(dateStr, out var parsedDate)
+                    ? parsedDate
+                    : ParseModDBDate(dateStr);
+            }
+        }
+
+        return null;
+    }
+
+    private static int? ExtractCommentKarma(IElement row)
+    {
+        var karmaEl = row.QuerySelector(ModDBParserConstants.CommentKarmaSelector);
+        if (karmaEl != null)
+        {
+            var karmaText = karmaEl.TextContent?.Trim();
+            if (!string.IsNullOrEmpty(karmaText) && int.TryParse(karmaText, out var karmaValue))
+            {
+                return karmaValue;
+            }
+        }
+
+        return null;
+    }
+
+    private static List<Comment> ExtractChildReplies(IElement row, int indentLevel)
+    {
+        var childReplies = new List<Comment>();
+        var childrenContainer = row.QuerySelector(".children");
+        if (childrenContainer == null)
+        {
+            return childReplies;
+        }
+
+        var directChildRows = childrenContainer.QuerySelectorAll(".rowcomment, div[id^='comment']:not([id^='comments'])");
+        var seenChildren = new HashSet<IElement>();
+        foreach (var childRow in directChildRows)
+        {
+            if (!seenChildren.Add(childRow))
+            {
+                continue;
+            }
+
+            var intermediateParent = childRow.Ancestors<IElement>()
+                .TakeWhile(a => a != childrenContainer)
+                .FirstOrDefault(a =>
+                    a.ClassList.Contains("rowcomment") ||
+                    (a.Id?.StartsWith("comment", StringComparison.OrdinalIgnoreCase) == true &&
+                     !a.Id.StartsWith("comments", StringComparison.OrdinalIgnoreCase)));
+
+            if (intermediateParent == null)
+            {
+                var childComment = ParseCommentElement(childRow, indentLevel + 1);
+                if (childComment != null)
+                {
+                    childReplies.Add(childComment);
+                }
+            }
+        }
+
+        return childReplies;
+    }
+
+    /// <summary>
+    /// Reads comment body text without nested reply threads or ModDB action chrome, which would
+    /// otherwise inflate the comment content into a huge empty-looking block in the UI.
+    /// </summary>
+    private static string? ExtractCleanCommentBody(IElement contentEl)
+    {
+        var clone = contentEl.Clone(deep: true) as IElement;
+        if (clone == null)
+        {
+            return CleanCommentContent(contentEl.TextContent);
+        }
+
+        foreach (var junk in clone.QuerySelectorAll(".children, .actions, .reply, .commentoptions, .toolbar"))
+        {
+            junk.Remove();
+        }
+
+        // Nested .rowcomment nodes sometimes sit inside .commentbody on live ModDB markup.
+        foreach (var nested in clone.QuerySelectorAll(".rowcomment, div[id^='comment']"))
+        {
+            nested.Remove();
+        }
+
+        return CleanCommentContent(clone.TextContent);
+    }
+
+    private static string? CleanCommentContent(string? rawText)
+    {
+        if (string.IsNullOrWhiteSpace(rawText))
+        {
+            return null;
+        }
+
+        var lines = rawText.Split(['\r', '\n']);
+        var cleanLines = new List<string>();
+        foreach (var line in lines)
+        {
+            var trimmed = line.Trim();
+            if (string.IsNullOrEmpty(trimmed) ||
+                trimmed.Equals("Reply", StringComparison.OrdinalIgnoreCase) ||
+                trimmed.StartsWith("Good karma", StringComparison.OrdinalIgnoreCase) ||
+                trimmed.StartsWith("Bad karma", StringComparison.OrdinalIgnoreCase) ||
+                trimmed.EndsWith("vote", StringComparison.OrdinalIgnoreCase) ||
+                IsJunkCommentContent(trimmed))
+            {
+                continue;
+            }
+
+            cleanLines.Add(trimmed);
+        }
+
+        return cleanLines.Count > 0 ? string.Join("\n", cleanLines) : null;
+    }
+
+    private static bool IsJunkCommentContent(string? text)
+    {
+        if (string.IsNullOrWhiteSpace(text))
+        {
+            return true;
+        }
+
+        if (text.Contains("Your comment will be anonymous", StringComparison.OrdinalIgnoreCase) ||
+            text.Contains("join the community", StringComparison.OrdinalIgnoreCase) ||
+            text.Contains("Post a comment", StringComparison.OrdinalIgnoreCase) ||
+            text.Contains("Save comment", StringComparison.OrdinalIgnoreCase) ||
+            text.Contains("sign in with your social", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        // Cloudflare/ModDB inject obfuscated CSS into the composer (span.abc { display: none; }).
+        return text.Contains('{') &&
+               (text.Contains("display:", StringComparison.OrdinalIgnoreCase) ||
+                text.Contains("formouter", StringComparison.OrdinalIgnoreCase));
+    }
+
+    private static bool IsJunkDeveloperName(string? name) =>
+        string.IsNullOrWhiteSpace(name) ||
+        name.Equals("register", StringComparison.OrdinalIgnoreCase) ||
+        name.Equals("sign in", StringComparison.OrdinalIgnoreCase) ||
+        name.Equals("login", StringComparison.OrdinalIgnoreCase) ||
+        name.Equals("guest", StringComparison.OrdinalIgnoreCase);
+
+    private static bool IsBreadcrumbOrLocationText(string? text)
+    {
+        if (string.IsNullOrWhiteSpace(text))
+        {
+            return true;
+        }
+
+        var trimmed = text.Trim();
+        return trimmed.StartsWith("Games :", StringComparison.OrdinalIgnoreCase) ||
+               trimmed.StartsWith("Mods :", StringComparison.OrdinalIgnoreCase) ||
+               (trimmed.Contains(" : Mods : ", StringComparison.OrdinalIgnoreCase) &&
+                trimmed.Contains(" : Files", StringComparison.OrdinalIgnoreCase)) ||
+               trimmed.Equals("Location", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static bool LooksLikeArchiveFileName(string? name)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            return false;
+        }
+
+        var dot = name.LastIndexOf('.');
+        if (dot <= 0 || dot >= name.Length - 1)
+        {
+            return false;
+        }
+
+        var ext = name[(dot + 1)..];
+        return ext.Length is >= 2 and <= 4 && ext.All(char.IsLetterOrDigit);
+    }
+
+    private static string? GetCanonicalModDBFileKey(string? url)
+    {
+        if (string.IsNullOrWhiteSpace(url))
+        {
+            return null;
+        }
+
+        if (!Uri.TryCreate(url, UriKind.Absolute, out var uri) &&
+            !Uri.TryCreate(new Uri(ModDBConstants.BaseUrl), url, out uri))
+        {
+            return url.Trim().TrimEnd('/').ToLowerInvariant();
+        }
+
+        var path = uri.AbsolutePath.TrimEnd('/');
+        var segments = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
+        if (segments.Length == 0)
+        {
+            return null;
+        }
+
+        if (segments.Length >= 3 && (segments[^2].Equals("start", StringComparison.OrdinalIgnoreCase) || segments[^2].Equals("mirror", StringComparison.OrdinalIgnoreCase)))
+        {
+            return $"start:{segments[^1].ToLowerInvariant()}";
+        }
+
+        var lastSegment = segments[^1].ToLowerInvariant();
+        if (lastSegment.Equals("downloads", StringComparison.OrdinalIgnoreCase) ||
+            lastSegment.Equals("addons", StringComparison.OrdinalIgnoreCase) ||
+            lastSegment.Equals("files", StringComparison.OrdinalIgnoreCase))
+        {
+            return null;
+        }
+
+        return lastSegment;
+    }
+
+    private static string? NormalizeDownloadUrl(string? url)
+    {
+        if (string.IsNullOrWhiteSpace(url))
+        {
+            return null;
+        }
+
+        var trimmed = url.Trim().TrimEnd('/');
+        return Uri.TryCreate(trimmed, UriKind.Absolute, out var uri)
+            ? uri.GetLeftPart(UriPartial.Path).TrimEnd('/')
+            : trimmed;
+    }
+
+    /// <summary>
+    /// Collapses FileDetail filename rows with the parent /downloads listing of the same binary
+    /// so the Releases tab does not show both "GeneralsUndone_v1.0.zip" and "C&amp;C Generals Undone".
+    /// </summary>
+    private static List<ContentSection> DeduplicateDownloadableFiles(List<ContentSection> sections)
+    {
+        var files = sections.OfType<DownloadableFile>().ToList();
+        if (files.Count <= 1)
+        {
+            return sections;
+        }
+
+        var merged = new List<DownloadableFile>();
+        var indexByKey = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var file in files)
+        {
+            var existingIndex = FindExistingFileIndex(file, merged, indexByKey);
+
+            if (existingIndex >= 0)
+            {
+                var updated = MergeDownloadableFiles(merged[existingIndex], file);
+                merged[existingIndex] = updated;
+                UpdateFileIndexKeys(updated, existingIndex, indexByKey);
+                continue;
+            }
+
+            var newIndex = merged.Count;
+            UpdateFileIndexKeys(file, newIndex, indexByKey);
+            merged.Add(file);
+        }
+
+        var sortedMerged = merged
+            .OrderByDescending(f => f.ReleaseDate ?? f.UploadDate ?? DateTime.MinValue)
+            .ThenByDescending(f => f.Version, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+
+        var result = new List<ContentSection>(sections.Count);
+        var filesEmitted = false;
+        foreach (var section in sections)
+        {
+            if (section is DownloadableFile)
+            {
+                if (!filesEmitted)
+                {
+                    result.AddRange(sortedMerged);
+                    filesEmitted = true;
+                }
+
+                continue;
+            }
+
+            result.Add(section);
+        }
+
+        return result;
+    }
+
+    private static int FindExistingFileIndex(
+        DownloadableFile file,
+        List<DownloadableFile> merged,
+        Dictionary<string, int> indexByKey)
+    {
+        var downloadKey = NormalizeDownloadUrl(file.DownloadUrl);
+        var detailsKey = NormalizeDownloadUrl(file.DetailsUrl);
+        var canonicalDownloadKey = GetCanonicalModDBFileKey(file.DownloadUrl);
+        var canonicalDetailsKey = GetCanonicalModDBFileKey(file.DetailsUrl);
+        var nameKey = !string.IsNullOrWhiteSpace(file.Name) ? file.Name.Trim().ToLowerInvariant() : null;
+        var filenameKey = !string.IsNullOrWhiteSpace(file.Filename) ? file.Filename.Trim().ToLowerInvariant() : null;
+
+        var keysToTry = new[] { downloadKey, detailsKey, canonicalDownloadKey, canonicalDetailsKey, filenameKey, nameKey };
+        int existingIndex = -1;
+
+        foreach (var key in keysToTry)
+        {
+            if (key != null && indexByKey.TryGetValue(key, out var idx))
+            {
+                existingIndex = idx;
+                break;
+            }
+        }
+
+        if (existingIndex >= 0)
+        {
+            var existing = merged[existingIndex];
+            var existingCanonDetails = GetCanonicalModDBFileKey(existing.DetailsUrl);
+            var existingCanonDownload = GetCanonicalModDBFileKey(existing.DownloadUrl);
+
+            var detailsConflict = canonicalDetailsKey != null && existingCanonDetails != null &&
+                                  !string.Equals(canonicalDetailsKey, existingCanonDetails, StringComparison.OrdinalIgnoreCase);
+            var downloadConflict = IsDirectDownloadUrl(file.DownloadUrl) && IsDirectDownloadUrl(existing.DownloadUrl) &&
+                                   canonicalDownloadKey != null && existingCanonDownload != null &&
+                                   !string.Equals(canonicalDownloadKey, existingCanonDownload, StringComparison.OrdinalIgnoreCase);
+
+            if (detailsConflict || downloadConflict)
+            {
+                return -1;
+            }
+        }
+
+        return existingIndex;
+    }
+
+    private static void UpdateFileIndexKeys(
+        DownloadableFile file,
+        int targetIndex,
+        Dictionary<string, int> indexByKey)
+    {
+        var downloadKey = NormalizeDownloadUrl(file.DownloadUrl);
+        var detailsKey = NormalizeDownloadUrl(file.DetailsUrl);
+        var canonDownload = GetCanonicalModDBFileKey(file.DownloadUrl);
+        var canonDetails = GetCanonicalModDBFileKey(file.DetailsUrl);
+        var nameKey = !string.IsNullOrWhiteSpace(file.Name) ? file.Name.Trim().ToLowerInvariant() : null;
+        var filenameKey = !string.IsNullOrWhiteSpace(file.Filename) ? file.Filename.Trim().ToLowerInvariant() : null;
+
+        if (downloadKey != null) indexByKey[downloadKey] = targetIndex;
+        if (detailsKey != null) indexByKey[detailsKey] = targetIndex;
+        if (canonDownload != null) indexByKey[canonDownload] = targetIndex;
+        if (canonDetails != null) indexByKey[canonDetails] = targetIndex;
+        if (nameKey != null) indexByKey[nameKey] = targetIndex;
+        if (filenameKey != null) indexByKey[filenameKey] = targetIndex;
+    }
+
+    private static DownloadableFile MergeDownloadableFiles(DownloadableFile left, DownloadableFile right)
+    {
+        var finalName = ResolveMergedName(left.Name, right.Name);
+        var finalFilename = ResolveMergedFilename(left, right);
+        var bestDownloadUrl = ResolveBestDownloadUrl(left.DownloadUrl, right.DownloadUrl);
+        var bestDetailsUrl = ResolveBestDetailsUrl(left, right);
+
+        FileSectionType bestSectionType = left.FileSectionType != FileSectionType.Downloads
+            ? left.FileSectionType
+            : right.FileSectionType;
+
+        return left with
+        {
+            Name = finalName ?? left.Name ?? string.Empty,
+            Filename = finalFilename,
+            DownloadUrl = bestDownloadUrl,
+            DetailsUrl = bestDetailsUrl,
+            FileSectionType = bestSectionType,
+            ReleaseDate = left.ReleaseDate ?? right.ReleaseDate,
+            UploadDate = left.UploadDate ?? right.UploadDate,
+            SizeBytes = left.SizeBytes ?? right.SizeBytes,
+            SizeDisplay = left.SizeDisplay ?? right.SizeDisplay,
+            Version = left.Version ?? right.Version,
+            Category = left.Category ?? right.Category,
+            Uploader = left.Uploader ?? right.Uploader,
+            Description = left.Description ?? right.Description,
+            ThumbnailUrl = left.ThumbnailUrl ?? right.ThumbnailUrl,
+            Md5Hash = left.Md5Hash ?? right.Md5Hash,
+            DownloadCount = left.DownloadCount ?? right.DownloadCount,
+            CommentCount = left.CommentCount ?? right.CommentCount,
+        };
+    }
+
+    private static string? ResolveMergedName(string? leftName, string? rightName)
+    {
+        var preferRightName = LooksLikeArchiveFileName(leftName) && !LooksLikeArchiveFileName(rightName);
+        var preferLeftName = !LooksLikeArchiveFileName(leftName) && LooksLikeArchiveFileName(rightName);
+
+        if (preferRightName)
+        {
+            return rightName;
+        }
+
+        if (preferLeftName)
+        {
+            return leftName;
+        }
+
+        return leftName ?? rightName;
+    }
+
+    private static string? ResolveMergedFilename(DownloadableFile left, DownloadableFile right)
+    {
+        var finalFilename = left.Filename ?? right.Filename;
+        if (string.IsNullOrEmpty(finalFilename))
+        {
+            if (LooksLikeArchiveFileName(left.Name))
+            {
+                finalFilename = left.Name;
+            }
+            else if (LooksLikeArchiveFileName(right.Name))
+            {
+                finalFilename = right.Name;
+            }
+        }
+
+        return finalFilename;
+    }
+
+    private static string? ResolveBestDownloadUrl(string? leftDownloadUrl, string? rightDownloadUrl)
+    {
+        if (IsDirectDownloadUrl(leftDownloadUrl))
+        {
+            return leftDownloadUrl;
+        }
+
+        if (IsDirectDownloadUrl(rightDownloadUrl))
+        {
+            return rightDownloadUrl;
+        }
+
+        return leftDownloadUrl ?? rightDownloadUrl;
+    }
+
+    private static string? ResolveBestDetailsUrl(DownloadableFile left, DownloadableFile right)
+    {
+        string? bestDetailsUrl = left.DetailsUrl ?? right.DetailsUrl;
+        if (bestDetailsUrl == null && !IsDirectDownloadUrl(left.DownloadUrl))
+        {
+            bestDetailsUrl = left.DownloadUrl;
+        }
+
+        if (bestDetailsUrl == null && !IsDirectDownloadUrl(right.DownloadUrl))
+        {
+            bestDetailsUrl = right.DownloadUrl;
+        }
+
+        return bestDetailsUrl;
+    }
+
+    private static List<ContentSection> DeduplicateImages(List<ContentSection> sections)
+    {
+        var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var result = new List<ContentSection>(sections.Count);
+        foreach (var section in sections)
+        {
+            if (section is Image image)
+            {
+                var key = GalleryImageKey(image.ThumbnailUrl ?? image.FullSizeUrl ?? image.Title);
+                if (!seen.Add(key))
+                {
+                    continue;
+                }
+            }
+
+            result.Add(section);
+        }
+
+        return result;
+    }
+
+    private static List<ContentSection> DeduplicateVideos(List<ContentSection> sections)
+    {
+        var videoList = sections.OfType<Video>().ToList();
+        if (videoList.Count == 0)
+        {
+            return sections;
+        }
+
+        var deduplicated = DeduplicateVideoList(videoList);
+        var result = new List<ContentSection>(sections.Count);
+        var videoEnumerator = deduplicated.GetEnumerator();
+
+        foreach (var section in sections)
+        {
+            if (section is Video)
+            {
+                if (videoEnumerator.MoveNext())
+                {
+                    result.Add(videoEnumerator.Current);
+                }
+            }
+            else
+            {
+                result.Add(section);
+            }
+        }
+
+        while (videoEnumerator.MoveNext())
+        {
+            result.Add(videoEnumerator.Current);
+        }
+
+        return result;
+    }
+
+    private static List<Video> DeduplicateVideoList(List<Video> videos)
+    {
+        var dict = new Dictionary<string, Video>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var video in videos)
+        {
+            var key = GetVideoKey(video);
+            if (!dict.TryGetValue(key, out var existing))
+            {
+                dict[key] = video;
+            }
+            else
+            {
+                var betterTitle = existing.Title;
+                if (!IsUsableVideoTitle(betterTitle) && IsUsableVideoTitle(video.Title))
+                {
+                    betterTitle = video.Title;
+                }
+
+                var betterThumb = !string.IsNullOrWhiteSpace(existing.ThumbnailUrl)
+                    ? existing.ThumbnailUrl
+                    : video.ThumbnailUrl;
+                var betterEmbed = !string.IsNullOrWhiteSpace(existing.EmbedUrl)
+                    ? existing.EmbedUrl
+                    : video.EmbedUrl;
+                var betterPlatform = !string.Equals(existing.Platform, "Unknown", StringComparison.OrdinalIgnoreCase)
+                    ? existing.Platform
+                    : video.Platform;
+
+                dict[key] = new Video(
+                    Title: betterTitle,
+                    ThumbnailUrl: betterThumb,
+                    EmbedUrl: betterEmbed,
+                    Platform: betterPlatform);
+            }
+        }
+
+        return [.. dict.Values];
+    }
+
+    private static string GetVideoKey(Video video)
+    {
+        if (!string.IsNullOrWhiteSpace(video.EmbedUrl))
+        {
+            var ytMatch = YouTubeVideoIdRegex().Match(video.EmbedUrl);
+            if (ytMatch.Success)
+            {
+                return "yt:" + ytMatch.Groups[1].Value.ToLowerInvariant();
+            }
+
+            var vimeoMatch = VimeoVideoIdRegex().Match(video.EmbedUrl);
+            if (vimeoMatch.Success)
+            {
+                return "vimeo:" + vimeoMatch.Groups[1].Value.ToLowerInvariant();
+            }
+
+            return "url:" + GalleryImageKey(video.EmbedUrl.Split('?')[0]).ToLowerInvariant();
+        }
+
+        if (!string.IsNullOrWhiteSpace(video.ThumbnailUrl))
+        {
+            var ytMatch = YouTubeVideoIdRegex().Match(video.ThumbnailUrl);
+            if (ytMatch.Success)
+            {
+                return "yt:" + ytMatch.Groups[1].Value.ToLowerInvariant();
+            }
+
+            return "thumb:" + GalleryImageKey(video.ThumbnailUrl.Split('?')[0]).ToLowerInvariant();
+        }
+
+        return "title:" + video.Title.ToLowerInvariant();
+    }
+
+    /// <summary>
+    /// Parses a file size string into bytes (e.g., "15.5 MB", "188.3kb (192,819 bytes)", "9,72 MB").
+    /// </summary>
+    private static long? ParseFileSize(string sizeText)
+    {
+        if (string.IsNullOrWhiteSpace(sizeText))
+        {
+            return null;
+        }
+
+        // Check for exact byte count in parentheses or text, e.g. "(192,819 bytes)"
+        var bytesMatch = ExactBytesRegex().Match(sizeText);
+        if (bytesMatch.Success)
+        {
+            var rawDigits = bytesMatch.Groups[1].Value.Replace(",", string.Empty).Replace(" ", string.Empty).Trim();
+            if (long.TryParse(rawDigits, NumberStyles.Integer, CultureInfo.InvariantCulture, out var exactBytesVal))
+            {
+                return exactBytesVal;
+            }
+        }
+
+        // Parse floating point size with unit, supporting comma or dot decimals and optional spacing
+        var match = NumericSizeWithUnitRegex().Match(sizeText);
+        if (!match.Success)
+        {
+            return null;
+        }
+
+        var numStr = match.Groups[1].Value.Replace(',', '.');
+        if (!double.TryParse(numStr, NumberStyles.Float, CultureInfo.InvariantCulture, out var value))
+        {
+            return null;
+        }
+
+        var unit = match.Groups[2].Value.ToUpperInvariant();
+
+        if (unit.StartsWith("G", StringComparison.OrdinalIgnoreCase))
+        {
+            return (long)(value * 1024 * 1024 * 1024);
+        }
+
+        if (unit.StartsWith("M", StringComparison.OrdinalIgnoreCase))
+        {
+            return (long)(value * 1024 * 1024);
+        }
+
+        if (unit.StartsWith("K", StringComparison.OrdinalIgnoreCase))
+        {
+            return (long)(value * 1024);
+        }
+
+        if (unit.StartsWith("B", StringComparison.OrdinalIgnoreCase))
+        {
+            return (long)value;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Parses ModDB date formats like "Mar 15th, 2024" or "Added Mar 15th, 2024".
+    /// </summary>
+    private static DateTime? ParseModDBDate(string dateStr)
+    {
+        if (string.IsNullOrEmpty(dateStr))
+        {
+            return null;
+        }
+
+        // Remove common prefixes
+        dateStr = dateStr.Replace("Added", string.Empty, StringComparison.OrdinalIgnoreCase)
+                        .Replace("Released", string.Empty, StringComparison.OrdinalIgnoreCase)
+                        .Replace("Updated", string.Empty, StringComparison.OrdinalIgnoreCase)
+                        .Trim();
+
+        // Try parsing common formats
+        // Format: "Mar 15th, 2024"
+        var format1 = "MMM d'th', yyyy";
+        if (DateTime.TryParseExact(dateStr, format1, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result1))
+        {
+            return result1;
+        }
+
+        // Try with st, nd, rd, th suffixes
+        var formats = new[]
+        {
+            "MMM d'st', yyyy",
+            "MMM d'nd', yyyy",
+            "MMM d'rd', yyyy",
+            "MMM d'th', yyyy",
+            "MMM dd, yyyy",
+            "MMM d, yyyy",
+            "MMMM d, yyyy",
+            "yyyy-MM-dd",
+            "MM/dd/yyyy",
+            "dd/MM/yyyy",
+        };
+
+        foreach (var format in formats)
+        {
+            if (DateTime.TryParseExact(dateStr, format, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
+            {
+                return result;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Helper class for profile metadata.
+    /// </summary>
+    private record ProfileMeta(
+        string? Name,
+        long? SizeBytes,
+        string? SizeDisplay,
+        DateTime? ReleaseDate,
+        string? Developer,
+        string? Md5Hash);
+
+    /// <summary>
+    /// Extracts content sections from list pages (addons, images).
+    /// </summary>
+    /// <param name="document">The document to extract from.</param>
+    /// <param name="sectionType">The type of file section (Release or Addon).</param>
+    private static List<ContentSection> ExtractListSections(IDocument document, FileSectionType sectionType = FileSectionType.Downloads)
+    {
+        var sections = new List<ContentSection>();
+
+        var rows = document.QuerySelectorAll(ModDBParserConstants.RowContentSelector);
+        foreach (var row in rows)
+        {
+            // Extract image
+            var image = ExtractImageFromRow(row);
+            if (image != null)
+            {
+                sections.Add(image);
+            }
+
+            // Extract file info if present
+            var file = ExtractFileFromRow(row, sectionType);
+            if (file != null)
+            {
+                sections.Add(file);
+            }
+        }
+
+        return sections;
+    }
+
+    /// <summary>
+    /// Extracts files from the document.
+    /// </summary>
+    /// <param name="document">The document to extract files from.</param>
+    /// <param name="sectionType">The type of file section (Release or Addon).</param>
+    private static List<DownloadableFile> ExtractFiles(IDocument document, FileSectionType sectionType = FileSectionType.Downloads)
+    {
+        var files = new List<DownloadableFile>();
+
+        var fileRows = document.QuerySelectorAll(ModDBParserConstants.FileRowSelector);
+        foreach (var row in fileRows)
+        {
+            var file = ExtractFileFromRow(row, sectionType);
+            if (file != null)
+            {
+                files.Add(file);
+            }
+        }
+
+        return files;
+    }
+
+    /// <summary>
+    /// Extracts content sections from detail pages.
+    /// </summary>
+    /// <param name="document">The document to extract from.</param>
+    /// <param name="sectionType">The type of file section (Release or Addon).</param>
+    private static List<ContentSection> ExtractDetailSections(IDocument document, FileSectionType sectionType = FileSectionType.Downloads)
+    {
+        var sections = new List<ContentSection>();
+
+        // Extract files
+        sections.AddRange(ExtractFiles(document, sectionType));
+
+        // Extract videos
+        sections.AddRange(ExtractVideos(document));
+
+        // Extract images
+        sections.AddRange(ExtractImages(document));
+
+        // Extract articles
+        sections.AddRange(ExtractArticles(document));
+
+        // Extract reviews
+        sections.AddRange(ExtractReviews(document));
+
+        // Extract comments
+        sections.AddRange(ExtractComments(document));
+
+        return sections;
+    }
+
+    /// <inheritdoc />
+    public string ParserId => "ModDB";
+
+    /// <inheritdoc />
+    public bool CanParse(string url) =>
+        Uri.TryCreate(url, UriKind.Absolute, out var uri) &&
+        (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps) &&
+        (uri.Host.Equals("moddb.com", StringComparison.OrdinalIgnoreCase) ||
+         uri.Host.EndsWith(".moddb.com", StringComparison.OrdinalIgnoreCase));
+
+    /// <inheritdoc />
+    public async Task<ParsedWebPage> ParseAsync(string url, CancellationToken cancellationToken = default)
+    {
+        logger.LogInformation("Parsing ModDB page: {Url}", url);
+
+        return await playwrightService.ExecuteInPersistentContextAsync(
+            ModDBConstants.BrowserProfileName,
+            async () =>
+            {
+                var urlsToFetch = GetUrlsToFetch(url);
+
+                // fetch all required URLs on one persistent Chromium page (profile) in a single batch.
+                var fetched = await playwrightService.FetchAndParsePersistentManyAsync(
+                    ModDBConstants.BrowserProfileName,
+                    urlsToFetch,
+                    cancellationToken);
+
+                if (!fetched.TryGetValue(url, out var document))
+                {
+                    throw new InvalidOperationException($"Failed to fetch document for {url}");
+                }
+
+                var parsedPage = ParseInternalWithFetched(url, document, fetched);
+
+                // check whether there are releases and addons to be loaded before closing the browser window
+                var releaseFilesToEnrich = parsedPage.Sections.OfType<DownloadableFile>()
+                    .Where(f => f.FileSectionType == FileSectionType.Downloads && !string.IsNullOrEmpty(f.DetailsUrl ?? f.DownloadUrl))
+                    .OrderByDescending(f => f.ReleaseDate ?? f.UploadDate ?? DateTime.MinValue)
+                    .ThenByDescending(f => f.Version, StringComparer.OrdinalIgnoreCase)
+                    .Take(ContentConstants.PreloadRecentItemsLimit);
+
+                var addonFilesToEnrich = parsedPage.Sections.OfType<DownloadableFile>()
+                    .Where(f => f.FileSectionType == FileSectionType.Addons && !string.IsNullOrEmpty(f.DetailsUrl ?? f.DownloadUrl))
+                    .OrderByDescending(f => f.ReleaseDate ?? f.UploadDate ?? DateTime.MinValue)
+                    .ThenByDescending(f => f.Version, StringComparer.OrdinalIgnoreCase)
+                    .Take(ContentConstants.PreloadRecentItemsLimit);
+
+                var filesToEnrich = releaseFilesToEnrich.Concat(addonFilesToEnrich).ToList();
+
+                var urlsToEnrich = filesToEnrich
+                    .Select(f => f.DetailsUrl ?? f.DownloadUrl!)
+                    .Where(u => !fetched.ContainsKey(u))
+                    .Distinct(StringComparer.OrdinalIgnoreCase)
+                    .ToList();
+
+                if (urlsToEnrich.Count > 0)
+                {
+                    logger.LogInformation("Enriching {Count} recent releases/addons in same browser window", urlsToEnrich.Count);
+                    var enrichedFetched = await playwrightService.FetchAndParsePersistentManyAsync(
+                        ModDBConstants.BrowserProfileName,
+                        urlsToEnrich,
+                        cancellationToken);
+
+                    if (enrichedFetched.Count > 0)
+                    {
+                        var enrichedFiles = new Dictionary<string, DownloadableFile>(StringComparer.OrdinalIgnoreCase);
+                        foreach (var kvp in enrichedFetched)
+                        {
+                            var detailUrl = kvp.Key;
+                            var detailDoc = kvp.Value;
+                            var detailed = ExtractDetailedFile(detailDoc, detailUrl);
+                            if (detailed != null)
+                            {
+                                enrichedFiles[detailUrl] = detailed;
+                            }
+                        }
+
+                        if (enrichedFiles.Count > 0)
+                        {
+                            var updatedSections = new List<ContentSection>();
+                            foreach (var section in parsedPage.Sections)
+                            {
+                                if (section is DownloadableFile file)
+                                {
+                                    var key = file.DetailsUrl ?? file.DownloadUrl;
+                                    if (key != null && enrichedFiles.TryGetValue(key, out var detailed))
+                                    {
+                                        var merged = detailed with
+                                        {
+                                            Category = !string.IsNullOrEmpty(detailed.Category) ? detailed.Category : file.Category,
+                                            FileSectionType = file.FileSectionType,
+                                            UploadDate = detailed.UploadDate ?? file.UploadDate,
+                                            ReleaseDate = detailed.ReleaseDate ?? file.ReleaseDate,
+                                            ThumbnailUrl = !string.IsNullOrEmpty(detailed.ThumbnailUrl) ? detailed.ThumbnailUrl : file.ThumbnailUrl,
+                                            DetailsUrl = !string.IsNullOrEmpty(detailed.DetailsUrl) ? detailed.DetailsUrl : file.DetailsUrl,
+                                            DownloadUrl = !string.IsNullOrEmpty(detailed.DownloadUrl) ? detailed.DownloadUrl : file.DownloadUrl,
+                                            SizeBytes = detailed.SizeBytes ?? file.SizeBytes,
+                                            SizeDisplay = !string.IsNullOrEmpty(detailed.SizeDisplay) ? detailed.SizeDisplay : file.SizeDisplay,
+                                            Name = !string.IsNullOrEmpty(detailed.Name) && !string.Equals(detailed.Name, "Unknown", StringComparison.OrdinalIgnoreCase) ? detailed.Name : file.Name,
+                                        };
+                                        updatedSections.Add(merged);
+                                        continue;
+                                    }
+                                }
+
+                                updatedSections.Add(section);
+                            }
+
+                            parsedPage = parsedPage with { Sections = updatedSections };
+                        }
+                    }
+                }
+
+                return parsedPage;
+            },
+            cancellationToken);
+    }
+
+    /// <summary>
+    /// File-only parse for acquisition: returns the single <see cref="DownloadableFile"/> from a
+    /// FileDetail page and the page's own metadata, without fetching the parent mod's downloads,
+    /// addons, videos, images, reviews, and articles sections. The download path needs only the
+    /// file; the FileDetail page already carries title/developer/icon/description via its profile
+    /// sidebar. Use <see cref="ParseAsync(string, CancellationToken)"/> when the full rich page
+    /// (Media/Community/Releases/Addons) is required for display.
+    /// </summary>
+    /// <param name="url">A FileDetail URL (<c>/mods/.../downloads/file-name</c> or <c>/addons/...</c>).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A parsed page containing the single file and the FileDetail page's context.</returns>
+    public async Task<ParsedWebPage> ParseFileDetailAsync(string url, CancellationToken cancellationToken = default)
+    {
+        logger.LogInformation("Parsing ModDB file detail (acquisition path): {Url}", url);
+
+        var document = await playwrightService.FetchAndParsePersistentAsync(
+            ModDBConstants.BrowserProfileName, url, cancellationToken);
+
+        var sections = new List<ContentSection>();
+        var file = ExtractDetailedFile(document, url);
+        if (file != null)
+        {
+            sections.Add(file);
+        }
+
+        var context = ExtractGlobalContext(document);
+
+        return new ParsedWebPage(
+            Url: new Uri(url),
+            Context: context,
+            Sections: sections,
+            PageType: PageType.FileDetail);
+    }
+
+    /// <summary>
+    /// Parses multiple file detail pages in a single parallel batch using persistent Chromium tabs.
+    /// </summary>
+    /// <param name="urls">The file detail URLs to parse.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A dictionary of URL -> ParsedWebPage results.</returns>
+    public async Task<IReadOnlyDictionary<string, ParsedWebPage>> ParseFileDetailsManyAsync(
+        IReadOnlyList<string> urls,
+        CancellationToken cancellationToken = default)
+    {
+        if (urls == null || urls.Count == 0)
+        {
+            return new Dictionary<string, ParsedWebPage>();
+        }
+
+        logger.LogInformation("Parsing ModDB file details in parallel batch ({Count} URLs)", urls.Count);
+
+        var fetched = await playwrightService.FetchAndParsePersistentManyAsync(
+            ModDBConstants.BrowserProfileName,
+            urls,
+            cancellationToken);
+
+        var results = new Dictionary<string, ParsedWebPage>(StringComparer.OrdinalIgnoreCase);
+        foreach (var (url, document) in fetched)
+        {
+            try
+            {
+                var sections = new List<ContentSection>();
+                var file = ExtractDetailedFile(document, url);
+                if (file != null)
+                {
+                    sections.Add(file);
+                }
+
+                var context = ExtractGlobalContext(document);
+                results[url] = new ParsedWebPage(
+                    Url: new Uri(url),
+                    Context: context,
+                    Sections: sections,
+                    PageType: PageType.FileDetail);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to parse file detail for {Url}", url);
+            }
+        }
+
+        return results;
+    }
+
+    /// <inheritdoc />
+    public Task<ParsedWebPage> ParseAsync(string url, string html, CancellationToken cancellationToken = default)
+    {
+        var browsingContext = BrowsingContext.New(Configuration.Default);
+        var document = browsingContext.OpenAsync(req => req.Content(html), cancellationToken).GetAwaiter().GetResult();
+        return Task.FromResult(ParseInternal(url, document));
+    }
+
+    /// <summary>
+    /// Determines whether a ModDB URL points directly to an acquisition endpoint (/start/ or /mirror/)
+    /// rather than an HTML content or detail listing page.
+    /// </summary>
+    /// <param name="url">The URL to test.</param>
+    /// <returns><see langword="true"/> if the URL is a direct download link; otherwise <see langword="false"/>.</returns>
+    internal static bool IsDirectDownloadUrl(string? url)
+    {
+        if (string.IsNullOrWhiteSpace(url))
+        {
+            return false;
+        }
+
+        if (url.Contains("/downloads/start/", StringComparison.OrdinalIgnoreCase) ||
+            url.Contains("/addons/start/", StringComparison.OrdinalIgnoreCase) ||
+            url.Contains("/downloads/mirror/", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        if ((url.Contains("/mods/", StringComparison.OrdinalIgnoreCase) || url.Contains("/games/", StringComparison.OrdinalIgnoreCase)) &&
+            (url.Contains("/downloads/", StringComparison.OrdinalIgnoreCase) || url.Contains("/addons/", StringComparison.OrdinalIgnoreCase)))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Computes the complete list of URLs needed to parse a ModDB page and its related sections
+    /// in a single Playwright batch, avoiding multiple browser launches.
+    /// </summary>
+    private static IReadOnlyList<string> GetUrlsToFetch(string url)
+    {
+        if (IsModDetailPage(url))
+        {
+            var baseUrl = Uri.TryCreate(url, UriKind.Absolute, out var uri)
+                ? $"{uri.Scheme}://{uri.Authority}{uri.AbsolutePath.TrimEnd('/')}"
+                : url.Split('?')[0].Split('#')[0].TrimEnd('/');
+
+            return
+            [
+                url,
+                baseUrl + "/downloads",
+                baseUrl + "/addons",
+                baseUrl + "/videos",
+                baseUrl + "/images",
+                baseUrl + "/reviews",
+                baseUrl + "/articles",
+            ];
+        }
+
+        var parentModUrl = ExtractParentModUrl(url);
+        if (!string.IsNullOrEmpty(parentModUrl))
+        {
+            var baseUrl = Uri.TryCreate(parentModUrl, UriKind.Absolute, out var parentUri)
+                ? $"{parentUri.Scheme}://{parentUri.Authority}{parentUri.AbsolutePath.TrimEnd('/')}"
+                : parentModUrl.Split('?')[0].Split('#')[0].TrimEnd('/');
+
+            return
+            [
+                url,
+                parentModUrl,
+                baseUrl + "/downloads",
+                baseUrl + "/addons",
+                baseUrl + "/videos",
+                baseUrl + "/images",
+                baseUrl + "/reviews",
+                baseUrl + "/articles",
+            ];
+        }
+
+        return [url];
+    }
+
+    /// <summary>
+    /// Determines if the URL is a mod detail page that should have all sections fetched.
+    /// Only the mod root (<c>/mods/{slug}</c>) qualifies — subpaths like comments, downloads,
+    /// or tutorials must not trigger the six-section Chromium sweep.
+    /// </summary>
+    private static bool IsModDetailPage(string url)
+    {
+        if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))
+        {
+            return false;
+        }
+
+        // /mods/{slug} optionally with a trailing slash — nothing after the slug.
+        var segments = uri.AbsolutePath.TrimEnd('/').Split('/', StringSplitOptions.RemoveEmptyEntries);
+        return segments.Length == 2 &&
+               segments[0].Equals("mods", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string ExtractDeveloper(IDocument document)
+    {
+        foreach (var el in document.QuerySelectorAll(ModDBParserConstants.DeveloperProfileSelector))
+        {
+            var href = el.GetAttribute("href") ?? string.Empty;
+            if (href.Contains("/register", StringComparison.OrdinalIgnoreCase) ||
+                href.Contains("/login", StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            var text = el.TextContent?.Trim();
+            if (!IsJunkDeveloperName(text))
+            {
+                return text!;
+            }
+        }
+
+        foreach (var el in document.QuerySelectorAll(ModDBParserConstants.DeveloperSelector))
+        {
+            var href = el.GetAttribute("href") ?? string.Empty;
+            if (href.Contains("/register", StringComparison.OrdinalIgnoreCase) ||
+                href.Contains("/login", StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            var text = el.TextContent?.Trim();
+            if (!IsJunkDeveloperName(text))
+            {
+                return text!;
+            }
+        }
+
+        return "Unknown";
+    }
+
+    private static string? ExtractDescription(IDocument document)
+    {
+        var fileDesc = ReadDescriptionFrom(document.QuerySelector(ModDBParserConstants.FileDescriptionSelector)
+            ?? document.QuerySelector("#downloaddescription")
+            ?? document.QuerySelector("#downloadsummary"));
+        if (!IsBreadcrumbOrLocationText(fileDesc))
+        {
+            var extra = document.QuerySelector("#downloaddescription");
+            var summary = document.QuerySelector("#downloadsummary");
+            var parts = new List<string>();
+            var summaryText = ReadDescriptionFrom(summary);
+            var fullText = extra != null && extra != summary ? ReadDescriptionFrom(extra) : null;
+            if (!IsBreadcrumbOrLocationText(summaryText))
+            {
+                parts.Add(summaryText!);
+            }
+
+            if (!IsBreadcrumbOrLocationText(fullText) &&
+                (summaryText == null || fullText!.IndexOf(summaryText, StringComparison.OrdinalIgnoreCase) < 0))
+            {
+                parts.Add(fullText!);
+            }
+
+            if (parts.Count > 0)
+            {
+                return string.Join("\n\n", parts);
+            }
+
+            return fileDesc;
+        }
+
+        var fullDescEl = document.QuerySelector(ModDBParserConstants.FullDescriptionSelector);
+        var fromFull = ReadDescriptionFrom(fullDescEl);
+        if (!IsBreadcrumbOrLocationText(fromFull))
+        {
+            return fromFull;
+        }
+
+        var summaryEl = document.QuerySelector(ModDBParserConstants.SummarySelector);
+        var fromSummary = ReadDescriptionFrom(summaryEl);
+        if (!IsBreadcrumbOrLocationText(fromSummary))
+        {
+            return fromSummary;
+        }
+
+        var metaDesc = document.QuerySelector("meta[name='description'], meta[property='og:description']");
+        var meta = metaDesc?.GetAttribute("content")?.Trim();
+        return IsBreadcrumbOrLocationText(meta) ? null : meta;
+    }
+
+    private static string? ReadDescriptionFrom(IElement? element)
+    {
+        if (element == null)
+        {
+            return null;
+        }
+
+        var paragraphs = element.QuerySelectorAll("p")
+            .Select(p => p.TextContent?.Trim())
+            .Where(t => !string.IsNullOrWhiteSpace(t) && !IsBreadcrumbOrLocationText(t))
+            .ToList();
+
+        if (paragraphs.Count > 0)
+        {
+            return string.Join("\n\n", paragraphs);
+        }
+
+        var text = element.TextContent?.Trim();
+        return string.IsNullOrWhiteSpace(text) ? null : text;
+    }
+
+    /// <summary>
+    /// Internal parsing logic that works with a parsed AngleSharp document.
+    /// </summary>
+    private ParsedWebPage ParseInternal(string url, IDocument document)
+    {
+        var context = ExtractGlobalContext(document);
+        var pageType = DetectPageType(url, document);
+
+        logger.LogDebug("Detected page type: {PageType}", pageType);
+
+        var sections = new List<ContentSection>();
+
+        switch (pageType)
+        {
+            case PageType.List:
+                // Determine if this is an addons list or generic list
+                var sectionType = url.Contains("/addons", StringComparison.OrdinalIgnoreCase)
+                    ? FileSectionType.Addons
+                    : FileSectionType.Downloads;
+                sections.AddRange(ExtractListSections(document, sectionType));
+                break;
+
+            case PageType.Summary:
+                sections.AddRange(ExtractSummarySections(document));
+                break;
+
+            case PageType.Detail:
+                sections.AddRange(ExtractDetailSections(document));
+                break;
+
+            case PageType.FileDetail:
+                sections.AddRange(ExtractFileDetailSections(document));
+                break;
+
+            default:
+                logger.LogWarning("Unknown page type for URL: {Url}", url);
+                break;
+        }
+
+        sections = DeduplicateDownloadableFiles(sections);
+        sections = DeduplicateImages(sections);
+        sections = DeduplicateVideos(sections);
+
+        logger.LogInformation(
+            "Parsed ModDB page: {Url}, Type={PageType}, Sections={SectionCount}",
+            url,
+            pageType,
+            sections.Count);
+
+        return new ParsedWebPage(
+            Url: new Uri(url),
+            Context: context,
+            Sections: sections,
+            PageType: pageType);
+    }
+
+    /// <summary>
+    /// Synchronous internal parsing logic that extracts content from the primary document
+    /// and any pre-fetched section documents (from the single Playwright batch).
+    /// </summary>
+    private ParsedWebPage ParseInternalWithFetched(
+        string url,
+        IDocument document,
+        IReadOnlyDictionary<string, IDocument> fetched)
+    {
+        var context = ExtractGlobalContext(document);
+        var pageType = DetectPageType(url, document);
+
+        logger.LogDebug("Detected page type: {PageType}", pageType);
+
+        var sections = new List<ContentSection>();
+
+        // Special handling for mod detail pages - populate ALL sections
+        if (IsModDetailPage(url) && pageType == PageType.Detail)
+        {
+            logger.LogInformation("Mod detail page detected, parsing all sections (downloads, addons, videos, images, reviews, articles)");
+
+            // Extract non-file content from the main page
+            sections.AddRange(ExtractVideos(document));
+            sections.AddRange(ExtractImages(document));
+            sections.AddRange(ExtractArticles(document));
+            sections.AddRange(ExtractReviews(document));
+            sections.AddRange(ExtractComments(document));
+
+            var baseUrl = url.TrimEnd('/');
+            AppendFetchedSections(sections, baseUrl, fetched);
+        }
+        else if (pageType == PageType.FileDetail)
+        {
+            var file = ExtractDetailedFile(document, url);
+            if (file != null)
+            {
+                sections.Add(file);
+            }
+
+            // Game downloads/addons are discovered as FileDetail URLs under /games/... and never enter
+            // the /mods/ parent sweep below. Pull comments and any inline media from this page so the
+            // detail view is not left with only a single Releases row.
+            AppendOnPageFileDetailSections(sections, document);
+
+            var parentModUrl = ExtractParentModUrl(url);
+            if (!string.IsNullOrEmpty(parentModUrl) && fetched.TryGetValue(parentModUrl, out var parentDoc))
+            {
+                logger.LogInformation("FileDetail page detected, extracted parent mod sections from: {ParentUrl}", parentModUrl);
+
+                var parentContext = ExtractGlobalContext(parentDoc);
+                if (!string.IsNullOrEmpty(parentContext.IconUrl))
+                {
+                    logger.LogInformation("Extracted icon from parent mod: {IconUrl}", parentContext.IconUrl);
+                }
+
+                context = MergeContext(context, parentContext);
+
+                sections.AddRange(ExtractVideos(parentDoc));
+                sections.AddRange(ExtractImages(parentDoc));
+                sections.AddRange(ExtractArticles(parentDoc));
+                sections.AddRange(ExtractReviews(parentDoc));
+                sections.AddRange(ExtractComments(parentDoc));
+
+                var baseUrl = parentModUrl.TrimEnd('/');
+                AppendFetchedSections(sections, baseUrl, fetched);
+            }
+        }
+        else
+        {
+            // Standard page handling
+            switch (pageType)
+            {
+                case PageType.List:
+                    var listSectionType = url.Contains("/addons", StringComparison.OrdinalIgnoreCase)
+                        ? FileSectionType.Addons
+                        : FileSectionType.Downloads;
+                    sections.AddRange(ExtractListSections(document, listSectionType));
+                    break;
+
+                case PageType.Summary:
+                    sections.AddRange(ExtractSummarySections(document));
+                    break;
+
+                case PageType.Detail:
+                    sections.AddRange(ExtractDetailSections(document));
+                    break;
+
+                default:
+                    logger.LogWarning("Unknown page type for URL: {Url}", url);
+                    break;
+            }
+        }
+
+        sections = DeduplicateDownloadableFiles(sections);
+        sections = DeduplicateImages(sections);
+        sections = DeduplicateVideos(sections);
+
+        logger.LogInformation(
+            "Parsed ModDB page: {Url}, Type={PageType}, Sections={SectionCount}",
+            url,
+            pageType,
+            sections.Count);
+
+        return new ParsedWebPage(
+            Url: new Uri(url),
+            Context: context,
+            Sections: sections,
+            PageType: pageType);
+    }
+
+    /// <summary>
+    /// Extracts global context from the page header and profile sidebar.
+    /// </summary>
+    private GlobalContext ExtractGlobalContext(IDocument document)
+    {
+        // 1. Extract title. File pages use h1 "... file" and h2 for the real content name.
+        var h2 = document.QuerySelector("h2 a, h2")?.TextContent?.Trim();
+        var h1 = document.QuerySelector("h1 a, h1")?.TextContent?.Trim();
+        var title = h1 ?? "Unknown";
+        if (!string.IsNullOrWhiteSpace(h2) &&
+            (string.IsNullOrWhiteSpace(h1) ||
+             h1.EndsWith(" file", StringComparison.OrdinalIgnoreCase)))
+        {
+            title = h2;
+        }
+
+        if (string.IsNullOrWhiteSpace(title) || title == "Unknown")
+        {
+            title = document.QuerySelector(".title")?.TextContent?.Trim() ?? "Unknown";
+        }
+
+        // 2. Extract developer — never the header "register" / "sign in" links.
+        var developer = ExtractDeveloper(document);
+
+        // 3. Extract release date
+        DateTime? releaseDate = null;
+        var releaseDateEl = document.QuerySelector(ModDBParserConstants.ReleaseDateSelector);
+        if (releaseDateEl != null)
+        {
+            var dateStr = releaseDateEl.GetAttribute("datetime") ?? releaseDateEl.TextContent?.Trim();
+            if (!string.IsNullOrEmpty(dateStr) && DateTime.TryParse(dateStr, out var parsedDate))
+            {
+                releaseDate = parsedDate;
+            }
+        }
+
+        // 4. Extract icon from profile sidebar
+        var iconEl = document.QuerySelector(ModDBParserConstants.ProfileIconSelector)
+            ?? document.QuerySelector(ModDBParserConstants.IconSelector);
+        var iconUrl = iconEl?.GetAttribute("src");
+        if (!string.IsNullOrEmpty(iconUrl))
+        {
+            if (!iconUrl.StartsWith("http", StringComparison.OrdinalIgnoreCase))
+            {
+                iconUrl = "https:" + iconUrl;
+            }
+
+            if (iconUrl.Contains("error_50x50", StringComparison.OrdinalIgnoreCase) ||
+                iconUrl.Contains("default/error", StringComparison.OrdinalIgnoreCase) ||
+                iconUrl.Contains("blank.gif", StringComparison.OrdinalIgnoreCase) ||
+                iconUrl.Contains("clear.gif", StringComparison.OrdinalIgnoreCase))
+            {
+                iconUrl = null;
+            }
+        }
+
+        // 5. Extract description. File pages put copy in #downloadsummary / #downloaddescription;
+        // the first .summary on those pages is the breadcrumb "Games : ... : Files".
+        var description = ExtractDescription(document);
+
+        // 6. Extract game name
+        var gameNameEl = document.QuerySelector(ModDBParserConstants.GameNameSelector);
+        var gameName = gameNameEl?.TextContent?.Trim();
+
+        logger.LogDebug(
+            "Extracted context: Title={Title}, Developer={Developer}, IconUrl={Icon}, DescriptionLength={DescLen}",
+            title,
+            developer,
+            iconUrl,
+            description?.Length ?? 0);
+
+        return new GlobalContext(
+            Title: title,
+            Developer: developer,
+            ReleaseDate: releaseDate,
+            GameName: gameName,
+            IconUrl: iconUrl,
+            Description: description);
+    }
+
+    /// <summary>
+    /// Extracts the downloadable file plus any Media/Community content already rendered on a
+    /// FileDetail page (comments, inline images, etc.). Game-scoped FileDetail URLs
+    /// (<c>/games/.../downloads/...</c>) never have a parent mod to sweep, so this on-page pass is
+    /// the only way those detail views get Community/Media tabs.
+    /// </summary>
+    private List<ContentSection> ExtractFileDetailSections(IDocument document)
+    {
+        var sections = new List<ContentSection>();
+
+        var file = ExtractDetailedFile(document, document.Url);
+        if (file != null)
+        {
+            sections.Add(file);
+        }
+
+        AppendOnPageFileDetailSections(sections, document);
+        return sections;
+    }
+
+    /// <summary>
+    /// Appends videos, images, articles, reviews, and comments already present on the current
+    /// FileDetail document. Does not navigate to sibling section URLs.
+    /// </summary>
+    private void AppendOnPageFileDetailSections(List<ContentSection> sections, IDocument document)
+    {
+        sections.AddRange(ExtractVideos(document));
+        sections.AddRange(ExtractImages(document));
+        sections.AddRange(ExtractArticles(document));
+        sections.AddRange(ExtractReviews(document));
+        sections.AddRange(ExtractComments(document));
+    }
+
+    /// <summary>
+    /// Maps already-fetched section documents into content sections. Missing keys are soft-failures
+    /// (logged by the Playwright batch fetch); this method only extracts what loaded.
+    /// </summary>
+    private void AppendFetchedSections(
+        List<ContentSection> sections,
+        string baseUrl,
+        IReadOnlyDictionary<string, IDocument> fetched)
+    {
+        TryAppendSection(sections, fetched, baseUrl + "/downloads", "downloads", doc => ExtractFiles(doc, FileSectionType.Downloads));
+        TryAppendSection(sections, fetched, baseUrl + "/addons", "addons", doc => ExtractFiles(doc, FileSectionType.Addons));
+        TryAppendSection(sections, fetched, baseUrl + "/videos", "videos", ExtractVideos);
+        TryAppendSection(sections, fetched, baseUrl + "/images", "images", ExtractImages);
+        TryAppendSection(sections, fetched, baseUrl + "/reviews", "reviews", ExtractReviews);
+        TryAppendSection(sections, fetched, baseUrl + "/articles", "articles", ExtractArticles);
+    }
+
+    private void TryAppendSection(
+        List<ContentSection> sections,
+        IReadOnlyDictionary<string, IDocument> fetched,
+        string sectionUrl,
+        string sectionName,
+        Func<IDocument, IEnumerable<ContentSection>> extract)
+    {
+        if (!fetched.TryGetValue(sectionUrl, out var sectionDoc))
+        {
+            logger.LogWarning("Failed to fetch {Section} section for {Url}", sectionName, sectionUrl);
+            return;
+        }
+
+        var sectionItems = extract(sectionDoc).ToList();
+        sections.AddRange(sectionItems);
+        logger.LogInformation("Found {Count} items in {Section} section", sectionItems.Count, sectionName);
+    }
+
+    /// <summary>
+    /// Extracts detailed file information from a file detail page.
+    /// Parses the metadata table with rows like: Filename, Category, Uploader, Size, MD5 Hash.
+    /// </summary>
+    private DownloadableFile? ExtractDetailedFile(IDocument document, string? pageUrl = null)
+    {
+        var detailsUrl = pageUrl;
+        if (string.IsNullOrEmpty(detailsUrl) && document.Url != null && document.Url.StartsWith("http", StringComparison.OrdinalIgnoreCase))
+        {
+            detailsUrl = document.Url;
+        }
+
+        var metadata = CollectDetailedFileMetadata(document);
+        var filename = metadata.GetValueOrDefault(ModDBParserConstants.MetadataFilename)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataFileNameAlt)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataFileAlt);
+
+        var name = ResolveDetailedFileName(document, filename);
+        var (sizeBytes, sizeDisplay) = ExtractDetailedFileSize(document, metadata);
+        var uploader = metadata.GetValueOrDefault(ModDBParserConstants.MetadataUploader)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataUploadedBy)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataAuthor);
+
+        var category = metadata.GetValueOrDefault(ModDBParserConstants.MetadataCategory)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataFileCategory)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataType);
+
+        var md5Hash = metadata.GetValueOrDefault(ModDBParserConstants.MetadataMd5Hash)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataMd5HashAlt)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataMd5Checksum)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataMd5)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataHash)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataChecksum);
+
+        var (uploadDate, releaseDate) = ExtractDetailedFileDates(metadata);
+        var downloadUrl = ExtractDetailedDownloadUrl(document);
+        var downloadCount = ExtractDetailedDownloadCount(metadata);
+        var description = ExtractDescription(document)
+            ?? document.QuerySelector(ModDBParserConstants.FileDescriptionContainerSelector)?.TextContent?.Trim();
+        var previewImages = ExtractDetailedPreviewImages(document);
+
+        logger.LogInformation(
+            "Extracted file: Name={Name}, Size={Size}, Uploader={Uploader}, DownloadUrl={Url}",
+            name,
+            sizeDisplay,
+            uploader,
+            downloadUrl);
+
+        var sectionType = detailsUrl?.Contains("/addons/", StringComparison.OrdinalIgnoreCase) == true ||
+                          category?.Contains("addon", StringComparison.OrdinalIgnoreCase) == true
+            ? FileSectionType.Addons
+            : FileSectionType.Downloads;
+
+        return new DownloadableFile(
+            Name: name,
+            SizeBytes: sizeBytes,
+            SizeDisplay: sizeDisplay,
+            UploadDate: uploadDate,
+            Category: category,
+            Uploader: uploader,
+            DownloadUrl: downloadUrl,
+            Md5Hash: md5Hash,
+            DownloadCount: downloadCount,
+            FileSectionType: sectionType,
+            ReleaseDate: releaseDate,
+            DetailsUrl: detailsUrl,
+            Description: description,
+            PreviewImages: previewImages.Count > 0 ? previewImages : null,
+            Filename: filename);
+    }
+
+    private Dictionary<string, string> CollectDetailedFileMetadata(IDocument document)
+    {
+        var metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        var containers = document.QuerySelectorAll("#downloadsinfo, .table, table.table, #downloadsfiles, .sidecolumn, #modsinfo, #profile");
+        foreach (var container in containers)
+        {
+            var rows = container.QuerySelectorAll("tr");
+            foreach (var row in rows)
+            {
+                var cells = row.QuerySelectorAll("td, th");
+                if (cells.Length >= 2)
+                {
+                    var key = cells[0].TextContent?.Trim().ToLowerInvariant().Replace(":", string.Empty);
+                    var value = cells[1].TextContent?.Trim();
+                    if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(value))
+                    {
+                        metadata[key] = value;
+                    }
+                }
+            }
+
+            var flexRows = container.QuerySelectorAll(".row.clear, .row, div.heading, dl");
+            foreach (var row in flexRows)
+            {
+                var labelEl = row.QuerySelector("h5, h4, dt, strong, .label, .rowlabel");
+                var label = labelEl?.TextContent?.Trim().ToLowerInvariant().Replace(":", string.Empty);
+                if (string.IsNullOrWhiteSpace(label))
+                {
+                    continue;
+                }
+
+                var valueElement = labelEl?.NextElementSibling
+                    ?? row.QuerySelector("span.summary, dd, time, a, .content, span");
+                var value = valueElement?.TextContent?.Trim();
+                if (!string.IsNullOrWhiteSpace(value))
+                {
+                    metadata[label] = value;
+                }
+            }
+        }
+
+        return metadata;
+    }
+
+    private string ResolveDetailedFileName(IDocument document, string? filename)
+    {
+        string? fileHeading = null;
+        var headingCandidates = document.QuerySelectorAll(ModDBParserConstants.FilePageTitleSelector);
+        foreach (var cand in headingCandidates)
+        {
+            if (cand.Closest(ModDBParserConstants.HeaderBoxSelector) != null)
+            {
+                continue;
+            }
+
+            var text = cand.TextContent?.Trim();
+            if (!string.IsNullOrWhiteSpace(text) && !text.Equals("Unknown", StringComparison.OrdinalIgnoreCase))
+            {
+                fileHeading = text;
+                break;
+            }
+        }
+
+        string? titleTagCandidate = null;
+        var docTitle = document.Title?.Trim();
+        if (!string.IsNullOrWhiteSpace(docTitle))
+        {
+            var match = ModDBPageTitleRegex().Match(docTitle);
+            if (match.Success)
+            {
+                titleTagCandidate = match.Groups["title"].Value.Trim();
+            }
+        }
+
+        var h1Title = document.QuerySelector("h1 a, h1")?.TextContent?.Trim();
+        if (!string.IsNullOrWhiteSpace(h1Title) && h1Title.EndsWith(" file", StringComparison.OrdinalIgnoreCase))
+        {
+            h1Title = h1Title[..^5].Trim();
+        }
+
+        var humanName = fileHeading
+            ?? titleTagCandidate
+            ?? (!string.IsNullOrWhiteSpace(h1Title) && !h1Title.Equals("Unknown", StringComparison.OrdinalIgnoreCase) ? h1Title : null)
+            ?? document.QuerySelector(ModDBParserConstants.FallbackTitleSelector)?.TextContent?.Trim();
+
+        return humanName ?? filename ?? "Unknown";
+    }
+
+    private (long? SizeBytes, string? SizeDisplay) ExtractDetailedFileSize(IDocument document, Dictionary<string, string> metadata)
+    {
+        string? sizeDisplay = metadata.GetValueOrDefault(ModDBParserConstants.MetadataSize)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataFileSizeAlt);
+        long? sizeBytes = null;
+
+        if (!string.IsNullOrEmpty(sizeDisplay))
+        {
+            if (sizeDisplay.Contains("bytes", StringComparison.OrdinalIgnoreCase) &&
+                sizeDisplay.Contains('(') && sizeDisplay.Contains(')'))
+            {
+                var bytesPart = sizeDisplay.Split('(').LastOrDefault()?.Replace("bytes)", string.Empty).Replace(",", string.Empty).Trim();
+                if (long.TryParse(bytesPart, out var bytesVal))
+                {
+                    sizeBytes = bytesVal;
+                }
+            }
+
+            sizeBytes ??= ParseFileSize(sizeDisplay);
+        }
+
+        if (string.IsNullOrEmpty(sizeDisplay))
+        {
+            var downloadButton = document.QuerySelector(ModDBParserConstants.MainDownloadButtonSelector);
+            sizeDisplay = downloadButton?.TextContent?.Trim();
+            if (!string.IsNullOrEmpty(sizeDisplay))
+            {
+                sizeBytes = ParseFileSize(sizeDisplay);
+            }
+        }
+
+        return (sizeBytes, sizeDisplay);
+    }
+
+    private (DateTime? UploadDate, DateTime? ReleaseDate) ExtractDetailedFileDates(Dictionary<string, string> metadata)
+    {
+        DateTime? uploadDate = null;
+        DateTime? releaseDate = null;
+        var addedStr = metadata.GetValueOrDefault(ModDBParserConstants.MetadataAdded)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataUpdated);
+
+        if (!string.IsNullOrEmpty(addedStr))
+        {
+            if (DateTime.TryParse(addedStr, out var parsedDate))
+            {
+                uploadDate = parsedDate;
+                releaseDate = parsedDate;
+            }
+            else
+            {
+                var modDBDate = ParseModDBDate(addedStr);
+                if (modDBDate.HasValue)
+                {
+                    uploadDate = modDBDate;
+                    releaseDate = modDBDate;
+                }
+            }
+        }
+
+        return (uploadDate, releaseDate);
+    }
+
+    private string? ExtractDetailedDownloadUrl(IDocument document)
+    {
+        var downloadButton = document.QuerySelector(ModDBParserConstants.MainDownloadButtonSelector);
+        if (downloadButton != null)
+        {
+            var href = downloadButton.GetAttribute("href");
+            if (!string.IsNullOrEmpty(href))
+            {
+                return ToAbsoluteUrl(href);
+            }
+        }
+
+        return null;
+    }
+
+    private int? ExtractDetailedDownloadCount(Dictionary<string, string> metadata)
+    {
+        var downloadsStr = metadata.GetValueOrDefault(ModDBParserConstants.MetadataTotalDownloads)
+            ?? metadata.GetValueOrDefault(ModDBParserConstants.MetadataDownloadCount)
+            ?? metadata.GetValueOrDefault("downloads");
+
+        if (!string.IsNullOrEmpty(downloadsStr))
+        {
+            var numberMatch = System.Text.RegularExpressions.Regex.Match(downloadsStr, @"[\d,]+");
+            if (numberMatch.Success && int.TryParse(numberMatch.Value.Replace(",", string.Empty), out var parsedDl))
+            {
+                return parsedDl;
+            }
+        }
+
+        return null;
+    }
+
+    private List<string> ExtractDetailedPreviewImages(IDocument document)
+    {
+        var previewImages = new List<string>();
+        var imageEls = document.QuerySelectorAll(ModDBParserConstants.FilePreviewImagesSelector);
+        foreach (var img in imageEls)
+        {
+            var src = img.GetAttribute("src") ?? img.GetAttribute("data-src");
+            if (string.IsNullOrWhiteSpace(src) ||
+                src.StartsWith("data:", StringComparison.OrdinalIgnoreCase) ||
+                src.Contains("blank.gif", StringComparison.OrdinalIgnoreCase) ||
+                src.Contains("clear.gif", StringComparison.OrdinalIgnoreCase) ||
+                src.Contains("guest", StringComparison.OrdinalIgnoreCase) ||
+                src.Contains("/avatar/", StringComparison.OrdinalIgnoreCase) ||
+                src.Contains("button", StringComparison.OrdinalIgnoreCase) ||
+                src.Contains("icon.gif", StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            var fullUrl = ToAbsoluteUrl(src);
+            var parentAnchor = img.Closest("a");
+            var anchorHref = parentAnchor?.GetAttribute("href");
+            if (!string.IsNullOrWhiteSpace(anchorHref))
+            {
+                var absAnchor = ToAbsoluteUrl(anchorHref);
+                var isDirectImage = absAnchor.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) ||
+                                    absAnchor.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ||
+                                    absAnchor.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase) ||
+                                    absAnchor.EndsWith(".webp", StringComparison.OrdinalIgnoreCase);
+
+                fullUrl = isDirectImage ? absAnchor : GetFullSizeModDBImageSource(fullUrl);
+            }
+            else
+            {
+                fullUrl = GetFullSizeModDBImageSource(fullUrl);
+            }
+
+            if (!previewImages.Contains(fullUrl))
+            {
+                previewImages.Add(fullUrl);
+            }
+        }
+
+        return previewImages;
+    }
+}
diff --git a/GenHub/GenHub/Features/Content/Services/Tools/ManagedChromiumRuntime.cs b/GenHub/GenHub/Features/Content/Services/Tools/ManagedChromiumRuntime.cs
new file mode 100644
index 000000000..a8034bac7
--- /dev/null
+++ b/GenHub/GenHub/Features/Content/Services/Tools/ManagedChromiumRuntime.cs
@@ -0,0 +1,193 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.Playwright;
+
+namespace GenHub.Features.Content.Services.Tools;
+
+/// <summary>
+/// Owns the app-local Playwright Chromium runtime. Playwright's NuGet package supplies the
+/// driver but deliberately does not ship browser binaries, so GenHub provisions Chromium under
+/// its application-data directory instead of relying on a system browser installation.
+/// System Chrome/Edge cannot satisfy this requirement — Playwright needs its own patched build.
+/// </summary>
+internal sealed class ManagedChromiumRuntime(
+    string runtimeDirectory,
+    Func<string[], int> installer,
+    Func<string, Task<bool>> requestInstallConsentAsync,
+    ILogger logger)
+{
+    /// <summary>
+    /// Environment variable used by Playwright to locate app-owned browser binaries.
+    /// </summary>
+    internal const string BrowserPathEnvironmentVariable = "PLAYWRIGHT_BROWSERS_PATH";
+
+    /// <summary>
+    /// Environment variable used by Playwright to locate its driver binary (node.exe).
+    /// </summary>
+    internal const string DriverPathEnvironmentVariable = "PLAYWRIGHT_DRIVER_PATH";
+
+    /// <summary>
+    /// Configures Playwright to resolve browsers only from GenHub's managed runtime directory.
+    /// </summary>
+    public void ConfigureEnvironment()
+    {
+        Directory.CreateDirectory(runtimeDirectory);
+        Environment.SetEnvironmentVariable(BrowserPathEnvironmentVariable, runtimeDirectory);
+        EnsureDriverEnvironmentVariable();
+    }
+
+    /// <summary>
+    /// Installs Chromium exactly once when the app-owned executable is unavailable,
+    /// after the user confirms the download via the standard confirmation dialog.
+    /// </summary>
+    /// <param name="chromium">The Playwright Chromium browser type.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A task representing the asynchronous provisioning operation.</returns>
+    /// <exception cref="OperationCanceledException">Thrown when the user declines installation.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when Chromium could not be provisioned.</exception>
+    public async Task EnsureInstalledAsync(IBrowserType chromium, CancellationToken cancellationToken)
+    {
+        ConfigureEnvironment();
+
+        if (File.Exists(chromium.ExecutablePath))
+        {
+            return;
+        }
+
+        logger.LogInformation(
+            "Managed Chromium is missing. Requesting user consent before installing under {RuntimeDirectory}",
+            runtimeDirectory);
+
+        var consented = await requestInstallConsentAsync(runtimeDirectory);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (!consented)
+        {
+            logger.LogInformation("User declined managed Chromium installation under {RuntimeDirectory}", runtimeDirectory);
+            throw new OperationCanceledException(
+                "ModDB requires GenHub's managed Chromium runtime. Installation was cancelled.");
+        }
+
+        logger.LogInformation("Managed Chromium install consented. Installing under {RuntimeDirectory}", runtimeDirectory);
+
+        int exitCode = 0;
+        try
+        {
+            exitCode = await Task.Run(
+                () =>
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    return installer(["install", "chromium"]);
+                },
+                cancellationToken);
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException(
+                "GenHub could not install its managed Chromium runtime. Check the network connection and try the ModDB action again.",
+                ex);
+        }
+
+        cancellationToken.ThrowIfCancellationRequested();
+        if (exitCode != 0 || !File.Exists(chromium.ExecutablePath))
+        {
+            throw new InvalidOperationException(
+                "GenHub could not install its managed Chromium runtime. Check the network connection and try the ModDB action again.");
+        }
+
+        logger.LogInformation("Managed Chromium installation completed in {RuntimeDirectory}", runtimeDirectory);
+    }
+
+    private static string GetPlatformFolder()
+    {
+        if (OperatingSystem.IsWindows())
+        {
+            return "win32_x64";
+        }
+
+        if (OperatingSystem.IsLinux())
+        {
+            return System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture == System.Runtime.InteropServices.Architecture.Arm64
+                ? "linux-arm64"
+                : "linux-x64";
+        }
+
+        if (OperatingSystem.IsMacOS())
+        {
+            return System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture == System.Runtime.InteropServices.Architecture.Arm64
+                ? "darwin-arm64"
+                : "darwin-x64";
+        }
+
+        return "win32_x64";
+    }
+
+    private static string? _cachedDriverPath;
+
+    private void EnsureDriverEnvironmentVariable()
+    {
+        if (!string.IsNullOrWhiteSpace(_cachedDriverPath) && File.Exists(_cachedDriverPath))
+        {
+            Environment.SetEnvironmentVariable(DriverPathEnvironmentVariable, _cachedDriverPath);
+            return;
+        }
+
+        var existingDriverPath = Environment.GetEnvironmentVariable(DriverPathEnvironmentVariable);
+        if (!string.IsNullOrWhiteSpace(existingDriverPath) && File.Exists(existingDriverPath))
+        {
+            _cachedDriverPath = existingDriverPath;
+            return;
+        }
+
+        var platformFolder = GetPlatformFolder();
+        var nodeBinaryName = OperatingSystem.IsWindows() ? "node.exe" : "node";
+
+        var searchDirectories = new[]
+        {
+            AppContext.BaseDirectory,
+            AppDomain.CurrentDomain.BaseDirectory,
+            Path.GetDirectoryName(typeof(ManagedChromiumRuntime).Assembly.Location) ?? string.Empty,
+            Path.GetDirectoryName(Environment.ProcessPath) ?? string.Empty,
+        };
+
+        foreach (var dir in searchDirectories)
+        {
+            if (string.IsNullOrWhiteSpace(dir) || !Directory.Exists(dir))
+            {
+                continue;
+            }
+
+            var candidate = Path.Combine(dir, ".playwright", "node", platformFolder, nodeBinaryName);
+            if (File.Exists(candidate))
+            {
+                _cachedDriverPath = candidate;
+                Environment.SetEnvironmentVariable(DriverPathEnvironmentVariable, candidate);
+                logger.LogInformation("Resolved Playwright driver path: {DriverPath}", candidate);
+                return;
+            }
+
+            var current = new DirectoryInfo(dir);
+            for (var depth = 0; depth < 4 && current?.Parent != null; depth++)
+            {
+                current = current.Parent;
+                candidate = Path.Combine(current.FullName, ".playwright", "node", platformFolder, nodeBinaryName);
+                if (File.Exists(candidate))
+                {
+                    _cachedDriverPath = candidate;
+                    Environment.SetEnvironmentVariable(DriverPathEnvironmentVariable, candidate);
+                    logger.LogInformation("Resolved Playwright driver path from parent directory: {DriverPath}", candidate);
+                    return;
+                }
+            }
+        }
+
+        logger.LogWarning("Could not resolve Playwright driver node executable in any standard directory");
+    }
+}
diff --git a/GenHub/GenHub/Features/Content/Services/Tools/PlaywrightService.cs b/GenHub/GenHub/Features/Content/Services/Tools/PlaywrightService.cs
new file mode 100644
index 000000000..b88b754bf
--- /dev/null
+++ b/GenHub/GenHub/Features/Content/Services/Tools/PlaywrightService.cs
@@ -0,0 +1,1372 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using AngleSharp;
+using AngleSharp.Dom;
+using Avalonia.Threading;
+using GenHub.Core.Constants;
+using GenHub.Core.Interfaces.Common;
+using GenHub.Core.Interfaces.Notifications;
+using GenHub.Core.Interfaces.Tools;
+using GenHub.Core.Models.Results;
+using Microsoft.Extensions.Logging;
+using Microsoft.Playwright;
+
+namespace GenHub.Features.Content.Services.Tools;
+
+/// <summary>
+/// Service for managing Playwright browser instances and fetching web content.
+/// Provides shared browser resources across the application.
+/// </summary>
+/// <remarks>
+/// Initializes a new instance of the <see cref="PlaywrightService"/> class.
+/// </remarks>
+/// <param name="logger">Logger instance.</param>
+/// <param name="configurationProvider">Application configuration provider.</param>
+/// <param name="dialogService">Dialog service used to confirm managed Chromium installation.</param>
+/// <param name="notificationService">Optional notifications shown before a headed browser window opens.</param>
+public class PlaywrightService(
+    ILogger<PlaywrightService> logger,
+    IConfigurationProviderService configurationProvider,
+    IDialogService dialogService,
+    INotificationService? notificationService = null) : IPlaywrightService, IDisposable, IAsyncDisposable
+{
+    private static readonly SemaphoreSlim _browserLock = new(1, 1);
+    private static readonly SemaphoreSlim _persistentLock = new(1, 1);
+    private static readonly SemaphoreSlim _playwrightLock = new(1, 1);
+
+    /// <summary>
+    /// Serializes all headed persistent-profile operations (single fetch, multi-URL sweep, ModDB
+    /// download).
+    /// </summary>
+    private static readonly SemaphoreSlim _persistentFetchLock = new(1, 1);
+    private static readonly AsyncLocal<bool> _isInPersistentSession = new();
+    private static readonly HashSet<IPage> _inUsePersistentPages = [];
+    private static readonly HashSet<string> UnsafeExtraHeaders = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "Connection",
+        "Content-Length",
+        "Cookie",
+        "Host",
+        "Proxy-Connection",
+        "Transfer-Encoding",
+        "Upgrade",
+    };
+
+    private static IPlaywright? _playwright;
+    private static IBrowser? _browser;
+    private static IBrowserContext? _persistentContext;
+    private static string? _persistentProfileName;
+    private static int _activePersistentSessions;
+
+    private ManagedChromiumRuntime? managedChromiumRuntime;
+
+    private bool _disposed;
+
+    /// <inheritdoc />
+    public async Task<IPage> CreatePageAsync(BrowserNewContextOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        await EnsurePlaywrightInitializedAsync(cancellationToken);
+
+        if (_browser == null)
+        {
+            throw new InvalidOperationException("Browser not initialized");
+        }
+
+        var contextOptions = options ?? new BrowserNewContextOptions
+        {
+            UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            ViewportSize = new ViewportSize { Width = 1366, Height = 768 },
+            Locale = "en-US",
+        };
+
+        var context = await _browser.NewContextAsync(contextOptions);
+
+        try
+        {
+            return await context.NewPageAsync();
+        }
+        catch
+        {
+            try
+            {
+                await context.CloseAsync();
+            }
+            catch (PlaywrightException)
+            {
+            }
+
+            throw;
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<IPage> CreatePersistentPageAsync(string profileName, CancellationToken cancellationToken = default)
+    {
+        var profileDir = Path.Combine(
+            configurationProvider.GetApplicationDataPath(),
+            DirectoryNames.BrowserProfiles,
+            profileName);
+
+        // Closing the last page of a headed persistent context also terminates its browser process,
+        // leaving the cached _persistentContext pointing at a dead channel. Detect that up front so
+        // the first operation after a previous page-close relaunches the profile instead of throwing
+        // TargetClosedException deep inside EnsurePersistentContextAsync/NewPageAsync.
+        await EnsurePersistentContextAsync(profileDir, cancellationToken);
+
+        if (_persistentContext == null)
+        {
+            throw new InvalidOperationException("Persistent browser context not initialized");
+        }
+
+        return await CreatePersistentPageWithRecoveryAsync(profileDir, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task ClosePersistentPageAsync(IPage page, bool keepOpen = false)
+    {
+        ArgumentNullException.ThrowIfNull(page);
+
+        if (keepOpen)
+        {
+            return;
+        }
+
+        await _persistentLock.WaitAsync();
+        try
+        {
+            _inUsePersistentPages.Remove(page);
+
+            if (_persistentContext != null && IsPersistentContextAlive())
+            {
+                try
+                {
+                    var otherPages = _persistentContext.Pages.Where(p => !p.IsClosed && p != page).ToList();
+
+                    if (_activePersistentSessions > 0)
+                    {
+                        // inside an active session: if this is the last page, navigate to about:blank
+                        // so chromium remains alive for subsequent steps within the session.
+                        if (otherPages.Count == 0 && _inUsePersistentPages.Count == 0)
+                        {
+                            if (!page.IsClosed)
+                            {
+                                try
+                                {
+                                    await page.GotoAsync("about:blank");
+                                }
+                                catch (PlaywrightException)
+                                {
+                                }
+                            }
+                        }
+                        else if (!page.IsClosed)
+                        {
+                            try
+                            {
+                                await page.CloseAsync();
+                            }
+                            catch (PlaywrightException ex)
+                            {
+                                logger.LogDebug(ex, "Persistent page already closed during cleanup.");
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // outside an active session: close page and immediately shut down persistent context
+                        // once all active pages finish.
+                        if (!page.IsClosed)
+                        {
+                            try
+                            {
+                                await page.CloseAsync();
+                            }
+                            catch (PlaywrightException ex)
+                            {
+                                logger.LogDebug(ex, "Persistent page already closed during cleanup.");
+                            }
+                        }
+
+                        if (_inUsePersistentPages.Count == 0)
+                        {
+                            await ClosePersistentContextCoreUnderLockAsync();
+                        }
+                    }
+                }
+                catch (PlaywrightException ex) when (IsContextClosedError(ex))
+                {
+                    _inUsePersistentPages.Clear();
+                    _persistentContext = null;
+                    _persistentProfileName = null;
+                }
+                catch (Exception ex)
+                {
+                    logger.LogDebug(ex, "Failed to inspect persistent context after page close.");
+                    _inUsePersistentPages.Clear();
+                    _persistentContext = null;
+                    _persistentProfileName = null;
+                }
+            }
+            else
+            {
+                if (!page.IsClosed)
+                {
+                    try
+                    {
+                        await page.CloseAsync();
+                    }
+                    catch (PlaywrightException)
+                    {
+                    }
+                }
+            }
+        }
+        finally
+        {
+            _persistentLock.Release();
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<string> FetchHtmlAsync(string url, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            logger.LogDebug("Fetching HTML from {Url}", url);
+
+            var page = await CreatePageAsync(cancellationToken: cancellationToken);
+            try
+            {
+                await page.GotoAsync(url, new PageGotoOptions
+                {
+                    Timeout = 30000,
+                    WaitUntil = WaitUntilState.DOMContentLoaded,
+                });
+
+                // Wait a bit for dynamic content to load
+                await Task.Delay(500, cancellationToken);
+
+                return await page.ContentAsync();
+            }
+            finally
+            {
+                var context = page.Context;
+                try
+                {
+                    await page.CloseAsync();
+                }
+                finally
+                {
+                    if (context != null)
+                    {
+                        await context.CloseAsync();
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to fetch HTML from {Url}", url);
+            throw;
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<IDocument> FetchAndParseAsync(string url, CancellationToken cancellationToken = default)
+    {
+        var html = await FetchHtmlAsync(url, cancellationToken);
+        var browsingContext = BrowsingContext.New(Configuration.Default);
+        return await browsingContext.OpenAsync(req => req.Content(html), cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task<IDocument> FetchAndParsePersistentAsync(string profileName, string url, CancellationToken cancellationToken = default)
+    {
+        var html = await FetchPersistentHtmlAsync(profileName, url, cancellationToken);
+        return await OpenDocumentAsync(html, cancellationToken);
+    }
+
+    /// <summary>
+    /// Executes an operation within a scoped persistent browser context session.
+    /// </summary>
+    /// <typeparam name="T">The return type of the operation.</typeparam>
+    /// <param name="profileName">The on-disk profile name.</param>
+    /// <param name="operation">The asynchronous operation to execute.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The result of the operation.</returns>
+    public async Task<T> ExecuteInPersistentContextAsync<T>(
+        string profileName,
+        Func<Task<T>> operation,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(operation);
+
+        var profileDir = Path.Combine(
+            configurationProvider.GetApplicationDataPath(),
+            DirectoryNames.BrowserProfiles,
+            profileName);
+
+        var isOuterSession = !_isInPersistentSession.Value;
+        if (isOuterSession)
+        {
+            await _persistentFetchLock.WaitAsync(cancellationToken);
+            _isInPersistentSession.Value = true;
+        }
+
+        try
+        {
+            Interlocked.Increment(ref _activePersistentSessions);
+            try
+            {
+                await EnsurePersistentContextAsync(profileDir, cancellationToken);
+                return await operation();
+            }
+            finally
+            {
+                if (Interlocked.Decrement(ref _activePersistentSessions) == 0)
+                {
+                    await ClosePersistentContextCoreAsync();
+                }
+            }
+        }
+        finally
+        {
+            if (isOuterSession)
+            {
+                _isInPersistentSession.Value = false;
+                _persistentFetchLock.Release();
+            }
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyDictionary<string, IDocument>> FetchAndParsePersistentManyAsync(
+        string profileName,
+        IReadOnlyList<string> urls,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(urls);
+
+        var results = new Dictionary<string, IDocument>(StringComparer.Ordinal);
+        if (urls.Count == 0)
+        {
+            return results;
+        }
+
+        // Preserve caller order while skipping duplicate URLs (section sweeps sometimes repeat a path).
+        var orderedUnique = new List<string>(urls.Count);
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var url in urls)
+        {
+            if (string.IsNullOrWhiteSpace(url) || !seen.Add(url))
+            {
+                continue;
+            }
+
+            orderedUnique.Add(url);
+        }
+
+        if (orderedUnique.Count == 0)
+        {
+            return results;
+        }
+
+        var isOuterSession = !_isInPersistentSession.Value;
+        if (isOuterSession)
+        {
+            await _persistentFetchLock.WaitAsync(cancellationToken);
+            _isInPersistentSession.Value = true;
+        }
+
+        try
+        {
+            logger.LogDebug(
+                "Fetching {Count} URL(s) in parallel on persistent context (profile '{Profile}')",
+                orderedUnique.Count,
+                profileName);
+
+            var profileDir = Path.Combine(
+                configurationProvider.GetApplicationDataPath(),
+                DirectoryNames.BrowserProfiles,
+                profileName);
+
+            await EnsurePersistentContextAsync(profileDir, cancellationToken);
+            if (_persistentContext == null)
+            {
+                throw new InvalidOperationException("Persistent browser context not initialized");
+            }
+
+            var concurrentResults = new System.Collections.Concurrent.ConcurrentDictionary<string, IDocument>(StringComparer.Ordinal);
+
+            // Limit parallel tabs to avoid overwhelming system resources (max 5 parallel tabs)
+            using var tabSemaphore = new SemaphoreSlim(Math.Min(orderedUnique.Count, 5));
+
+            var tasks = orderedUnique.Select(async url =>
+            {
+                await tabSemaphore.WaitAsync(cancellationToken);
+                IPage? page = null;
+                try
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+
+                    page = await CreatePersistentPageAsync(profileName, cancellationToken);
+
+                    var html = await NavigatePersistentPageAsync(page, url, cancellationToken);
+                    var doc = await OpenDocumentAsync(html, cancellationToken);
+                    concurrentResults[url] = doc;
+                }
+                catch (Exception ex) when (ex is not OperationCanceledException)
+                {
+                    // Soft-fail per URL so one dead section does not abort the rest of the sweep.
+                    logger.LogWarning(ex, "Failed to fetch persistent URL in parallel batch: {Url}", url);
+                }
+                finally
+                {
+                    if (page != null)
+                    {
+                        await ClosePersistentPageAsync(page);
+                    }
+
+                    tabSemaphore.Release();
+                }
+            });
+
+            await Task.WhenAll(tasks);
+
+            foreach (var kvp in concurrentResults)
+            {
+                results[kvp.Key] = kvp.Value;
+            }
+        }
+        finally
+        {
+            if (isOuterSession)
+            {
+                if (_activePersistentSessions == 0 && _inUsePersistentPages.Count == 0)
+                {
+                    await ClosePersistentContextCoreAsync();
+                }
+
+                _isInPersistentSession.Value = false;
+                _persistentFetchLock.Release();
+            }
+        }
+
+        return results;
+    }
+
+    /// <inheritdoc />
+    public async Task WarmupAsync(CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await EnsureManagedPlaywrightAsync(cancellationToken);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            logger.LogDebug(ex, "Background Playwright warmup did not complete.");
+        }
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        Task.Run(() => DisposeAsync().AsTask()).GetAwaiter().GetResult();
+    }
+
+    /// <inheritdoc />
+    public async ValueTask DisposeAsync()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (_persistentContext != null)
+        {
+            try
+            {
+                await _persistentContext.CloseAsync();
+            }
+            catch
+            {
+            }
+            finally
+            {
+                _inUsePersistentPages.Clear();
+                _persistentContext = null;
+                _persistentProfileName = null;
+            }
+        }
+
+        if (_browser != null)
+        {
+            await _browser.CloseAsync();
+            _browser = null;
+        }
+
+        if (_playwright != null)
+        {
+            _playwright.Dispose();
+            _playwright = null;
+        }
+
+        _disposed = true;
+    }
+
+    /// <inheritdoc />
+    public async Task<DownloadResult> DownloadFileAsync(GenHub.Core.Models.Common.DownloadConfiguration configuration, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            logger.LogInformation("Starting Playwright download from {Url}", configuration.Url);
+            var stopwatch = System.Diagnostics.Stopwatch.StartNew();
+
+            var usePersistentModDbProfile = configuration.Url.Host.Equals("moddb.com", StringComparison.OrdinalIgnoreCase) ||
+                                            configuration.Url.Host.EndsWith(".moddb.com", StringComparison.OrdinalIgnoreCase);
+
+            // Headed ModDB profile is shared with FetchPersistentHtmlAsync / multi-URL sweeps —
+            // serialize so a download cannot relaunch Chromium while a section page is mid-Goto.
+            var isOuterSession = usePersistentModDbProfile && !_isInPersistentSession.Value;
+            if (isOuterSession)
+            {
+                await _persistentFetchLock.WaitAsync(cancellationToken);
+                _isInPersistentSession.Value = true;
+            }
+
+            try
+            {
+                return await DownloadFileCoreAsync(configuration, usePersistentModDbProfile, stopwatch, cancellationToken);
+            }
+            finally
+            {
+                if (isOuterSession)
+                {
+                    if (_activePersistentSessions == 0 && _inUsePersistentPages.Count == 0)
+                    {
+                        await ClosePersistentContextCoreAsync();
+                    }
+
+                    _isInPersistentSession.Value = false;
+                    _persistentFetchLock.Release();
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Playwright download failed for {Url}", configuration.Url);
+            var message = ex.Message.Contains("Executable doesn't exist", StringComparison.OrdinalIgnoreCase)
+                ? "The bundled Chromium runtime is unavailable. Install the application browser runtime and retry the ModDB download."
+                : ex.Message;
+            return DownloadResult.CreateFailure(message, bytesDownloaded: 0, elapsed: TimeSpan.Zero);
+        }
+    }
+
+    /// <summary>
+    /// Builds browser-safe request headers from a download configuration. Headers which Chromium
+    /// owns itself are ignored, while site-required headers such as <c>Referer</c> are preserved.
+    /// </summary>
+    /// <param name="configuration">Download configuration containing optional request headers.</param>
+    /// <returns>Headers safe to apply to a Playwright page.</returns>
+    internal static IReadOnlyDictionary<string, string> BuildSafeDownloadHeaders(
+        GenHub.Core.Models.Common.DownloadConfiguration configuration)
+    {
+        ArgumentNullException.ThrowIfNull(configuration);
+
+        Dictionary<string, string> headers = new(StringComparer.OrdinalIgnoreCase);
+        foreach (var (name, value) in configuration.Headers)
+        {
+            if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(value) || UnsafeExtraHeaders.Contains(name))
+            {
+                continue;
+            }
+
+            headers[name] = value;
+        }
+
+        if (!string.IsNullOrWhiteSpace(configuration.UserAgent) && !headers.ContainsKey("User-Agent"))
+        {
+            headers["User-Agent"] = configuration.UserAgent;
+        }
+
+        return headers;
+    }
+
+    /// <summary>
+    /// Determines whether a Playwright exception represents a transient navigation or closed-target
+    /// condition that a polling loop can safely retry (Cloudflare interstitial redirecting to the
+    /// real document, a frame detaching mid-probe, or the persistent context dying between pages).
+    /// Shared with <see cref="ContentDiscoverers.ModDBDiscoverer"/> for its listing-wait loop.
+    /// </summary>
+    /// <param name="ex">The Playwright exception to classify.</param>
+    /// <returns><see langword="true"/> if the caller should retry rather than propagate.</returns>
+    internal static bool IsContextClosedError(PlaywrightException ex) =>
+        ex.Message.Contains("Target page, context or browser has been closed", StringComparison.OrdinalIgnoreCase) ||
+        ex.Message.Contains("Browser has been closed", StringComparison.OrdinalIgnoreCase) ||
+        ex.Message.Contains("Target closed", StringComparison.OrdinalIgnoreCase) ||
+        ex.Message.Contains("Execution context was destroyed", StringComparison.OrdinalIgnoreCase) ||
+        ex.Message.Contains("Target frame was detached", StringComparison.OrdinalIgnoreCase) ||
+        ex.Message.Contains("Target.createTarget", StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// A persistent context is only reusable while it is live and still owns at least one open
+    /// page. A headed Chromium process exits once its final page closes, after which the cached
+    /// IBrowserContext reference throws on every call. Touching <see cref="IBrowserContext.Pages"/>
+    /// is the cheapest probe: it fails on a dead channel and succeeds on a live one.
+    /// </summary>
+    private static bool IsPersistentContextAlive()
+    {
+        if (_persistentContext == null)
+        {
+            return false;
+        }
+
+        try
+        {
+            // Any property/method round-trip to the dead channel raises TargetClosedException.
+            _ = _persistentContext.Pages;
+            return true;
+        }
+        catch (PlaywrightException ex) when (IsContextClosedError(ex))
+        {
+            return false;
+        }
+    }
+
+    private static bool IsBlankStartupUrl(string url) =>
+        string.IsNullOrWhiteSpace(url) ||
+        url.Equals("about:blank", StringComparison.OrdinalIgnoreCase) ||
+        url.StartsWith("chrome://newtab", StringComparison.OrdinalIgnoreCase) ||
+        url.StartsWith("chrome://new-tab", StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Clears a closed persistent browser context so the next request launches a fresh one.
+    /// </summary>
+    private static async Task InvalidatePersistentContextAsync()
+    {
+        await _persistentLock.WaitAsync();
+        try
+        {
+            _inUsePersistentPages.Clear();
+            _persistentContext = null;
+            _persistentProfileName = null;
+        }
+        finally
+        {
+            _persistentLock.Release();
+        }
+    }
+
+    /// <summary>
+    /// Closes the persistent browser context when called under _persistentLock.
+    /// </summary>
+    private static async Task ClosePersistentContextCoreUnderLockAsync()
+    {
+        if (_persistentContext != null)
+        {
+            try
+            {
+                var nonClosedPages = _persistentContext.Pages.Where(p => !p.IsClosed).ToList();
+                foreach (var page in nonClosedPages)
+                {
+                    try
+                    {
+                        await page.CloseAsync();
+                    }
+                    catch (PlaywrightException)
+                    {
+                    }
+                }
+
+                await _persistentContext.CloseAsync();
+            }
+            catch (PlaywrightException)
+            {
+            }
+            finally
+            {
+                _inUsePersistentPages.Clear();
+                _persistentContext = null;
+                _persistentProfileName = null;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Closes the persistent browser context and acquires _persistentLock.
+    /// </summary>
+    private static async Task ClosePersistentContextCoreAsync()
+    {
+        await _persistentLock.WaitAsync();
+        try
+        {
+            await ClosePersistentContextCoreUnderLockAsync();
+        }
+        finally
+        {
+            _persistentLock.Release();
+        }
+    }
+
+    private static bool IsModDbVerificationPage(string? title) =>
+        !string.IsNullOrWhiteSpace(title) &&
+        (title.Contains("Just a moment", StringComparison.OrdinalIgnoreCase) ||
+         title.Contains("Attention Required", StringComparison.OrdinalIgnoreCase) ||
+         title.Contains("Checking your browser", StringComparison.OrdinalIgnoreCase) ||
+         title.Contains("Verify you are human", StringComparison.OrdinalIgnoreCase) ||
+         title.Contains("Cloudflare", StringComparison.OrdinalIgnoreCase));
+
+    private static async Task<IDocument> OpenDocumentAsync(string html, CancellationToken cancellationToken)
+    {
+        var browsingContext = BrowsingContext.New(Configuration.Default);
+        return await browsingContext.OpenAsync(req => req.Content(html), cancellationToken);
+    }
+
+    private async Task<DownloadResult> DownloadFileCoreAsync(
+        GenHub.Core.Models.Common.DownloadConfiguration configuration,
+        bool usePersistentModDbProfile,
+        System.Diagnostics.Stopwatch stopwatch,
+        CancellationToken cancellationToken)
+    {
+        var page = usePersistentModDbProfile
+            ? await CreatePersistentPageAsync(ModDBConstants.BrowserProfileName, cancellationToken)
+            : await CreatePageAsync(cancellationToken: cancellationToken);
+
+        List<IPage> popups = [];
+        var downloadTcs = new TaskCompletionSource<IDownload>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        void OnDownload(object? sender, IDownload download) => downloadTcs.TrySetResult(download);
+        void OnPopup(object? sender, IPage popup)
+        {
+            popups.Add(popup);
+            popup.Download += OnDownload;
+        }
+
+        try
+        {
+            var requestHeaders = BuildSafeDownloadHeaders(configuration);
+            if (requestHeaders.Count > 0)
+            {
+                await page.SetExtraHTTPHeadersAsync(requestHeaders);
+            }
+
+            if (usePersistentModDbProfile)
+            {
+                logger.LogInformation("Using persistent ModDB browser profile for protected download {Url}", configuration.Url);
+                NotifyBrowserWindowOpening(
+                    "ModDB download starting",
+                    "A browser window is opening to download this file. Wait for the download to finish and do not click anything in that window.");
+            }
+
+            // ModDB frequently hands the actual binary off to a new tab/popup rather than the page
+            // that performed the navigation. A page-level Download handler therefore misses the
+            // event and the wait times out, surfacing as a download that "never completes". The
+            // context-level handler catches downloads started in ANY page of the persistent context,
+            // which is what actually fires for ModDB's popup-style mirrors.
+            page.Download += OnDownload;
+            page.Popup += OnPopup;
+
+            // Trigger the download by navigating to the URL.
+            await page.GotoAsync(configuration.Url.ToString(), new PageGotoOptions
+            {
+                Timeout = (float)configuration.Timeout.TotalMilliseconds,
+                WaitUntil = WaitUntilState.DOMContentLoaded,
+            });
+
+            // Race the download TCS against a short delay to check if it auto-started. If not,
+            // try to click a fallback download link on the page (mirrors, manual Download btn).
+            var waitTask = Task.Delay(5000, cancellationToken);
+            var completedTask = await Task.WhenAny(downloadTcs.Task, waitTask);
+
+            if (completedTask != downloadTcs.Task)
+            {
+                logger.LogInformation("Download did not start automatically within 5s. Attempting to find fallback link...");
+
+                const string FallbackSelector = "a[href*='media.moddb.com'], a[href*='files.moddb.com'], a:has-text('click here'), a:has-text('Click here'), a:has-text('here'), a#download, a.download, a.btn-download, a.buttondownload, a[href*='/mirror/'], a[href*='/downloads/start/'], a[href*='/addons/start/'], a:has-text('Download Now'), a:has-text('download now'), a:has-text('Download'), a:has-text('download'), a:has-text('mirror')";
+
+                var fallbackLink = await page.QuerySelectorAsync(FallbackSelector);
+
+                if (fallbackLink != null)
+                {
+                    var text = await fallbackLink.InnerTextAsync();
+                    logger.LogInformation("Found fallback link '{Text}', clicking...", text);
+                    try
+                    {
+                        await fallbackLink.ClickAsync(new ElementHandleClickOptions { Timeout = 5000 });
+
+                        // If clicking navigated to a /start/ page, wait briefly and check for direct mirror link
+                        var secondWait = Task.Delay(4000, cancellationToken);
+                        var secondCompleted = await Task.WhenAny(downloadTcs.Task, secondWait);
+                        if (secondCompleted != downloadTcs.Task && !string.IsNullOrWhiteSpace(page.Url) && page.Url.Contains("/start/", StringComparison.OrdinalIgnoreCase))
+                        {
+                            var startPageFallback = await page.QuerySelectorAsync("a:has-text('click here'), a:has-text('Click here'), a[href*='media.moddb.com'], a[href*='files.moddb.com'], a[href*='/mirror/']");
+                            if (startPageFallback != null)
+                            {
+                                var startText = await startPageFallback.InnerTextAsync();
+                                logger.LogInformation("Found start-page mirror link '{Text}', clicking...", startText);
+                                await startPageFallback.ClickAsync(new ElementHandleClickOptions { Timeout = 5000 });
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        logger.LogWarning(ex, "Failed to click fallback link.");
+                    }
+                }
+                else
+                {
+                    logger.LogWarning("No fallback download link found. Continuing to wait for download event...");
+                }
+            }
+
+            // Wait for the download to START (not finish) with a generous timeout. ModDB's
+            // redirect chain plus Cloudflare can take a while before the binary begins streaming.
+            var waitTimeout = TimeSpan.FromMilliseconds(Math.Max(60000, configuration.Timeout.TotalMilliseconds));
+            var download = await downloadTcs.Task.WaitAsync(waitTimeout, cancellationToken);
+
+            if (download == null)
+            {
+                return DownloadResult.CreateFailure("Download failed to initialize (null download object).");
+            }
+
+            if (File.Exists(configuration.DestinationPath) && configuration.OverwriteExisting)
+            {
+                File.Delete(configuration.DestinationPath);
+            }
+
+            var dir = Path.GetDirectoryName(configuration.DestinationPath);
+            if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
+            {
+                Directory.CreateDirectory(dir);
+            }
+
+            // Wait for the full byte stream to land on disk before reporting success. SaveAsAsync
+            // streams the download into the destination; without awaiting it the file would be
+            // incomplete (or missing) and downstream extraction would fail.
+            await download.SaveAsAsync(configuration.DestinationPath);
+
+            var fileInfo = new FileInfo(configuration.DestinationPath);
+            logger.LogInformation("Playwright download completed: {Path}, Size: {Size}", configuration.DestinationPath, fileInfo.Length);
+
+            return DownloadResult.CreateSuccess(
+                configuration.DestinationPath,
+                fileInfo.Length,
+                stopwatch.Elapsed,
+                hashVerified: false);
+        }
+        finally
+        {
+            page.Popup -= OnPopup;
+            page.Download -= OnDownload;
+            foreach (var popup in popups)
+            {
+                popup.Download -= OnDownload;
+                if (!popup.IsClosed)
+                {
+                    try
+                    {
+                        await popup.CloseAsync();
+                    }
+                    catch (PlaywrightException ex)
+                    {
+                        logger.LogDebug(ex, "Popup already closed during download cleanup.");
+                    }
+                }
+            }
+
+            if (usePersistentModDbProfile)
+            {
+                await ClosePersistentPageAsync(page);
+            }
+            else
+            {
+                var context = page.Context;
+                try
+                {
+                    if (!page.IsClosed)
+                    {
+                        await page.CloseAsync();
+                    }
+                }
+                finally
+                {
+                    if (context != null)
+                    {
+                        try
+                        {
+                            await context.CloseAsync();
+                        }
+                        catch (PlaywrightException ex)
+                        {
+                            logger.LogDebug(ex, "Context already closed during download cleanup.");
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Ensures Playwright is initialized with a browser instance.
+    /// </summary>
+    private async Task EnsurePlaywrightInitializedAsync(CancellationToken cancellationToken)
+    {
+        if (_browser != null) return;
+
+        await _browserLock.WaitAsync(cancellationToken);
+        try
+        {
+            if (_browser != null) return;
+
+            await EnsureManagedPlaywrightAsync(cancellationToken);
+            _browser = await _playwright!.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
+            {
+                // The shared browser is headless for ordinary parsing/fetching. Bot-protected
+                // sites that need a visible window use the persistent context instead.
+                Headless = true,
+                Args =
+                [
+                    "--disable-blink-features=AutomationControlled",
+                    "--disable-dev-shm-usage",
+                    "--no-default-browser-check",
+                    "--no-first-run",
+                    "--disable-background-networking",
+                    "--disable-component-update",
+                    "--disable-sync",
+                ],
+            });
+        }
+        finally
+        {
+            _browserLock.Release();
+        }
+    }
+
+    /// <summary>
+    /// Lazily creates (or reuses) a persistent, headed browser context for the given profile path.
+    /// Cookies and storage are written to disk, so a Cloudflare clearance cookie obtained via a
+    /// single manual challenge solve is reused for every subsequent page in the profile — across
+    /// pages and across app restarts until it expires.
+    /// </summary>
+    /// <param name="profileDir">Absolute on-disk directory for the persistent profile.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    private async Task EnsurePersistentContextAsync(string profileDir, CancellationToken cancellationToken)
+    {
+        if (IsPersistentContextAlive() && string.Equals(_persistentProfileName, profileDir, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        await _persistentLock.WaitAsync(cancellationToken);
+        try
+        {
+            // Re-check under the lock: another caller may have just recreated the context. Also
+            // drop a cached-but-dead context so the relaunch below actually runs.
+            if (!IsPersistentContextAlive())
+            {
+                _inUsePersistentPages.Clear();
+                _persistentContext = null;
+                _persistentProfileName = null;
+            }
+            else if (string.Equals(_persistentProfileName, profileDir, StringComparison.Ordinal))
+            {
+                return;
+            }
+            else if (_persistentContext != null)
+            {
+                await ClosePersistentContextCoreUnderLockAsync();
+            }
+
+            await EnsureManagedPlaywrightAsync(cancellationToken);
+            Directory.CreateDirectory(profileDir);
+
+            var context = await _playwright!.Chromium.LaunchPersistentContextAsync(
+                profileDir,
+                new BrowserTypeLaunchPersistentContextOptions
+                {
+                    Headless = false,
+                    Args =
+                    [
+                        "--disable-blink-features=AutomationControlled",
+                        "--disable-dev-shm-usage",
+                        "--no-default-browser-check",
+                        "--no-first-run",
+                        "--disable-background-networking",
+                        "--disable-background-timer-throttling",
+                        "--disable-backgrounding-occluded-windows",
+                        "--disable-breakpad",
+                        "--disable-component-update",
+                        "--disable-domain-reliability",
+                        "--disable-features=Translate,OptimizationHints,MediaRouter,DialMediaRouteProvider",
+                        "--disable-ipc-flooding-protection",
+                        "--disable-renderer-backgrounding",
+                        "--disable-sync",
+                        "--metrics-recording-only",
+                        "--no-pings",
+                        "--password-store=basic",
+                        "--use-mock-keychain",
+                    ],
+                    UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+                    ViewportSize = new ViewportSize { Width = 1366, Height = 768 },
+                    Locale = "en-US",
+                    IgnoreDefaultArgs = ["--enable-automation"],
+                });
+
+            var ctx = context;
+            context.Close += (_, _) =>
+            {
+                if (ReferenceEquals(_persistentContext, ctx))
+                {
+                    _inUsePersistentPages.Clear();
+                    _persistentContext = null;
+                    _persistentProfileName = null;
+                }
+            };
+
+            _persistentContext = context;
+            _persistentProfileName = profileDir;
+        }
+        finally
+        {
+            _persistentLock.Release();
+        }
+    }
+
+    /// <summary>
+    /// Opens a new page in the persistent context, recovering once if the cached context or its
+    /// browser process has died (the headed Chromium exits when its last page closes). The recovery
+    /// recreates the profile — the Cloudflare clearance cookie persists on disk, so the user does
+    /// not need to re-solve any challenge.
+    /// </summary>
+    private async Task<IPage> CreatePersistentPageWithRecoveryAsync(string profileDir, CancellationToken cancellationToken)
+    {
+        IPage page = null!;
+        try
+        {
+            await _persistentLock.WaitAsync(cancellationToken);
+            try
+            {
+                page = await GetOrCreatePersistentPageCoreAsync();
+            }
+            finally
+            {
+                _persistentLock.Release();
+            }
+        }
+        catch (PlaywrightException ex) when (IsContextClosedError(ex))
+        {
+            logger.LogInformation("Persistent browser context was closed; recreating profile {ProfileName}", Path.GetFileName(profileDir));
+            await InvalidatePersistentContextAsync();
+            await EnsurePersistentContextAsync(profileDir, cancellationToken);
+
+            if (_persistentContext == null)
+            {
+                throw new InvalidOperationException("Persistent browser context could not be recreated");
+            }
+
+            await _persistentLock.WaitAsync(cancellationToken);
+            try
+            {
+                page = await GetOrCreatePersistentPageCoreAsync();
+            }
+            finally
+            {
+                _persistentLock.Release();
+            }
+        }
+
+        return page;
+    }
+
+    private async Task<IPage> GetOrCreatePersistentPageCoreAsync()
+    {
+        if (_persistentContext == null)
+        {
+            throw new InvalidOperationException("Persistent browser context not initialized");
+        }
+
+        foreach (var existing in _persistentContext.Pages)
+        {
+            if (!existing.IsClosed && IsBlankStartupUrl(existing.Url) && !_inUsePersistentPages.Contains(existing))
+            {
+                _inUsePersistentPages.Add(existing);
+                await CloseOrphanStartupPagesAsync(existing);
+                return existing;
+            }
+        }
+
+        var newPage = await _persistentContext.NewPageAsync();
+        _inUsePersistentPages.Add(newPage);
+        await CloseOrphanStartupPagesAsync(newPage);
+        return newPage;
+    }
+
+    /// <summary>
+    /// Manages pre-existing blank pages opened at persistent-context launch.
+    /// Closes startup blank tabs so about:blank does not linger on screen after operations complete.
+    /// </summary>
+    private async Task CloseOrphanStartupPagesAsync(IPage keepPage)
+    {
+        if (_persistentContext == null)
+        {
+            return;
+        }
+
+        List<IPage> pages = [];
+        try
+        {
+            pages = [.. _persistentContext.Pages];
+        }
+        catch (PlaywrightException ex) when (IsContextClosedError(ex))
+        {
+            logger.LogDebug(ex, "Persistent context closed while collecting orphan startup pages.");
+            return;
+        }
+
+        var blankPages = new List<IPage>();
+        foreach (var existing in pages)
+        {
+            if (existing == keepPage || existing.IsClosed || _inUsePersistentPages.Contains(existing))
+            {
+                continue;
+            }
+
+            string url = string.Empty;
+            try
+            {
+                url = existing.Url ?? string.Empty;
+            }
+            catch (PlaywrightException ex) when (IsContextClosedError(ex))
+            {
+                continue;
+            }
+
+            if (IsBlankStartupUrl(url))
+            {
+                blankPages.Add(existing);
+            }
+        }
+
+        // Close all orphan blank pages.
+        foreach (var blankPage in blankPages)
+        {
+            try
+            {
+                await blankPage.CloseAsync();
+            }
+            catch (PlaywrightException ex)
+            {
+                logger.LogDebug(ex, "Could not close orphan startup page; it may have closed already.");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Keeps Playwright's browser lookup app-owned, then installs Chromium only for a clean
+    /// runtime directory. This is shared by the headed ModDB profile and headless parsing.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A task representing the browser runtime initialization.</returns>
+    private async Task EnsureManagedPlaywrightAsync(CancellationToken cancellationToken)
+    {
+        await _playwrightLock.WaitAsync(cancellationToken);
+        try
+        {
+            var runtime = GetOrCreateManagedChromiumRuntime();
+            runtime.ConfigureEnvironment();
+            _playwright ??= await Playwright.CreateAsync();
+            await runtime.EnsureInstalledAsync(_playwright.Chromium, cancellationToken);
+        }
+        finally
+        {
+            _playwrightLock.Release();
+        }
+    }
+
+    private ManagedChromiumRuntime GetOrCreateManagedChromiumRuntime()
+    {
+        return managedChromiumRuntime ??= new ManagedChromiumRuntime(
+            Path.Combine(configurationProvider.GetApplicationDataPath(), DirectoryNames.BrowserRuntime),
+            Microsoft.Playwright.Program.Main,
+            RequestManagedChromiumInstallConsentAsync,
+            logger);
+    }
+
+    /// <summary>
+    /// Asks the user (via the same confirmation dialog used for profile deletion) whether to
+    /// download GenHub's managed Playwright Chromium runtime for ModDB. System Chrome/Edge is
+    /// not used — Playwright requires its own patched build under the app data directory.
+    /// </summary>
+    private async Task<bool> RequestManagedChromiumInstallConsentAsync(string runtimeDirectory)
+    {
+        var message =
+            "ModDB requires GenHub's managed Chromium runtime (Playwright). " +
+            "This is separate from any Chrome or Edge browser already installed on your PC — those cannot be used.\n\n" +
+            "What will be installed (~240 MB download):\n" +
+            "• Playwright Chromium browser\n" +
+            "• Chromium Headless Shell\n" +
+            "• FFmpeg and Windows helper binaries\n\n" +
+            $"Install location:\n{runtimeDirectory}";
+
+        async Task<bool> ShowAsync() =>
+            await dialogService.ShowConfirmationAsync(
+                "Install Chromium Runtime for ModDB",
+                message,
+                confirmText: "Install",
+                cancelText: "Cancel");
+
+        if (Dispatcher.UIThread.CheckAccess())
+        {
+            return await ShowAsync();
+        }
+
+        return await Dispatcher.UIThread.InvokeAsync(ShowAsync);
+    }
+
+    /// <summary>
+    /// Fetches HTML in the persistent headed context, reusing the on-disk Cloudflare clearance
+    /// cookie so bot-protected pages load without another manual challenge.
+    /// </summary>
+    /// <param name="profileName">The on-disk profile name.</param>
+    /// <param name="url">The URL to fetch.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The page HTML.</returns>
+    private async Task<string> FetchPersistentHtmlAsync(string profileName, string url, CancellationToken cancellationToken)
+    {
+        logger.LogDebug("Fetching HTML (persistent profile '{Profile}') from {Url}", profileName, url);
+
+        var isOuterSession = !_isInPersistentSession.Value;
+        if (isOuterSession)
+        {
+            await _persistentFetchLock.WaitAsync(cancellationToken);
+            _isInPersistentSession.Value = true;
+        }
+
+        try
+        {
+            var page = await CreatePersistentPageAsync(profileName, cancellationToken);
+            try
+            {
+                return await NavigatePersistentPageAsync(page, url, cancellationToken);
+            }
+            finally
+            {
+                await ClosePersistentPageAsync(page);
+            }
+        }
+        finally
+        {
+            if (isOuterSession)
+            {
+                _isInPersistentSession.Value = false;
+                _persistentFetchLock.Release();
+            }
+        }
+    }
+
+    /// <summary>
+    /// Navigates an already-open persistent page and returns its HTML after ModDB (or generic)
+    /// content is ready. Does not open or close the page — callers own the page lifetime.
+    /// </summary>
+    private async Task<string> NavigatePersistentPageAsync(IPage page, string url, CancellationToken cancellationToken)
+    {
+        await page.GotoAsync(url, new PageGotoOptions
+        {
+            Timeout = ModDBConstants.DefaultGotoTimeout,
+            WaitUntil = WaitUntilState.DOMContentLoaded,
+        });
+
+        if (url.Contains("moddb.com", StringComparison.OrdinalIgnoreCase))
+        {
+            await WaitForModDbContentAsync(page, url, cancellationToken);
+        }
+        else
+        {
+            await Task.Delay(500, cancellationToken);
+        }
+
+        return await page.ContentAsync();
+    }
+
+    private void NotifyBrowserWindowOpening(string title, string message)
+    {
+        try
+        {
+            notificationService?.ShowInfo(title, message, NotificationDurations.VeryLong);
+        }
+        catch (Exception ex)
+        {
+            logger.LogDebug(ex, "Failed to show browser-window notification.");
+        }
+    }
+
+    /// <summary>
+    /// Waits for real ModDB content instead of snapshotting the Cloudflare interstitial. This is
+    /// state-based waiting: a user can solve verification in the headed Chromium window and the
+    /// parser resumes as soon as the actual document is available.
+    /// </summary>
+    private async Task WaitForModDbContentAsync(IPage page, string url, CancellationToken cancellationToken)
+    {
+        var deadline = DateTime.UtcNow.AddMinutes(2);
+        var verificationObserved = false;
+
+        while (DateTime.UtcNow < deadline)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                var title = await page.TitleAsync();
+                var isVerificationPage = IsModDbVerificationPage(title);
+                if (isVerificationPage)
+                {
+                    if (!verificationObserved)
+                    {
+                        logger.LogInformation(
+                            "ModDB verification is open in Chromium for {Url}. Waiting for the user to complete it.",
+                            url);
+                        verificationObserved = true;
+                    }
+                }
+                else
+                {
+                    var contentMarker = await page.QuerySelectorAsync(
+                        "#downloadsinfo, .row.rowcontent, .headerbox, #articlebrowse, #profile");
+                    if (contentMarker != null)
+                    {
+                        if (verificationObserved)
+                        {
+                            logger.LogInformation("ModDB verification completed; parsing content from {Url}", url);
+                        }
+
+                        return;
+                    }
+                }
+            }
+            catch (PlaywrightException ex) when (IsContextClosedError(ex))
+            {
+                // The page is navigating (e.g. the user just solved the Cloudflare challenge, or
+                // the interstitial redirected to the real document). The in-flight title/selector
+                // probe dies mid-navigation; retry on the next tick once the new document settles.
+                logger.LogDebug(ex, "Transient navigation during ModDB content wait for {Url}; retrying", url);
+            }
+
+            await Task.Delay(TimeSpan.FromMilliseconds(250), cancellationToken);
+        }
+
+        throw new TimeoutException(
+            verificationObserved
+                ? "ModDB verification was not completed in the Chromium window. Complete the check and open the content again."
+                : $"ModDB did not expose parseable content for {url}.");
+    }
+}
diff --git a/GenHub/GenHub/Infrastructure/DependencyInjection/ContentPipelineModule.cs b/GenHub/GenHub/Infrastructure/DependencyInjection/ContentPipelineModule.cs
index ea7246dec..58d9be795 100644
--- a/GenHub/GenHub/Infrastructure/DependencyInjection/ContentPipelineModule.cs
+++ b/GenHub/GenHub/Infrastructure/DependencyInjection/ContentPipelineModule.cs
@@ -4,8 +4,10 @@
 using GenHub.Core.Interfaces.Content;
 using GenHub.Core.Interfaces.GitHub;
 using GenHub.Core.Interfaces.Manifest;
+using GenHub.Core.Interfaces.Parsers;
 using GenHub.Core.Interfaces.Providers;
 using GenHub.Core.Interfaces.Storage;
+using GenHub.Core.Interfaces.Tools;
 using GenHub.Core.Services.Content;
 using GenHub.Core.Services.Providers;
 using GenHub.Core.Services.Providers.VersionSchemes;
@@ -18,9 +20,11 @@
 using GenHub.Features.Content.Services.GeneralsOnline;
 using GenHub.Features.Content.Services.GitHub;
 using GenHub.Features.Content.Services.LocalContent;
+using GenHub.Features.Content.Services.Parsers;
 using GenHub.Features.Content.Services.Publishers;
 using GenHub.Features.Content.Services.Reconciliation;
 using GenHub.Features.Content.Services.SuperHackers;
+using GenHub.Features.Content.Services.Tools;
 using GenHub.Features.Downloads.ViewModels;
 using GenHub.Features.GitHub.Services;
 using GenHub.Features.Manifest;
@@ -308,6 +312,14 @@ private static void AddModDBPipeline(IServiceCollection services)
             httpClient.DefaultRequestHeaders.Add("User-Agent", ApiConstants.DefaultUserAgent);
         });
 
+        // Register Playwright service for web page parsing (singleton for shared browser instance)
+        services.AddSingleton<IPlaywrightService, PlaywrightService>();
+
+        // Register ModDB page parser (concrete and interface)
+        // Note: Multiple IWebPageParser implementations are registered for IEnumerable<IWebPageParser> injection
+        services.AddSingleton<ModDBPageParser>();
+        services.AddSingleton<IWebPageParser>(sp => sp.GetRequiredService<ModDBPageParser>());
+
         // Register ModDB discoverer (concrete and interface) with named HttpClient
         services.AddTransient<ModDBDiscoverer>(sp =>
         {