aeorank 1.6.0 → 2.0.0

package/dist/index.d.cts

@@ -233,7 +233,7 @@ interface SiteData {
     redirectedTo: string | null;
     /** Set when homepage is a parked/for-sale/lost domain */
     parkedReason: string | null;
-    /** Sampled blog/content pages from sitemap (up to 5) */
+    /** Sampled blog/content pages from sitemap (up to 50) */
     blogSample?: FetchResult[];
     /** Full-crawl statistics (set when --full-crawl is used) */
     crawlStats?: {

package/dist/index.d.ts

@@ -233,7 +233,7 @@ interface SiteData {
     redirectedTo: string | null;
     /** Set when homepage is a parked/for-sale/lost domain */
     parkedReason: string | null;
-    /** Sampled blog/content pages from sitemap (up to 5) */
+    /** Sampled blog/content pages from sitemap (up to 50) */
     blogSample?: FetchResult[];
     /** Full-crawl statistics (set when --full-crawl is used) */
     crawlStats?: {

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
@@ -3179,7 +3456,7 @@ function extractTitle2(html) {
 function getTextContent3(html) {
   return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
 }
-function countWords2(text) {
+function countWords3(text) {
   if (!text) return 0;
   return text.split(/\s+/).filter((w) => w.length > 0).length;
 }
@@ -3327,7 +3604,7 @@ function buildLinkGraph(pages, domain, homepageUrl) {
     if (nodes.has(norm)) continue;
     const title = extractTitle2(page.text);
     const text = getTextContent3(page.text);
-    const wordCount = countWords2(text);
+    const wordCount = countWords3(text);
     nodes.set(norm, {
       url: norm,
       title,