aeorank 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2584 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CRITERION_LABELS: () => CRITERION_LABELS,
+  analyzeAllPages: () => analyzeAllPages,
+  analyzePage: () => analyzePage,
+  audit: () => audit,
+  auditSiteFromData: () => auditSiteFromData,
+  buildDetailedFindings: () => buildDetailedFindings,
+  buildScorecard: () => buildScorecard,
+  calculateOverallScore: () => calculateOverallScore,
+  classifyRendering: () => classifyRendering,
+  detectParkedDomain: () => detectParkedDomain,
+  extractContentPagesFromSitemap: () => extractContentPagesFromSitemap,
+  extractNavLinks: () => extractNavLinks,
+  extractRawDataSummary: () => extractRawDataSummary,
+  fetchMultiPageData: () => fetchMultiPageData,
+  fetchWithHeadless: () => fetchWithHeadless,
+  generateBottomLine: () => generateBottomLine,
+  generateOpportunities: () => generateOpportunities,
+  generatePitchNumbers: () => generatePitchNumbers,
+  generateVerdict: () => generateVerdict,
+  isSpaShell: () => isSpaShell,
+  prefetchSiteData: () => prefetchSiteData,
+  scoreToStatus: () => scoreToStatus
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parked-domain.ts
+var PARKING_PATHS = ["/lander", "/parking", "/park", "/sedoparking"];
+var PARKING_SERVICE_DOMAINS = [
+  "sedoparking.com",
+  "parkingcrew.net",
+  "bodis.com",
+  "dsparking.com",
+  "hugedomains.com",
+  "afternic.com",
+  "dan.com",
+  "undeveloped.com",
+  "domainmarket.com",
+  "sav.com",
+  "domaincontrol.com",
+  "above.com",
+  "domainlore.com",
+  "domainnamesales.com",
+  "brandbucket.com",
+  "squadhelp.com",
+  "godaddy.com/domainsearch"
+];
+var PARKING_TEXT_PATTERNS = [
+  /\bbuy this domain\b/i,
+  /\bdomain is for sale\b/i,
+  /\bthis domain may be for sale\b/i,
+  /\bdomain for sale\b/i,
+  /\bthis domain name is available\b/i,
+  /\bparked by/i,
+  /\bthis page is parked/i,
+  /\bdomain has expired/i,
+  /\bthis domain has been registered/i,
+  /\bmake an offer on this domain\b/i,
+  /\bget this domain\b/i,
+  /\bacquire this domain\b/i
+];
+function detectParkingRedirect(bodySnippet) {
+  const relativeRedirect = bodySnippet.match(
+    /window\.location\.(replace|assign|href)\s*[=(]\s*['"](\/[^'"]*)['"]/i
+  );
+  if (!relativeRedirect) return null;
+  const path = relativeRedirect[2].toLowerCase().replace(/[?#].*/, "");
+  if (PARKING_PATHS.includes(path)) {
+    return `js-redirect to ${relativeRedirect[2]}`;
+  }
+  return null;
+}
+function detectParkingService(bodySnippet) {
+  const lower = bodySnippet.toLowerCase();
+  for (const service of PARKING_SERVICE_DOMAINS) {
+    if (lower.includes(service)) {
+      return `parking service: ${service}`;
+    }
+  }
+  return null;
+}
+function detectParkingText(bodySnippet) {
+  for (const pattern of PARKING_TEXT_PATTERNS) {
+    if (pattern.test(bodySnippet)) {
+      return `parking text: ${bodySnippet.match(pattern)?.[0]}`;
+    }
+  }
+  return null;
+}
+function detectParkedDomain(bodySnippet) {
+  const parkingRedirect = detectParkingRedirect(bodySnippet);
+  if (parkingRedirect) return { isParked: true, reason: parkingRedirect };
+  const parkingService = detectParkingService(bodySnippet);
+  if (parkingService) return { isParked: true, reason: parkingService };
+  const parkingText = detectParkingText(bodySnippet);
+  if (parkingText) return { isParked: true, reason: parkingText };
+  return { isParked: false };
+}
+
+// src/site-crawler.ts
+async function fetchText(url) {
+  try {
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(15e3),
+      headers: { "User-Agent": "AEO-Visibility-Bot/1.0" },
+      redirect: "follow"
+    });
+    const text = await res.text();
+    return { text: text.slice(0, 5e5), status: res.status, finalUrl: res.url };
+  } catch {
+    return null;
+  }
+}
+function extractDomain(url) {
+  return url.replace(/^https?:\/\//, "").replace(/\/.*/, "").replace(/:[0-9]+$/, "").replace(/^www\./, "").toLowerCase();
+}
+function extractBrandName(domain) {
+  const parts = domain.split(".");
+  const twoPartTlds = ["co.uk", "com.au", "co.jp", "com.br", "co.nz", "co.in"];
+  const lastTwo = parts.slice(-2).join(".");
+  if (twoPartTlds.includes(lastTwo) && parts.length > 2) {
+    return parts.slice(0, -2).join(".");
+  }
+  return parts.length > 1 ? parts.slice(0, -1).join(".") : domain;
+}
+function detectCrossDomainRedirect(originalDomain, homepage) {
+  if (!homepage.finalUrl) return null;
+  const finalDomain = extractDomain(homepage.finalUrl);
+  const cleanOriginal = originalDomain.replace(/^www\./, "").toLowerCase();
+  if (finalDomain === cleanOriginal || finalDomain === `www.${cleanOriginal}` || extractBrandName(finalDomain) === extractBrandName(cleanOriginal)) {
+    return null;
+  }
+  return finalDomain;
+}
+function detectJsRedirect(bodySnippet, originalDomain) {
+  const jsMatch = bodySnippet.match(
+    /window\.location\.(replace|assign|href)\s*[=(]\s*['"]https?:\/\/([^'"]+)['"]/i
+  );
+  if (!jsMatch) return null;
+  const jsDomain = extractDomain("https://" + jsMatch[2]);
+  const cleanOriginal = originalDomain.replace(/^www\./, "").toLowerCase();
+  if (jsDomain === cleanOriginal || jsDomain === `www.${cleanOriginal}` || extractBrandName(jsDomain) === extractBrandName(cleanOriginal)) {
+    return null;
+  }
+  return jsDomain;
+}
+function isHtmlResponse(result) {
+  if (!result || result.status !== 200) return false;
+  const trimmed = result.text.trimStart().slice(0, 200).toLowerCase();
+  return trimmed.startsWith("<!doctype html") || trimmed.startsWith("<html") || /<head[\s>]/i.test(trimmed);
+}
+async function prefetchSiteData(domain) {
+  let protocol = null;
+  let homepage = null;
+  homepage = await fetchText(`https://${domain}`);
+  if (homepage && homepage.status >= 200 && homepage.status < 400) {
+    protocol = "https";
+  } else {
+    homepage = await fetchText(`http://${domain}`);
+    if (homepage && homepage.status >= 200 && homepage.status < 400) {
+      protocol = "http";
+    }
+  }
+  if (!protocol) {
+    return { domain, protocol: null, homepage: null, llmsTxt: null, robotsTxt: null, faqPage: null, sitemapXml: null, rssFeed: null, aiTxt: null, redirectedTo: null, parkedReason: null, blogSample: [] };
+  }
+  const httpRedirect = homepage ? detectCrossDomainRedirect(domain, homepage) : null;
+  const jsRedirect = homepage ? detectJsRedirect(homepage.text.slice(0, 8192), domain) : null;
+  const redirectedTo = httpRedirect || jsRedirect;
+  if (redirectedTo) {
+    return { domain, protocol, homepage, llmsTxt: null, robotsTxt: null, faqPage: null, sitemapXml: null, rssFeed: null, aiTxt: null, redirectedTo, parkedReason: null, blogSample: [] };
+  }
+  const parkedResult = homepage ? detectParkedDomain(homepage.text.slice(0, 8192)) : { isParked: false };
+  if (parkedResult.isParked) {
+    return { domain, protocol, homepage, llmsTxt: null, robotsTxt: null, faqPage: null, sitemapXml: null, rssFeed: null, aiTxt: null, redirectedTo: null, parkedReason: parkedResult.reason || "parked", blogSample: [] };
+  }
+  const baseUrl = `${protocol}://${domain}`;
+  const [llmsTxt, robotsTxt, faqPage, sitemapXml, aiTxt] = await Promise.all([
+    fetchText(`${baseUrl}/llms.txt`),
+    fetchText(`${baseUrl}/robots.txt`),
+    fetchText(`${baseUrl}/faq`).then(async (result) => {
+      if (result && result.status === 200) return result;
+      for (const path of ["/frequently-asked-questions", "/help", "/support", "/help-center"]) {
+        const fallback = await fetchText(`${baseUrl}${path}`);
+        if (fallback && fallback.status === 200) return fallback;
+      }
+      return result;
+    }),
+    fetchText(`${baseUrl}/sitemap.xml`),
+    fetchText(`${baseUrl}/ai.txt`)
+  ]);
+  let rssFeed = null;
+  if (homepage) {
+    const rssLinkMatch = homepage.text.match(/<link[^>]*type="application\/(?:rss|atom)\+xml"[^>]*href="([^"]*)"[^>]*>/i);
+    if (rssLinkMatch) {
+      const rssUrl = rssLinkMatch[1].startsWith("http") ? rssLinkMatch[1] : `${baseUrl}${rssLinkMatch[1]}`;
+      rssFeed = await fetchText(rssUrl);
+    }
+    if (!rssFeed || rssFeed.status !== 200) {
+      for (const path of ["/feed", "/rss.xml", "/feed.xml"]) {
+        rssFeed = await fetchText(`${baseUrl}${path}`);
+        if (rssFeed && rssFeed.status === 200 && (rssFeed.text.includes("<rss") || rssFeed.text.includes("<feed") || rssFeed.text.includes("<channel"))) break;
+        rssFeed = null;
+      }
+    }
+  }
+  let blogSample = [];
+  if (sitemapXml && sitemapXml.status === 200) {
+    let sitemapForBlog = sitemapXml.text;
+    const subSitemapUrl = extractSubSitemapUrl(sitemapForBlog);
+    if (subSitemapUrl) {
+      const subSitemap = await fetchText(subSitemapUrl);
+      if (subSitemap && subSitemap.status === 200) {
+        sitemapForBlog = subSitemap.text;
+      }
+    }
+    const blogUrls = extractBlogUrlsFromSitemap(sitemapForBlog, domain, 10);
+    if (blogUrls.length > 0) {
+      const fetched = await Promise.all(blogUrls.map((url) => fetchText(url)));
+      blogSample = fetched.filter(
+        (r) => r !== null && r.status === 200 && r.text.length > 500
+      );
+      for (const page of blogSample) {
+        page.category = "blog";
+      }
+    }
+  }
+  if (homepage) homepage.category = "homepage";
+  return { domain, protocol, homepage, llmsTxt, robotsTxt, faqPage, sitemapXml, rssFeed, aiTxt, redirectedTo: null, parkedReason: null, blogSample };
+}
+function getCombinedHtml(data) {
+  const parts = [data.homepage?.text || ""];
+  if (data.blogSample) {
+    for (const page of data.blogSample) {
+      parts.push(page.text);
+    }
+  }
+  return parts.join("\n");
+}
+function getBlogHtml(data) {
+  if (!data.blogSample || data.blogSample.length === 0) return "";
+  return data.blogSample.map((p) => p.text).join("\n");
+}
+function checkLlmsTxt(data) {
+  const findings = [];
+  const result = data.llmsTxt;
+  if (!result || result.status !== 200 || isHtmlResponse(result)) {
+    const statusNote = result ? isHtmlResponse(result) ? "HTML page served (not a valid text file)" : `HTTP ${result.status}` : "connection failed";
+    findings.push({ severity: "critical", detail: `No llms.txt file found at ${data.protocol}://${data.domain}/llms.txt (${statusNote})`, fix: "Create a /llms.txt file that describes your site, services, and key pages in markdown format" });
+    return { criterion: "llms_txt", criterion_label: "llms.txt File", score: 0, status: "fail", findings, fix_priority: "P0" };
+  }
+  const text = result.text;
+  let score = 4;
+  if (text.length < 100) {
+    findings.push({ severity: "medium", detail: `llms.txt exists but is very short (${text.length} characters)`, fix: "Add comprehensive description of your services, team, and key content" });
+  } else {
+    score += 2;
+    findings.push({ severity: "info", detail: `llms.txt file found (${text.length} characters)` });
+  }
+  if (text.includes("#") || text.includes("##")) {
+    score += 2;
+    findings.push({ severity: "info", detail: "llms.txt uses markdown headings for structure" });
+  } else {
+    findings.push({ severity: "low", detail: "llms.txt lacks markdown structure", fix: "Add headings (# About, ## Services, etc.) for better LLM parsing" });
+  }
+  if (/https?:\/\//.test(text)) {
+    score += 2;
+    findings.push({ severity: "info", detail: "llms.txt includes URLs to key pages" });
+  } else {
+    findings.push({ severity: "medium", detail: "llms.txt does not link to key pages", fix: "Add URLs to your most important pages (services, about, FAQ)" });
+  }
+  return { criterion: "llms_txt", criterion_label: "llms.txt File", score: Math.min(10, score), status: score >= 7 ? "pass" : "partial", findings, fix_priority: score >= 7 ? "P3" : "P0" };
+}
+function checkSchemaMarkup(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage to check schema markup" });
+    return { criterion: "schema_markup", criterion_label: "Schema.org Structured Data", score: 0, status: "not_found", findings, fix_priority: "P1" };
+  }
+  const html = data.homepage.text;
+  const ldJsonMatches = html.match(/<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/gi) || [];
+  let score = 0;
+  if (ldJsonMatches.length === 0) {
+    findings.push({ severity: "critical", detail: "No JSON-LD structured data found on homepage", fix: 'Add Organization, LocalBusiness, or WebSite schema in a <script type="application/ld+json"> tag' });
+    return { criterion: "schema_markup", criterion_label: "Schema.org Structured Data", score: 0, status: "fail", findings, fix_priority: "P1" };
+  }
+  score += 3;
+  findings.push({ severity: "info", detail: `Found ${ldJsonMatches.length} JSON-LD block(s) on homepage` });
+  const allSchemaText = ldJsonMatches.join(" ").toLowerCase();
+  const schemaTypes = ["organization", "localbusiness", "faqpage", "service", "article", "webpage", "website", "breadcrumblist", "howto", "product"];
+  const foundTypes = [];
+  for (const type of schemaTypes) {
+    if (allSchemaText.includes(`"${type}"`) || allSchemaText.includes(`"@type":"${type}"`)) {
+      foundTypes.push(type);
+    }
+  }
+  if (foundTypes.length > 0) {
+    score += Math.min(4, foundTypes.length * 2);
+    findings.push({ severity: "info", detail: `Schema types found: ${foundTypes.join(", ")}` });
+  }
+  if (!foundTypes.includes("organization") && !foundTypes.includes("localbusiness")) {
+    findings.push({ severity: "high", detail: "Missing Organization or LocalBusiness schema", fix: "Add Organization schema with name, url, logo, contactPoint, and sameAs properties" });
+  } else {
+    score += 2;
+    findings.push({ severity: "info", detail: "Organization or LocalBusiness schema found" });
+  }
+  if (!foundTypes.includes("faqpage")) {
+    findings.push({ severity: "medium", detail: "No FAQPage schema found", fix: "Add FAQPage schema on pages with FAQ content" });
+  } else {
+    score += 1;
+    findings.push({ severity: "info", detail: "FAQPage schema markup present" });
+  }
+  if (data.blogSample && data.blogSample.length > 0) {
+    const blogHtml = getBlogHtml(data);
+    const blogLdJson = blogHtml.match(/<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/gi) || [];
+    if (blogLdJson.length > 0) {
+      const blogSchemaText = blogLdJson.join(" ").toLowerCase();
+      const blogTypes = schemaTypes.filter(
+        (t) => (blogSchemaText.includes(`"${t}"`) || blogSchemaText.includes(`"@type":"${t}"`)) && !foundTypes.includes(t)
+      );
+      if (blogTypes.length > 0) {
+        score += Math.min(2, blogTypes.length);
+        findings.push({ severity: "info", detail: `Additional schema types found on blog pages: ${blogTypes.join(", ")}` });
+      }
+      if (!foundTypes.includes("faqpage") && /faqpage/i.test(blogSchemaText)) {
+        score += 1;
+        findings.push({ severity: "info", detail: "FAQPage schema found on blog posts" });
+      }
+    }
+  }
+  return { criterion: "schema_markup", criterion_label: "Schema.org Structured Data", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P2" : "P1" };
+}
+function checkQAFormat(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "qa_content_format", criterion_label: "Q&A Content Format", score: 0, status: "not_found", findings, fix_priority: "P1" };
+  }
+  const html = data.homepage.text;
+  let score = 0;
+  const combinedHtml = getCombinedHtml(data);
+  const hTagContent = (combinedHtml.match(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/gi) || []).map((h) => h.replace(/<[^>]*>/g, ""));
+  const questionHeadings = hTagContent.filter((h) => h.includes("?") || /^(what|how|why|when|who|where|can|do|does|is|are|should)\s/i.test(h));
+  if (questionHeadings.length >= 10) {
+    score += 5;
+    findings.push({ severity: "info", detail: `Found ${questionHeadings.length} question-format headings` });
+  } else if (questionHeadings.length >= 3) {
+    score += 3;
+    findings.push({ severity: "info", detail: `Found ${questionHeadings.length} question-format headings` });
+  } else if (questionHeadings.length >= 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Only ${questionHeadings.length} question-format heading(s) found`, fix: "Structure more content as Q&A with question headings (H2/H3) followed by direct answers" });
+  } else {
+    findings.push({ severity: "high", detail: "No question-format headings found", fix: 'Add Q&A sections with headings like "What is...?", "How does...?" followed by concise answers' });
+  }
+  const hasDirectAnswers = /<h[2-3][^>]*>[^<]*\?<\/h[2-3]>\s*<p[^>]*>[\s\S]{20,500}<\/p>/i.test(combinedHtml);
+  if (hasDirectAnswers) {
+    score += 3;
+    findings.push({ severity: "info", detail: "Content uses direct-answer format after question headings" });
+  } else {
+    findings.push({ severity: "medium", detail: "Content does not follow direct-answer format", fix: "Start each answer paragraph with a concise 1-2 sentence definition before elaborating" });
+  }
+  const h1Count = (html.match(/<h1[\s>]/gi) || []).length;
+  if (h1Count === 1) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Proper single H1 tag hierarchy" });
+  } else if (h1Count === 0) {
+    findings.push({ severity: "high", detail: "No H1 tag found", fix: "Add exactly one H1 tag as the main page heading" });
+  } else {
+    score += 1;
+    findings.push({ severity: "medium", detail: `Multiple H1 tags found (${h1Count})`, fix: "Use only one H1 per page; use H2/H3 for subsections" });
+  }
+  return { criterion: "qa_content_format", criterion_label: "Q&A Content Format", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P2" : "P1" };
+}
+function checkCleanHTML(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "clean_html", criterion_label: "Clean, Crawlable HTML", score: 0, status: "not_found", findings, fix_priority: "P1" };
+  }
+  const html = data.homepage.text;
+  let score = 0;
+  const httpsAvailable = data.protocol === "https";
+  if (httpsAvailable) {
+    findings.push({ severity: "info", detail: "Site serves over HTTPS" });
+  } else {
+    findings.push({ severity: "critical", detail: "Site does not support HTTPS", fix: "Enable HTTPS with a valid SSL certificate. Sites without HTTPS are penalized by AI crawlers." });
+  }
+  const hasMain = /<main[\s>]/i.test(html);
+  const hasArticle = /<article[\s>]/i.test(html);
+  const hasSection = /<section[\s>]/i.test(html);
+  const semanticCount = [hasMain, hasArticle, hasSection].filter(Boolean).length;
+  score += Math.min(3, semanticCount * 1);
+  if (semanticCount >= 2) {
+    findings.push({ severity: "info", detail: `Uses semantic HTML5 elements: ${[hasMain && "main", hasArticle && "article", hasSection && "section"].filter(Boolean).join(", ")}` });
+  } else {
+    findings.push({ severity: "medium", detail: "Limited semantic HTML5 usage", fix: "Wrap main content in <main>, use <article> for standalone content, <section> for grouped content" });
+  }
+  const h1Count = (html.match(/<h1[\s>]/gi) || []).length;
+  if (h1Count === 1) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Single H1 tag found - correct heading hierarchy" });
+  } else {
+    findings.push({ severity: h1Count === 0 ? "high" : "medium", detail: `${h1Count === 0 ? "No" : "Multiple"} H1 tag(s) found (${h1Count})`, fix: "Use exactly one H1 per page" });
+  }
+  const textContent = html.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
+  if (textContent.length > 500) {
+    score += 3;
+    findings.push({ severity: "info", detail: "Page has substantial text content accessible without JavaScript" });
+  } else {
+    findings.push({ severity: "high", detail: "Very little text content visible in HTML source", fix: "Ensure key content is server-rendered, not loaded via JavaScript only" });
+  }
+  const hasMetaDesc = /<meta[^>]*name="description"[^>]*>/i.test(html);
+  const hasTitle = /<title[^>]*>[^<]+<\/title>/i.test(html);
+  if (hasMetaDesc && hasTitle) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Page has title and meta description" });
+  } else {
+    findings.push({ severity: "medium", detail: `Missing ${!hasTitle ? "title tag" : ""}${!hasTitle && !hasMetaDesc ? " and " : ""}${!hasMetaDesc ? "meta description" : ""}`, fix: 'Add <title> and <meta name="description"> tags' });
+  }
+  if (!httpsAvailable) {
+    score = Math.min(score, 3);
+  }
+  return { criterion: "clean_html", criterion_label: "Clean, Crawlable HTML", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P1" };
+}
+function checkEntityConsistency(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "entity_consistency", criterion_label: "Entity Authority & E-E-A-T", score: 0, status: "not_found", findings, fix_priority: "P1" };
+  }
+  const html = data.homepage.text;
+  const text = html.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  let score = 0;
+  const hasTelLink = /href="tel:/i.test(html);
+  const hasSchemaTelephone = /"telephone"/i.test(html);
+  const phoneContextWords = /\b(phone|call|tel:|contact\s*us|fax|dial)\b/i;
+  const phoneRegex = /(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g;
+  const phones = text.match(phoneRegex) || [];
+  const contextValidatedPhones = [];
+  if (hasTelLink || hasSchemaTelephone) {
+    contextValidatedPhones.push(...phones);
+  } else {
+    let match;
+    const phoneRegex2 = /(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g;
+    while ((match = phoneRegex2.exec(text)) !== null) {
+      const start = Math.max(0, match.index - 100);
+      const end = Math.min(text.length, match.index + match[0].length + 100);
+      const surrounding = text.slice(start, end);
+      if (phoneContextWords.test(surrounding)) {
+        contextValidatedPhones.push(match[0]);
+      }
+    }
+  }
+  const uniquePhones = [...new Set(contextValidatedPhones.map((p) => p.replace(/\D/g, "")))];
+  if (uniquePhones.length === 1) {
+    score += 3;
+    findings.push({ severity: "info", detail: "Single consistent phone number found" });
+  } else if (uniquePhones.length > 1) {
+    score += 1;
+    findings.push({ severity: "medium", detail: `Multiple phone numbers found (${uniquePhones.length})`, fix: "Use one primary phone number consistently across all pages" });
+  } else {
+    findings.push({ severity: "low", detail: "No phone number found on homepage" });
+    score += 1;
+  }
+  const hasAddress = /\d+\s+\w+\s+(street|st|avenue|ave|road|rd|drive|dr|blvd|boulevard|lane|ln|way|court|ct)/i.test(text);
+  if (hasAddress) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Physical address found on page" });
+  }
+  const hasOrgSchema = /organization|localbusiness/i.test(html);
+  if (hasOrgSchema) {
+    score += 3;
+    findings.push({ severity: "info", detail: "Organization/LocalBusiness schema reinforces entity identity" });
+  } else {
+    findings.push({ severity: "high", detail: "No Organization schema to reinforce entity identity", fix: "Add Organization JSON-LD with consistent name, address, phone, and social links" });
+  }
+  const hasSameAs = /sameas|linkedin\.com|facebook\.com|twitter\.com|x\.com/i.test(html);
+  if (hasSameAs) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Social media / sameAs references found" });
+  } else {
+    findings.push({ severity: "low", detail: "No social media links or sameAs found", fix: "Add sameAs links in Organization schema to social profiles" });
+  }
+  return { criterion: "entity_consistency", criterion_label: "Entity Authority & E-E-A-T", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P1" };
+}
+function checkRobotsTxt(data) {
+  const findings = [];
+  const result = data.robotsTxt;
+  if (!result || result.status !== 200 || isHtmlResponse(result)) {
+    findings.push({ severity: "high", detail: "No robots.txt file found", fix: "Create a robots.txt that explicitly allows AI crawlers" });
+    return { criterion: "robots_txt", criterion_label: "robots.txt for AI Crawlers", score: 2, status: "fail", findings, fix_priority: "P0" };
+  }
+  const text = result.text.toLowerCase();
+  let score = 3;
+  const aiCrawlers = ["gptbot", "claudebot", "perplexitybot", "anthropic", "chatgpt"];
+  const mentionedCrawlers = aiCrawlers.filter((c) => text.includes(c));
+  if (mentionedCrawlers.length > 0) {
+    score += 3;
+    findings.push({ severity: "info", detail: `AI crawlers mentioned: ${mentionedCrawlers.join(", ")}` });
+    const blocked = mentionedCrawlers.filter((c) => {
+      const sectionRegex = new RegExp(`user-agent:\\s*${c}[^\\S\\n]*\\n([\\s\\S]*?)(?=user-agent:|$)`, "i");
+      const match = sectionRegex.exec(result.text);
+      if (!match) return false;
+      const section = match[1];
+      if (/^allow:\s*\/\s*$/im.test(section)) return false;
+      return /^disallow:\s*\/\s*$/im.test(section);
+    });
+    if (blocked.length > 0) {
+      score -= 2;
+      findings.push({ severity: "critical", detail: `AI crawlers BLOCKED: ${blocked.join(", ")}`, fix: "Change Disallow: / to Allow: / for AI crawler user-agents" });
+    } else {
+      score += 2;
+      findings.push({ severity: "info", detail: "AI crawlers are allowed to index the site" });
+    }
+  } else {
+    findings.push({ severity: "medium", detail: "No explicit AI crawler rules in robots.txt", fix: "Add User-agent rules for GPTBot, ClaudeBot, PerplexityBot with Allow: /" });
+  }
+  if (text.includes("sitemap:")) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Sitemap URL referenced in robots.txt" });
+  } else {
+    findings.push({ severity: "low", detail: "No sitemap reference in robots.txt", fix: "Add Sitemap: https://yoursite.com/sitemap.xml to robots.txt" });
+  }
+  return { criterion: "robots_txt", criterion_label: "robots.txt for AI Crawlers", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 4 ? "P2" : "P0" };
+}
+function checkFAQSection(data) {
+  const findings = [];
+  let score = 0;
+  const homepage = data.homepage;
+  const hasHomepageFAQ = homepage && /faq|frequently\s+asked/i.test(homepage.text);
+  if (hasHomepageFAQ) {
+    score += 2;
+    findings.push({ severity: "info", detail: "FAQ content found on homepage" });
+  } else {
+    findings.push({ severity: "low", detail: "No FAQ content found on homepage", fix: "Add an FAQ section to your homepage addressing common visitor questions" });
+  }
+  const faqPage = data.faqPage;
+  const hasFaqPage = faqPage && faqPage.status === 200 && faqPage.text.length > 500;
+  if (hasFaqPage) {
+    score += 3;
+    findings.push({ severity: "info", detail: "Dedicated FAQ page exists" });
+    if (/accordion|toggle|collaps|expand/i.test(faqPage.text)) {
+      score += 1;
+      findings.push({ severity: "info", detail: "FAQ uses accordion/toggle UI pattern" });
+    }
+  } else {
+    findings.push({ severity: "high", detail: "No dedicated FAQ page found at /faq", fix: "Create a comprehensive FAQ page at /faq covering common questions about your service" });
+  }
+  const blogHtml = getBlogHtml(data);
+  const allHtml = (homepage?.text || "") + (faqPage?.text || "") + blogHtml;
+  if (/faqpage/i.test(allHtml) && /application\/ld\+json/i.test(allHtml)) {
+    score += 3;
+    const faqOnBlog = blogHtml && /faqpage/i.test(blogHtml) && /application\/ld\+json/i.test(blogHtml);
+    findings.push({ severity: "info", detail: faqOnBlog ? "FAQPage schema markup found on blog posts" : "FAQPage schema markup found" });
+  } else {
+    findings.push({ severity: "medium", detail: "No FAQPage schema markup", fix: "Add FAQPage JSON-LD schema to pages with FAQ content" });
+  }
+  const questionCount = (allHtml.match(/<h[2-4][^>]*>[^<]*\?<\/h[2-4]>/gi) || []).length;
+  if (questionCount >= 10) {
+    score += 1;
+    findings.push({ severity: "info", detail: `${questionCount} question headings found across checked pages` });
+  } else if (questionCount >= 5) {
+    findings.push({ severity: "low", detail: `Only ${questionCount} question headings found`, fix: "Expand FAQ to cover at least 10-15 common questions" });
+  }
+  return { criterion: "faq_section", criterion_label: "Comprehensive FAQ Sections", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 4 ? "P2" : "P1" };
+}
+function checkOriginalData(data) {
+  const findings = [];
+  if (!data.homepage) {
+    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 html = data.homepage.text;
+  const text = html.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)) {
+    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)) {
+      score += 3;
+      findings.push({ severity: "info", detail: "Proprietary statistics with research context found on homepage" });
+    } 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..."' });
+    }
+  } else {
+    findings.push({ severity: "medium", detail: "No proprietary data or statistics found", fix: "Add unique statistics, case study results, or industry data that LLMs would cite as authoritative" });
+  }
+  const caseStudyPattern = /case\s+stud|testimonial|success\s+stor|client\s+stor/i;
+  if (caseStudyPattern.test(text)) {
+    const caseStudyRegex = /case\s+stud|testimonial|success\s+stor|client\s+stor/gi;
+    let hasMetricNearby = false;
+    let csMatch;
+    while ((csMatch = caseStudyRegex.exec(text)) !== null) {
+      const start = Math.max(0, csMatch.index - 200);
+      const end = Math.min(text.length, csMatch.index + csMatch[0].length + 200);
+      const surrounding = text.slice(start, end);
+      if (/\d+%|\$[\d,]+|\d+x\b/i.test(surrounding)) {
+        hasMetricNearby = true;
+        break;
+      }
+    }
+    if (hasMetricNearby) {
+      score += 3;
+      findings.push({ severity: "info", detail: "Case studies or testimonials with specific metrics found" });
+    } else {
+      score += 1;
+      findings.push({ severity: "low", detail: "Case studies or testimonials mentioned but without specific metrics", fix: 'Add measurable outcomes to case studies (e.g., "increased traffic by 45%")' });
+    }
+  } else {
+    findings.push({ severity: "medium", detail: "No case studies or testimonials found", fix: "Add case studies with specific outcomes and metrics" });
+  }
+  const combinedText = data.blogSample && data.blogSample.length > 0 ? text + " " + data.blogSample.map((p) => p.text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ")).join(" ") : text;
+  if (/written\s+by|authored\s+by|expert|specialist|board.certified|licensed/i.test(combinedText)) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Expert attribution or credentials found" });
+  } else {
+    findings.push({ severity: "low", detail: "No expert attribution or credentials visible", fix: "Add author bios with credentials to establish E-E-A-T signals" });
+  }
+  const contentLinkPattern = /href="[^"]*\/(?:blog|articles|insights|guides|resources)\b[^"]*"/i;
+  if (contentLinkPattern.test(html)) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Links to blog/articles section found on site" });
+  } else {
+    findings.push({ severity: "medium", detail: "No links to blog or articles section found", fix: "Create a content section with expert articles and link to it from your homepage" });
+  }
+  if (data.blogSample && data.blogSample.length > 0 && !caseStudyPattern.test(text)) {
+    const blogText = data.blogSample.map((p) => p.text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ")).join(" ");
+    if (caseStudyPattern.test(blogText)) {
+      score += 1;
+      findings.push({ severity: "info", detail: "Case studies or testimonials found on blog posts" });
+    }
+  }
+  return { criterion: "original_data", criterion_label: "Original Data & Expert Content", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 4 ? "P2" : "P2" };
+}
+function checkInternalLinking(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "internal_linking", criterion_label: "Internal Linking Architecture", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const html = data.homepage.text;
+  let score = 0;
+  const linkMatches = html.match(/<a[^>]*href="([^"]*)"[^>]*>/gi) || [];
+  const internalLinks = linkMatches.filter((l) => {
+    const href = l.match(/href="([^"]*)"/)?.[1] || "";
+    return href.startsWith("/") || href.includes(data.domain);
+  });
+  if (internalLinks.length >= 20) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${internalLinks.length} internal links found on homepage` });
+  } else if (internalLinks.length >= 10) {
+    score += 2;
+    findings.push({ severity: "low", detail: `${internalLinks.length} internal links on homepage`, fix: "Add more internal links to key service/content pages" });
+  } else {
+    findings.push({ severity: "high", detail: `Only ${internalLinks.length} internal links on homepage`, fix: "Add prominent internal links to service pages, FAQ, blog, and about pages" });
+  }
+  if (/breadcrumb|aria-label="breadcrumb"/i.test(html)) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Breadcrumb navigation detected" });
+  } else {
+    findings.push({ severity: "medium", detail: "No breadcrumb navigation found", fix: "Add breadcrumb navigation with BreadcrumbList schema markup" });
+  }
+  if (/<nav[\s>]/i.test(html)) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Semantic <nav> element used for navigation" });
+  } else {
+    findings.push({ severity: "low", detail: "No semantic <nav> element found", fix: "Wrap navigation menus in <nav> for better AI and accessibility parsing" });
+  }
+  if (/related|see\s+also|learn\s+more|explore|you\s+may\s+also/i.test(html)) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Related content or cross-linking sections found" });
+  } else {
+    findings.push({ severity: "low", detail: "No related content or cross-linking found", fix: 'Add "Related Services" or "Learn More" sections to build topic clusters' });
+  }
+  if (/<footer[\s>]/i.test(html)) {
+    score += 1;
+    findings.push({ severity: "info", detail: "Footer element with likely navigation links" });
+  } else {
+    findings.push({ severity: "low", detail: "No <footer> element found", fix: "Add a <footer> with navigation links, contact info, and site structure" });
+  }
+  return { criterion: "internal_linking", criterion_label: "Internal Linking Architecture", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 4 ? "P2" : "P1" };
+}
+function checkSemanticHTML(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "semantic_html", criterion_label: "Semantic HTML5 & Accessibility", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const combinedHtml = getCombinedHtml(data);
+  const html = data.homepage.text;
+  let score = 0;
+  const checks = [
+    ["<main>", /<main[\s>]/i, "Wrap primary page content in <main>"],
+    ["<article>", /<article[\s>]/i, "Use <article> for standalone content blocks"],
+    ["<time>", /<time[\s>]/i, "Use <time> elements for dates"],
+    ["<nav>", /<nav[\s>]/i, "Use <nav> for navigation sections"],
+    ["<header>", /<header[\s>]/i, "Use <header> for page/section headers"],
+    ["<footer>", /<footer[\s>]/i, "Use <footer> for page/section footers"]
+  ];
+  let found = 0;
+  for (const [name, regex, fix] of checks) {
+    if (regex.test(combinedHtml)) {
+      found++;
+    } else {
+      findings.push({ severity: "low", detail: `Missing ${name} element`, fix });
+    }
+  }
+  score += Math.min(4, Math.floor(found * 0.7));
+  if (found >= 4) findings.push({ severity: "info", detail: `${found}/6 key semantic HTML5 elements found` });
+  const images = html.match(/<img[^>]*>/gi) || [];
+  const imagesWithAlt = images.filter((img) => /alt="[^"]+"/i.test(img));
+  if (images.length > 0) {
+    const ratio = imagesWithAlt.length / images.length;
+    if (ratio >= 0.8) {
+      score += 2;
+      findings.push({ severity: "info", detail: `${Math.round(ratio * 100)}% of images have alt text` });
+    } else {
+      findings.push({ severity: "medium", detail: `Only ${Math.round(ratio * 100)}% of images have alt text`, fix: "Add descriptive alt text to all images" });
+    }
+  }
+  if (/lang="[a-z]{2}"/i.test(html)) {
+    score += 2;
+    findings.push({ severity: "info", detail: "HTML lang attribute set" });
+  } else {
+    findings.push({ severity: "medium", detail: "Missing lang attribute on <html> tag", fix: 'Add lang="en" (or appropriate language) to the <html> tag' });
+  }
+  if (/role="|aria-/i.test(html)) {
+    score += 2;
+    findings.push({ severity: "info", detail: "ARIA attributes found for accessibility" });
+  } else {
+    findings.push({ severity: "low", detail: "No ARIA roles or attributes found", fix: "Add ARIA roles and labels to improve accessibility and semantic parsing" });
+  }
+  return { criterion: "semantic_html", criterion_label: "Semantic HTML5 & Accessibility", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 4 ? "P3" : "P2" };
+}
+function checkContentFreshness(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "content_freshness", criterion_label: "Content Freshness Signals", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const html = data.homepage.text;
+  let score = 0;
+  const hasDatePublished = /datePublished|dateCreated/i.test(html);
+  const hasDateModified = /dateModified/i.test(html);
+  if (hasDatePublished || hasDateModified) {
+    score += 3;
+    findings.push({ severity: "info", detail: `JSON-LD date properties found: ${[hasDatePublished && "datePublished", hasDateModified && "dateModified"].filter(Boolean).join(", ")}` });
+  } else {
+    findings.push({ severity: "high", detail: "No JSON-LD date properties (datePublished/dateModified) found", fix: "Add datePublished and dateModified to Article or WebPage schema" });
+  }
+  const timeElements = html.match(/<time[\s>]/gi) || [];
+  if (timeElements.length >= 2) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${timeElements.length} <time> elements found` });
+  } else if (timeElements.length === 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: "Only 1 <time> element found", fix: 'Use <time datetime="..."> for all dates to help AI parsers' });
+  } else {
+    findings.push({ severity: "medium", detail: "No <time> elements found", fix: 'Wrap publication and modification dates in <time datetime="..."> elements' });
+  }
+  const hasArticleMeta = /article:published_time|article:modified_time/i.test(html);
+  if (hasArticleMeta) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Open Graph article date meta tags found" });
+  } else {
+    findings.push({ severity: "low", detail: "No article:published_time or article:modified_time meta tags", fix: "Add Open Graph article date meta tags" });
+  }
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  const hasRecentYear = html.includes(String(currentYear)) || html.includes(String(currentYear - 1));
+  if (hasRecentYear) {
+    score += 2;
+    findings.push({ severity: "info", detail: `References to ${currentYear} or ${currentYear - 1} found, suggesting recent content` });
+  } else {
+    findings.push({ severity: "low", detail: "No references to recent years found on homepage" });
+  }
+  return { criterion: "content_freshness", criterion_label: "Content Freshness Signals", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
+function checkSitemapCompleteness(data) {
+  const findings = [];
+  const sitemap = data.sitemapXml;
+  if (!sitemap || sitemap.status !== 200) {
+    findings.push({ severity: "critical", detail: "No sitemap.xml found", fix: "Create a sitemap.xml with all indexable pages and submit to search engines" });
+    return { criterion: "sitemap_completeness", criterion_label: "Sitemap Completeness", score: 0, status: "fail", findings, fix_priority: "P1" };
+  }
+  const text = sitemap.text;
+  let score = 2;
+  if (text.includes("<urlset") || text.includes("<sitemapindex")) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Valid sitemap XML structure detected" });
+  } else {
+    findings.push({ severity: "high", detail: "sitemap.xml does not contain valid XML structure", fix: "Ensure sitemap uses proper <urlset> or <sitemapindex> XML format" });
+  }
+  const urlCount = (text.match(/<loc>/gi) || []).length;
+  if (urlCount >= 50) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${urlCount} URLs in sitemap` });
+  } else if (urlCount >= 10) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${urlCount} URLs in sitemap` });
+  } else if (urlCount > 0) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Only ${urlCount} URL(s) in sitemap`, fix: "Add all important pages to your sitemap" });
+  }
+  const lastmodMatches = text.match(/<lastmod>([^<]+)<\/lastmod>/gi) || [];
+  if (lastmodMatches.length > 0) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${lastmodMatches.length} URLs have lastmod dates` });
+  } else {
+    findings.push({ severity: "medium", detail: "No lastmod dates in sitemap", fix: "Add <lastmod> dates to sitemap entries for freshness signals" });
+  }
+  if (text.includes("<sitemapindex")) {
+    score += 1;
+    findings.push({ severity: "info", detail: "Sitemap index found, indicating organized sitemap structure" });
+  } else {
+    findings.push({ severity: "low", detail: "No sitemap index structure", fix: "Use a <sitemapindex> with multiple child sitemaps for larger sites to improve crawl efficiency" });
+  }
+  return { criterion: "sitemap_completeness", criterion_label: "Sitemap Completeness", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P1" };
+}
+function checkRssFeed(data) {
+  const findings = [];
+  let score = 0;
+  const hasRssLink = data.homepage && /<link[^>]*type="application\/(?:rss|atom)\+xml"/i.test(data.homepage.text);
+  if (hasRssLink) {
+    score += 3;
+    findings.push({ severity: "info", detail: "RSS/Atom feed link tag found in homepage <head>" });
+  } else {
+    findings.push({ severity: "high", detail: "No RSS/Atom feed link tag in homepage", fix: 'Add <link rel="alternate" type="application/rss+xml" href="/feed"> to your <head>' });
+  }
+  const feed = data.rssFeed;
+  if (feed && feed.status === 200) {
+    const feedText = feed.text;
+    const isValidFeed = feedText.includes("<rss") || feedText.includes("<feed") || feedText.includes("<channel");
+    if (isValidFeed) {
+      score += 3;
+      findings.push({ severity: "info", detail: "Valid RSS/Atom feed content detected" });
+      const itemCount = (feedText.match(/<item[\s>]|<entry[\s>]/gi) || []).length;
+      if (itemCount >= 5) {
+        score += 4;
+        findings.push({ severity: "info", detail: `Feed contains ${itemCount} items` });
+      } else if (itemCount > 0) {
+        score += 2;
+        findings.push({ severity: "low", detail: `Feed contains only ${itemCount} item(s)`, fix: "Publish more content to populate your RSS feed with at least 5 items" });
+      }
+    } else {
+      findings.push({ severity: "medium", detail: "Feed URL returned content but not valid RSS/Atom XML", fix: "Ensure your feed outputs valid RSS 2.0 or Atom XML" });
+    }
+  } else if (!hasRssLink) {
+    findings.push({ severity: "medium", detail: "No accessible RSS/Atom feed found", fix: "Create an RSS feed to help AI engines discover and index new content automatically" });
+  }
+  return { criterion: "rss_feed", criterion_label: "RSS/Atom Feed", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 4 ? "P3" : "P2" };
+}
+function checkTableListExtractability(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "table_list_extractability", criterion_label: "Table & List Extractability", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const html = getCombinedHtml(data);
+  let score = 0;
+  const tables = html.match(/<table[\s>]/gi) || [];
+  const tablesWithHeaders = (html.match(/<table[\s\S]*?<\/table>/gi) || []).filter((t) => /<th[\s>]/i.test(t));
+  if (tablesWithHeaders.length >= 1) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${tablesWithHeaders.length} table(s) with <th> headers found` });
+  } else if (tables.length > 0) {
+    score += 1;
+    findings.push({ severity: "medium", detail: `${tables.length} table(s) found but without <th> header cells`, fix: "Add <th> header cells to tables for better AI extraction" });
+  } else {
+    findings.push({ severity: "low", detail: "No HTML tables found", fix: "Use comparison tables with <th> headers for structured data AI engines can extract" });
+  }
+  if (tablesWithHeaders.length >= 2) {
+    score += 1;
+    findings.push({ severity: "info", detail: "Multiple well-structured tables present" });
+  } else if (tablesWithHeaders.length === 1) {
+    findings.push({ severity: "low", detail: "Only 1 table with headers found", fix: "Add more comparison or data tables with <th> headers to increase extractable structured content" });
+  }
+  const olCount = (html.match(/<ol[\s>]/gi) || []).length;
+  if (olCount >= 1) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${olCount} ordered list(s) found - good for step-by-step content` });
+  } else {
+    findings.push({ severity: "low", detail: "No ordered lists (<ol>) found", fix: "Use <ol> for sequential content (steps, rankings, processes)" });
+  }
+  const ulCount = (html.match(/<ul[\s>]/gi) || []).length;
+  if (ulCount >= 1) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${ulCount} unordered list(s) found` });
+  } else {
+    findings.push({ severity: "low", detail: "No unordered lists (<ul>) found", fix: "Use <ul> for feature lists, benefits, and bullet-point content" });
+  }
+  const liCount = (html.match(/<li[\s>]/gi) || []).length;
+  if (liCount >= 10) {
+    score += 1;
+    findings.push({ severity: "info", detail: `${liCount} list items - substantial extractable content` });
+  }
+  const dlCount = (html.match(/<dl[\s>]/gi) || []).length;
+  if (dlCount >= 1) {
+    score += 1;
+    findings.push({ severity: "info", detail: `${dlCount} definition list(s) found` });
+  } else {
+    findings.push({ severity: "low", detail: "No definition lists (<dl>) found", fix: "Use <dl>/<dt>/<dd> for term-definition pairs to improve AI extractability" });
+  }
+  return { criterion: "table_list_extractability", criterion_label: "Table & List Extractability", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
+function checkDefinitionPatterns(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "definition_patterns", criterion_label: "Definition Patterns", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const combinedHtml = getCombinedHtml(data);
+  const text = combinedHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  const html = combinedHtml;
+  let score = 0;
+  const definitionPatterns = [
+    /\b\w[\w\s]{2,30}\bis\s+(?:a|an|the)\s/gi,
+    /\b\w[\w\s]{2,30}\bare\s+(?:a|an|the)\s/gi,
+    /\brefers?\s+to\b/gi,
+    /\bdefined\s+as\b/gi,
+    /\bknown\s+as\b/gi,
+    /\bmeans?\s+that\b/gi
+  ];
+  let patternCount = 0;
+  for (const pattern of definitionPatterns) {
+    const matches = text.match(pattern) || [];
+    patternCount += matches.length;
+  }
+  if (patternCount >= 3) {
+    score += 5;
+    findings.push({ severity: "info", detail: `${patternCount} definition-style patterns found (e.g., "X is a...", "refers to", "defined as")` });
+  } else if (patternCount >= 1) {
+    score += 3;
+    findings.push({ severity: "low", detail: `Only ${patternCount} definition pattern(s) found`, fix: 'Start key descriptions with clear definition patterns like "X is a..." or "X refers to..."' });
+  } else {
+    findings.push({ severity: "medium", detail: "No definition patterns found", fix: 'Add clear definitions using patterns like "[Term] is [definition]" that AI engines can extract as snippets' });
+  }
+  const earlyText = text.slice(0, 2e3);
+  const earlyDefinitions = definitionPatterns.some((p) => p.test(earlyText));
+  definitionPatterns.forEach((p) => {
+    p.lastIndex = 0;
+  });
+  if (earlyDefinitions) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Definition patterns appear early in page content - good for snippet extraction" });
+  } else {
+    findings.push({ severity: "low", detail: "No definition patterns in the first 2000 characters of content", fix: "Place key definitions early on the page where AI engines prioritize extraction" });
+  }
+  const hasDfn = /<dfn[\s>]/i.test(html);
+  const hasAbbr = /<abbr[\s>]/i.test(html);
+  if (hasDfn || hasAbbr) {
+    score += 1;
+    findings.push({ severity: "info", detail: `Semantic definition elements found: ${[hasDfn && "<dfn>", hasAbbr && "<abbr>"].filter(Boolean).join(", ")}` });
+  } else {
+    findings.push({ severity: "low", detail: "No <dfn> or <abbr> elements found", fix: "Use <dfn> for term definitions and <abbr> for abbreviations to help AI parse terminology" });
+  }
+  if (/<dl[\s>]/i.test(html) || /glossary|definitions|terminology/i.test(html)) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Glossary or definition list structure detected" });
+  } else {
+    findings.push({ severity: "low", detail: "No glossary or definition list found", fix: "Add a glossary section using <dl>/<dt>/<dd> for key industry terms" });
+  }
+  return { criterion: "definition_patterns", criterion_label: "Definition Patterns", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
+function checkDirectAnswerDensity(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "direct_answer_density", criterion_label: "Direct Answer Paragraphs", score: 0, status: "not_found", findings, fix_priority: "P1" };
+  }
+  const html = getCombinedHtml(data);
+  let score = 0;
+  const qaPairs = html.match(/<h[2-4][^>]*>[^<]*\?<\/h[2-4]>\s*<p[^>]*>/gi) || [];
+  if (qaPairs.length >= 3) {
+    score += 6;
+    findings.push({ severity: "info", detail: `${qaPairs.length} question-answer pairs found (question heading + direct answer paragraph)` });
+  } else if (qaPairs.length >= 1) {
+    score += 3;
+    findings.push({ severity: "low", detail: `${qaPairs.length} question-answer pair(s) found`, fix: "Add more question headings (H2/H3) immediately followed by concise answer paragraphs" });
+  } else {
+    findings.push({ severity: "high", detail: "No direct question-answer pairs found", fix: 'Structure content with question headings (e.g., "What is X?") immediately followed by a concise answer paragraph' });
+  }
+  const paragraphs = html.match(/<p[^>]*>([\s\S]*?)<\/p>/gi) || [];
+  const snippetZoneParagraphs = paragraphs.filter((p) => {
+    const text2 = p.replace(/<[^>]*>/g, "").trim();
+    const wordCount = text2.split(/\s+/).length;
+    return wordCount >= 40 && wordCount <= 150;
+  });
+  if (snippetZoneParagraphs.length >= 3) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${snippetZoneParagraphs.length} paragraphs in snippet zone (40-150 words) - ideal for AI extraction` });
+  } else if (snippetZoneParagraphs.length >= 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Only ${snippetZoneParagraphs.length} paragraph(s) in optimal snippet length`, fix: "Write more paragraphs in the 40-150 word range for AI snippet extraction" });
+  } else {
+    findings.push({ severity: "medium", detail: "No paragraphs in the optimal snippet zone (40-150 words)", fix: "Write self-contained paragraphs of 40-150 words that directly answer common questions" });
+  }
+  const text = data.homepage.text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  const directOpeners = /\b(yes|no|the answer is|in short|simply put|to summarize)\b/gi;
+  const openerCount = (text.match(directOpeners) || []).length;
+  if (openerCount >= 2) {
+    score += 2;
+    findings.push({ severity: "info", detail: 'Direct answer openers found (e.g., "Yes,", "In short,")' });
+  } else {
+    findings.push({ severity: "low", detail: "Few or no direct answer openers found", fix: 'Start answers with direct phrases like "Yes,", "No,", "In short," to signal definitive answers to AI engines' });
+  }
+  return { criterion: "direct_answer_density", criterion_label: "Direct Answer Paragraphs", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P2" : "P1" };
+}
+function checkContentLicensing(data) {
+  const findings = [];
+  let score = 0;
+  const aiTxt = data.aiTxt;
+  if (aiTxt && aiTxt.status === 200 && aiTxt.text.length > 20 && !isHtmlResponse(aiTxt)) {
+    score += 4;
+    findings.push({ severity: "info", detail: `ai.txt file found (${aiTxt.text.length} characters)` });
+  } else {
+    findings.push({ severity: "high", detail: "No ai.txt file found", fix: "Create /ai.txt to declare your AI usage policy and content permissions for AI crawlers" });
+  }
+  const html = data.homepage?.text || "";
+  const text = html.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  const hasPolicyLanguage = /content\s+policy|terms\s+of\s+use|usage\s+rights|permission|copyright\s+policy|licensing|creative\s+commons/i.test(text);
+  if (hasPolicyLanguage) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Content policy or licensing language found on page" });
+  } else {
+    findings.push({ severity: "low", detail: "No content policy or licensing language visible", fix: "Add clear content usage terms or licensing information" });
+  }
+  const hasLicenseSchema = /license|copyrightHolder|copyrightYear/i.test(html) && /application\/ld\+json/i.test(html);
+  if (hasLicenseSchema) {
+    score += 2;
+    findings.push({ severity: "info", detail: "License or copyright properties found in schema markup" });
+  } else {
+    findings.push({ severity: "low", detail: "No license or copyright properties in schema", fix: "Add license, copyrightHolder, and copyrightYear to your schema markup" });
+  }
+  const hasTdmOrCC = /tdm|text\s+and\s+data\s+mining|creative\s+commons|CC\s+BY|creativecommons\.org/i.test(html + (aiTxt?.text || ""));
+  if (hasTdmOrCC) {
+    score += 2;
+    findings.push({ severity: "info", detail: "TDM or Creative Commons licensing references found" });
+  } else {
+    findings.push({ severity: "low", detail: "No TDM or Creative Commons licensing references found", fix: "Add Text and Data Mining (TDM) permissions or Creative Commons licensing to signal AI-friendly content use" });
+  }
+  return { criterion: "content_licensing", criterion_label: "Content Licensing & AI Permissions", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 4 ? "P3" : "P2" };
+}
+function checkAuthorSchemaDepth(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "author_schema_depth", criterion_label: "Author & Expert Schema", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const combinedHtml = getCombinedHtml(data);
+  const html = data.homepage.text;
+  const text = combinedHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  let score = 0;
+  const hasPersonSchema = /"@type"\s*:\s*"Person"/i.test(combinedHtml);
+  if (hasPersonSchema) {
+    score += 3;
+    findings.push({ severity: "info", detail: "Person schema found in JSON-LD" });
+  } else {
+    findings.push({ severity: "medium", detail: "No Person schema found", fix: "Add Person schema for authors with name, jobTitle, knowsAbout, and sameAs properties" });
+  }
+  const hasJobTitle = /jobTitle|knowsAbout|expertise|hasCredential/i.test(combinedHtml);
+  if (hasJobTitle) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Author credential properties found (jobTitle/knowsAbout)" });
+  } else {
+    findings.push({ severity: "low", detail: "No jobTitle or knowsAbout in author schema", fix: "Add jobTitle and knowsAbout to Person schema to establish expertise" });
+  }
+  const hasSameAs = /sameAs/i.test(combinedHtml) && hasPersonSchema;
+  if (hasSameAs) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Author sameAs social profile links found" });
+  } else {
+    findings.push({ severity: "low", detail: "No sameAs links to author social profiles", fix: "Add sameAs URLs (LinkedIn, GitHub) to Person schema to strengthen entity connections" });
+  }
+  const hasByline = /written\s+by|authored?\s+by|by\s+[A-Z][a-z]+\s+[A-Z]/i.test(text) || /class="[^"]*author[^"]*"/i.test(html) || /rel="author"/i.test(html);
+  if (hasByline) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Visible author byline or attribution found" });
+  } else {
+    findings.push({ severity: "medium", detail: "No visible author byline found", fix: "Add visible author names with credentials to establish E-E-A-T" });
+  }
+  if (/<address[\s>]/i.test(combinedHtml)) {
+    score += 1;
+    findings.push({ severity: "info", detail: "<address> element found for contact information" });
+  } else {
+    findings.push({ severity: "low", detail: "No <address> element found for contact information", fix: "Add an <address> element with contact details to reinforce entity identity" });
+  }
+  return { criterion: "author_schema_depth", criterion_label: "Author & Expert Schema", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
+function checkFactDensity(data) {
+  const findings = [];
+  if (!data.homepage) {
+    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, " ");
+  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) {
+    score += 5;
+    findings.push({ severity: "info", detail: `${totalDataPoints} quantitative data points found on homepage` });
+  } else if (totalDataPoints >= 3) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${totalDataPoints} quantitative data points found` });
+  } 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" });
+  } else {
+    findings.push({ severity: "high", detail: "No quantitative data points found", fix: "Add specific statistics (percentages, counts, comparisons) that AI engines can cite" });
+  }
+  const yearRefs = text.match(/(?:19|20)\d{2}/g) || [];
+  const uniqueYears = [...new Set(yearRefs)];
+  if (uniqueYears.length >= 2) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${uniqueYears.length} different year references found - suggests dated, verifiable claims` });
+  } else if (uniqueYears.length === 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: "Only 1 year reference found on page", fix: "Add more dated references and timestamps to demonstrate current, verifiable information" });
+  } else {
+    findings.push({ severity: "low", detail: "No year references found on page", fix: "Include specific years and dates to provide verifiable, time-anchored facts" });
+  }
+  const attributions = text.match(/according\s+to|source:|study\s+(?:by|from)|research\s+(?:by|from|shows)|data\s+from|report\s+(?:by|from)|published\s+(?:by|in)/gi) || [];
+  if (attributions.length >= 1) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${attributions.length} source attribution(s) found (e.g., "according to", "study by")` });
+  } else {
+    findings.push({ severity: "low", detail: "No source attributions found", fix: 'Add citations like "According to [source]" or "Research from [org] shows" for credibility' });
+  }
+  const units = text.match(/\d+\s*(?:hours?|minutes?|days?|weeks?|months?|years?|miles?|km|lbs?|kg|mg|sq\s*ft|acres?|gallons?|liters?)/gi) || [];
+  if (units.length >= 2) {
+    score += 1;
+    findings.push({ severity: "info", detail: `${units.length} measurement units found (hours, miles, etc.) - adds factual precision` });
+  } else {
+    findings.push({ severity: "low", detail: "Few or no units of measurement found", fix: "Include specific measurements (hours, miles, sq ft, etc.) to add factual precision AI engines can extract" });
+  }
+  return { criterion: "fact_density", criterion_label: "Fact & Data Density", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
+function checkCanonicalUrl(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "canonical_url", criterion_label: "Canonical URL Strategy", score: 0, status: "not_found", findings, fix_priority: "P1" };
+  }
+  const html = data.homepage.text;
+  let score = 0;
+  const canonicalMatch = html.match(/<link[^>]*rel="canonical"[^>]*href="([^"]*)"[^>]*>/i) || html.match(/<link[^>]*href="([^"]*)"[^>]*rel="canonical"[^>]*>/i);
+  if (canonicalMatch) {
+    score += 4;
+    findings.push({ severity: "info", detail: `Canonical URL found: ${canonicalMatch[1].slice(0, 80)}` });
+    const canonicalUrl = canonicalMatch[1];
+    if (canonicalUrl.includes(data.domain)) {
+      score += 3;
+      findings.push({ severity: "info", detail: "Canonical URL is self-referencing (points to same domain)" });
+    } else {
+      findings.push({ severity: "medium", detail: "Canonical URL points to a different domain", fix: "Ensure canonical URL points to the authoritative version of this page" });
+    }
+    if (canonicalUrl.startsWith("https://")) {
+      score += 2;
+      findings.push({ severity: "info", detail: "Canonical URL uses HTTPS" });
+    } else {
+      findings.push({ severity: "medium", detail: "Canonical URL does not use HTTPS", fix: "Update canonical URL to use https://" });
+    }
+  } else {
+    findings.push({ severity: "high", detail: "No canonical URL tag found", fix: 'Add <link rel="canonical" href="https://yoursite.com/page"> to prevent duplicate content issues' });
+  }
+  const allCanonicals = html.match(/<link[^>]*(?:rel="canonical"|rel='canonical')[^>]*>/gi) || [];
+  if (allCanonicals.length > 1) {
+    score -= 1;
+    findings.push({ severity: "high", detail: `${allCanonicals.length} canonical tags found - must have exactly one`, fix: "Remove duplicate canonical tags, keeping only one per page" });
+  } else if (allCanonicals.length === 1) {
+    score += 1;
+    findings.push({ severity: "info", detail: "Single canonical tag present (no duplicates)" });
+  }
+  return { criterion: "canonical_url", criterion_label: "Canonical URL Strategy", score: Math.max(0, Math.min(10, score)), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P1" };
+}
+function countRecentSitemapDates(sitemapText) {
+  const lastmodMatches = sitemapText.match(/<lastmod>([^<]+)<\/lastmod>/gi) || [];
+  if (lastmodMatches.length === 0) {
+    return { recentCount: 0, isUniform: false, totalWithDates: 0, distinctRecentDays: 0 };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const ninetyDaysAgo = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1e3);
+  const dayCounts = {};
+  let recentCount = 0;
+  const recentDays = /* @__PURE__ */ new Set();
+  for (const match of lastmodMatches) {
+    const dateStr = match.replace(/<\/?lastmod>/gi, "").trim();
+    const date = new Date(dateStr);
+    if (isNaN(date.getTime())) continue;
+    const dayKey = date.toISOString().split("T")[0];
+    dayCounts[dayKey] = (dayCounts[dayKey] || 0) + 1;
+    if (date >= ninetyDaysAgo) {
+      recentCount++;
+      recentDays.add(dayKey);
+    }
+  }
+  const totalWithDates = Object.values(dayCounts).reduce((a, b) => a + b, 0);
+  const maxDayCount = Math.max(...Object.values(dayCounts));
+  const isUniform = totalWithDates >= 5 && maxDayCount / totalWithDates > 0.8;
+  let uniformDetail;
+  if (isUniform) {
+    const topDay = Object.entries(dayCounts).find(([, count]) => count === maxDayCount)[0];
+    uniformDetail = `${maxDayCount} of ${totalWithDates} URLs share lastmod date ${topDay} - likely auto-generated by build system`;
+  }
+  return {
+    recentCount,
+    isUniform,
+    uniformDetail,
+    totalWithDates,
+    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 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) {
+  const urlBlocks = sitemapText.match(/<url>([\s\S]*?)<\/url>/gi) || [];
+  const candidates = [];
+  const cleanDomain = domain.replace(/^www\./, "").toLowerCase();
+  for (const block of urlBlocks) {
+    const locMatch = block.match(/<loc>([^<]+)<\/loc>/i);
+    if (!locMatch) continue;
+    const url = locMatch[1].trim();
+    try {
+      const parsed = new URL(url);
+      const urlDomain = parsed.hostname.replace(/^www\./, "").toLowerCase();
+      if (urlDomain !== cleanDomain) continue;
+      if (parsed.pathname === "/" || parsed.pathname === "") continue;
+      const path = parsed.pathname.toLowerCase();
+      if (EXCLUDE_PATH_PATTERNS.test(path)) continue;
+      const segments = path.split("/").filter(Boolean);
+      const isBlogPath = BLOG_PATH_PATTERNS.test(path);
+      const isDeepPath = segments.length >= 2;
+      if (!isBlogPath && !isDeepPath) continue;
+    } catch {
+      continue;
+    }
+    const lastmodMatch = block.match(/<lastmod>([^<]+)<\/lastmod>/i);
+    const lastmod = lastmodMatch ? lastmodMatch[1].trim() : "";
+    candidates.push({ url, lastmod });
+  }
+  candidates.sort((a, b) => {
+    if (a.lastmod && b.lastmod) return b.lastmod.localeCompare(a.lastmod);
+    if (a.lastmod) return -1;
+    if (b.lastmod) return 1;
+    return 0;
+  });
+  return candidates.slice(0, limit).map((c) => c.url);
+}
+function extractSubSitemapUrl(sitemapText) {
+  if (!sitemapText.includes("<sitemapindex")) return null;
+  const sitemapLocs = sitemapText.match(/<sitemap>[\s\S]*?<loc>([^<]+)<\/loc>[\s\S]*?<\/sitemap>/gi) || [];
+  if (sitemapLocs.length === 0) return null;
+  const urls = sitemapLocs.map((block) => {
+    const match = block.match(/<loc>([^<]+)<\/loc>/i);
+    return match ? match[1].trim() : "";
+  }).filter(Boolean);
+  const preferred = urls.find((u) => /post|blog|article/i.test(u));
+  return preferred || urls[0] || null;
+}
+function checkContentVelocity(data) {
+  const findings = [];
+  const sitemap = data.sitemapXml;
+  let score = 0;
+  if (!sitemap || sitemap.status !== 200) {
+    findings.push({ severity: "medium", detail: "No sitemap available to assess content velocity", fix: "Create a sitemap.xml with lastmod dates to signal content publishing frequency" });
+    return { criterion: "content_velocity", criterion_label: "Content Publishing Velocity", score: 0, status: "fail", findings, fix_priority: "P2" };
+  }
+  const analysis = countRecentSitemapDates(sitemap.text);
+  if (analysis.totalWithDates === 0) {
+    findings.push({ severity: "medium", detail: "No lastmod dates in sitemap", fix: "Add lastmod dates to sitemap entries to signal content freshness" });
+    return { criterion: "content_velocity", criterion_label: "Content Publishing Velocity", score: 2, status: "fail", findings, fix_priority: "P2" };
+  }
+  score += 2;
+  findings.push({ severity: "info", detail: `${analysis.totalWithDates} pages have lastmod dates` });
+  const effectiveCount = analysis.isUniform ? analysis.distinctRecentDays : analysis.recentCount;
+  if (analysis.isUniform) {
+    findings.push({ severity: "medium", detail: analysis.uniformDetail, fix: "Set genuine lastmod dates per page reflecting actual content changes, not build timestamps" });
+  }
+  if (effectiveCount >= 20) {
+    score += 8;
+    findings.push({ severity: "info", detail: `${effectiveCount} ${analysis.isUniform ? "distinct dates" : "pages updated"} in last 90 days - excellent content velocity` });
+  } else if (effectiveCount >= 10) {
+    score += 5;
+    findings.push({ severity: "info", detail: `${effectiveCount} ${analysis.isUniform ? "distinct dates" : "pages updated"} in last 90 days - good velocity` });
+  } else if (effectiveCount >= 5) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${effectiveCount} ${analysis.isUniform ? "distinct dates" : "pages updated"} in last 90 days` });
+  } else if (effectiveCount >= 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Only ${effectiveCount} ${analysis.isUniform ? "distinct date(s)" : "page(s) updated"} in last 90 days`, fix: "Publish or update content more frequently to signal active maintenance" });
+  } else {
+    findings.push({ severity: "medium", detail: "No pages updated in the last 90 days", fix: "Update existing content and publish new pages regularly" });
+  }
+  return { criterion: "content_velocity", criterion_label: "Content Publishing Velocity", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
+function checkSchemaCoverage(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "schema_coverage", criterion_label: "Schema Coverage & Depth", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const combinedHtml = getCombinedHtml(data);
+  const html = data.homepage.text;
+  const ldJsonMatches = combinedHtml.match(/<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/gi) || [];
+  let score = 0;
+  if (ldJsonMatches.length === 0) {
+    findings.push({ severity: "critical", detail: "No JSON-LD found - cannot assess schema coverage", fix: "Add JSON-LD schema markup to improve AI engine understanding" });
+    return { criterion: "schema_coverage", criterion_label: "Schema Coverage & Depth", score: 0, status: "fail", findings, fix_priority: "P1" };
+  }
+  const allSchemaText = ldJsonMatches.join(" ");
+  const allSchemaLower = allSchemaText.toLowerCase();
+  const propertyMatches = allSchemaText.match(/"[a-zA-Z@]+"\s*:/g) || [];
+  const uniqueProperties = new Set(propertyMatches.map((p) => p.replace(/[":\s]/g, "").toLowerCase()));
+  if (uniqueProperties.size >= 15) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${uniqueProperties.size} unique schema properties used - rich schema depth` });
+  } else if (uniqueProperties.size >= 5) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${uniqueProperties.size} unique schema properties found` });
+  } else {
+    score += 1;
+    findings.push({ severity: "low", detail: `Only ${uniqueProperties.size} schema properties`, fix: "Add more properties to your schema types for richer AI understanding" });
+  }
+  const orgProps = ["name", "url", "logo", "contactpoint", "sameas", "address", "telephone", "description", "founder", "foundingdate"];
+  const orgPropsFound = orgProps.filter((p) => allSchemaLower.includes(`"${p}"`));
+  if (orgPropsFound.length >= 5) {
+    score += 2;
+    findings.push({ severity: "info", detail: `Organization schema has ${orgPropsFound.length}/10 key properties` });
+  } else if (orgPropsFound.length >= 3) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Organization schema has only ${orgPropsFound.length}/10 key properties`, fix: "Add more Organization properties: logo, contactPoint, sameAs, address" });
+  } else {
+    findings.push({ severity: "medium", detail: `Organization schema has only ${orgPropsFound.length} key properties`, fix: "Add essential Organization properties: name, url, logo, contactPoint, sameAs, address, telephone" });
+  }
+  const articleProps = ["headline", "datepublished", "datemodified", "author", "image", "description", "publisher"];
+  const articlePropsFound = articleProps.filter((p) => allSchemaLower.includes(`"${p}"`));
+  if (articlePropsFound.length >= 4) {
+    score += 2;
+    findings.push({ severity: "info", detail: `Article schema has ${articlePropsFound.length}/7 key properties` });
+  } else if (articlePropsFound.length >= 2) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Article schema has only ${articlePropsFound.length}/7 key properties`, fix: "Add headline, datePublished, dateModified, author, image, and publisher to Article schema" });
+  } else {
+    findings.push({ severity: "medium", detail: "Article schema missing or has fewer than 2 key properties", fix: "Add Article schema with headline, datePublished, author, and publisher properties" });
+  }
+  const hasIdLinking = /"@id"\s*:/i.test(allSchemaText);
+  if (hasIdLinking) {
+    score += 2;
+    findings.push({ severity: "info", detail: "@id linking found - schema types are connected in a graph" });
+  } else {
+    findings.push({ severity: "low", detail: "No @id linking between schema types", fix: "Use @id references to connect schema types (e.g., article.publisher -> organization)" });
+  }
+  const schemaTypes = ["organization", "localbusiness", "faqpage", "service", "article", "webpage", "website", "breadcrumblist", "howto", "product", "person", "event", "offer", "review", "aboutpage"];
+  const foundTypes = schemaTypes.filter((t) => allSchemaLower.includes(`"${t}"`));
+  if (foundTypes.length >= 3) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${foundTypes.length} distinct schema types used: ${foundTypes.join(", ")}` });
+  } else if (foundTypes.length >= 2) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Only ${foundTypes.length} distinct schema types used`, fix: "Add more schema types (FAQPage, BreadcrumbList, Service) for comprehensive AI understanding" });
+  } else {
+    findings.push({ severity: "medium", detail: `Only ${foundTypes.length} schema type(s) found - limited coverage`, fix: "Add multiple schema types (Organization, WebSite, FAQPage, BreadcrumbList) for comprehensive AI understanding" });
+  }
+  return { criterion: "schema_coverage", criterion_label: "Schema Coverage & Depth", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P1" };
+}
+function checkSpeakableSchema(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "speakable_schema", criterion_label: "Speakable Schema", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const combinedHtml = getCombinedHtml(data);
+  const ldJsonMatches = combinedHtml.match(/<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/gi) || [];
+  let score = 0;
+  if (ldJsonMatches.length === 0) {
+    findings.push({ severity: "critical", detail: "No JSON-LD found - cannot assess speakable schema", fix: "Add JSON-LD schema markup with SpeakableSpecification to indicate voice-readable content sections" });
+    return { criterion: "speakable_schema", criterion_label: "Speakable Schema", score: 0, status: "fail", findings, fix_priority: "P2" };
+  }
+  const allSchemaText = ldJsonMatches.join(" ");
+  const allSchemaLower = allSchemaText.toLowerCase();
+  const hasSpeakableType = /speakablespecification/i.test(allSchemaLower);
+  const hasSpeakableProperty = /"speakable"\s*:/i.test(allSchemaText);
+  const hasSpeakable = hasSpeakableType || hasSpeakableProperty;
+  if (!hasSpeakable) {
+    findings.push({ severity: "medium", detail: "No SpeakableSpecification schema found - voice assistants cannot identify readable sections", fix: "Add SpeakableSpecification schema with cssSelector or xpath targeting key content sections (headlines, summaries, FAQ answers)" });
+    return { criterion: "speakable_schema", criterion_label: "Speakable Schema", score: 0, status: "fail", findings, fix_priority: "P2" };
+  }
+  score += 4;
+  findings.push({ severity: "info", detail: "SpeakableSpecification schema detected - voice assistants can identify readable content" });
+  const hasCssSelector = /"cssselector"/i.test(allSchemaLower);
+  const hasXpath = /"xpath"/i.test(allSchemaLower);
+  if (hasCssSelector || hasXpath) {
+    score += 3;
+    const targetType = hasCssSelector && hasXpath ? "cssSelector and xpath" : hasCssSelector ? "cssSelector" : "xpath";
+    findings.push({ severity: "info", detail: `Speakable uses ${targetType} targeting for precise content selection` });
+  } else {
+    findings.push({ severity: "low", detail: "Speakable schema lacks cssSelector or xpath targeting", fix: 'Add cssSelector (e.g., ".article-headline, .article-summary") or xpath to precisely target speakable sections' });
+  }
+  if (data.blogSample && data.blogSample.length > 0) {
+    const blogHtml = data.blogSample.map((p) => p.text).join("\n");
+    const blogHasSpeakable = /speakablespecification/i.test(blogHtml) || /"speakable"\s*:/i.test(blogHtml);
+    if (blogHasSpeakable) {
+      score += 3;
+      findings.push({ severity: "info", detail: "Speakable schema also found in blog/content pages - comprehensive voice coverage" });
+    } else {
+      findings.push({ severity: "low", detail: "Speakable schema only on homepage, not found in blog/content pages", fix: "Add SpeakableSpecification to article pages to make blog content voice-assistant readable" });
+    }
+  } else {
+    findings.push({ severity: "info", detail: "No blog pages sampled - blog speakable coverage not assessed" });
+  }
+  return { criterion: "speakable_schema", criterion_label: "Speakable Schema", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
+function extractRawDataSummary(data) {
+  const html = data.homepage?.text || "";
+  const text = html.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  const ldJsonMatches = html.match(/<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/gi) || [];
+  const allSchemaText = ldJsonMatches.join(" ").toLowerCase();
+  const schemaTypes = ["organization", "localbusiness", "faqpage", "service", "article", "webpage", "website", "breadcrumblist", "howto", "product"];
+  const foundSchemaTypes = schemaTypes.filter(
+    (t) => allSchemaText.includes(`"${t}"`) || allSchemaText.includes(`"@type":"${t}"`)
+  );
+  const linkMatches = html.match(/<a[^>]*href="([^"]*)"[^>]*>/gi) || [];
+  const internalLinks = linkMatches.filter((l) => {
+    const href = l.match(/href="([^"]*)"/)?.[1] || "";
+    return href.startsWith("/") || href.includes(data.domain);
+  });
+  const externalLinks = linkMatches.filter((l) => {
+    const href = l.match(/href="([^"]*)"/)?.[1] || "";
+    return href.startsWith("http") && !href.includes(data.domain);
+  });
+  const robotsText = (data.robotsTxt?.text || "").toLowerCase();
+  const aiCrawlers = ["gptbot", "claudebot", "perplexitybot", "anthropic", "chatgpt"];
+  const mentionedCrawlers = aiCrawlers.filter((c) => robotsText.includes(c));
+  const blockedCrawlers = mentionedCrawlers.filter((c) => {
+    const sectionRegex = new RegExp(`user-agent:\\s*${c}[^\\S\\n]*\\n([\\s\\S]*?)(?=user-agent:|$)`, "i");
+    const match = sectionRegex.exec(data.robotsTxt?.text || "");
+    if (!match) return false;
+    const section = match[1];
+    if (/^allow:\s*\/\s*$/im.test(section)) return false;
+    return /^disallow:\s*\/\s*$/im.test(section);
+  });
+  const hTagContent = (html.match(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/gi) || []).map((h) => h.replace(/<[^>]*>/g, ""));
+  const questionHeadings = hTagContent.filter((h) => h.includes("?") || /^(what|how|why|when|who|where|can|do|does|is|are|should)\s/i.test(h));
+  const h1Count = (html.match(/<h1[\s>]/gi) || []).length;
+  const images = html.match(/<img[^>]*>/gi) || [];
+  const imagesWithAlt = images.filter((img) => /alt="[^"]+"/i.test(img));
+  const semanticChecks = ["main", "article", "nav", "header", "footer", "section", "time"];
+  const foundElements = semanticChecks.filter((el) => new RegExp(`<${el}[\\s>]`, "i").test(html));
+  return {
+    domain: data.domain,
+    protocol: data.protocol,
+    homepage_length: html.length,
+    homepage_text_length: text.trim().length,
+    has_https: data.protocol === "https",
+    llms_txt_status: data.llmsTxt && !isHtmlResponse(data.llmsTxt) ? data.llmsTxt.status : null,
+    llms_txt_length: data.llmsTxt?.status === 200 && !isHtmlResponse(data.llmsTxt) ? data.llmsTxt.text.length : 0,
+    robots_txt_status: data.robotsTxt && !isHtmlResponse(data.robotsTxt) ? data.robotsTxt.status : null,
+    robots_txt_snippet: (data.robotsTxt?.text || "").slice(0, 500),
+    robots_txt_ai_crawlers: mentionedCrawlers,
+    robots_txt_blocked_crawlers: blockedCrawlers,
+    schema_types_found: foundSchemaTypes,
+    schema_block_count: ldJsonMatches.length,
+    faq_page_status: data.faqPage?.status ?? null,
+    faq_page_length: data.faqPage?.status === 200 ? data.faqPage.text.length : 0,
+    sitemap_status: data.sitemapXml?.status ?? null,
+    internal_link_count: internalLinks.length,
+    external_link_count: externalLinks.length,
+    question_headings_count: questionHeadings.length,
+    h1_count: h1Count,
+    has_meta_description: /<meta[^>]*name="description"[^>]*>/i.test(html),
+    has_title: /<title[^>]*>[^<]+<\/title>/i.test(html),
+    has_phone: (() => {
+      const phoneMatch = /(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/.test(text);
+      if (!phoneMatch) return false;
+      return /href="tel:/i.test(html) || /"telephone"/i.test(html) || /\b(phone|call|tel:|contact\s*us|fax|dial)\b/i.test(text);
+    })(),
+    has_address: /\d+\s+\w+\s+(street|st|avenue|ave|road|rd|drive|dr|blvd|boulevard|lane|ln|way|court|ct)/i.test(text),
+    has_org_schema: /organization|localbusiness/i.test(html),
+    has_social_links: /sameas|linkedin\.com|facebook\.com|twitter\.com|x\.com/i.test(html),
+    semantic_elements_found: foundElements,
+    img_count: images.length,
+    img_with_alt_count: imagesWithAlt.length,
+    has_lang_attr: /lang="[a-z]{2}"/i.test(html),
+    has_aria: /role="|aria-/i.test(html),
+    has_breadcrumbs: /breadcrumb|aria-label="breadcrumb"/i.test(html),
+    has_nav: /<nav[\s>]/i.test(html),
+    has_footer: /<footer[\s>]/i.test(html),
+    has_case_studies: /case\s+stud|testimonial|success\s+stor|client\s+stor/i.test(text),
+    has_statistics: /\d+%|\d+\s*(patients|clients|customers|cases|years|professionals|specialists|companies|users|businesses|domains|audits)/i.test(text),
+    has_expert_attribution: /written\s+by|authored\s+by|expert|specialist|board.certified|licensed/i.test(text),
+    has_blog_section: /href="[^"]*\/(?:blog|articles|insights|guides|resources)\b[^"]*"/i.test(html),
+    // New criteria fields
+    has_date_modified_schema: /dateModified/i.test(html),
+    time_element_count: (html.match(/<time[\s>]/gi) || []).length,
+    sitemap_url_count: (data.sitemapXml?.text?.match(/<loc>/gi) || []).length,
+    has_rss_feed: !!(data.rssFeed && data.rssFeed.status === 200 && !isHtmlResponse(data.rssFeed)),
+    table_count: (html.match(/<table[\s>]/gi) || []).length,
+    ordered_list_count: (html.match(/<ol[\s>]/gi) || []).length,
+    unordered_list_count: (html.match(/<ul[\s>]/gi) || []).length,
+    definition_pattern_count: (text.match(/\brefers?\s+to\b|\bdefined\s+as\b|\bknown\s+as\b/gi) || []).length,
+    has_ai_txt: !!(data.aiTxt && data.aiTxt.status === 200 && !isHtmlResponse(data.aiTxt)),
+    has_person_schema: /"@type"\s*:\s*"Person"/i.test(html),
+    fact_data_point_count: (text.match(/\d+(?:\.\d+)?(?:\s*%|\s*\$|\s*USD)/g) || []).length,
+    has_canonical: /<link[^>]*rel="canonical"/i.test(html),
+    has_license_schema: /license|copyrightHolder/i.test(html) && /application\/ld\+json/i.test(html),
+    sitemap_recent_lastmod_count: (() => {
+      const analysis = countRecentSitemapDates(data.sitemapXml?.text || "");
+      return analysis.isUniform ? analysis.distinctRecentDays : analysis.recentCount;
+    })(),
+    // Speakable schema fields
+    has_speakable_schema: /speakablespecification/i.test(ldJsonMatches.join(" ")) || /"speakable"\s*:/i.test(ldJsonMatches.join(" ")),
+    speakable_selector_count: (ldJsonMatches.join(" ").match(/"cssselector"|"xpath"/gi) || []).length,
+    // Blog sample fields
+    blog_sample_count: data.blogSample?.length ?? 0,
+    blog_sample_urls: data.blogSample?.map((p) => p.finalUrl || "").filter(Boolean) ?? [],
+    blog_sample_schema_types: (() => {
+      if (!data.blogSample || data.blogSample.length === 0) return [];
+      const blogHtml = data.blogSample.map((p) => p.text).join("\n");
+      const blogLd = blogHtml.match(/<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/gi) || [];
+      const blogSchema = blogLd.join(" ").toLowerCase();
+      const types = ["organization", "localbusiness", "faqpage", "service", "article", "webpage", "website", "breadcrumblist", "howto", "product", "person"];
+      return types.filter((t) => blogSchema.includes(`"${t}"`));
+    })(),
+    blog_sample_question_headings: (() => {
+      if (!data.blogSample || data.blogSample.length === 0) return 0;
+      const blogHtml = data.blogSample.map((p) => p.text).join("\n");
+      const hTags = (blogHtml.match(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/gi) || []).map((h) => h.replace(/<[^>]*>/g, ""));
+      return hTags.filter((h) => h.includes("?") || /^(what|how|why|when|who|where|can|do|does|is|are|should)\s/i.test(h)).length;
+    })(),
+    blog_sample_faq_schema_found: (() => {
+      if (!data.blogSample || data.blogSample.length === 0) return false;
+      const blogHtml = data.blogSample.map((p) => p.text).join("\n");
+      return /faqpage/i.test(blogHtml) && /application\/ld\+json/i.test(blogHtml);
+    })()
+  };
+}
+function auditSiteFromData(data) {
+  return [
+    checkLlmsTxt(data),
+    checkSchemaMarkup(data),
+    checkQAFormat(data),
+    checkCleanHTML(data),
+    checkEntityConsistency(data),
+    checkRobotsTxt(data),
+    checkFAQSection(data),
+    checkOriginalData(data),
+    checkInternalLinking(data),
+    checkSemanticHTML(data),
+    checkContentFreshness(data),
+    checkSitemapCompleteness(data),
+    checkRssFeed(data),
+    checkTableListExtractability(data),
+    checkDefinitionPatterns(data),
+    checkDirectAnswerDensity(data),
+    checkContentLicensing(data),
+    checkAuthorSchemaDepth(data),
+    checkFactDensity(data),
+    checkCanonicalUrl(data),
+    checkContentVelocity(data),
+    checkSchemaCoverage(data),
+    checkSpeakableSchema(data)
+  ];
+}
+
+// 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,
+  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
+};
+function calculateOverallScore(criteria) {
+  let totalWeight = 0;
+  let weightedSum = 0;
+  for (const c of criteria) {
+    const weight = WEIGHTS[c.criterion] ?? 0.1;
+    weightedSum += c.score / 10 * weight * 100;
+    totalWeight += weight;
+  }
+  if (totalWeight === 0) return 0;
+  return Math.round(weightedSum / totalWeight);
+}
+
+// src/headless-fetch.ts
+var SPA_INDICATORS = [
+  // Root mount points (empty or nearly empty, including self-closing)
+  /<div\s+id=["'](root|app|__next|__nuxt|__vue)["'][^>]*(?:\/>|>\s*<\/div>)/i,
+  // Framework globals
+  /__NEXT_DATA__/,
+  /__NUXT__/,
+  // CRA / Vite bundle patterns
+  /src=["'][^"']*\/static\/js\/main\.[a-f0-9]+\.js["']/i,
+  /src=["'][^"']*\/assets\/index-[a-f0-9]+\.js["']/i,
+  // React markers
+  /data-reactroot/i,
+  // Angular
+  /ng-version/i,
+  // Noscript JS warnings
+  /<noscript>[^<]*(?:javascript|enable\s+js|requires?\s+javascript)[^<]*<\/noscript>/i
+];
+function isSpaShell(html) {
+  const text = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+  if (text.length >= 500) return false;
+  return SPA_INDICATORS.some((pattern) => pattern.test(html));
+}
+function classifyRendering(html) {
+  if (!isSpaShell(html)) return { method: "server", framework: null };
+  const frameworkPatterns = [
+    [/__NEXT_DATA__/, "next"],
+    [/__NUXT__/, "nuxt"],
+    [/<div\s+id=["']__vue["']/i, "vue"],
+    [/ng-version/i, "angular"],
+    [/data-reactroot/i, "react"],
+    [/<div\s+id=["'](root|app)["'][^>]*(?:\/>|>\s*<\/div>)/i, "react"],
+    [/src=["'][^"']*\/static\/js\/main\.[a-f0-9]+\.js["']/i, "react"],
+    [/src=["'][^"']*\/assets\/index-[a-f0-9]+\.js["']/i, "vite"]
+  ];
+  for (const [pattern, framework] of frameworkPatterns) {
+    if (pattern.test(html)) return { method: "client-spa", framework };
+  }
+  return { method: "client-spa", framework: null };
+}
+async function fetchWithHeadless(url, options) {
+  let puppeteer;
+  try {
+    const mod = "puppeteer";
+    puppeteer = await import(
+      /* @vite-ignore */
+      mod
+    );
+  } catch {
+    return null;
+  }
+  const timeout = options?.timeout ?? 25e3;
+  let browser = null;
+  try {
+    browser = await puppeteer.launch({
+      headless: true,
+      args: [
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-gpu",
+        "--single-process"
+      ]
+    });
+    const page = await browser.newPage();
+    await page.setRequestInterception(true);
+    page.on("request", (req) => {
+      const type = req.resourceType();
+      if (["image", "font", "media", "stylesheet"].includes(type)) {
+        req.abort();
+      } else {
+        req.continue();
+      }
+    });
+    await page.setUserAgent("AEO-Visibility-Bot/1.0");
+    await page.goto(url, { waitUntil: "networkidle2", timeout });
+    try {
+      await page.waitForFunction(
+        'document.body && document.body.innerText && document.body.innerText.replace(/\\s+/g, " ").trim().length > 100',
+        { timeout: 5e3 }
+      );
+    } catch {
+    }
+    const html = await page.content();
+    const finalUrl = page.url();
+    return {
+      text: html.slice(0, 5e5),
+      status: 200,
+      finalUrl
+    };
+  } catch {
+    return null;
+  } finally {
+    if (browser) {
+      try {
+        await browser.close();
+      } catch {
+      }
+    }
+  }
+}
+
+// src/scorecard-builder.ts
+var CRITERION_LABELS = {
+  "llms.txt File": "llms.txt File",
+  "Schema.org Structured Data": "Schema.org Structured Data",
+  "Q&A Content Format": "Q&A Content Format",
+  "Clean, Crawlable HTML": "Clean, Crawlable HTML",
+  "Entity Authority & E-E-A-T": "Entity Authority & NAP Consistency",
+  "robots.txt for AI Crawlers": "robots.txt for AI Crawlers",
+  "Comprehensive FAQ Sections": "Comprehensive FAQ Section",
+  "Original Data & Expert Content": "Original Data & Expert Analysis",
+  "Internal Linking Architecture": "Internal Linking Structure",
+  "Semantic HTML5 & Accessibility": "Semantic HTML5 & Accessibility",
+  "Content Freshness Signals": "Content Freshness Signals",
+  "Sitemap Completeness": "Sitemap Completeness",
+  "RSS/Atom Feed": "RSS/Atom Feed",
+  "Table & List Extractability": "Table & List Extractability",
+  "Definition Patterns": "Definition Patterns",
+  "Direct Answer Paragraphs": "Direct Answer Paragraphs",
+  "Content Licensing & AI Permissions": "Content Licensing & AI Permissions",
+  "Author & Expert Schema": "Author & Expert Schema",
+  "Fact & Data Density": "Fact & Data Density",
+  "Canonical URL Strategy": "Canonical URL Strategy",
+  "Content Publishing Velocity": "Content Publishing Velocity",
+  "Schema Coverage & Depth": "Schema Coverage & Depth",
+  "Speakable Schema": "Speakable Schema"
+};
+function scoreToStatus(score) {
+  if (score === 0) return "MISSING";
+  if (score === 1) return "NEARLY EMPTY";
+  if (score === 2) return "POOR";
+  if (score === 3) return "WEAK";
+  if (score <= 5) return "PARTIAL";
+  if (score === 6) return "MODERATE";
+  if (score === 7) return "GOOD";
+  return "STRONG";
+}
+function mapFindingSeverity(severity) {
+  switch (severity) {
+    case "critical":
+      return "CRITICAL";
+    case "high":
+      return "MISSING";
+    case "medium":
+      return "ADD";
+    case "low":
+      return "PARTIAL";
+    case "info":
+      return "WORKING";
+    default:
+      return "PARTIAL";
+  }
+}
+function mapFindingType(severity, hasFix) {
+  if (severity === "info") return "Good";
+  if (severity === "critical") return "Critical";
+  if (severity === "high") return "Missing";
+  if (hasFix) return "Issue";
+  return "Note";
+}
+function buildScorecard(results) {
+  return results.map((r, i) => {
+    const label = CRITERION_LABELS[r.criterion_label] || r.criterion_label;
+    const keyParts = [];
+    for (const f of r.findings) {
+      if (keyParts.length >= 3) break;
+      keyParts.push(f.detail);
+    }
+    const keyFindings = keyParts.join(". ") + (keyParts.length > 0 && !keyParts[keyParts.length - 1].endsWith(".") ? "." : "");
+    return {
+      id: i + 1,
+      criterion: label,
+      score: r.score,
+      status: scoreToStatus(r.score),
+      keyFindings
+    };
+  });
+}
+function buildDetailedFindings(results) {
+  return results.map((r, i) => {
+    const label = CRITERION_LABELS[r.criterion_label] || r.criterion_label;
+    const rawFindings = r.findings.map((f) => ({
+      type: mapFindingType(f.severity, !!f.fix),
+      description: f.fix ? `${f.detail}. ${f.fix}` : f.detail,
+      severity: mapFindingSeverity(f.severity)
+    }));
+    const seen = /* @__PURE__ */ new Set();
+    const findings = [];
+    for (const f of rawFindings) {
+      if (!seen.has(f.description)) {
+        seen.add(f.description);
+        findings.push(f);
+      }
+    }
+    if (findings.length < 2) {
+      if (r.score >= 7) {
+        findings.push({ type: "Good", description: `${label} is well-implemented for AI engine visibility.`, severity: "WORKING" });
+      } else {
+        findings.push({ type: "Note", description: `${label} needs improvement - review specific issues above.`, severity: "PARTIAL" });
+      }
+    }
+    return {
+      id: i + 1,
+      name: label,
+      findings
+    };
+  });
+}
+
+// src/narrative-generator.ts
+var CRITERION_WEIGHTS = {
+  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
+};
+var OPPORTUNITY_TEMPLATES = {
+  llms_txt: {
+    name: "Create llms.txt File",
+    effort: "Low",
+    description: "Add a /llms.txt file that describes your site, core services, and key pages in markdown format. This helps AI engines like ChatGPT and Claude understand your site structure and content offerings."
+  },
+  schema_markup: {
+    name: "Add Schema.org Structured Data",
+    effort: "Medium",
+    description: "Implement JSON-LD structured data (Organization, Service, Product, FAQPage) on key pages. Schema markup helps AI engines extract and cite your content accurately."
+  },
+  qa_content_format: {
+    name: "Restructure Content as Q&A",
+    effort: "Medium",
+    description: 'Add question-based headings (H2/H3) throughout your content. Use "What is...", "How does...", "Why should..." patterns that match how users query AI assistants.'
+  },
+  clean_html: {
+    name: "Fix HTML Structure & Enable HTTPS",
+    effort: "Medium",
+    description: "Ensure clean, well-structured HTML with proper meta tags, semantic elements, and HTTPS. Clean HTML makes your content more parseable by AI crawlers."
+  },
+  entity_consistency: {
+    name: "Strengthen Entity Authority (NAP)",
+    effort: "Low",
+    description: "Add Organization schema with consistent name, address, phone (NAP). Include sameAs links to social profiles and authoritative directories to strengthen entity recognition."
+  },
+  robots_txt: {
+    name: "Configure robots.txt for AI Crawlers",
+    effort: "Low",
+    description: "Update robots.txt to explicitly allow AI crawlers (GPTBot, ClaudeBot, PerplexityBot). Add a Sitemap directive to help crawlers discover your content."
+  },
+  faq_section: {
+    name: "Build Comprehensive FAQ Section",
+    effort: "Medium",
+    description: "Create a dedicated FAQ page with FAQPage schema markup. Cover common questions about your products, services, and industry to become a direct answer source for AI engines."
+  },
+  original_data: {
+    name: "Add Original Data & Case Studies",
+    effort: "High",
+    description: "Publish original research, statistics, case studies, or proprietary data that AI engines can cite. Unique data points make your content a primary source rather than a derivative one."
+  },
+  internal_linking: {
+    name: "Improve Internal Linking Architecture",
+    effort: "Medium",
+    description: "Strengthen internal linking with descriptive anchor text between related pages. Add breadcrumb navigation and ensure every key page is reachable within 3 clicks from the homepage."
+  },
+  semantic_html: {
+    name: "Implement Semantic HTML5",
+    effort: "Low",
+    description: "Use semantic HTML5 elements (main, article, nav, header, footer, section) to give AI parsers clear content structure. Add lang attribute and ARIA labels for accessibility."
+  },
+  content_freshness: {
+    name: "Add Content Freshness Signals",
+    effort: "Low",
+    description: "Include dateModified schema, visible last-updated dates, and time elements on content pages. Fresh content signals help AI engines prioritize your pages over stale alternatives."
+  },
+  sitemap_completeness: {
+    name: "Create Complete Sitemap",
+    effort: "Low",
+    description: "Generate a comprehensive sitemap.xml with lastmod dates for all important pages. A complete sitemap ensures AI crawlers can discover and prioritize your full content library."
+  },
+  rss_feed: {
+    name: "Deploy RSS/Atom Feed",
+    effort: "Low",
+    description: "Add an RSS or Atom feed linked from your homepage. Feeds signal active content publishing and give AI engines a structured way to track your latest content."
+  },
+  table_list_extractability: {
+    name: "Add Structured Tables & Lists",
+    effort: "Medium",
+    description: "Use HTML tables for comparison data and ordered/unordered lists for features, steps, and specifications. Structured data formats are directly extractable by AI engines for answers."
+  },
+  definition_patterns: {
+    name: "Add Definition-Style Content",
+    effort: "Low",
+    description: 'Include clear definition patterns ("X refers to...", "X is defined as...") for key terms and concepts. Definition-style content is highly citable by AI engines answering "what is" queries.'
+  },
+  direct_answer_density: {
+    name: "Add Direct Answer Paragraphs",
+    effort: "Medium",
+    description: 'Write concise, standalone answer paragraphs (2-3 sentences) immediately after question headings. These "snippet-ready" paragraphs are ideal for AI engine citations.'
+  },
+  content_licensing: {
+    name: "Add Content Licensing & ai.txt",
+    effort: "Low",
+    description: "Create an /ai.txt file specifying AI usage permissions and add license schema to your structured data. Clear licensing signals help AI engines understand how they can use your content."
+  },
+  author_schema_depth: {
+    name: "Enhance Author & Expert Schema",
+    effort: "Low",
+    description: "Add Person schema for content authors with credentials, expertise, and sameAs links. Expert attribution strengthens E-E-A-T signals that AI engines use to evaluate source credibility."
+  },
+  fact_density: {
+    name: "Increase Fact & Data Density",
+    effort: "Medium",
+    description: "Add specific numbers, percentages, statistics, and data points throughout your content. Fact-dense content gives AI engines concrete data to cite rather than vague claims."
+  },
+  canonical_url: {
+    name: "Fix Canonical URL Strategy",
+    effort: "Low",
+    description: 'Add rel="canonical" tags to all pages pointing to the preferred URL version. Canonical URLs prevent duplicate content confusion and consolidate AI engine citations to a single authoritative URL.'
+  },
+  content_velocity: {
+    name: "Increase Publishing Frequency",
+    effort: "High",
+    description: "Establish a regular content publishing cadence with dated entries in your sitemap. Consistent publishing signals to AI engines that your site is an active, current information source."
+  },
+  schema_coverage: {
+    name: "Deepen Schema Coverage",
+    effort: "Medium",
+    description: "Extend structured data beyond the homepage to inner pages (articles, services, products). Consistent schema coverage across your site helps AI engines understand your full content depth."
+  },
+  speakable_schema: {
+    name: "Add Speakable Schema",
+    effort: "Low",
+    description: "Add SpeakableSpecification schema with CSS selectors pointing to key content sections. This tells voice assistants and AI engines which parts of your page are most suitable for spoken answers."
+  }
+};
+function calculateImpact(score, weight, effort) {
+  const impactScore = (10 - score) * weight * 100;
+  if (effort === "Low" && impactScore >= 3) return "QUICK WIN";
+  if (impactScore >= 12) return "CRITICAL";
+  if (impactScore >= 8) return "HIGH";
+  if (impactScore >= 5) return "CORE AEO";
+  if (impactScore >= 3) return "MEDIUM";
+  return "LOW";
+}
+function generateVerdict(score, scorecard, rawData, domain) {
+  let opening;
+  if (score >= 86) {
+    opening = `Excellent AEO implementation scoring ${score}/100.`;
+  } else if (score >= 71) {
+    opening = `Strong AEO fundamentals scoring ${score}/100 with room for optimization.`;
+  } else if (score >= 56) {
+    opening = `Moderate AEO readiness at ${score}/100 with significant gaps to address.`;
+  } else if (score >= 41) {
+    opening = `Below-average AEO readiness at ${score}/100 - multiple areas need attention.`;
+  } else {
+    opening = `Critical AEO gaps at ${score}/100 - ${domain} is largely invisible to AI engines.`;
+  }
+  const strengths = scorecard.filter((s) => s.score >= 8).sort((a, b) => b.score - a.score).slice(0, 3);
+  const weaknesses = scorecard.filter((s) => s.score <= 4).sort((a, b) => a.score - b.score).slice(0, 3);
+  const parts = [opening];
+  if (strengths.length > 0) {
+    const names = strengths.map((s) => s.criterion);
+    parts.push(`Key strengths include ${formatList(names)}.`);
+  }
+  if (weaknesses.length > 0) {
+    const names = weaknesses.map((s) => s.criterion);
+    parts.push(`Priority gaps: ${formatList(names)}.`);
+  }
+  if (!rawData.has_https) {
+    parts.push("HTTPS is not enabled, which caps several criteria scores and reduces AI crawler trust.");
+  }
+  if (rawData.rendered_with_headless) {
+    parts.push("Note: this site uses client-side JavaScript rendering. AI crawlers see an empty page shell instead of content, which is the primary factor limiting the score.");
+  }
+  return parts.join(" ");
+}
+function generateOpportunities(scorecard, criterionResults) {
+  const candidates = [];
+  for (const result of criterionResults) {
+    if (result.score > 7) continue;
+    const weight = CRITERION_WEIGHTS[result.criterion] ?? 0.05;
+    const template = OPPORTUNITY_TEMPLATES[result.criterion];
+    if (!template) continue;
+    const impactScore = (10 - result.score) * weight * 100;
+    const impact = calculateImpact(result.score, weight, template.effort);
+    candidates.push({
+      criterion: result.criterion,
+      score: result.score,
+      weight,
+      impactScore,
+      template,
+      impact
+    });
+  }
+  candidates.sort((a, b) => b.impactScore - a.impactScore);
+  const top = candidates.slice(0, 10);
+  return top.map((c, i) => ({
+    id: i + 1,
+    name: c.template.name,
+    description: c.template.description,
+    effort: c.template.effort,
+    impact: c.impact
+  }));
+}
+function generatePitchNumbers(score, rawData, scorecard) {
+  const metrics = [];
+  if (rawData.rendered_with_headless) {
+    metrics.push({
+      metric: "Rendering Method",
+      value: "Client-Side Only",
+      significance: "AI crawlers see empty HTML. All content loads via JavaScript, making this site invisible to ChatGPT, Claude, and Perplexity."
+    });
+  }
+  metrics.push({
+    metric: "AEO Score",
+    value: `${score}/100`,
+    significance: score >= 70 ? "Above average AI engine visibility" : score >= 50 ? "Moderate AI visibility with clear improvement paths" : "Below average - significant optimization needed"
+  });
+  const schemaCount = rawData.schema_types_found.length;
+  metrics.push({
+    metric: "Schema Types",
+    value: `${schemaCount} found`,
+    significance: schemaCount >= 4 ? "Rich structured data helps AI engines parse content" : schemaCount >= 1 ? "Basic schema present but more types would improve AI extraction" : "No structured data - AI engines cannot reliably extract content"
+  });
+  const aiCrawlerCount = rawData.robots_txt_ai_crawlers.length;
+  const blockedCount = rawData.robots_txt_blocked_crawlers.length;
+  metrics.push({
+    metric: "AI Crawler Access",
+    value: blockedCount > 0 ? `${blockedCount} blocked` : aiCrawlerCount > 0 ? `${aiCrawlerCount} configured` : "Not configured",
+    significance: blockedCount > 0 ? "Active AI crawlers are blocked from accessing content" : aiCrawlerCount > 0 ? "robots.txt explicitly addresses AI crawler access" : "No AI-specific crawler directives in robots.txt"
+  });
+  const sitemapUrls = rawData.sitemap_url_count;
+  metrics.push({
+    metric: "Sitemap URLs",
+    value: sitemapUrls > 0 ? `${sitemapUrls} pages` : "No sitemap",
+    significance: sitemapUrls >= 50 ? "Comprehensive content library discoverable by AI crawlers" : sitemapUrls >= 10 ? "Moderate content footprint in sitemap" : sitemapUrls > 0 ? "Small sitemap - expanding content improves AI coverage" : "No sitemap means AI crawlers must discover pages via links only"
+  });
+  const linkCount = rawData.internal_link_count;
+  metrics.push({
+    metric: "Internal Links",
+    value: `${linkCount} links`,
+    significance: linkCount >= 30 ? "Strong internal linking supports AI content discovery" : linkCount >= 10 ? "Moderate linking - adding more cross-references improves navigability" : "Weak internal linking limits AI crawler depth"
+  });
+  const questionCount = rawData.question_headings_count + (rawData.blog_sample_question_headings || 0);
+  if (questionCount > 0) {
+    metrics.push({
+      metric: "Question Headings",
+      value: `${questionCount} found`,
+      significance: "Question-based headings match how users query AI assistants"
+    });
+  }
+  const passing = scorecard.filter((s) => s.score >= 7).length;
+  metrics.push({
+    metric: "Criteria Passing",
+    value: `${passing}/23`,
+    significance: passing >= 18 ? "Excellent coverage across AEO dimensions" : passing >= 12 ? "Good foundation with room to improve remaining criteria" : `${23 - passing} criteria need attention for full AI visibility`
+  });
+  return metrics;
+}
+function generateBottomLine(score, opportunities, scorecard, domain) {
+  const quickWins = opportunities.filter((o) => o.impact === "QUICK WIN");
+  const criticalOps = opportunities.filter((o) => o.impact === "CRITICAL" || o.impact === "HIGH");
+  const passing = scorecard.filter((s) => s.score >= 7).length;
+  const total = scorecard.length;
+  let summary;
+  if (score >= 86) {
+    summary = `${domain} demonstrates excellent AI engine optimization with ${passing}/${total} criteria at good or strong levels. Focus on maintaining content freshness and expanding structured data coverage to stay ahead.`;
+  } else if (score >= 71) {
+    summary = `${domain} has a solid AEO foundation with ${passing}/${total} criteria passing.`;
+    if (quickWins.length > 0) {
+      summary += ` ${quickWins.length} quick wins available: ${quickWins.slice(0, 3).map((q) => q.name).join(", ")}.`;
+    }
+    if (criticalOps.length > 0) {
+      summary += ` Address ${criticalOps.length} high-impact opportunities to push the score above 85.`;
+    }
+  } else if (score >= 56) {
+    summary = `${domain} has moderate AI visibility with ${passing}/${total} criteria passing. ${opportunities.length} improvement opportunities identified.`;
+    if (quickWins.length > 0) {
+      summary += ` Start with quick wins: ${quickWins.slice(0, 3).map((q) => q.name).join(", ")}.`;
+    }
+  } else if (score >= 41) {
+    summary = `${domain} needs significant AEO work with only ${passing}/${total} criteria passing.`;
+    if (criticalOps.length > 0) {
+      summary += ` Priority: ${criticalOps.slice(0, 3).map((c) => c.name).join(", ")}.`;
+    }
+    summary += ` Implementing the top ${Math.min(5, opportunities.length)} recommendations could improve the score by 15-25 points.`;
+  } else {
+    summary = `${domain} is largely invisible to AI engines with only ${passing}/${total} criteria passing. Fundamental AEO infrastructure is missing.`;
+    if (opportunities.length > 0) {
+      summary += ` Start with: ${opportunities.slice(0, 3).map((o) => o.name).join(", ")}.`;
+    }
+    summary += ` A comprehensive AEO implementation could transform AI visibility from near-zero to competitive.`;
+  }
+  return summary;
+}
+function formatList(items) {
+  if (items.length === 0) return "";
+  if (items.length === 1) return items[0];
+  if (items.length === 2) return `${items[0]} and ${items[1]}`;
+  return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+
+// src/multi-page-fetcher.ts
+async function fetchPage(url, timeoutMs = 1e4) {
+  try {
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { "User-Agent": "AEO-Visibility-Bot/1.0" },
+      redirect: "follow"
+    });
+    if (res.status !== 200) return null;
+    const text = await res.text();
+    if (text.length < 200) return null;
+    return { text: text.slice(0, 5e5), status: res.status, finalUrl: res.url };
+  } catch {
+    return null;
+  }
+}
+var PAGE_VARIANTS = {
+  about: ["/about", "/about-us", "/company", "/who-we-are"],
+  pricing: ["/pricing", "/plans", "/packages"],
+  services: ["/services", "/features", "/solutions", "/products", "/what-we-do"],
+  contact: ["/contact", "/contact-us", "/get-in-touch"],
+  team: ["/team", "/our-team", "/authors", "/people", "/leadership"],
+  resources: ["/resources", "/resource-center", "/library"],
+  docs: ["/docs", "/documentation", "/help", "/help-center", "/support"],
+  cases: ["/case-studies", "/customers", "/success-stories", "/testimonials"]
+};
+function extractNavLinks(html, domain) {
+  const navBlocks = html.match(/<nav[\s\S]*?<\/nav>/gi) || [];
+  const navHtml = navBlocks.join("\n");
+  const hrefMatches = navHtml.match(/href="([^"#]*)"/gi) || [];
+  const paths = /* @__PURE__ */ new Set();
+  const cleanDomain = domain.replace(/^www\./, "").toLowerCase();
+  for (const match of hrefMatches) {
+    const href = match.match(/href="([^"#]*)"/i)?.[1];
+    if (!href) continue;
+    let path;
+    if (href.startsWith("/")) {
+      path = href;
+    } else if (href.startsWith("http")) {
+      try {
+        const url = new URL(href);
+        const linkDomain = url.hostname.replace(/^www\./, "").toLowerCase();
+        if (linkDomain !== cleanDomain) continue;
+        path = url.pathname;
+      } catch {
+        continue;
+      }
+    } else {
+      continue;
+    }
+    path = path.replace(/\/+$/, "") || "/";
+    if (path === "/") continue;
+    if (path.includes("#")) continue;
+    if (/\.(js|css|png|jpg|svg|ico|pdf|xml|txt)$/i.test(path)) continue;
+    if (/^\/(api|wp-|static|assets|_next|auth|login|signup|cart|checkout)\b/i.test(path)) continue;
+    paths.add(path);
+  }
+  return Array.from(paths);
+}
+function extractContentPagesFromSitemap(sitemapText, domain, limit = 6) {
+  const urlBlocks = sitemapText.match(/<url>([\s\S]*?)<\/url>/gi) || [];
+  const cleanDomain = domain.replace(/^www\./, "").toLowerCase();
+  const candidates = [];
+  const skipPatterns = /\/(?:blog|articles?|posts?|news|tag|category|author|feed|faq|about|pricing|contact|team|resources?|docs?|documentation|help|support|case-studies|customers|testimonials|sitemap|wp-|api|login|cart|checkout|search)\b/i;
+  for (const block of urlBlocks) {
+    const locMatch = block.match(/<loc>([^<]+)<\/loc>/i);
+    if (!locMatch) continue;
+    const url = locMatch[1].trim();
+    try {
+      const parsed = new URL(url);
+      const urlDomain = parsed.hostname.replace(/^www\./, "").toLowerCase();
+      if (urlDomain !== cleanDomain) continue;
+      if (parsed.pathname === "/" || parsed.pathname === "") continue;
+      const path = parsed.pathname.toLowerCase();
+      if (skipPatterns.test(path)) continue;
+      const segments = path.split("/").filter(Boolean);
+      if (segments.length < 1 || segments.length > 3) continue;
+      candidates.push(url);
+    } catch {
+      continue;
+    }
+  }
+  if (candidates.length <= limit) return candidates;
+  const result = [];
+  for (let i = 0; i < limit; i++) {
+    const index = Math.round(i * (candidates.length - 1) / (limit - 1));
+    result.push(candidates[index]);
+  }
+  return result;
+}
+async function fetchMultiPageData(siteData, options) {
+  if (!siteData.protocol || !siteData.homepage) return 0;
+  const timeoutMs = options?.timeoutMs ?? 1e4;
+  const baseUrl = `${siteData.protocol}://${siteData.domain}`;
+  const existingUrls = /* @__PURE__ */ new Set();
+  existingUrls.add(baseUrl + "/");
+  existingUrls.add(baseUrl);
+  if (siteData.blogSample) {
+    for (const page of siteData.blogSample) {
+      if (page.finalUrl) existingUrls.add(page.finalUrl);
+    }
+  }
+  const urlsToFetch = /* @__PURE__ */ new Map();
+  const navPaths = extractNavLinks(siteData.homepage.text, siteData.domain);
+  for (const [category, variants] of Object.entries(PAGE_VARIANTS)) {
+    const navMatch = navPaths.find(
+      (p) => variants.some((v) => p.toLowerCase() === v || p.toLowerCase().startsWith(v + "/"))
+    );
+    if (navMatch) {
+      const url = `${baseUrl}${navMatch}`;
+      if (!existingUrls.has(url)) urlsToFetch.set(url, category);
+    } else {
+      const url = `${baseUrl}${variants[0]}`;
+      if (!existingUrls.has(url)) urlsToFetch.set(url, category);
+    }
+  }
+  if (siteData.sitemapXml && siteData.sitemapXml.status === 200) {
+    const contentUrls = extractContentPagesFromSitemap(
+      siteData.sitemapXml.text,
+      siteData.domain,
+      6
+    );
+    for (const url of contentUrls) {
+      if (!existingUrls.has(url)) urlsToFetch.set(url, "content");
+    }
+  }
+  const entries = Array.from(urlsToFetch.entries());
+  if (entries.length === 0) return 0;
+  const results = await Promise.all(entries.map(([url]) => fetchPage(url, timeoutMs)));
+  if (!siteData.blogSample) siteData.blogSample = [];
+  let added = 0;
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result && result.text.length > 500) {
+      result.category = entries[i][1];
+      siteData.blogSample.push(result);
+      added++;
+    }
+  }
+  return added;
+}
+
+// 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) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+function countWords(text) {
+  if (!text) return 0;
+  return text.split(/\s+/).filter((w) => w.length > 0).length;
+}
+function checkMissingTitle(html) {
+  const hasTitle = /<title[^>]*>[\s\S]*?<\/title>/i.test(html);
+  if (!hasTitle) {
+    return { check: "missing-title", label: "Missing <title> tag", severity: "error" };
+  }
+  const title = extractTitle(html);
+  if (!title) {
+    return { check: "missing-title", label: "Empty <title> tag", severity: "error" };
+  }
+  return null;
+}
+function checkMissingMetaDescription(html) {
+  const hasDesc = /<meta\s[^>]*name=["']description["'][^>]*content=["'][^"']+["']/i.test(html) || /<meta\s[^>]*content=["'][^"']+["'][^>]*name=["']description["']/i.test(html);
+  if (!hasDesc) {
+    return { check: "missing-meta-description", label: "Missing meta description", severity: "error" };
+  }
+  return null;
+}
+function checkNoH1(html) {
+  const h1Matches = html.match(/<h1[\s>]/gi);
+  if (!h1Matches || h1Matches.length === 0) {
+    return { check: "no-h1", label: "No <h1> tag", severity: "error" };
+  }
+  return null;
+}
+function checkMultipleH1(html) {
+  const h1Matches = html.match(/<h1[\s>]/gi);
+  if (h1Matches && h1Matches.length > 1) {
+    return { check: "multiple-h1", label: `Multiple <h1> tags (${h1Matches.length})`, severity: "warning" };
+  }
+  return null;
+}
+function checkNoSchema(html) {
+  const hasLdJson = /<script[^>]*type=["']application\/ld\+json["'][^>]*>/i.test(html);
+  if (!hasLdJson) {
+    return { check: "no-schema", label: "No JSON-LD structured data", severity: "warning" };
+  }
+  return null;
+}
+function checkMissingCanonical(html) {
+  const hasCanonical = /<link[^>]*rel=["']canonical["'][^>]*>/i.test(html);
+  if (!hasCanonical) {
+    return { check: "missing-canonical", label: "Missing canonical link", severity: "warning" };
+  }
+  return null;
+}
+function checkMissingOgTags(html) {
+  const hasOg = /<meta\s[^>]*property=["']og:/i.test(html);
+  if (!hasOg) {
+    return { check: "missing-og-tags", label: "No Open Graph tags", severity: "warning" };
+  }
+  return null;
+}
+function checkThinContent(wordCount) {
+  if (wordCount < 300) {
+    return { check: "thin-content", label: `Thin content (${wordCount} words)`, severity: "warning" };
+  }
+  return null;
+}
+function checkImagesMissingAlt(html) {
+  const imgTags = html.match(/<img\s[^>]*>/gi) || [];
+  if (imgTags.length === 0) return null;
+  let missingAlt = 0;
+  for (const img of imgTags) {
+    const hasAlt = /\salt=["'][^"']+["']/i.test(img);
+    const hasEmptyAlt = /\salt=["']["']/i.test(img);
+    if (!hasAlt && !hasEmptyAlt) missingAlt++;
+  }
+  if (missingAlt > 0) {
+    return {
+      check: "images-missing-alt",
+      label: `${missingAlt} image${missingAlt > 1 ? "s" : ""} missing alt text`,
+      severity: "warning"
+    };
+  }
+  return null;
+}
+function checkNoInternalLinks(html, url) {
+  let domain;
+  try {
+    domain = new URL(url).hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return null;
+  }
+  const links = html.match(/<a\s[^>]*href=["']([^"'#]*?)["'][^>]*>/gi) || [];
+  let internalCount = 0;
+  for (const link of links) {
+    const hrefMatch = link.match(/href=["']([^"'#]*?)["']/i);
+    if (!hrefMatch) continue;
+    const href = hrefMatch[1];
+    if (href.startsWith("/") && !href.startsWith("//")) {
+      internalCount++;
+    } else if (href.startsWith("http")) {
+      try {
+        const linkDomain = new URL(href).hostname.replace(/^www\./, "").toLowerCase();
+        if (linkDomain === domain) internalCount++;
+      } catch {
+      }
+    }
+  }
+  if (internalCount === 0) {
+    return { check: "no-internal-links", label: "No internal links found", severity: "warning" };
+  }
+  return null;
+}
+function checkHasStructuredData(html) {
+  const ldBlocks = html.match(/<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi) || [];
+  if (ldBlocks.length === 0) return null;
+  const types = /* @__PURE__ */ new Set();
+  for (const block of ldBlocks) {
+    const content = block.replace(/<\/?script[^>]*>/gi, "");
+    const typeMatches = content.match(/"@type"\s*:\s*"([^"]+)"/g) || [];
+    for (const m of typeMatches) {
+      const t = m.match(/"@type"\s*:\s*"([^"]+)"/);
+      if (t) types.add(t[1]);
+    }
+  }
+  if (types.size > 0) {
+    return {
+      check: "has-structured-data",
+      label: `JSON-LD: ${Array.from(types).join(", ")}`,
+      severity: "info"
+    };
+  }
+  return null;
+}
+function checkHasQuestionHeadings(html) {
+  const headings = html.match(/<h[2-4][^>]*>[\s\S]*?<\/h[2-4]>/gi) || [];
+  let questionCount = 0;
+  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)) {
+      questionCount++;
+    }
+  }
+  if (questionCount > 0) {
+    return {
+      check: "has-question-headings",
+      label: `${questionCount} question-format heading${questionCount > 1 ? "s" : ""}`,
+      severity: "info"
+    };
+  }
+  return null;
+}
+function analyzePage(html, url, category) {
+  const title = extractTitle(html);
+  const textContent = getTextContent(html);
+  const wordCount = countWords(textContent);
+  const issues = [];
+  const strengths = [];
+  const issueChecks = [
+    checkMissingTitle(html),
+    checkMissingMetaDescription(html),
+    checkNoH1(html),
+    checkMultipleH1(html),
+    checkNoSchema(html),
+    checkMissingCanonical(html),
+    checkMissingOgTags(html),
+    checkThinContent(wordCount),
+    checkImagesMissingAlt(html),
+    checkNoInternalLinks(html, url)
+  ];
+  for (const result of issueChecks) {
+    if (result) issues.push(result);
+  }
+  const strengthChecks = [
+    checkHasStructuredData(html),
+    checkHasQuestionHeadings(html)
+  ];
+  for (const result of strengthChecks) {
+    if (result) strengths.push(result);
+  }
+  return { url, title, category, wordCount, issues, strengths };
+}
+function analyzeAllPages(siteData) {
+  const reviews = [];
+  if (siteData.homepage) {
+    const url = `${siteData.protocol}://${siteData.domain}`;
+    reviews.push(analyzePage(siteData.homepage.text, url, siteData.homepage.category || "homepage"));
+  }
+  if (siteData.blogSample) {
+    for (const page of siteData.blogSample) {
+      const url = page.finalUrl || "unknown";
+      reviews.push(analyzePage(page.text, url, page.category || "content"));
+    }
+  }
+  return reviews;
+}
+
+// src/audit.ts
+function getTextLength(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim().length;
+}
+async function audit(domain, options) {
+  const startTime = Date.now();
+  let renderedWithHeadless = false;
+  const siteData = await prefetchSiteData(domain);
+  if (!siteData.protocol) {
+    throw new Error(`Could not connect to ${domain} (no HTTPS or HTTP response)`);
+  }
+  if (siteData.redirectedTo) {
+    throw new Error(`${domain} redirects to ${siteData.redirectedTo} (hijacked domain)`);
+  }
+  if (siteData.parkedReason) {
+    throw new Error(`${domain} is a parked/lost domain (${siteData.parkedReason})`);
+  }
+  if (!options?.noHeadless && siteData.homepage && isSpaShell(siteData.homepage.text)) {
+    const rawTextLen = getTextLength(siteData.homepage.text);
+    const url = `${siteData.protocol}://${domain}`;
+    const rendered = await fetchWithHeadless(url);
+    if (rendered) {
+      const renderedTextLen = getTextLength(rendered.text);
+      if (renderedTextLen > rawTextLen) {
+        siteData.homepage = rendered;
+        renderedWithHeadless = true;
+      }
+    }
+    if (renderedWithHeadless && siteData.faqPage && isSpaShell(siteData.faqPage.text)) {
+      const faqUrl = `${siteData.protocol}://${domain}/faq`;
+      const renderedFaq = await fetchWithHeadless(faqUrl);
+      if (renderedFaq && getTextLength(renderedFaq.text) > getTextLength(siteData.faqPage.text)) {
+        siteData.faqPage = renderedFaq;
+      }
+    }
+  }
+  if (!options?.noMultiPage) {
+    await fetchMultiPageData(siteData);
+  }
+  const results = auditSiteFromData(siteData);
+  const overallScore = calculateOverallScore(results);
+  const rawData = extractRawDataSummary(siteData);
+  if (renderedWithHeadless) rawData.rendered_with_headless = true;
+  const scorecard = buildScorecard(results);
+  const detailedFindings = buildDetailedFindings(results);
+  const verdict = generateVerdict(overallScore, scorecard, rawData, domain);
+  const opportunities = generateOpportunities(scorecard, results);
+  const pitchNumbers = generatePitchNumbers(overallScore, rawData, scorecard);
+  const bottomLine = generateBottomLine(overallScore, opportunities, scorecard, domain);
+  const pagesReviewed = analyzeAllPages(siteData);
+  const elapsed = Math.round((Date.now() - startTime) / 100) / 10;
+  return {
+    site: domain,
+    auditDate: (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { year: "numeric", month: "long", day: "numeric" }),
+    auditor: "AEORank",
+    engine: "instant",
+    overallScore,
+    verdict,
+    scorecard,
+    detailedFindings,
+    opportunities,
+    pitchNumbers,
+    bottomLine,
+    pagesReviewed,
+    elapsed,
+    ...renderedWithHeadless && { renderedWithHeadless: true }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CRITERION_LABELS,
+  analyzeAllPages,
+  analyzePage,
+  audit,
+  auditSiteFromData,
+  buildDetailedFindings,
+  buildScorecard,
+  calculateOverallScore,
+  classifyRendering,
+  detectParkedDomain,
+  extractContentPagesFromSitemap,
+  extractNavLinks,
+  extractRawDataSummary,
+  fetchMultiPageData,
+  fetchWithHeadless,
+  generateBottomLine,
+  generateOpportunities,
+  generatePitchNumbers,
+  generateVerdict,
+  isSpaShell,
+  prefetchSiteData,
+  scoreToStatus
+});
+//# sourceMappingURL=index.cjs.map