aeorank 1.5.0 → 2.0.0

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   extractAllUrlsFromSitemap,
   extractInternalLinks,
   inferCategory
-} from "./chunk-3IJISYWT.js";
+} from "./chunk-PKJIKMLV.js";
 
 // src/parked-domain.ts
 var PARKING_PATHS = ["/lander", "/parking", "/park", "/sedoparking"];
@@ -195,7 +195,7 @@ async function prefetchSiteData(domain) {
         sitemapForBlog = subSitemap.text;
       }
     }
-    const blogUrls = extractBlogUrlsFromSitemap(sitemapForBlog, domain, 10);
+    const blogUrls = extractBlogUrlsFromSitemap(sitemapForBlog, domain, 50);
     if (blogUrls.length > 0) {
       const fetched = await Promise.all(blogUrls.map((url) => fetchText(url)));
       blogSample = fetched.filter(
@@ -552,15 +552,17 @@ function checkOriginalData(data) {
     findings.push({ severity: "critical", detail: "Could not fetch homepage" });
     return { criterion: "original_data", criterion_label: "Original Data & Expert Content", score: 0, status: "not_found", findings, fix_priority: "P2" };
   }
+  const allPages = [data.homepage, ...data.blogSample || []].filter(Boolean);
   const html = data.homepage.text;
-  const text = html.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  const allText = allPages.map((p) => p.text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ")).join(" ");
+  const text = data.homepage.text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
   let score = 0;
   const statPatterns = /\d+%|\d+\s*(patients|clients|customers|cases|years|professionals|specialists|companies|users|businesses|domains|audits)/i;
-  if (statPatterns.test(text)) {
+  if (statPatterns.test(allText)) {
     const researchContext = /\b(our\s+(?:study|analysis|research|data|survey|findings|report)|we\s+(?:surveyed|analyzed|studied|measured|tracked)|proprietary|methodology|original\s+research)\b/i;
-    if (researchContext.test(text)) {
+    if (researchContext.test(allText)) {
       score += 3;
-      findings.push({ severity: "info", detail: "Proprietary statistics with research context found on homepage" });
+      findings.push({ severity: "info", detail: "Proprietary statistics with research context found" });
     } else {
       score += 1;
       findings.push({ severity: "low", detail: 'Statistics found but without research context (e.g., "500+ clients")', fix: 'Add context about your methodology: "Our analysis of X found..." or "We surveyed Y..."' });
@@ -1075,20 +1077,24 @@ function checkFactDensity(data) {
     findings.push({ severity: "critical", detail: "Could not fetch homepage" });
     return { criterion: "fact_density", criterion_label: "Fact & Data Density", score: 0, status: "not_found", findings, fix_priority: "P2" };
   }
-  const text = data.homepage.text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  const allPages = [data.homepage, ...data.blogSample || []].filter(Boolean);
+  const allText = allPages.map((p) => p.text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ")).join(" ");
+  const text = allText;
+  const pageCount = allPages.length;
   let score = 0;
   const dataPoints = text.match(/\d+(?:\.\d+)?(?:\s*%|\s*\$|\s*USD|\s*EUR)/g) || [];
   const countPhrases = text.match(/\d+(?:,\d{3})*\+?\s+(?:users?|clients?|customers?|companies|businesses|patients?|members?|employees?|projects?|downloads?)/gi) || [];
   const totalDataPoints = dataPoints.length + countPhrases.length;
-  if (totalDataPoints >= 6) {
+  const avgPerPage = pageCount > 0 ? totalDataPoints / pageCount : 0;
+  if (avgPerPage >= 4) {
     score += 5;
-    findings.push({ severity: "info", detail: `${totalDataPoints} quantitative data points found on homepage` });
-  } else if (totalDataPoints >= 3) {
+    findings.push({ severity: "info", detail: `${totalDataPoints} quantitative data points found across ${pageCount} pages (avg ${avgPerPage.toFixed(1)}/page)` });
+  } else if (avgPerPage >= 2) {
     score += 3;
-    findings.push({ severity: "info", detail: `${totalDataPoints} quantitative data points found` });
+    findings.push({ severity: "info", detail: `${totalDataPoints} quantitative data points found across ${pageCount} pages` });
   } else if (totalDataPoints >= 1) {
     score += 1;
-    findings.push({ severity: "low", detail: `Only ${totalDataPoints} quantitative data point(s) found`, fix: "Add more specific numbers, percentages, and metrics to strengthen credibility" });
+    findings.push({ severity: "low", detail: `Only ${totalDataPoints} quantitative data point(s) found across ${pageCount} pages`, fix: "Add more specific numbers, percentages, and metrics to strengthen credibility" });
   } else {
     findings.push({ severity: "high", detail: "No quantitative data points found", fix: "Add specific statistics (percentages, counts, comparisons) that AI engines can cite" });
   }
@@ -1194,9 +1200,9 @@ function countRecentSitemapDates(sitemapText) {
     distinctRecentDays: recentDays.size
   };
 }
-var BLOG_PATH_PATTERNS = /\/(?:blog|articles?|insights?|guides?|resources?|news|posts?|learn|help|how-?to|tutorials?|case-stud|whitepapers?)\b/i;
+var BLOG_PATH_PATTERNS = /\/(?:[^/]*-?)?(?:blog|articles?|insights?|guides?|resources?|news|posts?|learn|help|how-?to|tutorials?|case-stud|whitepapers?)\b/i;
 var EXCLUDE_PATH_PATTERNS = /\/(?:tag|category|author|page|feed|wp-content|wp-admin|wp-json|cart|checkout|login|search|api|static|assets|_next)\b/i;
-function extractBlogUrlsFromSitemap(sitemapText, domain, limit = 5) {
+function extractBlogUrlsFromSitemap(sitemapText, domain, limit = 50) {
   const urlBlocks = sitemapText.match(/<url>([\s\S]*?)<\/url>/gi) || [];
   const candidates = [];
   const cleanDomain = domain.replace(/^www\./, "").toLowerCase();
@@ -1492,7 +1498,7 @@ function jaccardSimilarity(a, b) {
   const union = a.size + b.size - intersection;
   return union === 0 ? 0 : intersection / union;
 }
-function checkContentCannibalization(data) {
+function checkContentCannibalization(data, topicCoherenceScore) {
   const findings = [];
   if (!data.homepage) {
     findings.push({ severity: "critical", detail: "No homepage available for cannibalization analysis" });
@@ -1502,7 +1508,7 @@ function checkContentCannibalization(data) {
     { html: data.homepage.text, url: data.homepage.finalUrl || `https://${data.domain}/` }
   ];
   if (data.blogSample) {
-    for (const page of data.blogSample.slice(0, 5)) {
+    for (const page of data.blogSample) {
       pages.push({ html: page.text, url: page.finalUrl || "" });
     }
   }
@@ -1512,10 +1518,29 @@ function checkContentCannibalization(data) {
   }
   const pageTitles = pages.map((p) => ({ title: extractPageTitle(p.html), url: p.url }));
   const wordSets = pageTitles.map((p) => titleToWordSet(p.title));
+  const termPageCount = /* @__PURE__ */ new Map();
+  for (const ws of wordSets) {
+    for (const w of ws) {
+      termPageCount.set(w, (termPageCount.get(w) || 0) + 1);
+    }
+  }
+  const commonTermThreshold = Math.max(3, pages.length * 0.4);
+  const siteThemeTerms = /* @__PURE__ */ new Set();
+  for (const [term, count] of termPageCount) {
+    if (count >= commonTermThreshold) siteThemeTerms.add(term);
+  }
+  const filteredSets = wordSets.map((ws) => {
+    const filtered = /* @__PURE__ */ new Set();
+    for (const w of ws) {
+      if (!siteThemeTerms.has(w)) filtered.add(w);
+    }
+    return filtered;
+  });
   const cannibalPairs = [];
   for (let i = 0; i < pages.length; i++) {
     for (let j = i + 1; j < pages.length; j++) {
-      const sim = jaccardSimilarity(wordSets[i], wordSets[j]);
+      if (filteredSets[i].size === 0 && filteredSets[j].size === 0) continue;
+      const sim = jaccardSimilarity(filteredSets[i], filteredSets[j]);
       if (sim > 0.6) {
         cannibalPairs.push({
           urlA: pageTitles[i].url.slice(0, 60),
@@ -1525,23 +1550,39 @@ function checkContentCannibalization(data) {
       }
     }
   }
+  const cannibalUrls = /* @__PURE__ */ new Set();
+  for (const pair of cannibalPairs) {
+    cannibalUrls.add(pair.urlA);
+    cannibalUrls.add(pair.urlB);
+  }
+  const cannibalRatio = pages.length > 0 ? cannibalUrls.size / pages.length : 0;
   let score;
   if (cannibalPairs.length === 0) {
     score = 10;
     findings.push({ severity: "info", detail: `${pages.length} pages analyzed - no content cannibalization detected` });
-  } else if (cannibalPairs.length === 1) {
-    score = 8;
-    findings.push({ severity: "low", detail: `1 pair of pages with overlapping topics (${cannibalPairs[0].similarity}% similarity)`, fix: "Differentiate titles and H1 headings to reduce topic overlap" });
-  } else if (cannibalPairs.length === 2) {
+  } else if (cannibalRatio <= 0.05) {
+    score = 9;
+    findings.push({ severity: "info", detail: `${cannibalPairs.length} pair(s) of pages with minor topic overlap (${cannibalUrls.size}/${pages.length} pages affected)` });
+  } else if (cannibalRatio <= 0.1) {
+    score = 7;
+    findings.push({ severity: "low", detail: `${cannibalUrls.size} pages (${Math.round(cannibalRatio * 100)}%) have overlapping topics`, fix: "Differentiate titles and H1 headings to reduce topic overlap" });
+  } else if (cannibalRatio <= 0.2) {
     score = 5;
-    findings.push({ severity: "medium", detail: `${cannibalPairs.length} pairs of pages with overlapping topics`, fix: "Consolidate overlapping pages or differentiate their titles and content focus" });
+    findings.push({ severity: "medium", detail: `${cannibalUrls.size} pages (${Math.round(cannibalRatio * 100)}%) competing for overlapping topics`, fix: "Consolidate overlapping pages or differentiate their titles and content focus" });
+  } else if (cannibalRatio <= 0.4) {
+    score = 3;
+    findings.push({ severity: "medium", detail: `${cannibalUrls.size} pages (${Math.round(cannibalRatio * 100)}%) have significant content overlap`, fix: "Many pages compete for the same topics - consolidate or clearly differentiate them" });
   } else {
     score = 0;
-    findings.push({ severity: "high", detail: `${cannibalPairs.length} pairs of pages competing for the same topics`, fix: "Significant content overlap detected - consolidate or clearly differentiate competing pages" });
+    findings.push({ severity: "high", detail: `${cannibalUrls.size} pages (${Math.round(cannibalRatio * 100)}%) competing for the same topics`, fix: "Severe content cannibalization - consolidate overlapping pages or create clear topic differentiation" });
   }
   for (const pair of cannibalPairs.slice(0, 3)) {
     findings.push({ severity: "low", detail: `Overlap (${pair.similarity}%): ${pair.urlA} vs ${pair.urlB}` });
   }
+  if (topicCoherenceScore !== void 0 && topicCoherenceScore <= 4 && score >= 8) {
+    score = 6;
+    findings.push({ severity: "low", detail: "Low topic overlap but content lacks coherent focus - not a strong signal for AI authority", fix: "Focus content on fewer core topics to build topical authority that AI engines can identify" });
+  }
   return { criterion: "content_cannibalization", criterion_label: "Content Cannibalization", score, status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P1" };
 }
 function checkVisibleDateSignal(data) {
@@ -1767,7 +1808,233 @@ function extractRawDataSummary(data) {
     crawl_skipped: data.crawlStats?.skipped ?? 0
   };
 }
+function getPageTopicText(html) {
+  const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+  const h1Match = html.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+  return [
+    titleMatch?.[1] || "",
+    h1Match?.[1]?.replace(/<[^>]*>/g, "") || ""
+  ].join(" ").toLowerCase().trim();
+}
+function extractBigrams(text) {
+  const words = text.split(/[\s,.!?;:()\[\]{}"'\/&]+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w) && !/^\d+$/.test(w));
+  const bigrams = [];
+  for (let i = 0; i < words.length - 1; i++) {
+    bigrams.push(words[i] + " " + words[i + 1]);
+  }
+  return bigrams;
+}
+function checkTopicCoherence(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "topic_coherence", criterion_label: "Topic Coherence", score: 0, status: "not_found", findings, fix_priority: "P0" };
+  }
+  if (!data.blogSample || data.blogSample.length < 3) {
+    findings.push({ severity: "info", detail: `Only ${data.blogSample?.length || 0} blog pages found - insufficient for topic coherence analysis` });
+    return { criterion: "topic_coherence", criterion_label: "Topic Coherence", score: 5, status: "partial", findings, fix_priority: "P2" };
+  }
+  const blogPages = data.blogSample;
+  const domainBase = data.domain.replace(/^www\./, "").replace(/\.(com|org|net|io|co|ai)$/i, "").toLowerCase();
+  const brandWords = /* @__PURE__ */ new Set();
+  brandWords.add(domainBase);
+  for (const part of domainBase.split(/[-_]/)) {
+    if (part.length > 2) brandWords.add(part);
+  }
+  const rawTermFreq = /* @__PURE__ */ new Map();
+  const pageTitleTexts = [];
+  for (const page of blogPages) {
+    const topicText = getPageTopicText(page.text);
+    pageTitleTexts.push(topicText);
+    const words = topicText.split(/[\s,.!?;:()\[\]{}"'\/&]+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w) && !/^\d+$/.test(w));
+    const uniqueWords = new Set(words);
+    for (const w of uniqueWords) {
+      rawTermFreq.set(w, (rawTermFreq.get(w) || 0) + 1);
+    }
+  }
+  for (const [term, count] of rawTermFreq) {
+    if (count / blogPages.length >= 0.8 && domainBase.includes(term)) {
+      brandWords.add(term);
+    }
+  }
+  const termFreq = /* @__PURE__ */ new Map();
+  for (const page of blogPages) {
+    const topicText = getPageTopicText(page.text);
+    const words = topicText.split(/[\s,.!?;:()\[\]{}"'\/&]+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w) && !/^\d+$/.test(w) && !brandWords.has(w));
+    const uniqueWords = new Set(words);
+    for (const w of uniqueWords) {
+      termFreq.set(w, (termFreq.get(w) || 0) + 1);
+    }
+  }
+  const sortedTerms = [...termFreq.entries()].sort((a, b) => b[1] - a[1]);
+  const topTerm = sortedTerms[0];
+  const bigramFreq = /* @__PURE__ */ new Map();
+  const pageBigrams = [];
+  for (const topicText of pageTitleTexts) {
+    const bigrams = extractBigrams(topicText).filter((bg) => !bg.split(" ").some((w) => brandWords.has(w)));
+    pageBigrams.push(bigrams);
+    const uniqueBigrams = new Set(bigrams);
+    for (const bg of uniqueBigrams) {
+      bigramFreq.set(bg, (bigramFreq.get(bg) || 0) + 1);
+    }
+  }
+  const sortedBigrams = [...bigramFreq.entries()].sort((a, b) => b[1] - a[1]);
+  const topBigram = sortedBigrams[0];
+  const significantBigrams = sortedBigrams.filter(([, count]) => count >= 2);
+  const clusterRoots = [];
+  const assigned = /* @__PURE__ */ new Set();
+  for (const [bg] of significantBigrams) {
+    if (assigned.has(bg)) continue;
+    clusterRoots.push(bg);
+    assigned.add(bg);
+    const [w1, w2] = bg.split(" ");
+    for (const [otherBg] of significantBigrams) {
+      if (assigned.has(otherBg)) continue;
+      if (otherBg.includes(w1) || otherBg.includes(w2)) {
+        assigned.add(otherBg);
+      }
+    }
+  }
+  const topicClusterCount = clusterRoots.length;
+  const dominantTerm = topTerm?.[0] || "";
+  const dominantTermCount = topTerm?.[1] || 0;
+  const focusRatio = blogPages.length > 0 ? dominantTermCount / blogPages.length : 0;
+  const dominantBigram = topBigram?.[0] || "";
+  const dominantBigramCount = topBigram?.[1] || 0;
+  const bigramFocusRatio = blogPages.length > 0 ? dominantBigramCount / blogPages.length : 0;
+  let score = 0;
+  const bestFocusRatio = Math.max(focusRatio, bigramFocusRatio);
+  if (bestFocusRatio >= 0.8) {
+    score += 7;
+  } else if (bestFocusRatio >= 0.6) {
+    score += 6;
+  } else if (bestFocusRatio >= 0.45) {
+    score += 5;
+  } else if (bestFocusRatio >= 0.3) {
+    score += 3;
+  } else if (bestFocusRatio >= 0.15) {
+    score += 2;
+  } else {
+    score += 1;
+  }
+  const clusterPenaltyReduced = focusRatio >= 0.7;
+  if (topicClusterCount <= 3) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${topicClusterCount} topic cluster(s) - tightly focused content` });
+  } else if (topicClusterCount <= 6) {
+    score += clusterPenaltyReduced ? 2 : 1;
+    findings.push({ severity: "info", detail: `${topicClusterCount} topic clusters${clusterPenaltyReduced ? " within a focused niche" : " - moderately focused"}` });
+  } else if (topicClusterCount <= 10) {
+    score += clusterPenaltyReduced ? 1 : 0;
+    if (!clusterPenaltyReduced) {
+      findings.push({ severity: "low", detail: `${topicClusterCount} topic clusters - scattered content`, fix: "Reduce the number of distinct topics. Focus blog content on 2-3 core expertise areas." });
+    } else {
+      findings.push({ severity: "info", detail: `${topicClusterCount} topic clusters but strong core topic focus (${Math.round(focusRatio * 100)}%)` });
+    }
+  } else {
+    score += clusterPenaltyReduced ? 0 : -2;
+    if (!clusterPenaltyReduced) {
+      findings.push({ severity: "medium", detail: `${topicClusterCount} topic clusters - highly scattered content`, fix: "Content covers too many unrelated topics. AI engines cannot identify your expertise. Focus on your core niche." });
+    } else {
+      findings.push({ severity: "low", detail: `${topicClusterCount} topic clusters despite strong core topic focus`, fix: "Consider narrowing subtopics within your niche for even stronger AI visibility." });
+    }
+  }
+  score = Math.max(0, Math.min(10, score));
+  if (dominantTerm) {
+    const focusPct = Math.round(focusRatio * 100);
+    findings.push({ severity: "info", detail: `Dominant topic term: "${dominantTerm}" (${focusPct}% of ${blogPages.length} pages)` });
+  }
+  if (dominantBigram && dominantBigramCount >= 2) {
+    findings.push({ severity: "info", detail: `Dominant topic phrase: "${dominantBigram}" (${dominantBigramCount}/${blogPages.length} pages)` });
+  }
+  const offTopicExamples = [];
+  for (let i = 0; i < pageTitleTexts.length && offTopicExamples.length < 3; i++) {
+    if (dominantTerm && !pageTitleTexts[i].includes(dominantTerm)) {
+      const title = blogPages[i].text.match(/<title[^>]*>([^<]+)<\/title>/i)?.[1]?.trim();
+      if (title && title.length > 3) offTopicExamples.push(title.slice(0, 60));
+    }
+  }
+  if (offTopicExamples.length > 0 && score < 8) {
+    findings.push({ severity: "low", detail: `Off-topic examples: ${offTopicExamples.join("; ")}` });
+  }
+  return { criterion: "topic_coherence", criterion_label: "Topic Coherence", score, status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P0" };
+}
+function countWords(html) {
+  const text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+  return text.split(/\s+/).filter((w) => w.length > 0).length;
+}
+function countHeadings(html) {
+  const headings = html.match(/<h[2-6][^>]*>/gi) || [];
+  return headings.length;
+}
+function checkContentDepth(data, topicCoherenceScore) {
+  const findings = [];
+  if (!data.blogSample || data.blogSample.length < 2) {
+    findings.push({ severity: "info", detail: `Only ${data.blogSample?.length || 0} blog pages found - insufficient for depth analysis` });
+    return { criterion: "content_depth", criterion_label: "Content Depth", score: 3, status: "partial", findings, fix_priority: "P2" };
+  }
+  const blogPages = data.blogSample;
+  const wordCounts = blogPages.map((p) => countWords(p.text));
+  const headingCounts = blogPages.map((p) => countHeadings(p.text));
+  const avgWords = wordCounts.reduce((a, b) => a + b, 0) / wordCounts.length;
+  const avgHeadings = headingCounts.reduce((a, b) => a + b, 0) / headingCounts.length;
+  const deepPages = wordCounts.filter((w) => w >= 1e3).length;
+  const thinPages = wordCounts.filter((w) => w < 300).length;
+  const deepRatio = deepPages / blogPages.length;
+  const thinRatio = thinPages / blogPages.length;
+  let score = 0;
+  if (avgWords >= 2e3) {
+    score += 5;
+    findings.push({ severity: "info", detail: `Average ${Math.round(avgWords)} words per page across ${blogPages.length} pages - excellent depth` });
+  } else if (avgWords >= 1200) {
+    score += 4;
+    findings.push({ severity: "info", detail: `Average ${Math.round(avgWords)} words per page across ${blogPages.length} pages - good depth` });
+  } else if (avgWords >= 800) {
+    score += 3;
+    findings.push({ severity: "info", detail: `Average ${Math.round(avgWords)} words per page - moderate depth` });
+  } else if (avgWords >= 400) {
+    score += 2;
+    findings.push({ severity: "low", detail: `Average ${Math.round(avgWords)} words per page - shallow content`, fix: "Expand articles with more detail, examples, and expert analysis to build AI citation authority" });
+  } else {
+    score += 1;
+    findings.push({ severity: "medium", detail: `Average ${Math.round(avgWords)} words per page - very thin content`, fix: "Content is too thin for AI engines to cite. Aim for 1000+ words per article with structured sections." });
+  }
+  if (avgHeadings >= 8) {
+    score += 3;
+    findings.push({ severity: "info", detail: `Average ${avgHeadings.toFixed(1)} subheadings per page - well-structured` });
+  } else if (avgHeadings >= 5) {
+    score += 2;
+    findings.push({ severity: "info", detail: `Average ${avgHeadings.toFixed(1)} subheadings per page - decent structure` });
+  } else if (avgHeadings >= 2) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Average ${avgHeadings.toFixed(1)} subheadings per page`, fix: "Add more H2/H3 headings to break content into extractable sections" });
+  } else {
+    findings.push({ severity: "medium", detail: `Average ${avgHeadings.toFixed(1)} subheadings per page - minimal structure`, fix: "Add question-format H2/H3 headings so AI engines can extract specific answers" });
+  }
+  if (deepRatio >= 0.5) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${deepPages}/${blogPages.length} pages (${Math.round(deepRatio * 100)}%) have 1000+ words` });
+  } else if (deepRatio >= 0.25) {
+    score += 1;
+    findings.push({ severity: "info", detail: `${deepPages}/${blogPages.length} pages have 1000+ words` });
+  }
+  if (thinRatio >= 0.5) {
+    score = Math.max(0, score - 2);
+    findings.push({ severity: "medium", detail: `${thinPages}/${blogPages.length} pages (${Math.round(thinRatio * 100)}%) have under 300 words - high thin content ratio`, fix: "Remove or expand thin pages. Thin content dilutes site quality for AI engines." });
+  } else if (thinRatio >= 0.25) {
+    score = Math.max(0, score - 1);
+    findings.push({ severity: "low", detail: `${thinPages}/${blogPages.length} pages have under 300 words` });
+  }
+  let finalScore = Math.min(10, score);
+  if (topicCoherenceScore !== void 0 && topicCoherenceScore <= 4 && finalScore >= 8) {
+    finalScore = 7;
+    findings.push({ severity: "low", detail: "Deep content but low topic coherence - depth on scattered topics has reduced AI citation value", fix: "Focus content depth on your core expertise area for maximum AI visibility" });
+  }
+  return { criterion: "content_depth", criterion_label: "Content Depth", score: finalScore, status: finalScore >= 7 ? "pass" : finalScore >= 4 ? "partial" : "fail", findings, fix_priority: finalScore >= 7 ? "P3" : "P1" };
+}
 function auditSiteFromData(data) {
+  const topicCoherence = checkTopicCoherence(data);
+  const cannibalization = checkContentCannibalization(data, topicCoherence.score);
   return [
     checkLlmsTxt(data),
     checkSchemaMarkup(data),
@@ -1793,47 +2060,55 @@ function auditSiteFromData(data) {
     checkSchemaCoverage(data),
     checkSpeakableSchema(data),
     checkQueryAnswerAlignment(data),
-    checkContentCannibalization(data),
-    checkVisibleDateSignal(data)
+    cannibalization,
+    checkVisibleDateSignal(data),
+    topicCoherence,
+    checkContentDepth(data, topicCoherence.score)
   ];
 }
 
 // src/scoring.ts
 var WEIGHTS = {
-  // Original 10
-  llms_txt: 0.1,
-  schema_markup: 0.15,
-  qa_content_format: 0.15,
-  clean_html: 0.1,
-  entity_consistency: 0.1,
-  robots_txt: 0.05,
-  faq_section: 0.1,
-  original_data: 0.1,
-  internal_linking: 0.1,
-  semantic_html: 0.05,
-  // New 12
-  content_freshness: 0.07,
-  sitemap_completeness: 0.05,
-  rss_feed: 0.03,
-  table_list_extractability: 0.07,
-  definition_patterns: 0.04,
+  // ─── Core Content (high weight - these determine real AI citation quality) ──
+  qa_content_format: 0.12,
+  original_data: 0.12,
+  topic_coherence: 0.14,
+  // NEW v2.0: biggest predictor of AI citation quality
+  fact_density: 0.08,
   direct_answer_density: 0.07,
-  content_licensing: 0.04,
+  content_depth: 0.06,
+  // NEW v2.0: substantive content vs thin pages
+  // ─── Structure & Discovery (medium weight - technical readiness) ────────────
+  schema_markup: 0.08,
+  llms_txt: 0.08,
+  clean_html: 0.08,
+  entity_consistency: 0.08,
+  faq_section: 0.08,
+  internal_linking: 0.08,
+  // ─── Content Signals (moderate weight) ──────────────────────────────────────
+  content_freshness: 0.06,
+  table_list_extractability: 0.05,
+  query_answer_alignment: 0.06,
+  definition_patterns: 0.04,
   author_schema_depth: 0.04,
-  fact_density: 0.05,
-  canonical_url: 0.04,
-  content_velocity: 0.03,
-  schema_coverage: 0.03,
-  speakable_schema: 0.03,
-  query_answer_alignment: 0.08,
   content_cannibalization: 0.05,
-  visible_date_signal: 0.04
+  visible_date_signal: 0.04,
+  semantic_html: 0.04,
+  // ─── Plumbing (low weight - nice to have but not what drives citations) ─────
+  robots_txt: 0.03,
+  sitemap_completeness: 0.03,
+  content_velocity: 0.03,
+  rss_feed: 0.02,
+  content_licensing: 0.03,
+  canonical_url: 0.02,
+  schema_coverage: 0.02,
+  speakable_schema: 0.02
 };
 function calculateOverallScore(criteria) {
   let totalWeight = 0;
   let weightedSum = 0;
   for (const c of criteria) {
-    const weight = WEIGHTS[c.criterion] ?? 0.1;
+    const weight = WEIGHTS[c.criterion] ?? 0.05;
     weightedSum += c.score / 10 * weight * 100;
     totalWeight += weight;
   }
@@ -1969,7 +2244,9 @@ var CRITERION_LABELS = {
   "Speakable Schema": "Speakable Schema",
   "Query-Answer Alignment": "Query-Answer Alignment",
   "Content Cannibalization": "Content Cannibalization",
-  "Visible Date Signal": "Visible Date Signal"
+  "Visible Date Signal": "Visible Date Signal",
+  "Topic Coherence": "Topic Coherence",
+  "Content Depth": "Content Depth"
 };
 function scoreToStatus(score) {
   if (score === 0) return "MISSING";
@@ -2878,7 +3155,7 @@ function extractTitle(html) {
 function getTextContent2(html) {
   return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
 }
-function countWords(text) {
+function countWords2(text) {
   if (!text) return 0;
   return text.split(/\s+/).filter((w) => w.length > 0).length;
 }
@@ -3029,7 +3306,7 @@ function checkHasQuestionHeadings(html) {
 function analyzePage(html, url, category) {
   const title = extractTitle(html);
   const textContent = getTextContent2(html);
-  const wordCount = countWords(textContent);
+  const wordCount = countWords2(textContent);
   const issues = [];
   const strengths = [];
   const issueChecks = [
@@ -3109,7 +3386,7 @@ async function audit(domain, options) {
     }
   }
   if (options?.fullCrawl) {
-    const { crawlFullSite: crawlFullSite2 } = await import("./full-site-crawler-VFARFR2C.js");
+    const { crawlFullSite: crawlFullSite2 } = await import("./full-site-crawler-UIOMKOZA.js");
     const crawlResult = await crawlFullSite2(siteData, {
       maxPages: options.maxPages ?? 200,
       concurrency: options.concurrency ?? 5
@@ -3154,6 +3431,1314 @@ async function audit(domain, options) {
   };
 }
 
+// src/link-graph.ts
+function serializeLinkGraph(graph) {
+  return {
+    nodes: Array.from(graph.nodes.values()),
+    stats: graph.stats,
+    clusters: graph.clusters
+  };
+}
+function normalizeUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return (parsed.origin + parsed.pathname.replace(/\/+$/, "") + parsed.search).toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+}
+var RESOURCE_EXTENSIONS = /\.(js|css|png|jpg|jpeg|gif|svg|ico|pdf|xml|txt|woff|woff2|ttf|eot|mp4|mp3|webp|avif|zip|gz|tar|json)$/i;
+var SKIP_PATH_PATTERNS = /^\/(api|wp-admin|wp-json|static|assets|_next|auth|login|signup|cart|checkout|admin|feed|xmlrpc)\b/i;
+function extractTitle2(html) {
+  const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return match ? match[1].replace(/\s+/g, " ").trim() : "";
+}
+function getTextContent3(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+function countWords3(text) {
+  if (!text) return 0;
+  return text.split(/\s+/).filter((w) => w.length > 0).length;
+}
+function extractLinksWithAnchors(html, sourceUrl, domain) {
+  const cleanDomain = domain.replace(/^www\./, "").toLowerCase();
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const anchorRegex = /<a\s[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+  let match;
+  while ((match = anchorRegex.exec(html)) !== null) {
+    const href = match[1];
+    const rawAnchor = match[2];
+    if (!href || !href.trim()) continue;
+    let fullUrl;
+    if (href.startsWith("//")) {
+      fullUrl = `https:${href}`;
+    } else if (href.startsWith("/")) {
+      if (href === "/" || href.startsWith("/#")) continue;
+      fullUrl = `https://${domain}${href}`;
+    } else if (href.startsWith("http")) {
+      fullUrl = href;
+    } else if (href.startsWith("#") || href.startsWith("?") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("javascript:")) {
+      continue;
+    } else {
+      fullUrl = `https://${domain}/${href}`;
+    }
+    try {
+      const parsed = new URL(fullUrl);
+      const linkDomain = parsed.hostname.replace(/^www\./, "").toLowerCase();
+      if (linkDomain !== cleanDomain) continue;
+      parsed.hash = "";
+      const path = parsed.pathname;
+      if (path === "/" || path === "") continue;
+      if (RESOURCE_EXTENSIONS.test(path)) continue;
+      if (SKIP_PATH_PATTERNS.test(path)) continue;
+      const normalized = normalizeUrl(fullUrl);
+      const sourceNorm = normalizeUrl(sourceUrl);
+      if (normalized === sourceNorm) continue;
+      const edgeKey = `${sourceNorm}->${normalized}`;
+      if (seen.has(edgeKey)) continue;
+      seen.add(edgeKey);
+      const anchorText = rawAnchor.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
+      edges.push({
+        source: sourceNorm,
+        target: normalized,
+        anchorText
+      });
+    } catch {
+      continue;
+    }
+  }
+  return edges;
+}
+function calculateDepths(nodes, adjacency, homepageUrl) {
+  const homeNorm = normalizeUrl(homepageUrl);
+  for (const node of nodes.values()) {
+    node.depth = Infinity;
+  }
+  const homeNode = nodes.get(homeNorm);
+  if (homeNode) {
+    homeNode.depth = 0;
+  }
+  const queue = [homeNorm];
+  const visited = /* @__PURE__ */ new Set([homeNorm]);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const currentNode = nodes.get(current);
+    if (!currentNode) continue;
+    const nextDepth = currentNode.depth + 1;
+    const neighbors = adjacency.get(current);
+    if (!neighbors) continue;
+    for (const neighbor of neighbors) {
+      if (visited.has(neighbor)) continue;
+      visited.add(neighbor);
+      const neighborNode = nodes.get(neighbor);
+      if (neighborNode) {
+        neighborNode.depth = nextDepth;
+        queue.push(neighbor);
+      }
+    }
+  }
+}
+var PILLAR_CATEGORIES = /* @__PURE__ */ new Set(["blog", "content", "resources", "docs"]);
+function detectPillars(nodes) {
+  for (const node of nodes.values()) {
+    node.isPillar = node.wordCount >= 1500 && node.inDegree >= 3 && node.outDegree >= 3 && PILLAR_CATEGORIES.has(node.category) && node.depth > 0;
+  }
+}
+var HUB_CATEGORIES = /* @__PURE__ */ new Set(["homepage", "resources", "docs"]);
+function detectHubs(nodes) {
+  for (const node of nodes.values()) {
+    node.isHub = node.outDegree >= 10 && HUB_CATEGORIES.has(node.category) || node.outDegree >= 15;
+  }
+}
+function detectClusters(nodes, edges) {
+  const clusters = [];
+  const edgeSet = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    edgeSet.add(`${edge.source}->${edge.target}`);
+  }
+  for (const node of nodes.values()) {
+    if (!node.isPillar) continue;
+    const pillarNorm = normalizeUrl(node.url);
+    const spokeSet = /* @__PURE__ */ new Set();
+    for (const edge of edges) {
+      if (edge.source === pillarNorm && nodes.has(edge.target)) {
+        spokeSet.add(edge.target);
+      }
+      if (edge.target === pillarNorm && nodes.has(edge.source)) {
+        spokeSet.add(edge.source);
+      }
+    }
+    spokeSet.delete(pillarNorm);
+    if (spokeSet.size < 2) continue;
+    const spokes = Array.from(spokeSet);
+    const members = [pillarNorm, ...spokes];
+    let actualEdges = 0;
+    const possibleEdges = members.length * (members.length - 1);
+    for (const from of members) {
+      for (const to of members) {
+        if (from === to) continue;
+        if (edgeSet.has(`${from}->${to}`)) {
+          actualEdges++;
+        }
+      }
+    }
+    const cohesion = possibleEdges > 0 ? Math.round(actualEdges / possibleEdges * 100) : 0;
+    clusters.push({
+      pillarUrl: node.url,
+      pillarTitle: node.title,
+      spokes,
+      cohesion
+    });
+  }
+  return clusters;
+}
+function buildLinkGraph(pages, domain, homepageUrl) {
+  const nodes = /* @__PURE__ */ new Map();
+  const allEdges = [];
+  const adjacency = /* @__PURE__ */ new Map();
+  const inDegreeMap = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const url = page.finalUrl || `https://${domain}`;
+    const norm = normalizeUrl(url);
+    if (nodes.has(norm)) continue;
+    const title = extractTitle2(page.text);
+    const text = getTextContent3(page.text);
+    const wordCount = countWords3(text);
+    nodes.set(norm, {
+      url: norm,
+      title,
+      wordCount,
+      category: page.category || "content",
+      inDegree: 0,
+      outDegree: 0,
+      depth: Infinity,
+      isPillar: false,
+      isHub: false,
+      isOrphan: false
+    });
+  }
+  for (const page of pages) {
+    const url = page.finalUrl || `https://${domain}`;
+    const sourceNorm = normalizeUrl(url);
+    const edges = extractLinksWithAnchors(page.text, url, domain);
+    for (const edge of edges) {
+      const targetNorm = normalizeUrl(edge.target);
+      if (!nodes.has(targetNorm)) continue;
+      allEdges.push({
+        source: sourceNorm,
+        target: targetNorm,
+        anchorText: edge.anchorText
+      });
+      if (!adjacency.has(sourceNorm)) {
+        adjacency.set(sourceNorm, /* @__PURE__ */ new Set());
+      }
+      adjacency.get(sourceNorm).add(targetNorm);
+      inDegreeMap.set(targetNorm, (inDegreeMap.get(targetNorm) || 0) + 1);
+    }
+  }
+  for (const [url, node] of nodes) {
+    node.inDegree = inDegreeMap.get(url) || 0;
+    node.outDegree = adjacency.get(url)?.size || 0;
+  }
+  calculateDepths(nodes, adjacency, homepageUrl);
+  detectPillars(nodes);
+  detectHubs(nodes);
+  const homeNorm = normalizeUrl(homepageUrl);
+  for (const [url, node] of nodes) {
+    node.isOrphan = node.inDegree === 0 && url !== homeNorm;
+  }
+  const clusters = detectClusters(nodes, allEdges);
+  const depthValues = Array.from(nodes.values()).map((n) => n.depth).filter((d) => d !== Infinity);
+  const avgDepth = depthValues.length > 0 ? Math.round(depthValues.reduce((s, d) => s + d, 0) / depthValues.length * 10) / 10 : 0;
+  const maxDepth = depthValues.length > 0 ? Math.max(...depthValues) : 0;
+  const stats = {
+    totalPages: nodes.size,
+    totalEdges: allEdges.length,
+    orphanPages: Array.from(nodes.values()).filter((n) => n.isOrphan).length,
+    pillarPages: Array.from(nodes.values()).filter((n) => n.isPillar).length,
+    hubPages: Array.from(nodes.values()).filter((n) => n.isHub).length,
+    avgDepth,
+    maxDepth,
+    clusters: clusters.length
+  };
+  return { nodes, edges: allEdges, stats, clusters };
+}
+
+// src/fix-engine.ts
+var CRITERION_WEIGHTS2 = {
+  llms_txt: 0.1,
+  schema_markup: 0.15,
+  qa_content_format: 0.15,
+  clean_html: 0.1,
+  entity_consistency: 0.1,
+  robots_txt: 0.05,
+  faq_section: 0.1,
+  original_data: 0.1,
+  internal_linking: 0.1,
+  semantic_html: 0.05,
+  content_freshness: 0.07,
+  sitemap_completeness: 0.05,
+  rss_feed: 0.03,
+  table_list_extractability: 0.07,
+  definition_patterns: 0.04,
+  direct_answer_density: 0.07,
+  content_licensing: 0.04,
+  author_schema_depth: 0.04,
+  fact_density: 0.05,
+  canonical_url: 0.04,
+  content_velocity: 0.03,
+  schema_coverage: 0.03,
+  speakable_schema: 0.03,
+  query_answer_alignment: 0.08,
+  content_cannibalization: 0.05,
+  visible_date_signal: 0.04
+};
+var PHASE_CONFIG = [
+  {
+    phase: 1,
+    title: "Foundation",
+    description: "Discovery and structural fixes that enable AI crawlers to access and parse your content.",
+    criteria: ["robots_txt", "llms_txt", "canonical_url", "clean_html", "sitemap_completeness"]
+  },
+  {
+    phase: 2,
+    title: "Content",
+    description: "Content quality and format improvements that make your pages citable by AI engines.",
+    criteria: [
+      "qa_content_format",
+      "faq_section",
+      "original_data",
+      "definition_patterns",
+      "direct_answer_density",
+      "fact_density",
+      "content_freshness",
+      "table_list_extractability",
+      "query_answer_alignment",
+      "visible_date_signal"
+    ]
+  },
+  {
+    phase: 3,
+    title: "Authority",
+    description: "Trust signals, schema depth, and semantic structure that establish credibility with AI engines.",
+    criteria: [
+      "schema_markup",
+      "schema_coverage",
+      "speakable_schema",
+      "author_schema_depth",
+      "content_licensing",
+      "entity_consistency",
+      "semantic_html"
+    ]
+  },
+  {
+    phase: 4,
+    title: "Architecture",
+    description: "Site architecture, linking patterns, and publishing cadence that support long-term AI visibility.",
+    criteria: ["internal_linking", "content_velocity", "content_cannibalization", "rss_feed"]
+  }
+];
+function impactFromScore(score) {
+  if (score <= 3) return "critical";
+  if (score <= 5) return "high";
+  if (score <= 7) return "medium";
+  return "low";
+}
+function effortForCriterion(criterion, score) {
+  const trivialCriteria = ["llms_txt", "robots_txt", "canonical_url", "content_licensing", "visible_date_signal"];
+  const lowCriteria = ["rss_feed", "sitemap_completeness", "speakable_schema", "author_schema_depth", "semantic_html", "definition_patterns", "content_freshness"];
+  const highCriteria = ["original_data", "content_velocity", "content_cannibalization"];
+  if (trivialCriteria.includes(criterion)) return score <= 3 ? "low" : "trivial";
+  if (lowCriteria.includes(criterion)) return score <= 3 ? "medium" : "low";
+  if (highCriteria.includes(criterion)) return score <= 5 ? "high" : "medium";
+  return score <= 3 ? "medium" : "low";
+}
+function getAffectedPages(criterion, pages, threshold = 7) {
+  if (!pages || pages.length === 0) return void 0;
+  const affected = pages.filter((p) => {
+    const cs = p.criterionScores?.find((c) => c.criterion === criterion);
+    return cs && cs.score < threshold;
+  });
+  if (affected.length === 0) return void 0;
+  return affected.map((p) => p.url);
+}
+function effortToHours(effort) {
+  switch (effort) {
+    case "trivial":
+      return 0.5;
+    case "low":
+      return 1;
+    case "medium":
+      return 3;
+    case "high":
+      return 8;
+  }
+}
+var FIX_GENERATORS = {
+  llms_txt: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("llms_txt", c.score);
+    const fixes = [];
+    if (c.score <= 6) {
+      fixes.push({
+        id: "fix-llms-txt-create",
+        criterion: c.criterion_label,
+        criterionId: c.criterion,
+        title: "Create /llms.txt file",
+        description: "Add a machine-readable llms.txt file at your domain root that describes your site, services, and key pages for AI engines.",
+        impact,
+        effort,
+        impactScore: 0,
+        // calculated later
+        category: "discovery",
+        steps: [
+          "Create a file named llms.txt in your site root",
+          "Add site name, description, and core URLs in markdown format",
+          "Include key service/product pages and their descriptions",
+          "Deploy and verify access at yourdomain.com/llms.txt"
+        ],
+        codeExample: `# Site Name
+> One-line site description
+
+## Core Pages
+- [About](/about): Company overview
+- [Services](/services): Service offerings
+- [Blog](/blog): Latest articles
+
+## Key Topics
+- Topic 1
+- Topic 2`,
+        successCriteria: "/llms.txt returns 200 with valid markdown content"
+      });
+    }
+    if (c.score <= 3) {
+      fixes.push({
+        id: "fix-llms-txt-full",
+        criterion: c.criterion_label,
+        criterionId: c.criterion,
+        title: "Add llms-full.txt with extended content",
+        description: "Create a comprehensive llms-full.txt with detailed page descriptions, content summaries, and topic taxonomy.",
+        impact: "medium",
+        effort: "low",
+        impactScore: 0,
+        category: "discovery",
+        steps: [
+          "Create llms-full.txt alongside llms.txt",
+          "Include full page descriptions with word counts",
+          "Add topic categories and content clusters",
+          "Link from llms.txt to llms-full.txt"
+        ],
+        successCriteria: "/llms-full.txt returns 200 with comprehensive site map"
+      });
+    }
+    return fixes;
+  },
+  schema_markup: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("schema_markup", c.score);
+    const affected = getAffectedPages("schema_markup", pages);
+    const fixes = [{
+      id: "fix-schema-markup",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add JSON-LD structured data",
+      description: "Implement Organization, WebSite, and page-specific schema.org JSON-LD to help AI engines extract your content.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "trust",
+      steps: [
+        "Add Organization JSON-LD to your homepage with name, url, logo, sameAs",
+        "Add WebSite schema with SearchAction",
+        "Add page-specific schema (Article, Service, Product, FAQPage) to relevant pages",
+        "Validate with Google Rich Results Test"
+      ],
+      codeExample: `<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "Organization",
+  "name": "Your Company",
+  "url": "https://example.com",
+  "logo": "https://example.com/logo.png",
+  "sameAs": [
+    "https://twitter.com/company",
+    "https://linkedin.com/company/company"
+  ]
+}
+</script>`,
+      successCriteria: "Homepage and key pages have valid JSON-LD schema",
+      dependsOn: ["fix-clean-html-structure"],
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+    return fixes;
+  },
+  qa_content_format: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("qa_content_format", c.score);
+    const affected = getAffectedPages("qa_content_format", pages);
+    return [{
+      id: "fix-qa-format",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add question-based headings",
+      description: "Restructure content with H2/H3 question headings that match how users query AI assistants.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Identify top user questions for each page topic",
+        "Convert section headings to question format (What, How, Why, When)",
+        "Follow each question heading with a direct 2-3 sentence answer",
+        "Add a summary answer box at the top of long-form content"
+      ],
+      successCriteria: "At least 50% of H2/H3 headings use question format",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  clean_html: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("clean_html", c.score);
+    const affected = getAffectedPages("clean_html", pages);
+    const fixes = [{
+      id: "fix-clean-html-structure",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Fix HTML structure and meta tags",
+      description: "Ensure clean, well-structured HTML with proper meta tags, HTTPS, and parseable content for AI crawlers.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "structure",
+      steps: [
+        "Enable HTTPS and redirect HTTP to HTTPS",
+        "Add proper <title>, meta description, and viewport meta tags",
+        "Fix HTML validation errors (unclosed tags, invalid nesting)",
+        "Ensure content is server-rendered (not client-side only)"
+      ],
+      successCriteria: "Pages pass HTML validation with proper meta tags and HTTPS",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+    return fixes;
+  },
+  entity_consistency: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("entity_consistency", c.score);
+    return [{
+      id: "fix-entity-consistency",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Strengthen entity authority (NAP)",
+      description: "Add consistent name, address, phone (NAP) and sameAs links across all pages to strengthen entity recognition.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "trust",
+      steps: [
+        "Ensure company name is consistent across all pages",
+        "Add Organization schema with full NAP details",
+        "Include sameAs links to social profiles and directories",
+        "Add logo and brand marks consistently"
+      ],
+      successCriteria: "Organization schema present with consistent NAP on all pages"
+    }];
+  },
+  robots_txt: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("robots_txt", c.score);
+    return [{
+      id: "fix-robots-txt",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Configure robots.txt for AI crawlers",
+      description: "Update robots.txt to explicitly allow AI crawlers and include sitemap directive.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "discovery",
+      steps: [
+        "Create or update robots.txt at domain root",
+        "Add User-agent rules for GPTBot, ClaudeBot, PerplexityBot",
+        "Include Sitemap directive pointing to sitemap.xml",
+        "Verify no accidental Disallow rules blocking content pages"
+      ],
+      codeExample: `User-agent: *
+Allow: /
+
+User-agent: GPTBot
+Allow: /
+
+User-agent: ClaudeBot
+Allow: /
+
+User-agent: PerplexityBot
+Allow: /
+
+Sitemap: https://example.com/sitemap.xml`,
+      successCriteria: "robots.txt returns 200 with AI crawler directives and Sitemap"
+    }];
+  },
+  faq_section: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("faq_section", c.score);
+    const affected = getAffectedPages("faq_section", pages);
+    return [{
+      id: "fix-faq-section",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Build FAQ sections with schema",
+      description: "Create FAQ content with FAQPage schema markup on key pages to become a direct answer source for AI engines.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Identify 8-10 most common customer questions per service area",
+        "Create dedicated FAQ page with categorized Q&A pairs",
+        "Add inline FAQ sections to key service/product pages",
+        "Implement FAQPage JSON-LD schema on all FAQ content"
+      ],
+      successCriteria: "FAQ page exists with FAQPage schema, key pages have inline FAQ sections",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  original_data: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("original_data", c.score);
+    const affected = getAffectedPages("original_data", pages);
+    return [{
+      id: "fix-original-data",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add original data and case studies",
+      description: "Publish proprietary data, statistics, case studies, or research that AI engines cannot find elsewhere.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Identify internal data assets (customer metrics, case study results, survey data)",
+        "Create data-driven content with specific numbers and percentages",
+        "Publish case studies with measurable outcomes",
+        "Add comparison tables with proprietary benchmarks"
+      ],
+      successCriteria: "At least 3 pages contain original data points not found elsewhere online",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  internal_linking: (c, pages, linkGraph) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("internal_linking", c.score);
+    const fixes = [];
+    if (linkGraph) {
+      const orphans = [];
+      linkGraph.nodes.forEach((node) => {
+        if (node.isOrphan) orphans.push(node.url);
+      });
+      if (orphans.length > 0) {
+        fixes.push({
+          id: "fix-internal-linking-orphans",
+          criterion: c.criterion_label,
+          criterionId: c.criterion,
+          title: "Link orphan pages into site navigation",
+          description: `${orphans.length} pages have no incoming internal links. These are invisible to AI crawlers that follow links.`,
+          impact: orphans.length > 5 ? "critical" : "high",
+          effort: orphans.length > 10 ? "medium" : "low",
+          impactScore: 0,
+          category: "structure",
+          steps: [
+            `Identify the ${orphans.length} orphan pages with zero incoming links`,
+            "Add contextual links from related content pages",
+            "Include orphan pages in navigation menus or footer links",
+            'Add "Related Content" sections on relevant pages'
+          ],
+          successCriteria: "All content pages have at least 1 incoming internal link",
+          affectedPages: orphans.slice(0, 20),
+          pageCount: orphans.length
+        });
+      }
+      if (linkGraph.stats.maxDepth > 3) {
+        fixes.push({
+          id: "fix-internal-linking-depth",
+          criterion: c.criterion_label,
+          criterionId: c.criterion,
+          title: "Reduce page depth for deep content",
+          description: `Max depth is ${linkGraph.stats.maxDepth} clicks from homepage. AI crawlers rarely follow links beyond 3 levels.`,
+          impact: "medium",
+          effort: "medium",
+          impactScore: 0,
+          category: "structure",
+          steps: [
+            "Identify pages more than 3 clicks from the homepage",
+            "Add direct links from high-level pages to deep content",
+            "Consider flattening URL structure for key pages",
+            "Add hub pages that aggregate related deep content"
+          ],
+          successCriteria: "All important content pages reachable within 3 clicks from homepage"
+        });
+      }
+      if (linkGraph.clusters.length === 0) {
+        fixes.push({
+          id: "fix-internal-linking-clusters",
+          criterion: c.criterion_label,
+          criterionId: c.criterion,
+          title: "Create topic clusters with pillar pages",
+          description: "No topic clusters detected. Organizing content into pillar-spoke clusters strengthens topical authority for AI engines.",
+          impact: "high",
+          effort: "high",
+          impactScore: 0,
+          category: "structure",
+          steps: [
+            "Identify 3-5 core topic areas for your business",
+            "Create comprehensive pillar pages (3000+ words) for each topic",
+            "Write 5-7 supporting articles per pillar linking back to pillar",
+            "Interlink supporting articles within each cluster"
+          ],
+          successCriteria: "At least 2 topic clusters with pillar page and 5+ spoke pages"
+        });
+      }
+    } else {
+      fixes.push({
+        id: "fix-internal-linking-generic",
+        criterion: c.criterion_label,
+        criterionId: c.criterion,
+        title: "Improve internal linking architecture",
+        description: "Strengthen internal linking with descriptive anchor text between related pages.",
+        impact,
+        effort,
+        impactScore: 0,
+        category: "structure",
+        steps: [
+          "Audit current internal link structure",
+          "Add contextual links between related content pages",
+          "Ensure every key page is reachable within 3 clicks from homepage",
+          'Use descriptive anchor text instead of "click here" or "read more"'
+        ],
+        successCriteria: "Key pages have 3+ incoming internal links with descriptive anchors"
+      });
+    }
+    return fixes;
+  },
+  semantic_html: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("semantic_html", c.score);
+    const affected = getAffectedPages("semantic_html", pages);
+    return [{
+      id: "fix-semantic-html",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Implement semantic HTML5 elements",
+      description: "Use semantic HTML5 elements (main, article, nav, header, footer, section) to give AI parsers clear content structure.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "structure",
+      steps: [
+        "Wrap main content in <main> element",
+        "Use <article> for self-contained content blocks",
+        "Add <nav> for navigation and <aside> for sidebars",
+        "Add lang attribute to <html> and ARIA labels for accessibility"
+      ],
+      successCriteria: "Pages use semantic HTML5 elements with lang attribute",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  content_freshness: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("content_freshness", c.score);
+    const affected = getAffectedPages("content_freshness", pages);
+    return [{
+      id: "fix-content-freshness",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add content freshness signals",
+      description: "Include dateModified schema, visible dates, and recent content updates to signal freshness to AI engines.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Add datePublished and dateModified to Article schema",
+        'Display visible "Last updated" dates on content pages',
+        "Update stale content with current information",
+        "Add <time> elements with datetime attributes for all dates"
+      ],
+      successCriteria: "Content pages show visible dates and have dateModified in schema",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  sitemap_completeness: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("sitemap_completeness", c.score);
+    return [{
+      id: "fix-sitemap",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Create complete sitemap.xml",
+      description: "Generate a comprehensive sitemap with lastmod dates for all important pages.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "discovery",
+      steps: [
+        "Generate sitemap.xml listing all content pages",
+        "Include <lastmod> dates for each URL",
+        "Set <changefreq> and <priority> appropriately",
+        "Reference sitemap in robots.txt"
+      ],
+      successCriteria: "sitemap.xml returns 200 with all content pages and lastmod dates"
+    }];
+  },
+  rss_feed: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("rss_feed", c.score);
+    return [{
+      id: "fix-rss-feed",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Deploy RSS/Atom feed",
+      description: "Add an RSS or Atom feed for your blog/news content to signal active publishing to AI engines.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "discovery",
+      steps: [
+        "Create RSS 2.0 or Atom feed for blog/news content",
+        "Include title, description, pubDate, and full content for each item",
+        'Add <link rel="alternate" type="application/rss+xml"> to page head',
+        "Auto-generate feed on each new publish"
+      ],
+      codeExample: `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>Your Site Blog</title>
+    <link>https://example.com/blog</link>
+    <description>Latest articles</description>
+    <item>
+      <title>Article Title</title>
+      <link>https://example.com/blog/article</link>
+      <pubDate>Mon, 01 Jan 2024 00:00:00 GMT</pubDate>
+      <description>Article summary</description>
+    </item>
+  </channel>
+</rss>`,
+      successCriteria: "RSS feed returns valid XML with recent content items"
+    }];
+  },
+  table_list_extractability: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("table_list_extractability", c.score);
+    const affected = getAffectedPages("table_list_extractability", pages);
+    return [{
+      id: "fix-tables-lists",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add structured tables and lists",
+      description: "Use HTML tables for comparison data and lists for features, steps, and specifications.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Identify data suitable for table format (comparisons, pricing, specs)",
+        "Convert bullet points to proper <ul>/<ol> lists",
+        "Add comparison tables with <th> headers",
+        "Ensure tables have descriptive captions"
+      ],
+      successCriteria: "Key pages contain at least one HTML table or structured list",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  definition_patterns: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("definition_patterns", c.score);
+    const affected = getAffectedPages("definition_patterns", pages);
+    return [{
+      id: "fix-definitions",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add definition-style content",
+      description: 'Include clear definition patterns for key terms and concepts that AI engines can cite for "what is" queries.',
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Identify key industry terms your audience searches for",
+        'Write clear definitions using "X is..." or "X refers to..." patterns',
+        "Place definitions near the top of relevant pages",
+        "Consider a glossary page for comprehensive term coverage"
+      ],
+      successCriteria: "Key pages contain definition patterns for relevant terms",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  direct_answer_density: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("direct_answer_density", c.score);
+    const affected = getAffectedPages("direct_answer_density", pages);
+    return [{
+      id: "fix-direct-answers",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add direct answer paragraphs",
+      description: "Write concise, standalone answer paragraphs after question headings for AI engine citations.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Identify question-format headings on each page",
+        "Write a 2-3 sentence direct answer immediately after each heading",
+        "Ensure answers are self-contained (don't require context from other sections)",
+        "Use bold for key facts within answer paragraphs"
+      ],
+      successCriteria: "Question headings are followed by direct, concise answer paragraphs",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  content_licensing: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("content_licensing", c.score);
+    return [{
+      id: "fix-content-licensing",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add ai.txt and content licensing",
+      description: "Create an /ai.txt file specifying AI usage permissions and add license schema to structured data.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "trust",
+      steps: [
+        "Create ai.txt at domain root with usage permissions",
+        "Specify allowed AI uses (training, citation, summarization)",
+        "Add license information to schema markup",
+        "Consider a content licensing page linked from footer"
+      ],
+      codeExample: `# ai.txt - AI Usage Policy for example.com
+
+User-Agent: *
+Allow: /blog/
+Allow: /docs/
+
+# Permissions
+Training: yes
+Citation: yes with attribution
+Summarization: yes`,
+      successCriteria: "/ai.txt returns 200 with clear AI usage permissions"
+    }];
+  },
+  author_schema_depth: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("author_schema_depth", c.score);
+    return [{
+      id: "fix-author-schema",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Enhance author and expert schema",
+      description: "Add Person schema for content authors with credentials and sameAs links for E-E-A-T signals.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "trust",
+      steps: [
+        "Create author profile pages for content creators",
+        "Add Person schema with name, jobTitle, credentials, sameAs",
+        "Link articles to author profiles via schema author property",
+        "Include author bio and expertise on article pages"
+      ],
+      successCriteria: "Articles have Person schema for authors with credentials"
+    }];
+  },
+  fact_density: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("fact_density", c.score);
+    const affected = getAffectedPages("fact_density", pages);
+    return [{
+      id: "fix-fact-density",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Increase fact and data density",
+      description: "Add specific numbers, percentages, statistics, and data points that AI engines can cite.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Review content for vague claims and replace with specific data",
+        "Add statistics, percentages, and measurable outcomes",
+        "Include source citations for data points",
+        "Add data tables or comparison charts where appropriate"
+      ],
+      successCriteria: "Key pages contain at least 3 specific data points per 500 words",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  canonical_url: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("canonical_url", c.score);
+    const affected = getAffectedPages("canonical_url", pages);
+    return [{
+      id: "fix-canonical-url",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Fix canonical URL strategy",
+      description: 'Add rel="canonical" tags to all pages to prevent duplicate content confusion.',
+      impact,
+      effort,
+      impactScore: 0,
+      category: "structure",
+      steps: [
+        'Add <link rel="canonical"> to every page pointing to preferred URL',
+        "Ensure canonical URLs use consistent scheme (https) and format",
+        "Handle www vs non-www with proper redirects",
+        "Set canonical for paginated content to the main page"
+      ],
+      codeExample: `<link rel="canonical" href="https://example.com/page" />`,
+      successCriteria: 'All pages have rel="canonical" pointing to the correct URL',
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  content_velocity: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("content_velocity", c.score);
+    return [{
+      id: "fix-content-velocity",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Increase publishing frequency",
+      description: "Establish a regular content publishing cadence to signal active, current information to AI engines.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Set a publishing schedule (weekly or bi-weekly minimum)",
+        "Create a content calendar covering key topics",
+        "Update sitemap and RSS feed with each new publish",
+        "Refresh existing evergreen content with current data"
+      ],
+      successCriteria: "At least 2 new or updated content pages per month with dated entries"
+    }];
+  },
+  schema_coverage: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("schema_coverage", c.score);
+    return [{
+      id: "fix-schema-coverage",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Extend schema to inner pages",
+      description: "Add page-specific structured data beyond the homepage to articles, services, and product pages.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "trust",
+      steps: [
+        "Add Article schema to blog/news pages",
+        "Add Service/Product schema to service/product pages",
+        "Add BreadcrumbList schema to all inner pages",
+        "Validate each page type with Rich Results Test"
+      ],
+      successCriteria: "At least 50% of content pages have page-specific schema",
+      dependsOn: ["fix-schema-markup"]
+    }];
+  },
+  speakable_schema: (c) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("speakable_schema", c.score);
+    return [{
+      id: "fix-speakable-schema",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add SpeakableSpecification schema",
+      description: "Add Speakable schema to tell voice assistants which content sections are best for spoken answers.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "trust",
+      steps: [
+        "Identify key paragraphs suitable for voice readout",
+        "Add SpeakableSpecification with CSS selectors to Article schema",
+        "Point speakable selectors to headline and summary paragraphs",
+        "Test with Google structured data testing tool"
+      ],
+      codeExample: `"speakable": {
+  "@type": "SpeakableSpecification",
+  "cssSelector": [
+    ".article-headline",
+    ".article-summary"
+  ]
+}`,
+      successCriteria: "Article pages include SpeakableSpecification in schema",
+      dependsOn: ["fix-schema-markup"]
+    }];
+  },
+  query_answer_alignment: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("query_answer_alignment", c.score);
+    const affected = getAffectedPages("query_answer_alignment", pages);
+    return [{
+      id: "fix-query-answer-alignment",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Improve query-answer alignment",
+      description: "Ensure question headings are followed by direct, concise answers in the first paragraph.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Audit question-format headings and their following paragraphs",
+        "Add direct answers in the first 1-2 sentences after each question heading",
+        "Remove filler text between question and answer",
+        "Ensure answers are self-contained and citable"
+      ],
+      successCriteria: "Question headings have direct answer paragraphs within 50 words",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  content_cannibalization: (c, pages, linkGraph) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("content_cannibalization", c.score);
+    const fixes = [];
+    if (linkGraph && linkGraph.clusters.length > 0) {
+      const lowCohesion = linkGraph.clusters.filter((cl) => cl.cohesion < 50);
+      if (lowCohesion.length > 0) {
+        const affected = lowCohesion.flatMap((cl) => [cl.pillarUrl, ...cl.spokes]);
+        fixes.push({
+          id: "fix-content-cannibalization-overlap",
+          criterion: c.criterion_label,
+          criterionId: c.criterion,
+          title: "Consolidate overlapping content",
+          description: `${lowCohesion.length} content clusters have low cohesion, suggesting pages compete for the same topics.`,
+          impact,
+          effort,
+          impactScore: 0,
+          category: "content",
+          steps: [
+            "Identify pages targeting the same keywords or topics",
+            "Merge overlapping pages into single authoritative pages",
+            "Set up 301 redirects from merged pages to consolidated page",
+            "Differentiate remaining similar pages with distinct angles"
+          ],
+          successCriteria: "No two pages target the same primary keyword or topic",
+          affectedPages: affected.slice(0, 20),
+          pageCount: affected.length
+        });
+      }
+    }
+    if (fixes.length === 0) {
+      const affected = getAffectedPages("content_cannibalization", pages);
+      fixes.push({
+        id: "fix-content-cannibalization",
+        criterion: c.criterion_label,
+        criterionId: c.criterion,
+        title: "Resolve content cannibalization",
+        description: "Multiple pages may be targeting the same topics, diluting AI engine citations.",
+        impact,
+        effort,
+        impactScore: 0,
+        category: "content",
+        steps: [
+          "Audit pages for overlapping topic coverage",
+          "Consolidate similar pages into comprehensive single pages",
+          "Differentiate remaining pages with distinct angles and keywords",
+          "Add canonical tags to prevent duplicate content issues"
+        ],
+        successCriteria: "Each topic is covered by a single authoritative page",
+        affectedPages: affected,
+        pageCount: affected?.length
+      });
+    }
+    return fixes;
+  },
+  visible_date_signal: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("visible_date_signal", c.score);
+    const affected = getAffectedPages("visible_date_signal", pages);
+    return [{
+      id: "fix-visible-dates",
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add visible date signals",
+      description: "Add visible publication and modification dates using <time> elements for AI engine freshness assessment.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        'Add visible "Published" and "Last updated" dates to content pages',
+        "Use <time> elements with datetime attributes",
+        "Ensure dates match dateModified in schema markup",
+        "Update dates when content is refreshed"
+      ],
+      codeExample: `<time datetime="2024-01-15">January 15, 2024</time>`,
+      successCriteria: "Content pages show visible dates with <time> elements",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  }
+};
+function generateFixPlan(domain, overallScore, criteria, pagesReviewed, linkGraph) {
+  const allFixes = [];
+  for (const criterion of criteria) {
+    const generator = FIX_GENERATORS[criterion.criterion];
+    if (!generator) continue;
+    const fixes = generator(criterion, pagesReviewed, linkGraph);
+    for (const fix of fixes) {
+      const weight = CRITERION_WEIGHTS2[criterion.criterion] ?? 0.05;
+      fix.impactScore = Math.round((10 - criterion.score) * weight * 100);
+      allFixes.push(fix);
+    }
+  }
+  const phases = PHASE_CONFIG.map((config) => {
+    const phaseFixes = allFixes.filter((fix) => config.criteria.includes(fix.criterionId)).sort((a, b) => b.impactScore - a.impactScore);
+    return {
+      phase: config.phase,
+      title: config.title,
+      description: config.description,
+      fixes: phaseFixes,
+      estimatedImpact: 0
+      // calculated after projected score
+    };
+  });
+  for (const phase of phases) {
+    for (const fix of phase.fixes) {
+      if (!fix.dependsOn) continue;
+      for (const depId of fix.dependsOn) {
+        const depPhase = phases.find((p) => p.fixes.some((f) => f.id === depId));
+        if (depPhase && depPhase.phase > phase.phase) {
+          phase.fixes = phase.fixes.filter((f) => f.id !== fix.id);
+          depPhase.fixes.push(fix);
+          depPhase.fixes.sort((a, b) => b.impactScore - a.impactScore);
+          break;
+        }
+      }
+    }
+  }
+  const totalWeight = Object.values(CRITERION_WEIGHTS2).reduce((s, w) => s + w, 0);
+  const bestDeltaPerCriterion = /* @__PURE__ */ new Map();
+  for (const fix of allFixes) {
+    const criterion = criteria.find((c) => c.criterion === fix.criterionId);
+    if (!criterion) continue;
+    const weight = CRITERION_WEIGHTS2[fix.criterionId] ?? 0.05;
+    let targetScore;
+    switch (fix.effort) {
+      case "trivial":
+      case "low":
+        targetScore = 8;
+        break;
+      case "medium":
+        targetScore = 7;
+        break;
+      case "high":
+        targetScore = 6;
+        break;
+    }
+    const improvement = Math.max(0, targetScore - criterion.score);
+    const delta = improvement * weight / totalWeight * 100;
+    const existing = bestDeltaPerCriterion.get(fix.criterionId) ?? 0;
+    if (delta > existing) bestDeltaPerCriterion.set(fix.criterionId, delta);
+  }
+  const scoreDelta = Array.from(bestDeltaPerCriterion.values()).reduce((s, d) => s + d, 0);
+  const projectedScore = Math.min(100, Math.round(overallScore + scoreDelta));
+  for (const phase of phases) {
+    let phaseImpact = 0;
+    const seenCriteria = /* @__PURE__ */ new Set();
+    for (const fix of phase.fixes) {
+      if (seenCriteria.has(fix.criterionId)) continue;
+      seenCriteria.add(fix.criterionId);
+      const criterion = criteria.find((c) => c.criterion === fix.criterionId);
+      if (!criterion) continue;
+      const weight = CRITERION_WEIGHTS2[fix.criterionId] ?? 0.05;
+      let targetScore;
+      switch (fix.effort) {
+        case "trivial":
+        case "low":
+          targetScore = 8;
+          break;
+        case "medium":
+          targetScore = 7;
+          break;
+        case "high":
+          targetScore = 6;
+          break;
+      }
+      const improvement = Math.max(0, targetScore - criterion.score);
+      phaseImpact += improvement * weight / totalWeight * 100;
+    }
+    phase.estimatedImpact = Math.round(phaseImpact);
+  }
+  const quickWins = allFixes.filter(
+    (f) => (f.effort === "trivial" || f.effort === "low") && (f.impact === "critical" || f.impact === "high")
+  );
+  const summary = {
+    criticalCount: allFixes.filter((f) => f.impact === "critical").length,
+    highCount: allFixes.filter((f) => f.impact === "high").length,
+    mediumCount: allFixes.filter((f) => f.impact === "medium").length,
+    lowCount: allFixes.filter((f) => f.impact === "low").length,
+    quickWinCount: quickWins.length,
+    topOpportunity: allFixes.length > 0 ? allFixes.sort((a, b) => b.impactScore - a.impactScore)[0].title : "None",
+    estimatedTotalEffort: formatEffort(allFixes.reduce((s, f) => s + effortToHours(f.effort), 0))
+  };
+  return {
+    domain,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    overallScore,
+    projectedScore,
+    totalFixes: allFixes.length,
+    phases,
+    quickWins,
+    summary
+  };
+}
+function formatEffort(hours) {
+  if (hours < 1) return "<1h";
+  return `~${Math.round(hours)}h`;
+}
+
 // src/html-report.ts
 function scoreColor(score) {
   if (score <= 40) return "#F44336";
@@ -3489,21 +5074,28 @@ export {
   audit,
   auditSiteFromData,
   buildDetailedFindings,
+  buildLinkGraph,
   buildScorecard,
+  calculateDepths,
   calculateOverallScore,
   classifyRendering,
   compare,
   crawlFullSite,
+  detectClusters,
+  detectHubs,
   detectParkedDomain,
+  detectPillars,
   extractAllUrlsFromSitemap,
   extractContentPagesFromSitemap,
   extractInternalLinks,
+  extractLinksWithAnchors,
   extractNavLinks,
   extractRawDataSummary,
   fetchMultiPageData,
   fetchWithHeadless,
   generateBottomLine,
   generateComparisonHtmlReport,
+  generateFixPlan,
   generateHtmlReport,
   generateOpportunities,
   generatePitchNumbers,
@@ -3513,6 +5105,7 @@ export {
   prefetchSiteData,
   scoreAllPages,
   scorePage,
-  scoreToStatus
+  scoreToStatus,
+  serializeLinkGraph
 };
 //# sourceMappingURL=index.js.map