aeorank 1.4.0 → 1.6.0

package/dist/index.js

@@ -2523,12 +2523,359 @@ async function fetchMultiPageData(siteData, options) {
   return added;
 }
 
+// src/page-scorer.ts
+var PAGE_CRITERIA = {
+  schema_markup: { weight: 0.15, label: "Schema.org Structured Data" },
+  qa_content_format: { weight: 0.15, label: "Q&A Content Format" },
+  clean_html: { weight: 0.1, label: "Clean, Crawlable HTML" },
+  faq_section: { weight: 0.1, label: "FAQ Section Content" },
+  original_data: { weight: 0.1, label: "Original Data & Expert Content" },
+  query_answer_alignment: { weight: 0.08, label: "Query-Answer Alignment" },
+  content_freshness: { weight: 0.07, label: "Content Freshness Signals" },
+  table_list_extractability: { weight: 0.07, label: "Table & List Extractability" },
+  direct_answer_density: { weight: 0.07, label: "Direct Answer Paragraphs" },
+  semantic_html: { weight: 0.05, label: "Semantic HTML5 & Accessibility" },
+  fact_density: { weight: 0.05, label: "Fact & Data Density" },
+  definition_patterns: { weight: 0.04, label: "Definition Patterns" },
+  canonical_url: { weight: 0.04, label: "Canonical URL Strategy" },
+  visible_date_signal: { weight: 0.04, label: "Visible Date Signal" }
+};
+function extractJsonLdBlocks(html) {
+  const blocks = [];
+  const regex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    blocks.push(match[1]);
+  }
+  return blocks;
+}
+function extractTypesFromJsonLd(blocks) {
+  const types = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    const typeMatches = block.match(/"@type"\s*:\s*"([^"]+)"/g) || [];
+    for (const m of typeMatches) {
+      const t = m.match(/"@type"\s*:\s*"([^"]+)"/);
+      if (t) types.add(t[1]);
+    }
+  }
+  return types;
+}
+function getTextContent(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+function extractQuestionHeadings2(html) {
+  const headings = html.match(/<h[2-3][^>]*>([\s\S]*?)<\/h[2-3]>/gi) || [];
+  const questions = [];
+  for (const h of headings) {
+    const text = h.replace(/<[^>]*>/g, "").trim();
+    if (/\?$/.test(text) || /^(what|how|why|when|where|who|which|can|do|does|is|are|should|will)\b/i.test(text)) {
+      questions.push(text);
+    }
+  }
+  return questions;
+}
+function countAnsweredQuestions(html) {
+  const questions = extractQuestionHeadings2(html);
+  if (questions.length === 0) return { total: 0, answered: 0 };
+  let answered = 0;
+  for (const q of questions) {
+    const escaped = q.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(escaped + "[\\s\\S]*?</h[2-3]>\\s*<p[^>]*>([\\s\\S]*?)</p>", "i");
+    const match = html.match(pattern);
+    if (match && match[1].replace(/<[^>]*>/g, "").trim().length >= 20) {
+      answered++;
+    }
+  }
+  return { total: questions.length, answered };
+}
+function cap(value, max) {
+  return Math.min(value, max);
+}
+function scoreSchemaMarkup(html) {
+  const blocks = extractJsonLdBlocks(html);
+  if (blocks.length === 0) return 0;
+  let score = 3;
+  const types = extractTypesFromJsonLd(blocks);
+  const knownTypes = [
+    "Organization",
+    "LocalBusiness",
+    "Article",
+    "FAQPage",
+    "Product",
+    "WebPage",
+    "BreadcrumbList",
+    "HowTo",
+    "Person",
+    "WebSite",
+    "BlogPosting",
+    "Service"
+  ];
+  let knownCount = 0;
+  for (const t of types) {
+    if (knownTypes.includes(t)) knownCount++;
+  }
+  score += cap(knownCount * 2, 4);
+  if (types.has("Organization") || types.has("LocalBusiness")) score += 2;
+  if (types.has("FAQPage")) score += 1;
+  return cap(score, 10);
+}
+function scoreQAFormat(html) {
+  const questions = extractQuestionHeadings2(html);
+  let score = 0;
+  if (questions.length >= 10) score += 5;
+  else if (questions.length >= 3) score += 3;
+  else if (questions.length >= 1) score += 1;
+  const { answered } = countAnsweredQuestions(html);
+  if (answered >= 1) score += 3;
+  const h1Matches = html.match(/<h1[\s>]/gi) || [];
+  if (h1Matches.length === 1) score += 2;
+  return cap(score, 10);
+}
+function scoreCleanHtml(html) {
+  let score = 0;
+  const semantics = ["<main", "<article", "<section"];
+  let semCount = 0;
+  for (const tag of semantics) {
+    if (html.toLowerCase().includes(tag)) semCount++;
+  }
+  score += cap(semCount, 3);
+  const h1Matches = html.match(/<h1[\s>]/gi) || [];
+  if (h1Matches.length === 1) score += 2;
+  const text = getTextContent(html);
+  if (text.length > 500) score += 3;
+  const hasTitle = /<title[^>]*>[^<]+<\/title>/i.test(html);
+  const hasDesc = /<meta\s[^>]*name=["']description["'][^>]*content=["'][^"']+["']/i.test(html) || /<meta\s[^>]*content=["'][^"']+["'][^>]*name=["']description["']/i.test(html);
+  if (hasTitle && hasDesc) score += 2;
+  return cap(score, 10);
+}
+function scoreFaqSection(html) {
+  let score = 0;
+  const lowerHtml = html.toLowerCase();
+  if (/frequently\s*asked|faq/i.test(html)) score += 2;
+  const blocks = extractJsonLdBlocks(html);
+  const types = extractTypesFromJsonLd(blocks);
+  if (types.has("FAQPage")) score += 3;
+  const questions = extractQuestionHeadings2(html);
+  if (questions.length >= 10) score += 1;
+  if (/<details[\s>]/i.test(html) || /accordion|collapsible|toggle/i.test(lowerHtml)) score += 1;
+  return cap(score, 10);
+}
+function scoreOriginalData(html) {
+  let score = 0;
+  const text = getTextContent(html);
+  if (/\b(our (study|analysis|research|survey|data|findings))\b/i.test(text)) {
+    score += 3;
+  } else if (/\d+(\.\d+)?%|\$[\d,.]+|\b\d{1,3}(,\d{3})+\b/.test(text)) {
+    score += 1;
+  }
+  if (/\bcase\s+stud(y|ies)\b/i.test(text) && /\d+(\.\d+)?%|\$[\d,.]+/.test(text)) {
+    score += 3;
+  } else if (/\bcase\s+stud(y|ies)\b/i.test(text)) {
+    score += 1;
+  }
+  if (/\baccording\s+to\b|\bexpert|\b(Ph\.?D|MD|professor|analyst|researcher)\b/i.test(text)) {
+    score += 2;
+  }
+  if (/href=["'][^"']*\/blog\b/i.test(html)) {
+    score += 2;
+  }
+  return cap(score, 10);
+}
+function scoreQueryAnswerAlignment(html) {
+  const { total, answered } = countAnsweredQuestions(html);
+  if (total === 0) return 5;
+  const ratio = answered / total;
+  if (ratio >= 0.8) return 10;
+  if (ratio >= 0.5) return 7;
+  if (answered > 0) return 4;
+  return 0;
+}
+function scoreContentFreshness(html) {
+  let score = 0;
+  const blocks = extractJsonLdBlocks(html);
+  const allJsonLd = blocks.join(" ");
+  if (/datePublished|dateModified/i.test(allJsonLd)) score += 3;
+  const timeElements = html.match(/<time[\s>]/gi) || [];
+  if (timeElements.length >= 2) score += 3;
+  else if (timeElements.length === 1) score += 1;
+  if (/<meta\s[^>]*property=["']article:(published_time|modified_time)["']/i.test(html)) score += 2;
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  const yearPattern = new RegExp(`\\b(${currentYear}|${currentYear - 1})\\b`);
+  if (yearPattern.test(html)) score += 2;
+  return cap(score, 10);
+}
+function scoreTableListExtractability(html) {
+  let score = 0;
+  const tablesWithHeaders = html.match(/<table[\s\S]*?<th[\s>]/gi) || [];
+  if (tablesWithHeaders.length >= 2) score += 4;
+  else if (tablesWithHeaders.length === 1) score += 3;
+  if (tablesWithHeaders.length === 0 && /<table[\s>]/i.test(html)) score += 1;
+  if (/<ol[\s>]/i.test(html)) score += 2;
+  if (/<ul[\s>]/i.test(html)) score += 2;
+  const listItems = html.match(/<li[\s>]/gi) || [];
+  if (listItems.length >= 10) score += 1;
+  if (/<dl[\s>]/i.test(html)) score += 1;
+  return cap(score, 10);
+}
+function scoreDirectAnswerDensity(html) {
+  let score = 0;
+  const { answered } = countAnsweredQuestions(html);
+  if (answered >= 3) score += 6;
+  else if (answered >= 1) score += 3;
+  const paragraphs = html.match(/<p[^>]*>([\s\S]*?)<\/p>/gi) || [];
+  let snippetCount = 0;
+  for (const p of paragraphs) {
+    const text = p.replace(/<[^>]*>/g, "").trim();
+    const words = text.split(/\s+/).filter((w) => w.length > 0).length;
+    if (words >= 40 && words <= 150) snippetCount++;
+  }
+  if (snippetCount >= 3) score += 2;
+  else if (snippetCount >= 1) score += 1;
+  const directOpeners = getTextContent(html).match(/\b(yes|no|in short|the answer is|simply put|in summary)\b/gi) || [];
+  if (directOpeners.length >= 2) score += 2;
+  return cap(score, 10);
+}
+function scoreSemanticHtml(html) {
+  let score = 0;
+  const lowerHtml = html.toLowerCase();
+  const elements = ["<main", "<article", "<time", "<nav", "<header", "<footer"];
+  let count = 0;
+  for (const el of elements) {
+    if (lowerHtml.includes(el)) count++;
+  }
+  score += cap(Math.floor(count * 0.7), 4);
+  const imgTags = html.match(/<img\s[^>]*>/gi) || [];
+  if (imgTags.length > 0) {
+    let withAlt = 0;
+    for (const img of imgTags) {
+      if (/\salt=["'][^"']*["']/i.test(img)) withAlt++;
+    }
+    if (withAlt / imgTags.length >= 0.8) score += 2;
+  }
+  if (/<html[^>]*\slang=["'][^"']+["']/i.test(html)) score += 2;
+  if (/\baria-/i.test(html)) score += 2;
+  return cap(score, 10);
+}
+function scoreFactDensity(html) {
+  let score = 0;
+  const text = getTextContent(html);
+  const numericPatterns = text.match(/\d+(\.\d+)?%|\$[\d,.]+|\b\d{1,3}(,\d{3})+\b|\b\d+\s*(million|billion|thousand|users|customers|employees)\b/gi) || [];
+  if (numericPatterns.length >= 6) score += 5;
+  else if (numericPatterns.length >= 3) score += 3;
+  else if (numericPatterns.length >= 1) score += 1;
+  const years = /* @__PURE__ */ new Set();
+  const yearMatches = text.match(/\b(19|20)\d{2}\b/g) || [];
+  for (const y of yearMatches) years.add(y);
+  if (years.size >= 2) score += 2;
+  else if (years.size === 1) score += 1;
+  if (/\baccording to\b|\bsource:\s|\bcited\b|\breported by\b/i.test(text)) score += 2;
+  const units = text.match(/\b\d+\s*(kg|lb|miles|km|hours|minutes|days|months|years|GB|MB|TB)\b/gi) || [];
+  if (units.length >= 2) score += 1;
+  return cap(score, 10);
+}
+function scoreDefinitionPatterns(html) {
+  let score = 0;
+  const text = getTextContent(html);
+  const defPatterns = text.match(/\b(is a|is an|refers to|defined as|means that|also known as|abbreviated as)\b/gi) || [];
+  if (defPatterns.length >= 3) score += 5;
+  else if (defPatterns.length >= 1) score += 3;
+  const early = text.slice(0, 2e3);
+  if (/\b(is a|is an|refers to|defined as)\b/i.test(early)) score += 2;
+  if (/<dfn[\s>]/i.test(html) || /<abbr[\s>]/i.test(html)) score += 1;
+  if (/<dl[\s>]/i.test(html) || /glossary/i.test(html)) score += 2;
+  return cap(score, 10);
+}
+function scoreCanonicalUrl(html, url) {
+  let score = 0;
+  const canonicalMatch = html.match(/<link[^>]*rel=["']canonical["'][^>]*href=["']([^"']+)["']/i) || html.match(/<link[^>]*href=["']([^"']+)["'][^>]*rel=["']canonical["']/i);
+  if (!canonicalMatch) return 0;
+  score += 4;
+  const canonicalHref = canonicalMatch[1];
+  if (url) {
+    try {
+      const canonicalUrl = new URL(canonicalHref, url);
+      const pageUrl = new URL(url);
+      if (canonicalUrl.pathname === pageUrl.pathname && canonicalUrl.hostname === pageUrl.hostname) {
+        score += 3;
+      }
+    } catch {
+    }
+  }
+  if (canonicalHref.startsWith("https://")) score += 2;
+  const allCanonicals = html.match(/<link[^>]*rel=["']canonical["'][^>]*>/gi) || [];
+  if (allCanonicals.length === 1) score += 1;
+  return cap(score, 10);
+}
+function scoreVisibleDateSignal(html) {
+  let score = 0;
+  const timeWithDatetime = html.match(/<time[^>]*datetime=["'][^"']+["'][^>]*>[^<]+<\/time>/gi) || [];
+  if (timeWithDatetime.length > 0) score += 5;
+  const blocks = extractJsonLdBlocks(html);
+  const allJsonLd = blocks.join(" ");
+  if (/datePublished|dateModified/i.test(allJsonLd)) score += 3;
+  if (/<meta\s[^>]*property=["']article:(published_time|modified_time)["']/i.test(html)) score += 2;
+  const modifiedMatch = allJsonLd.match(/"dateModified"\s*:\s*"([^"]+)"/i);
+  if (modifiedMatch) {
+    try {
+      const modified = new Date(modifiedMatch[1]);
+      const daysDiff = (Date.now() - modified.getTime()) / (1e3 * 60 * 60 * 24);
+      if (daysDiff <= 180) score += 1;
+    } catch {
+    }
+  }
+  return cap(score, 10);
+}
+var SCORING_FUNCTIONS = {
+  schema_markup: scoreSchemaMarkup,
+  qa_content_format: scoreQAFormat,
+  clean_html: scoreCleanHtml,
+  faq_section: scoreFaqSection,
+  original_data: scoreOriginalData,
+  query_answer_alignment: scoreQueryAnswerAlignment,
+  content_freshness: scoreContentFreshness,
+  table_list_extractability: scoreTableListExtractability,
+  direct_answer_density: scoreDirectAnswerDensity,
+  semantic_html: scoreSemanticHtml,
+  fact_density: scoreFactDensity,
+  definition_patterns: scoreDefinitionPatterns,
+  canonical_url: scoreCanonicalUrl,
+  visible_date_signal: scoreVisibleDateSignal
+};
+function scorePage(html, url) {
+  let totalWeight = 0;
+  let weightedSum = 0;
+  const criterionScores = [];
+  for (const [criterion, { weight, label }] of Object.entries(PAGE_CRITERIA)) {
+    const fn = SCORING_FUNCTIONS[criterion];
+    const score = fn(html, url);
+    criterionScores.push({ criterion, criterion_label: label, score, weight });
+    weightedSum += score / 10 * weight * 100;
+    totalWeight += weight;
+  }
+  const aeoScore = totalWeight === 0 ? 0 : Math.round(weightedSum / totalWeight);
+  return { aeoScore, criterionScores };
+}
+function scoreAllPages(siteData) {
+  const results = [];
+  if (siteData.homepage) {
+    const url = siteData.protocol ? `${siteData.protocol}://${siteData.domain}` : void 0;
+    results.push(scorePage(siteData.homepage.text, url));
+  }
+  if (siteData.blogSample) {
+    for (const page of siteData.blogSample) {
+      const url = page.finalUrl || void 0;
+      results.push(scorePage(page.text, url));
+    }
+  }
+  return results;
+}
+
 // src/page-analyzer.ts
 function extractTitle(html) {
   const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
   return match ? match[1].replace(/\s+/g, " ").trim() : "";
 }
-function getTextContent(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) {
@@ -2681,7 +3028,7 @@ function checkHasQuestionHeadings(html) {
 }
 function analyzePage(html, url, category) {
   const title = extractTitle(html);
-  const textContent = getTextContent(html);
+  const textContent = getTextContent2(html);
   const wordCount = countWords(textContent);
   const issues = [];
   const strengths = [];
@@ -2707,7 +3054,8 @@ function analyzePage(html, url, category) {
   for (const result of strengthChecks) {
     if (result) strengths.push(result);
   }
-  return { url, title, category, wordCount, issues, strengths };
+  const { aeoScore, criterionScores } = scorePage(html, url);
+  return { url, title, category, wordCount, issues, strengths, aeoScore, criterionScores };
 }
 function analyzeAllPages(siteData) {
   const reviews = [];
@@ -2806,6 +3154,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 countWords2(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 = countWords2(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";
@@ -2915,17 +4571,22 @@ function generateHtmlReport(result) {
         <td>${escapeHtml(opp.description)}</td>
       </tr>`;
   }).join("\n");
-  const pagesRows = (result.pagesReviewed || []).map((page) => {
+  const pagesReviewed = result.pagesReviewed || [];
+  const pagesRows = pagesReviewed.map((page) => {
     const issueCount = page.issues.length;
     const strengthCount = page.strengths.length;
+    const aeoDisplay = page.aeoScore != null ? `<span style="font-weight:600;color:${scoreColor(page.aeoScore)}">${page.aeoScore}</span>` : "-";
     return `<tr>
         <td>${escapeHtml(page.url)}</td>
         <td>${escapeHtml(page.category)}</td>
         <td>${page.wordCount}</td>
+        <td>${aeoDisplay}</td>
         <td>${issueCount}</td>
         <td>${strengthCount}</td>
       </tr>`;
   }).join("\n");
+  const scoredPages = pagesReviewed.filter((p) => p.aeoScore != null);
+  const avgPageScore = scoredPages.length > 0 ? Math.round(scoredPages.reduce((sum, p) => sum + p.aeoScore, 0) / scoredPages.length) : null;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return `<!DOCTYPE html>
 <html lang="en">
@@ -2961,10 +4622,11 @@ function generateHtmlReport(result) {
     </table>
     ` : ""}
 
-    ${(result.pagesReviewed || []).length > 0 ? `
-    <h2 class="section-title">Pages Reviewed (${(result.pagesReviewed || []).length})</h2>
+    ${pagesReviewed.length > 0 ? `
+    <h2 class="section-title">Pages Reviewed (${pagesReviewed.length})</h2>
+    ${avgPageScore != null ? `<div class="summary-box"><div class="summary-stat"><div class="num" style="color:${scoreColor(avgPageScore)}">${avgPageScore}</div><div class="label">Avg Page AEO Score</div></div></div>` : ""}
     <table>
-      <thead><tr><th>URL</th><th>Category</th><th>Words</th><th>Issues</th><th>Strengths</th></tr></thead>
+      <thead><tr><th>URL</th><th>Category</th><th>Words</th><th>AEO Score</th><th>Issues</th><th>Strengths</th></tr></thead>
       <tbody>${pagesRows}</tbody>
     </table>
     ` : ""}
@@ -3135,21 +4797,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,
@@ -3157,6 +4826,9 @@ export {
   inferCategory,
   isSpaShell,
   prefetchSiteData,
-  scoreToStatus
+  scoreAllPages,
+  scorePage,
+  scoreToStatus,
+  serializeLinkGraph
 };
 //# sourceMappingURL=index.js.map