aiseo-audit 1.4.7 → 1.4.8

package/dist/chunk-2BXVAEAS.mjs

@@ -0,0 +1,4483 @@
+// src/modules/analyzer/constants.ts
+var DOMAIN_SIGNAL_TIMEOUT_CAP = 5e3;
+var VERSION = true ? "1.4.8" : "0.0.0";
+
+// src/modules/fetcher/constants.ts
+var MAX_RESPONSE_SIZE = 10 * 1024 * 1024;
+var DEFAULT_HEADERS = {
+  Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+  "Accept-Language": "en-US,en;q=0.9",
+  "Accept-Encoding": "gzip, deflate, br",
+  "Cache-Control": "no-cache"
+};
+
+// src/utils/http.ts
+var FetchError = class extends Error {
+  code;
+  url;
+  constructor(code, url, message) {
+    super(message);
+    this.name = "FetchError";
+    this.code = code;
+    this.url = url;
+  }
+};
+function classifyFetchError(err, url) {
+  if (err instanceof FetchError) return err;
+  const msg = err instanceof Error ? err.message : String(err);
+  const cause = err instanceof Error && err.cause instanceof Error ? err.cause.message : "";
+  const combined = `${msg} ${cause}`.toLowerCase();
+  if (err instanceof DOMException || err instanceof Error && err.name === "AbortError" || combined.includes("abort")) {
+    return new FetchError(
+      "TIMEOUT",
+      url,
+      `Request timed out. The server at "${new URL(url).hostname}" did not respond in time.`
+    );
+  }
+  if (combined.includes("getaddrinfo") || combined.includes("enotfound")) {
+    const hostname = new URL(url).hostname;
+    return new FetchError(
+      "DNS_FAILURE",
+      url,
+      `DNS lookup failed for "${hostname}". Check that the domain exists and is spelled correctly.`
+    );
+  }
+  if (combined.includes("econnrefused")) {
+    return new FetchError(
+      "CONNECTION_REFUSED",
+      url,
+      `Connection refused by "${new URL(url).hostname}". The server may be down or not accepting connections.`
+    );
+  }
+  if (combined.includes("cert") || combined.includes("ssl") || combined.includes("tls") || combined.includes("unable to verify")) {
+    return new FetchError(
+      "TLS_ERROR",
+      url,
+      `TLS/SSL error connecting to "${new URL(url).hostname}". The site may have an invalid or expired certificate.`
+    );
+  }
+  return new FetchError(
+    "NETWORK_ERROR",
+    url,
+    `Network error fetching "${url}": ${msg}`
+  );
+}
+async function httpGet(options) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeout);
+  try {
+    const response = await fetch(options.url, {
+      method: "GET",
+      headers: {
+        "User-Agent": options.userAgent,
+        ...DEFAULT_HEADERS
+      },
+      signal: controller.signal,
+      redirect: "follow"
+    });
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && parseInt(contentLength, 10) > MAX_RESPONSE_SIZE) {
+      throw new FetchError(
+        "TOO_LARGE",
+        options.url,
+        `Response from "${new URL(options.url).hostname}" exceeds the ${Math.round(MAX_RESPONSE_SIZE / 1024 / 1024)}MB size limit.`
+      );
+    }
+    const data = await response.text();
+    if (data.length > MAX_RESPONSE_SIZE) {
+      throw new FetchError(
+        "TOO_LARGE",
+        options.url,
+        `Response from "${new URL(options.url).hostname}" exceeds the ${Math.round(MAX_RESPONSE_SIZE / 1024 / 1024)}MB size limit.`
+      );
+    }
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      status: response.status,
+      data,
+      headers,
+      finalUrl: response.url
+    };
+  } catch (err) {
+    throw classifyFetchError(err, options.url);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function httpHead(options) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeout);
+  try {
+    const response = await fetch(options.url, {
+      method: "HEAD",
+      headers: {
+        "User-Agent": options.userAgent,
+        ...DEFAULT_HEADERS
+      },
+      signal: controller.signal,
+      redirect: "follow"
+    });
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      status: response.status,
+      data: "",
+      headers,
+      finalUrl: response.url
+    };
+  } catch (err) {
+    throw classifyFetchError(err, options.url);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/utils/url.ts
+function normalizeUrl(input) {
+  let url = input.trim();
+  if (!/^https?:\/\//i.test(url)) {
+    url = `https://${url}`;
+  }
+  const parsed = new URL(url);
+  return parsed.toString().replace(/\/+$/, "");
+}
+function isValidUrl(input) {
+  try {
+    const url = normalizeUrl(input);
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+
+// src/modules/nlp/service.ts
+import compromise from "compromise";
+
+// src/modules/nlp/constants.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "as",
+  "is",
+  "was",
+  "are",
+  "were",
+  "been",
+  "be",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "must",
+  "that",
+  "which",
+  "who",
+  "whom",
+  "this",
+  "these",
+  "those",
+  "it",
+  "its",
+  "he",
+  "she",
+  "they",
+  "we",
+  "you",
+  "i",
+  "me",
+  "him",
+  "her",
+  "us",
+  "them",
+  "my",
+  "your",
+  "his",
+  "our",
+  "their",
+  "what",
+  "when",
+  "where",
+  "how",
+  "why",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "about",
+  "above",
+  "after",
+  "again",
+  "also",
+  "any",
+  "because",
+  "before",
+  "between",
+  "during",
+  "here",
+  "if",
+  "into",
+  "like",
+  "new",
+  "now",
+  "over",
+  "then",
+  "there",
+  "through",
+  "under",
+  "up",
+  "out",
+  "off",
+  "down",
+  "much",
+  "well",
+  "back",
+  "even",
+  "still",
+  "also",
+  "get",
+  "got",
+  "one",
+  "two",
+  "make",
+  "many",
+  "say",
+  "said",
+  "see",
+  "go",
+  "come",
+  "take",
+  "know",
+  "think",
+  "good",
+  "great",
+  "first",
+  "last",
+  "long",
+  "way",
+  "find",
+  "use",
+  "used",
+  "using",
+  "while",
+  "being",
+  "made",
+  "however",
+  "since",
+  "per",
+  "via",
+  "based",
+  "within",
+  "without",
+  "across",
+  "along",
+  "around",
+  "among",
+  "until",
+  "another",
+  "www",
+  "http",
+  "https",
+  "com"
+]);
+var ACRONYM_STOPLIST = /* @__PURE__ */ new Set([
+  "I",
+  "A",
+  "OK",
+  "AM",
+  "PM",
+  "US",
+  "UK",
+  "EU",
+  "VS",
+  "EG",
+  "IE",
+  "ET",
+  "AL",
+  "HTML",
+  "CSS",
+  "JS",
+  "TS",
+  "URL",
+  "HTTP",
+  "HTTPS",
+  "API",
+  "SDK",
+  "CLI",
+  "GUI",
+  "PDF",
+  "CSV",
+  "JSON",
+  "XML",
+  "SQL",
+  "RSS",
+  "FTP",
+  "SSH",
+  "SSL",
+  "TLS",
+  "DNS",
+  "TCP",
+  "UDP",
+  "IP",
+  "RAM",
+  "ROM",
+  "CPU",
+  "GPU",
+  "SSD",
+  "HDD",
+  "USB",
+  "HDMI",
+  "FAQ",
+  "DIY",
+  "ASAP",
+  "FYI",
+  "TBD",
+  "TBA",
+  "ETA",
+  "ROI",
+  "KPI",
+  "CEO",
+  "CTO",
+  "CFO",
+  "COO",
+  "CIO",
+  "VP",
+  "SVP",
+  "EVP",
+  "HR",
+  "PR",
+  "QA",
+  "IT",
+  "RD",
+  "RND",
+  "LLC",
+  "INC",
+  "LTD",
+  "CORP",
+  "PLC",
+  "USD",
+  "EUR",
+  "GBP",
+  "JPY",
+  "CAD",
+  "ID",
+  "NO",
+  "RE",
+  "CC",
+  "BCC",
+  "GEO",
+  "SEO",
+  "SEM",
+  "PPC",
+  "CMS",
+  "CRM",
+  "ERP",
+  "SaaS",
+  "AI",
+  "ML",
+  "NLP",
+  "LLM",
+  "GPT",
+  "NER",
+  "TLDR",
+  "AKA",
+  "RSVP",
+  "PS"
+]);
+var ORG_SUFFIXES = /\b(?:Inc|Corp|Corporation|LLC|Ltd|Limited|Co|Company|Group|Foundation|Institute|University|Association|Society|Agency|Authority|Bureau|Commission|Council|Department|Board|Trust|Fund|Partners|Ventures|Labs|Technologies|Solutions|Systems|Services|Consulting|Media|Network|Studios|Entertainment|Healthcare|Pharmaceuticals|Dynamics|Holdings|Capital|Enterprises|International)\b/i;
+var PERSON_HONORIFICS = /\b(?:Mr|Mrs|Ms|Miss|Dr|Prof|Professor|Rev|Reverend|Sen|Senator|Rep|Representative|Gov|Governor|Pres|President|Gen|General|Col|Colonel|Sgt|Sergeant|Cpl|Corporal|Pvt|Private|Adm|Admiral|Capt|Captain|Lt|Lieutenant|Maj|Major|Sir|Dame|Lord|Lady|Hon|Honorable|Judge|Justice|Chancellor|Dean|Provost)\.\s*/;
+
+// src/modules/nlp/support/entities.ts
+function extractAcronymEntities(text) {
+  const matches = text.match(/\b[A-Z]{2,6}\b/g);
+  if (!matches) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const m of matches) {
+    if (!ACRONYM_STOPLIST.has(m) && !seen.has(m)) {
+      seen.add(m);
+      results.push(m);
+    }
+  }
+  return results;
+}
+function extractTitleCaseEntities(text) {
+  const pattern = /\b([A-Z][a-z]+(?:\s+(?:of|the|and|for|de|van|von|al|el|la|le|del|der|den|das|di|du))?\s+(?:[A-Z][a-z]+)(?:\s+[A-Z][a-z]+){0,3})\b/g;
+  const sentences = text.split(/[.!?]\s+/);
+  const sentenceStarts = /* @__PURE__ */ new Set();
+  for (const s of sentences) {
+    const trimmed = s.trim();
+    const firstWord = trimmed.split(/\s+/)[0];
+    if (firstWord) sentenceStarts.add(firstWord);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    const entity = match[1];
+    const firstWord = entity.split(/\s+/)[0];
+    if (sentenceStarts.has(firstWord) && !text.includes(`. ${entity}`) && !text.includes(`, ${entity}`)) {
+      const escapedEntity = entity.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const appearances = text.match(new RegExp(escapedEntity, "g"));
+      if (!appearances || appearances.length < 2) continue;
+    }
+    if (!seen.has(entity) && entity.split(/\s+/).length >= 2) {
+      seen.add(entity);
+      results.push(entity);
+    }
+  }
+  return results;
+}
+function isOrganizationByPattern(entity) {
+  return ORG_SUFFIXES.test(entity);
+}
+function isPersonByHonorific(text, entity) {
+  const escapedEntity = entity.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `(?:${PERSON_HONORIFICS.source})\\s*${escapedEntity}`,
+    "i"
+  );
+  return pattern.test(text);
+}
+function smartDedup(entities) {
+  if (entities.length === 0) return [];
+  const sorted = [...entities].sort((a, b) => b.length - a.length);
+  const result = [];
+  const lowerSeen = /* @__PURE__ */ new Set();
+  for (const entity of sorted) {
+    const lower = entity.toLowerCase();
+    if (lowerSeen.has(lower)) continue;
+    let isSubstring = false;
+    for (const accepted of lowerSeen) {
+      if (accepted.includes(lower)) {
+        isSubstring = true;
+        break;
+      }
+    }
+    if (isSubstring) continue;
+    result.push(entity);
+    lowerSeen.add(lower);
+  }
+  return result;
+}
+function mergeEntityLists(compromiseList, supplementalList, limit) {
+  const combined = [...compromiseList, ...supplementalList];
+  return smartDedup(combined).slice(0, limit);
+}
+
+// src/modules/nlp/support/topics.ts
+function extractTopicsByTfIdf(text, limit) {
+  const lower = text.toLowerCase();
+  const words = lower.replace(/[^a-z0-9\s'-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS.has(w));
+  if (words.length === 0) return [];
+  const freq = /* @__PURE__ */ new Map();
+  for (const w of words) {
+    freq.set(w, (freq.get(w) || 0) + 1);
+  }
+  for (let i = 0; i < words.length - 1; i++) {
+    const bigram = `${words[i]} ${words[i + 1]}`;
+    freq.set(bigram, (freq.get(bigram) || 0) + 1);
+  }
+  const candidates = [];
+  for (const [term, count] of freq) {
+    if (count >= 2) {
+      const isBigram = term.includes(" ");
+      const score = isBigram ? count * 1.5 : count;
+      candidates.push([term, score]);
+    }
+  }
+  candidates.sort((a, b) => b[1] - a[1]);
+  return candidates.slice(0, limit).map(([term]) => term);
+}
+
+// src/modules/nlp/support/patterns.ts
+function countPatternMatches(text, patterns) {
+  let count = 0;
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.source, pattern.flags);
+    const matches = text.match(re);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function countTransitionWords(text, words) {
+  const lower = text.toLowerCase();
+  return words.filter((w) => lower.includes(w)).length;
+}
+
+// src/utils/strings.ts
+function countWords(text) {
+  return text.split(/\s+/).filter((w) => w.length > 0).length;
+}
+function countSentences(text) {
+  return text.split(/[.!?]+/).filter((s) => s.trim().length > 5).length;
+}
+function countSyllables(word) {
+  word = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (word.length <= 3) return 1;
+  word = word.replace(/(?:[^laeiouy]es|ed|[^laeiouy]e)$/, "");
+  word = word.replace(/^y/, "");
+  const matches = word.match(/[aeiouy]{1,2}/g);
+  return matches ? Math.max(matches.length, 1) : 1;
+}
+
+// src/modules/nlp/support/readability.ts
+function computeFleschReadingEase(text) {
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 5);
+  const totalSyllables = words.reduce((sum, w) => sum + countSyllables(w), 0);
+  if (words.length === 0 || sentences.length === 0) return 0;
+  const avgSentenceLength2 = words.length / sentences.length;
+  const avgSyllablesPerWord = totalSyllables / words.length;
+  return 206.835 - 1.015 * avgSentenceLength2 - 84.6 * avgSyllablesPerWord;
+}
+function countComplexWords(text) {
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+  return words.filter((w) => countSyllables(w) >= 4).length;
+}
+function avgSentenceLength(text) {
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 5);
+  if (sentences.length === 0) return 0;
+  return Math.round(words.length / sentences.length);
+}
+
+// src/modules/nlp/service.ts
+function extractEntities(text) {
+  const doc = compromise(text);
+  const compromisePeople = [...new Set(doc.people().out("array"))];
+  const compromiseOrgs = [
+    ...new Set(doc.organizations().out("array"))
+  ];
+  const compromisePlaces = [...new Set(doc.places().out("array"))];
+  const acronyms = extractAcronymEntities(text);
+  const titleCaseEntities = extractTitleCaseEntities(text);
+  const supplementalPeople = [];
+  const supplementalOrgs = [];
+  const unclassified = [];
+  for (const entity of titleCaseEntities) {
+    if (isPersonByHonorific(text, entity)) {
+      supplementalPeople.push(entity);
+    } else if (isOrganizationByPattern(entity)) {
+      supplementalOrgs.push(entity);
+    } else {
+      unclassified.push(entity);
+    }
+  }
+  unclassified.push(...acronyms);
+  const people = mergeEntityLists(compromisePeople, supplementalPeople, 10);
+  const organizations = mergeEntityLists(
+    compromiseOrgs,
+    [...supplementalOrgs, ...unclassified],
+    10
+  );
+  const places = smartDedup([...new Set(compromisePlaces)]).slice(0, 10);
+  const topics = extractTopicsByTfIdf(text, 15);
+  const imperativeVerbCount = doc.verbs().isImperative().length;
+  const numberCount = doc.numbers().length;
+  return {
+    people,
+    organizations,
+    places,
+    topics,
+    imperativeVerbCount,
+    numberCount
+  };
+}
+
+// src/modules/audits/constants.ts
+var CATEGORY_DISPLAY_NAMES = {
+  contentExtractability: "Content Extractability",
+  contentStructure: "Content Structure for Reuse",
+  answerability: "Answerability",
+  entityClarity: "Entity Clarity",
+  groundingSignals: "Grounding Signals",
+  authorityContext: "Authority Context",
+  readabilityForCompression: "Readability for Compression"
+};
+
+// src/modules/audits/support/patterns.ts
+var DEFINITION_PATTERNS = [
+  /\bis\s+defined\s+as\b/gi,
+  /\brefers?\s+to\b/gi,
+  /\bmeans?\s+that\b/gi,
+  /\bis\s+a\s+type\s+of\b/gi,
+  /\bcan\s+be\s+described\s+as\b/gi,
+  /\balso\s+known\s+as\b/gi
+];
+var CITATION_PATTERNS = [
+  /\[\d+\]/g,
+  /\([\w\s]+,?\s*\d{4}\)/g,
+  /according\s+to/gi,
+  /research\s+(?:shows|indicates|suggests)/gi,
+  /studies?\s+(?:show|indicate|suggest|found)/gi,
+  /data\s+from/gi,
+  /as\s+reported\s+by/gi
+];
+var ATTRIBUTION_PATTERNS = [
+  /according\s+to/gi,
+  /\bsaid\b/gi,
+  /\bstated\b/gi,
+  /\breported\b/gi,
+  /\bcited\s+by\b/gi
+];
+var NUMERIC_CLAIM_PATTERNS = [
+  /\d+(?:\.\d+)?\s*%/g,
+  /\d+(?:\.\d+)?\s*(?:million|billion|thousand|trillion)/gi,
+  /\$[\d,.]+/g,
+  /increased\s+by/gi,
+  /decreased\s+by/gi,
+  /grew\s+by/gi
+];
+var STEP_PATTERNS = [
+  /step\s+\d+/gi,
+  /^\s*\d+\.\s+\w/gm,
+  /\bfirst(?:ly)?,?\s/gi,
+  /\bsecond(?:ly)?,?\s/gi,
+  /\bfinally,?\s/gi,
+  /\bhow\s+to\b/gi
+];
+var SUMMARY_MARKERS = [
+  /\bin\s+summary\b/gi,
+  /\bin\s+conclusion\b/gi,
+  /\bto\s+summarize\b/gi,
+  /\bkey\s+takeaways?\b/gi,
+  /\bbottom\s+line\b/gi,
+  /\btl;?dr\b/gi
+];
+var QUESTION_PATTERNS = [
+  /what\s+is/gi,
+  /what\s+are/gi,
+  /how\s+to/gi,
+  /how\s+do/gi,
+  /why\s+is/gi,
+  /why\s+do/gi,
+  /when\s+to/gi,
+  /where\s+to/gi,
+  /which\s+is/gi,
+  /who\s+is/gi
+];
+var DIRECT_ANSWER_PATTERNS = [
+  /^The\s+\w+\s+is\b/gm,
+  /^It\s+is\b/gm,
+  /^This\s+is\b/gm,
+  /^They\s+are\b/gm,
+  /\bsimply\s+put\b/gi,
+  /\bin\s+short\b/gi
+];
+var TRANSITION_WORDS = [
+  "however",
+  "therefore",
+  "moreover",
+  "furthermore",
+  "consequently",
+  "additionally",
+  "in contrast",
+  "similarly",
+  "as a result",
+  "for example",
+  "for instance",
+  "on the other hand",
+  "nevertheless",
+  "meanwhile",
+  "likewise",
+  "in addition",
+  "specifically",
+  "in particular",
+  "notably",
+  "importantly"
+];
+var AUTHOR_SELECTORS = [
+  '[rel="author"]',
+  ".author",
+  ".byline",
+  '[itemprop="author"]',
+  ".post-author",
+  ".entry-author",
+  'meta[name="author"]'
+];
+var DATE_SELECTORS = [
+  "time[datetime]",
+  '[itemprop="datePublished"]',
+  '[itemprop="dateModified"]',
+  ".published",
+  ".post-date",
+  ".entry-date",
+  'meta[property="article:published_time"]',
+  'meta[property="article:modified_time"]'
+];
+var QUESTION_HEADING_PATTERN = /^(?:what|how|why|when|where|which|who|can|do|does|is|are|should|will)\b/i;
+var QUOTED_ATTRIBUTION_PATTERNS = [
+  /"[^"]{10,}"\s*[-\u2013\u2014]\s*[A-Z][a-z]+/g,
+  /"[^"]{10,}",?\s+said\s+[A-Z]/g,
+  /"[^"]{10,}",?\s+according\s+to\s+[A-Z]/g,
+  /according\s+to\s+[A-Z][a-z]+[^,]*,\s*"[^"]{10,}"/g,
+  /\u201c[^\u201d]{10,}\u201d\s*[-\u2013\u2014]\s*[A-Z][a-z]+/g,
+  /\u201c[^\u201d]{10,}\u201d,?\s+said\s+[A-Z]/g
+];
+var AI_CRAWLERS = [
+  "GPTBot",
+  "ChatGPT-User",
+  "ClaudeBot",
+  "PerplexityBot",
+  "Google-Extended"
+];
+var MODIFIED_DATE_SELECTORS = [
+  '[itemprop="dateModified"]',
+  'meta[property="article:modified_time"]'
+];
+var PUBLISH_DATE_SELECTORS = [
+  "time[datetime]",
+  '[itemprop="datePublished"]',
+  'meta[property="article:published_time"]'
+];
+
+// src/modules/audits/support/dom.ts
+function detectAnswerCapsules($) {
+  let total = 0;
+  let withCapsule = 0;
+  $("h2").each((_, el) => {
+    const headingText = $(el).text().trim();
+    const isQuestion = headingText.includes("?") || QUESTION_HEADING_PATTERN.test(headingText);
+    if (!isQuestion) return;
+    total++;
+    const nextP = $(el).nextAll("p").first();
+    if (!nextP.length) return;
+    const pText = nextP.text().trim();
+    const firstSentence = pText.split(/[.!?]/)[0] || "";
+    if (firstSentence.length > 0 && firstSentence.length <= 200) {
+      withCapsule++;
+    }
+  });
+  return { total, withCapsule };
+}
+function measureSectionLengths($) {
+  const headings = $("h1, h2, h3, h4, h5, h6");
+  if (headings.length === 0)
+    return { sectionCount: 0, avgWordsPerSection: 0, sections: [] };
+  const sections = [];
+  headings.each((_, el) => {
+    let words = 0;
+    let sibling = $(el).next();
+    while (sibling.length && !sibling.is("h1, h2, h3, h4, h5, h6")) {
+      const text = sibling.text().trim();
+      words += text.split(/\s+/).filter((w) => w.length > 0).length;
+      sibling = sibling.next();
+    }
+    if (words > 0) sections.push(words);
+  });
+  const avg = sections.length > 0 ? Math.round(sections.reduce((a, b) => a + b, 0) / sections.length) : 0;
+  return { sectionCount: sections.length, avgWordsPerSection: avg, sections };
+}
+function parseJsonLdObjects($) {
+  const objects = [];
+  $('script[type="application/ld+json"]').each((_, el) => {
+    try {
+      const data = JSON.parse($(el).html() || "{}");
+      if (Array.isArray(data)) objects.push(...data);
+      else objects.push(data);
+    } catch {
+    }
+  });
+  return objects;
+}
+
+// src/modules/audits/support/scoring.ts
+function thresholdScore(value, brackets) {
+  for (const [threshold, score] of brackets) {
+    if (value >= threshold) return score;
+  }
+  return 0;
+}
+function statusFromScore(score, maxScore) {
+  const pct = maxScore > 0 ? score / maxScore : 0;
+  if (pct >= 0.7) return "good";
+  if (pct >= 0.3) return "needs_improvement";
+  return "critical";
+}
+function makeFactor(name, score, maxScore, value, statusOverride) {
+  return {
+    name,
+    score: Math.round(Math.min(score, maxScore)),
+    maxScore,
+    value,
+    status: statusOverride ?? statusFromScore(score, maxScore)
+  };
+}
+function sumFactors(factors) {
+  return factors.reduce((sum, f) => sum + f.score, 0);
+}
+function maxFactors(factors) {
+  return factors.reduce((sum, f) => sum + f.maxScore, 0);
+}
+
+// src/modules/audits/categories/answerability.ts
+function auditAnswerability(page, preExtracted) {
+  const text = page.cleanText;
+  const $ = page.$;
+  const factors = [];
+  const { imperativeVerbCount = 0 } = preExtracted ?? extractEntities(text);
+  const defCount = countPatternMatches(text, DEFINITION_PATTERNS);
+  const defScore = thresholdScore(defCount, [
+    [6, 10],
+    [3, 7],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Definition Patterns",
+      defScore,
+      10,
+      `${defCount} definition patterns`
+    )
+  );
+  const directCount = countPatternMatches(text, DIRECT_ANSWER_PATTERNS);
+  const directScore = thresholdScore(directCount, [
+    [5, 11],
+    [2, 8],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Direct Answer Statements",
+      directScore,
+      11,
+      `${directCount} direct statements`
+    )
+  );
+  const capsules = detectAnswerCapsules(page.$);
+  const capsuleRatio = capsules.total > 0 ? capsules.withCapsule / capsules.total : 0;
+  const capsuleScore = capsules.total === 0 ? 0 : capsuleRatio >= 0.7 ? 13 : capsuleRatio >= 0.4 ? 9 : capsuleRatio > 0 ? 5 : 2;
+  factors.push(
+    makeFactor(
+      "Answer Capsules",
+      capsuleScore,
+      13,
+      capsules.total > 0 ? `${capsules.withCapsule}/${capsules.total} question headings have answer capsules` : "No question-framed H2s found",
+      capsules.total === 0 ? "neutral" : void 0
+    )
+  );
+  const stepCount = countPatternMatches(text, STEP_PATTERNS);
+  const hasOl = $("ol").length > 0;
+  const stepTotal = stepCount + imperativeVerbCount + (hasOl ? 2 : 0);
+  const stepScore = thresholdScore(stepTotal, [
+    [5, 10],
+    [2, 7],
+    [1, 3],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Step-by-Step Content",
+      stepScore,
+      10,
+      `${stepCount} step indicators, ${imperativeVerbCount} instruction verbs${hasOl ? ", ordered lists found" : ""}`
+    )
+  );
+  const questionMatches = text.match(/[^.!?]*\?/g) || [];
+  const queryMatches = countPatternMatches(text, QUESTION_PATTERNS);
+  const qaScore = thresholdScore(questionMatches.length + queryMatches, [
+    [10, 11],
+    [5, 8],
+    [2, 5],
+    [1, 2],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Q/A Patterns",
+      qaScore,
+      11,
+      `${questionMatches.length} questions, ${queryMatches} query patterns`
+    )
+  );
+  const summaryCount = countPatternMatches(text, SUMMARY_MARKERS);
+  const summaryScore = summaryCount >= 2 ? 9 : summaryCount > 0 ? 5 : 0;
+  factors.push(
+    makeFactor(
+      "Summary/Conclusion",
+      summaryScore,
+      9,
+      summaryCount > 0 ? `${summaryCount} summary markers` : "No summary markers"
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.answerability,
+      key: "answerability",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      answerCapsules: capsules,
+      questionsFound: questionMatches.slice(0, 5)
+    }
+  };
+}
+
+// src/modules/audits/support/entity.ts
+function resolveEntityName($) {
+  const ogSiteName = $('meta[property="og:site_name"]').attr("content")?.trim();
+  if (ogSiteName) return ogSiteName;
+  const jsonLdScripts = $('script[type="application/ld+json"]');
+  let orgName = null;
+  jsonLdScripts.each((_, el) => {
+    try {
+      const data = JSON.parse($(el).html() || "{}");
+      if (data["@type"] === "Organization" && data.name) {
+        orgName = String(data.name).trim();
+      }
+      if (data.publisher?.name) {
+        orgName = orgName || String(data.publisher.name).trim();
+      }
+    } catch {
+    }
+  });
+  return orgName || null;
+}
+function measureEntityConsistency($, pageTitle, entityName) {
+  if (!entityName) return { score: 0, surfacesFound: 0, surfacesChecked: 0 };
+  const nameLower = entityName.toLowerCase();
+  const surfacesChecked = 4;
+  let surfacesFound = 0;
+  if (pageTitle.toLowerCase().includes(nameLower)) surfacesFound++;
+  const ogTitle = $('meta[property="og:title"]').attr("content") || "";
+  if (ogTitle.toLowerCase().includes(nameLower)) surfacesFound++;
+  const footerText = $("footer").text().toLowerCase();
+  if (footerText.includes(nameLower)) surfacesFound++;
+  const copyrightText = $('[class*="copyright"], [class*="legal"]').text().toLowerCase();
+  const headerText = $("header").text().toLowerCase();
+  if (copyrightText.includes(nameLower) || headerText.includes(nameLower))
+    surfacesFound++;
+  const score = surfacesFound >= 4 ? 10 : surfacesFound >= 3 ? 7 : surfacesFound >= 2 ? 4 : surfacesFound >= 1 ? 2 : 0;
+  return { score, surfacesFound, surfacesChecked };
+}
+
+// src/modules/audits/support/freshness.ts
+function evaluateFreshness($) {
+  let modifiedDate = null;
+  let publishDate = null;
+  for (const sel of MODIFIED_DATE_SELECTORS) {
+    const el = $(sel).first();
+    if (el.length) {
+      modifiedDate = el.attr("datetime") || el.attr("content") || el.text().trim();
+      break;
+    }
+  }
+  for (const sel of PUBLISH_DATE_SELECTORS) {
+    const el = $(sel).first();
+    if (el.length) {
+      publishDate = el.attr("datetime") || el.attr("content") || el.text().trim();
+      break;
+    }
+  }
+  const mostRecent = modifiedDate || publishDate;
+  let ageInMonths = null;
+  if (mostRecent) {
+    const parsed = new Date(mostRecent);
+    if (!isNaN(parsed.getTime())) {
+      const now = /* @__PURE__ */ new Date();
+      ageInMonths = (now.getFullYear() - parsed.getFullYear()) * 12 + (now.getMonth() - parsed.getMonth());
+    }
+  }
+  return {
+    publishDate,
+    modifiedDate,
+    ageInMonths,
+    hasModifiedDate: !!modifiedDate
+  };
+}
+
+// src/modules/audits/support/schema-analysis.ts
+var SCHEMA_REQUIRED_PROPERTIES = {
+  Article: ["headline", "author", "datePublished"],
+  NewsArticle: ["headline", "author", "datePublished"],
+  BlogPosting: ["headline", "author", "datePublished"],
+  FAQPage: ["mainEntity"],
+  HowTo: ["name", "step"],
+  Organization: ["name", "url"],
+  LocalBusiness: ["name", "address"],
+  Product: ["name"],
+  WebPage: ["name"]
+};
+function evaluateSchemaCompleteness(schemas) {
+  const details = [];
+  for (const schema of schemas) {
+    const type = String(schema["@type"] || "");
+    const requiredProps = SCHEMA_REQUIRED_PROPERTIES[type];
+    if (!requiredProps) continue;
+    const present = requiredProps.filter((prop) => schema[prop] != null);
+    const missing = requiredProps.filter((prop) => schema[prop] == null);
+    details.push({ type, present, missing });
+  }
+  const avgCompleteness = details.length > 0 ? details.reduce(
+    (sum, d) => sum + d.present.length / (d.present.length + d.missing.length),
+    0
+  ) / details.length : 0;
+  return { totalTypes: details.length, avgCompleteness, details };
+}
+
+// src/modules/audits/categories/authority-context.ts
+function auditAuthorityContext(page) {
+  const $ = page.$;
+  const factors = [];
+  const rawData = {};
+  let authorFound = false;
+  let authorName = "";
+  for (const selector of AUTHOR_SELECTORS) {
+    const elem = $(selector).first();
+    if (elem.length) {
+      authorFound = true;
+      authorName = elem.text().trim() || elem.attr("content") || "Found";
+      break;
+    }
+  }
+  factors.push(
+    makeFactor(
+      "Author Attribution",
+      authorFound ? 10 : 0,
+      10,
+      authorFound ? authorName : "Not found"
+    )
+  );
+  const hasOrgSchema = page.html.includes('"@type":"Organization"') || page.html.includes('"@type": "Organization"');
+  const ogSiteName = $('meta[property="og:site_name"]').attr("content") || "";
+  const orgFound = hasOrgSchema || ogSiteName.length > 0;
+  factors.push(
+    makeFactor(
+      "Organization Identity",
+      orgFound ? 10 : 0,
+      10,
+      orgFound ? ogSiteName || "Schema found" : "Not found"
+    )
+  );
+  const aboutLink = $('a[href*="about"], a[href*="team"], a[href*="company"]').length > 0;
+  const contactLink = $('a[href*="contact"]').length > 0;
+  const contactScore = aboutLink && contactLink ? 10 : aboutLink || contactLink ? 5 : 0;
+  factors.push(
+    makeFactor(
+      "Contact/About Links",
+      contactScore,
+      10,
+      `${aboutLink ? "About" : ""}${aboutLink && contactLink ? " + " : ""}${contactLink ? "Contact" : ""}${!aboutLink && !contactLink ? "Not found" : ""}`
+    )
+  );
+  let dateFound = false;
+  let dateValue = "";
+  for (const selector of DATE_SELECTORS) {
+    const elem = $(selector).first();
+    if (elem.length) {
+      dateFound = true;
+      dateValue = elem.attr("datetime") || elem.attr("content") || elem.text().trim();
+      break;
+    }
+  }
+  factors.push(
+    makeFactor(
+      "Publication Date",
+      dateFound ? 8 : 0,
+      8,
+      dateFound ? dateValue : "Not found"
+    )
+  );
+  const freshness = evaluateFreshness(page.$);
+  let freshScore = 0;
+  if (freshness.ageInMonths !== null) {
+    if (freshness.ageInMonths <= 6) freshScore = 12;
+    else if (freshness.ageInMonths <= 12) freshScore = 9;
+    else if (freshness.ageInMonths <= 24) freshScore = 5;
+    else freshScore = 2;
+    if (freshness.hasModifiedDate && freshScore < 12)
+      freshScore = Math.min(freshScore + 2, 12);
+  }
+  factors.push(
+    makeFactor(
+      "Content Freshness",
+      freshScore,
+      12,
+      freshness.ageInMonths !== null ? `${freshness.ageInMonths} months old${freshness.hasModifiedDate ? ", modified date present" : ""}` : "No parseable date found"
+    )
+  );
+  rawData.freshness = freshness;
+  const jsonLdScripts = $('script[type="application/ld+json"]');
+  const structuredDataTypes = [];
+  jsonLdScripts.each((_, el) => {
+    try {
+      const data = JSON.parse($(el).html() || "{}");
+      if (data["@type"]) structuredDataTypes.push(data["@type"]);
+    } catch {
+    }
+  });
+  const ogTags = ["og:title", "og:description", "og:image", "og:type"];
+  const foundOgTags = ogTags.filter(
+    (tag) => $(`meta[property="${tag}"]`).length > 0
+  );
+  const canonical = $('link[rel="canonical"]').attr("href");
+  let structuredScore = 0;
+  if (structuredDataTypes.length > 0) structuredScore += 4;
+  if (foundOgTags.length >= 3) structuredScore += 4;
+  else if (foundOgTags.length > 0) structuredScore += 2;
+  if (canonical) structuredScore += 4;
+  rawData.structuredDataTypes = structuredDataTypes;
+  factors.push(
+    makeFactor(
+      "Structured Data",
+      structuredScore,
+      12,
+      `${structuredDataTypes.length > 0 ? structuredDataTypes.join(", ") : "No JSON-LD"}, ${foundOgTags.length}/4 OG tags${canonical ? ", canonical" : ""}`
+    )
+  );
+  const schemaObjects = parseJsonLdObjects(page.$);
+  const completeness = evaluateSchemaCompleteness(schemaObjects);
+  const schemaCompleteScore = completeness.totalTypes === 0 ? 0 : completeness.avgCompleteness >= 0.8 ? 10 : completeness.avgCompleteness >= 0.5 ? 7 : completeness.avgCompleteness > 0 ? 4 : 0;
+  factors.push(
+    makeFactor(
+      "Schema Completeness",
+      schemaCompleteScore,
+      10,
+      completeness.totalTypes > 0 ? `${completeness.totalTypes} schema types, ${Math.round(completeness.avgCompleteness * 100)}% complete` : "No recognized JSON-LD schemas found",
+      completeness.totalTypes === 0 ? "neutral" : void 0
+    )
+  );
+  rawData.schemaCompleteness = completeness;
+  const entityName = resolveEntityName(page.$);
+  const consistency = measureEntityConsistency(page.$, page.title, entityName);
+  factors.push(
+    makeFactor(
+      "Entity Consistency",
+      consistency.score,
+      10,
+      entityName ? `"${entityName}" found in ${consistency.surfacesFound}/${consistency.surfacesChecked} surfaces` : "No identifiable entity name",
+      !entityName ? "neutral" : void 0
+    )
+  );
+  rawData.entityConsistency = {
+    entityName: entityName || null,
+    surfacesFound: consistency.surfacesFound,
+    surfacesChecked: consistency.surfacesChecked
+  };
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.authorityContext,
+      key: "authorityContext",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData
+  };
+}
+
+// src/modules/audits/support/robots.ts
+function parseRobotGroups(robotsTxt) {
+  const groups = [];
+  let current = null;
+  for (const raw of robotsTxt.split("\n")) {
+    const line = raw.split("#")[0].trim();
+    if (!line) {
+      current = null;
+      continue;
+    }
+    const colonAt = line.indexOf(":");
+    if (colonAt === -1) continue;
+    const field = line.slice(0, colonAt).trim().toLowerCase();
+    const value = line.slice(colonAt + 1).trim();
+    if (field === "user-agent") {
+      if (!current) {
+        current = { agents: [], rules: [] };
+        groups.push(current);
+      }
+      current.agents.push(value.toLowerCase());
+    } else if (field === "disallow" || field === "allow") {
+      if (current) {
+        current.rules.push({ type: field, path: value });
+      }
+    }
+  }
+  return groups;
+}
+function matchingRulesForCrawler(groups, crawlerLower) {
+  const specific = [];
+  const wildcard = [];
+  for (const group of groups) {
+    if (group.agents.includes(crawlerLower)) specific.push(...group.rules);
+    else if (group.agents.includes("*")) wildcard.push(...group.rules);
+  }
+  return { specific, wildcard };
+}
+function resolvesPathAsBlocked(rules, path) {
+  let bestMatchLength = -1;
+  let bestMatchIsDisallow = false;
+  for (const rule of rules) {
+    const rulePath = rule.path;
+    if (!rulePath || !path.startsWith(rulePath)) continue;
+    if (rulePath.length > bestMatchLength) {
+      bestMatchLength = rulePath.length;
+      bestMatchIsDisallow = rule.type === "disallow";
+    } else if (rulePath.length === bestMatchLength && rule.type === "allow") {
+      bestMatchIsDisallow = false;
+    }
+  }
+  return bestMatchLength >= 0 && bestMatchIsDisallow;
+}
+function findPartialBlocks(rules) {
+  return rules.filter((r) => r.type === "disallow" && r.path && r.path !== "/").map((r) => r.path);
+}
+function checkCrawlerAccess(robotsTxt) {
+  if (!robotsTxt)
+    return { allowed: [], blocked: [], unknown: [...AI_CRAWLERS] };
+  const groups = parseRobotGroups(robotsTxt);
+  const allowed = [];
+  const blocked = [];
+  const unknown = [];
+  const partiallyBlocked = [];
+  for (const crawler of AI_CRAWLERS) {
+    const crawlerLower = crawler.toLowerCase();
+    const { specific, wildcard } = matchingRulesForCrawler(
+      groups,
+      crawlerLower
+    );
+    const applicableRules = specific.length > 0 ? specific : wildcard;
+    if (applicableRules.length === 0) {
+      unknown.push(crawler);
+      continue;
+    }
+    const isSiteBlocked = resolvesPathAsBlocked(applicableRules, "/");
+    if (isSiteBlocked) {
+      blocked.push(crawler);
+    } else {
+      allowed.push(crawler);
+      const pathBlocks = findPartialBlocks(applicableRules);
+      for (const path of pathBlocks) {
+        const entry = `${crawler}: ${path}`;
+        if (!partiallyBlocked.includes(entry)) {
+          partiallyBlocked.push(entry);
+        }
+      }
+    }
+  }
+  return {
+    allowed,
+    blocked,
+    unknown,
+    ...partiallyBlocked.length > 0 && { partiallyBlocked }
+  };
+}
+
+// src/modules/audits/categories/content-extractability.ts
+function auditContentExtractability(page, fetchResult, domainSignals) {
+  const factors = [];
+  const rawData = {};
+  const fetchScore = fetchResult.statusCode === 200 ? 12 : fetchResult.statusCode < 400 ? 8 : 0;
+  factors.push(
+    makeFactor(
+      "Fetch Success",
+      fetchScore,
+      12,
+      `HTTP ${fetchResult.statusCode} in ${fetchResult.fetchTimeMs}ms`
+    )
+  );
+  const extractRatio = page.stats.rawByteLength > 0 ? page.stats.cleanTextLength / page.stats.rawByteLength : 0;
+  const extractScore = extractRatio >= 0.05 && extractRatio <= 0.15 ? 12 : extractRatio > 0.15 ? 10 : extractRatio >= 0.01 ? 8 : 2;
+  factors.push(
+    makeFactor(
+      "Text Extraction Quality",
+      extractScore,
+      12,
+      `${(extractRatio * 100).toFixed(1)}% content ratio`
+    )
+  );
+  const boilerplateRatio = page.stats.boilerplateRatio;
+  const bpScore = thresholdScore(1 - boilerplateRatio, [
+    [0.7, 12],
+    [0.5, 9],
+    [0.3, 6],
+    [0, 2]
+  ]);
+  factors.push(
+    makeFactor(
+      "Boilerplate Ratio",
+      bpScore,
+      12,
+      `${(boilerplateRatio * 100).toFixed(0)}% boilerplate`
+    )
+  );
+  const wordCount = page.stats.wordCount;
+  const wcScore = wordCount >= 300 && wordCount <= 3e3 ? 12 : wordCount > 3e3 ? 10 : wordCount >= 100 ? 8 : 2;
+  factors.push(
+    makeFactor("Word Count Adequacy", wcScore, 12, `${wordCount} words`)
+  );
+  if (domainSignals) {
+    const access2 = checkCrawlerAccess(domainSignals.robotsTxt);
+    const blockedCount = access2.blocked.length;
+    const crawlerScore = blockedCount === 0 ? 10 : blockedCount <= 2 ? 6 : blockedCount <= 4 ? 3 : 0;
+    factors.push(
+      makeFactor(
+        "AI Crawler Access",
+        crawlerScore,
+        10,
+        blockedCount === 0 ? `All major AI crawlers allowed` : `${access2.blocked.join(", ")} blocked in robots.txt`
+      )
+    );
+    rawData.crawlerAccess = access2;
+    rawData.llmsTxt = {
+      llmsTxtExists: domainSignals.llmsTxtExists,
+      llmsFullTxtExists: domainSignals.llmsFullTxtExists
+    };
+    const hasLlms = domainSignals.llmsTxtExists;
+    const hasLlmsFull = domainSignals.llmsFullTxtExists;
+    const llmsScore = hasLlms && hasLlmsFull ? 6 : hasLlms || hasLlmsFull ? 4 : 0;
+    factors.push(
+      makeFactor(
+        "LLMs.txt Presence",
+        llmsScore,
+        6,
+        hasLlms && hasLlmsFull ? "llms.txt + llms-full.txt found" : hasLlms ? "llms.txt found" : hasLlmsFull ? "llms-full.txt found" : "Not found",
+        !hasLlms && !hasLlmsFull ? "neutral" : void 0
+      )
+    );
+  }
+  const imageCount = page.stats.imageCount;
+  const imagesWithAlt = page.stats.imagesWithAlt;
+  const figcaptionCount = page.$("figure figcaption").length;
+  const altRatio = imageCount > 0 ? imagesWithAlt / imageCount : 0;
+  let imageAccessibilityScore = 0;
+  if (imageCount > 0) {
+    if (altRatio >= 0.9) imageAccessibilityScore += 5;
+    else if (altRatio >= 0.5) imageAccessibilityScore += 3;
+    else imageAccessibilityScore += 1;
+    if (figcaptionCount > 0) imageAccessibilityScore += 3;
+  }
+  factors.push(
+    makeFactor(
+      "Image Accessibility",
+      imageAccessibilityScore,
+      8,
+      imageCount > 0 ? `${imagesWithAlt}/${imageCount} images have alt text${figcaptionCount > 0 ? `, ${figcaptionCount} figcaptions` : ""}` : "No images found",
+      imageCount === 0 ? "neutral" : void 0
+    )
+  );
+  rawData.imageAccessibility = { imageCount, imagesWithAlt, figcaptionCount };
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.contentExtractability,
+      key: "contentExtractability",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData
+  };
+}
+
+// src/modules/audits/categories/content-structure.ts
+function auditContentStructure(page) {
+  const $ = page.$;
+  const factors = [];
+  const h1 = page.stats.h1Count;
+  const h2 = page.stats.h2Count;
+  const h3 = page.stats.h3Count;
+  let headingScore = 0;
+  if (h1 === 1) headingScore += 4;
+  else if (h1 > 0) headingScore += 2;
+  if (h2 >= 2) headingScore += 4;
+  else if (h2 > 0) headingScore += 2;
+  if (h3 > 0) headingScore += 3;
+  factors.push(
+    makeFactor(
+      "Heading Hierarchy",
+      headingScore,
+      11,
+      `${h1} H1, ${h2} H2, ${h3} H3`
+    )
+  );
+  const listItems = page.stats.listItemCount;
+  const listScore = thresholdScore(listItems, [
+    [10, 11],
+    [5, 8],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor("Lists Presence", listScore, 11, `${listItems} list items`)
+  );
+  const tables = page.stats.tableCount;
+  const tableScore = tables >= 2 ? 8 : tables >= 1 ? 5 : 0;
+  factors.push(
+    makeFactor(
+      "Tables Presence",
+      tableScore,
+      8,
+      `${tables} table(s)`,
+      tables === 0 ? "neutral" : void 0
+    )
+  );
+  const pCount = page.stats.paragraphCount;
+  const avgParagraphWords = pCount > 0 ? Math.round(page.stats.wordCount / pCount) : 0;
+  const paragraphScore = avgParagraphWords >= 30 && avgParagraphWords <= 150 ? 11 : avgParagraphWords > 0 && avgParagraphWords < 200 ? 7 : 2;
+  factors.push(
+    makeFactor(
+      "Paragraph Structure",
+      paragraphScore,
+      11,
+      `${pCount} paragraphs, avg ${avgParagraphWords} words`
+    )
+  );
+  const hasBold = $("strong, b").length > 0;
+  const headingRatio = pCount > 0 ? page.stats.headingCount / pCount : 0;
+  let scanScore = 0;
+  if (hasBold) scanScore += 4;
+  if (avgParagraphWords <= 150) scanScore += 4;
+  if (headingRatio >= 0.1) scanScore += 3;
+  factors.push(
+    makeFactor(
+      "Scannability",
+      scanScore,
+      11,
+      `${hasBold ? "Bold text found" : "No bold text"}, ${headingRatio.toFixed(2)} heading ratio`
+    )
+  );
+  const sectionData = measureSectionLengths(page.$);
+  let sectionScore = 0;
+  if (sectionData.sectionCount === 0) {
+    sectionScore = 0;
+  } else if (sectionData.avgWordsPerSection >= 120 && sectionData.avgWordsPerSection <= 180) {
+    sectionScore = 12;
+  } else if (sectionData.avgWordsPerSection >= 80 && sectionData.avgWordsPerSection <= 250) {
+    sectionScore = 8;
+  } else if (sectionData.avgWordsPerSection > 0) {
+    sectionScore = 4;
+  }
+  factors.push(
+    makeFactor(
+      "Section Length",
+      sectionScore,
+      12,
+      sectionData.sectionCount > 0 ? `${sectionData.sectionCount} sections, avg ${sectionData.avgWordsPerSection} words` : "No headed sections found",
+      sectionData.sectionCount === 0 ? "neutral" : void 0
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.contentStructure,
+      key: "contentStructure",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      sectionLengths: sectionData
+    }
+  };
+}
+
+// src/modules/audits/categories/entity-clarity.ts
+function auditEntityClarity(page, preExtracted) {
+  const text = page.cleanText;
+  const factors = [];
+  const entities = preExtracted ?? extractEntities(text);
+  const totalEntities = entities.people.length + entities.organizations.length + entities.places.length + entities.topics.length;
+  const richScore = thresholdScore(totalEntities, [
+    [9, 20],
+    [4, 14],
+    [1, 7],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Entity Richness",
+      richScore,
+      20,
+      `${totalEntities} entities (${entities.people.length} people, ${entities.organizations.length} orgs, ${entities.places.length} places)`,
+      totalEntities === 0 ? "neutral" : void 0
+    )
+  );
+  const titleWords = page.title.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+  const h1Text = page.$("h1").first().text().toLowerCase();
+  const h1Words = h1Text.split(/\s+/).filter((w) => w.length > 3);
+  const keyWords = [.../* @__PURE__ */ new Set([...titleWords, ...h1Words])];
+  const topicLower = entities.topics.map((t) => t.toLowerCase());
+  let topicOverlap = 0;
+  for (const kw of keyWords) {
+    if (topicLower.some((t) => t.includes(kw)) || text.toLowerCase().split(kw).length > 3) {
+      topicOverlap++;
+    }
+  }
+  const consistencyRatio = keyWords.length > 0 ? topicOverlap / keyWords.length : 0;
+  const consistencyScore = keyWords.length === 0 ? 0 : consistencyRatio >= 0.5 ? 25 : consistencyRatio > 0 ? 15 : 0;
+  factors.push(
+    makeFactor(
+      "Topic Consistency",
+      consistencyScore,
+      25,
+      `${topicOverlap}/${keyWords.length} title keywords align with content topics`,
+      keyWords.length === 0 ? "neutral" : void 0
+    )
+  );
+  const wordCount = countWords(text);
+  const densityPer100 = wordCount > 0 ? totalEntities / wordCount * 100 : 0;
+  const densityScore = densityPer100 >= 2 && densityPer100 <= 8 ? 15 : densityPer100 >= 1 ? 10 : densityPer100 > 8 ? 10 : 3;
+  factors.push(
+    makeFactor(
+      "Entity Density",
+      densityScore,
+      15,
+      `${densityPer100.toFixed(1)} entities per 100 words`
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.entityClarity,
+      key: "entityClarity",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      entities
+    }
+  };
+}
+
+// src/modules/audits/categories/grounding-signals.ts
+function auditGroundingSignals(page, preExtracted) {
+  const $ = page.$;
+  const text = page.cleanText;
+  const factors = [];
+  const { numberCount = 0 } = preExtracted ?? extractEntities(text);
+  const externalLinks = page.externalLinks;
+  const extScore = thresholdScore(externalLinks.length, [
+    [6, 13],
+    [3, 10],
+    [1, 6],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "External References",
+      extScore,
+      13,
+      `${externalLinks.length} external links`
+    )
+  );
+  const citationCount = countPatternMatches(text, CITATION_PATTERNS);
+  const blockquotes = $("blockquote, cite, q").length;
+  const totalCitations = citationCount + blockquotes;
+  const citScore = thresholdScore(totalCitations, [
+    [6, 13],
+    [3, 9],
+    [1, 5],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Citation Patterns",
+      citScore,
+      13,
+      `${citationCount} citation indicators, ${blockquotes} quote elements`
+    )
+  );
+  const numericCount = countPatternMatches(text, NUMERIC_CLAIM_PATTERNS);
+  const totalNumericSignals = numericCount + numberCount;
+  const numScore = thresholdScore(totalNumericSignals, [
+    [9, 13],
+    [4, 9],
+    [1, 5],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Numeric Claims",
+      numScore,
+      13,
+      `${numericCount} statistical references, ${numberCount} numeric values`
+    )
+  );
+  const attrCount = countPatternMatches(text, ATTRIBUTION_PATTERNS);
+  const attrScore = thresholdScore(attrCount, [
+    [5, 11],
+    [2, 8],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Attribution Indicators",
+      attrScore,
+      11,
+      `${attrCount} attribution patterns`
+    )
+  );
+  const quotedAttrPatterns = countPatternMatches(
+    text,
+    QUOTED_ATTRIBUTION_PATTERNS
+  );
+  const blockquotesWithCite = $("blockquote").filter(
+    (_, el) => $(el).find("cite, footer, figcaption").length > 0
+  ).length;
+  const totalQuotedAttr = quotedAttrPatterns + blockquotesWithCite;
+  const quotedAttrScore = thresholdScore(totalQuotedAttr, [
+    [4, 10],
+    [2, 7],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Quoted Attribution",
+      quotedAttrScore,
+      10,
+      `${totalQuotedAttr} attributed quotes`,
+      totalQuotedAttr === 0 ? "neutral" : void 0
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.groundingSignals,
+      key: "groundingSignals",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      externalLinks: externalLinks.slice(0, 10)
+    }
+  };
+}
+
+// src/modules/audits/categories/readability.ts
+function auditReadabilityForCompression(page) {
+  const text = page.cleanText;
+  const factors = [];
+  const avgSentLen = avgSentenceLength(text);
+  const sentScore = avgSentLen >= 12 && avgSentLen <= 22 ? 15 : avgSentLen >= 8 && avgSentLen < 30 ? 10 : avgSentLen > 0 ? 5 : 0;
+  factors.push(
+    makeFactor(
+      "Sentence Length",
+      sentScore,
+      15,
+      `Avg ${avgSentLen} words/sentence`
+    )
+  );
+  const fre = computeFleschReadingEase(text);
+  const freScore = fre >= 60 && fre <= 70 ? 15 : fre > 70 ? 13 : fre >= 50 ? 10 : fre >= 30 ? 6 : 3;
+  factors.push(
+    makeFactor(
+      "Readability",
+      freScore,
+      15,
+      `Flesch Reading Ease: ${fre.toFixed(1)}`
+    )
+  );
+  const totalWords = countWords(text);
+  const complex = countComplexWords(text);
+  const jargonRatio = totalWords > 0 ? complex / totalWords : 0;
+  const jargonScore = jargonRatio <= 0.02 ? 15 : jargonRatio <= 0.05 ? 12 : jargonRatio <= 0.1 ? 8 : 3;
+  factors.push(
+    makeFactor(
+      "Jargon Density",
+      jargonScore,
+      15,
+      `${(jargonRatio * 100).toFixed(1)}% complex words`
+    )
+  );
+  const transCount = countTransitionWords(text, TRANSITION_WORDS);
+  const transScore = thresholdScore(transCount, [
+    [10, 15],
+    [5, 11],
+    [2, 7],
+    [1, 3],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Transition Usage",
+      transScore,
+      15,
+      `${transCount} transition types found`
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.readabilityForCompression,
+      key: "readabilityForCompression",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      avgSentenceLength: avgSentLen,
+      readabilityScore: fre
+    }
+  };
+}
+
+// src/modules/audits/service.ts
+function runAudits(page, fetchResult, domainSignals) {
+  const entities = extractEntities(page.cleanText);
+  const extractability = auditContentExtractability(
+    page,
+    fetchResult,
+    domainSignals
+  );
+  const structure = auditContentStructure(page);
+  const answerability = auditAnswerability(page, entities);
+  const entityClarity = auditEntityClarity(page, entities);
+  const groundingSignals = auditGroundingSignals(page, entities);
+  const authorityContext = auditAuthorityContext(page);
+  const readability = auditReadabilityForCompression(page);
+  return {
+    categories: {
+      contentExtractability: extractability.category,
+      contentStructure: structure.category,
+      answerability: answerability.category,
+      entityClarity: entityClarity.category,
+      groundingSignals: groundingSignals.category,
+      authorityContext: authorityContext.category,
+      readabilityForCompression: readability.category
+    },
+    rawData: {
+      title: page.title,
+      metaDescription: page.metaDescription,
+      wordCount: page.stats.wordCount,
+      ...extractability.rawData,
+      ...structure.rawData,
+      ...answerability.rawData,
+      ...entityClarity.rawData,
+      ...groundingSignals.rawData,
+      ...authorityContext.rawData,
+      ...readability.rawData
+    }
+  };
+}
+
+// src/modules/extractor/service.ts
+import * as cheerio from "cheerio";
+
+// src/modules/extractor/support/boilerplate.ts
+var REMOVE_SELECTORS = [
+  "script",
+  "style",
+  "noscript",
+  "svg",
+  "iframe",
+  "nav",
+  "header",
+  "footer",
+  "aside",
+  '[role="navigation"]',
+  '[role="banner"]',
+  '[role="contentinfo"]',
+  ".sidebar",
+  "#sidebar",
+  ".cookie-banner",
+  "#cookie-consent",
+  ".cookie-notice",
+  ".nav",
+  ".navbar",
+  ".footer",
+  ".header",
+  ".menu",
+  ".ad",
+  ".ads",
+  ".advertisement",
+  '[class*="cookie"]',
+  '[class*="consent"]',
+  '[class*="popup"]',
+  '[class*="modal"]'
+];
+function removeBoilerplate($) {
+  for (const selector of REMOVE_SELECTORS) {
+    $(selector).remove();
+  }
+}
+
+// src/modules/extractor/support/text.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+var BLOCK_ELEMENTS = "p,div,td,th,li,h1,h2,h3,h4,h5,h6,dt,dd,br,blockquote,section,article";
+function extractCleanText($) {
+  $(BLOCK_ELEMENTS).each((_, el) => {
+    $(el).append(" ");
+  });
+  return normalizeWhitespace($("body").text());
+}
+
+// src/modules/extractor/service.ts
+function extractPage(html, url) {
+  const $ = cheerio.load(html);
+  const title = $("title").text().trim() || $('meta[property="og:title"]').attr("content")?.trim() || "";
+  const metaDescription = $('meta[name="description"]').attr("content")?.trim() || $('meta[property="og:description"]').attr("content")?.trim() || "";
+  const $raw = cheerio.load(html);
+  $raw("script, style, noscript").remove();
+  const rawText = $raw("body").text().replace(/\s+/g, " ").trim();
+  const rawByteLength = Buffer.byteLength(html, "utf-8");
+  const h1Count = $("h1").length;
+  const h2Count = $("h2").length;
+  const h3Count = $("h3").length;
+  const headingCount = h1Count + h2Count + h3Count + $("h4, h5, h6").length;
+  const linkCount = $("a[href]").length;
+  const imageCount = $("img").length;
+  const listCount = $("ul, ol").length;
+  const listItemCount = $("li").length;
+  const tableCount = $("table").length;
+  const paragraphCount = $("p").length;
+  const GENERIC_ALT_VALUES = /* @__PURE__ */ new Set([
+    "image",
+    "photo",
+    "logo",
+    "icon",
+    "picture",
+    "img",
+    "graphic",
+    "thumbnail"
+  ]);
+  let imagesWithAlt = 0;
+  $("img").each((_, el) => {
+    const alt = $(el).attr("alt")?.trim() ?? "";
+    const words = alt.split(/\s+/).filter((w) => w.length > 0);
+    const isMeaningful = words.length > 1 && alt.length < 200 && !GENERIC_ALT_VALUES.has(alt.toLowerCase());
+    if (isMeaningful) imagesWithAlt++;
+  });
+  const pageDomain = getDomain(url);
+  const externalLinks = [];
+  $('a[href^="http"]').each((_, el) => {
+    const href = $(el).attr("href");
+    try {
+      if (getDomain(href) !== pageDomain) {
+        externalLinks.push({
+          url: href,
+          text: $(el).text().trim().substring(0, 50)
+        });
+      }
+    } catch {
+    }
+  });
+  const externalLinkCount = externalLinks.length;
+  const $clean = cheerio.load(html);
+  removeBoilerplate($clean);
+  const cleanText = extractCleanText($clean);
+  const cleanTextLength = cleanText.length;
+  const boilerplateRatio = rawText.length > 0 ? Math.max(0, Math.min(1, 1 - cleanTextLength / rawText.length)) : 0;
+  const stats = {
+    wordCount: countWords(cleanText),
+    sentenceCount: countSentences(cleanText),
+    paragraphCount,
+    headingCount,
+    h1Count,
+    h2Count,
+    h3Count,
+    linkCount,
+    externalLinkCount,
+    imageCount,
+    imagesWithAlt,
+    listCount,
+    listItemCount,
+    tableCount,
+    boilerplateRatio,
+    rawByteLength,
+    cleanTextLength
+  };
+  return {
+    url,
+    html,
+    cleanText,
+    title,
+    metaDescription,
+    stats,
+    $,
+    externalLinks
+  };
+}
+
+// src/modules/fetcher/schema.ts
+import { z } from "zod";
+var FetchOptionsSchema = z.object({
+  url: z.url(),
+  timeout: z.number().positive().default(45e3),
+  userAgent: z.string().default(`AISEOAudit/${VERSION}`)
+});
+var FetchResultSchema = z.object({
+  url: z.string(),
+  finalUrl: z.string(),
+  statusCode: z.number(),
+  contentType: z.string(),
+  html: z.string(),
+  byteLength: z.number(),
+  fetchTimeMs: z.number(),
+  redirected: z.boolean()
+});
+
+// src/modules/fetcher/service.ts
+async function fetchUrl(options) {
+  const opts = FetchOptionsSchema.parse(options);
+  const start = Date.now();
+  const response = await httpGet({
+    url: opts.url,
+    timeout: opts.timeout,
+    userAgent: opts.userAgent
+  });
+  const fetchTimeMs = Date.now() - start;
+  const html = response.data;
+  const finalUrl = response.finalUrl || opts.url;
+  const contentType = response.headers["content-type"] || "unknown";
+  return {
+    url: opts.url,
+    finalUrl,
+    statusCode: response.status,
+    contentType,
+    html,
+    byteLength: Buffer.byteLength(html, "utf-8"),
+    fetchTimeMs,
+    redirected: finalUrl !== opts.url
+  };
+}
+
+// src/modules/recommendations/examples.ts
+var listsConversionExample = `<!-- Before: prose enumeration -->
+<p>We offer design, development, and strategy services.</p>
+
+<!-- After: unordered list -->
+<ul>
+  <li>Design \u2014 UI/UX and brand identity</li>
+  <li>Development \u2014 web and mobile engineering</li>
+  <li>Strategy \u2014 AI readiness and growth planning</li>
+</ul>
+
+<!-- Ordered list for sequential steps -->
+<ol>
+  <li>Submit your project brief</li>
+  <li>Schedule a discovery call</li>
+  <li>Receive your proposal within 48 hours</li>
+</ol>`;
+var tablesMarkupExample = `<table>
+  <caption>Plan feature comparison</caption>
+  <thead>
+    <tr>
+      <th>Feature</th>
+      <th>Starter</th>
+      <th>Pro</th>
+      <th>Enterprise</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>Users</td>
+      <td>1</td>
+      <td>10</td>
+      <td>Unlimited</td>
+    </tr>
+    <tr>
+      <td>Storage</td>
+      <td>10 GB</td>
+      <td>100 GB</td>
+      <td>1 TB</td>
+    </tr>
+  </tbody>
+</table>`;
+var directAnswerExample = `<!-- Before: buried answer -->
+<p>There are many factors involved, and while it depends on the situation,
+in most cases companies that invest in AI SEO tend to see better visibility
+in AI-generated answers.</p>
+
+<!-- After: direct answer first -->
+<p>Companies that invest in AI SEO see better visibility in AI-generated answers.
+Results depend on content quality, structured data completeness, and how well
+headings are framed as questions.</p>`;
+var summaryStructureExample = `<h2>Key Takeaways</h2>
+<ul>
+  <li>AI SEO focuses on being cited in generated answers, not ranked in link lists.</li>
+  <li>Structured data, answer capsules, and clear entity attribution are the highest-impact factors.</li>
+  <li>Content freshness acts as a hard gate \u2014 AI engines strongly prefer content under 12 months old.</li>
+</ul>
+
+<h2>Next Steps</h2>
+<p>Run an audit on your top pages to identify your highest-priority improvements.</p>`;
+var attributionIndicatorExample = `<!-- Before: unattributed claim -->
+<p>72% of AI-cited content uses question-framed headings.</p>
+
+<!-- After: attributed with a link -->
+<p>According to <a href="https://arxiv.org/abs/2311.09735">Princeton's GEO research</a>,
+72% of AI-cited content uses question-framed headings.</p>`;
+var citationMarkupExample = `<!-- In-text citation with marker -->
+<p>AI engines prioritize structured content by a factor of 3x <a href="#ref-1">[1]</a>.</p>
+
+<!-- Cited title -->
+<p>As described in <cite>Generative Engine Optimization</cite>, answer density is key.</p>
+
+<!-- References section -->
+<section>
+  <h2>References</h2>
+  <ol>
+    <li id="ref-1">
+      <cite><a href="https://arxiv.org/abs/2311.09735">Generative Engine Optimization (GEO)</a></cite>
+      \u2014 Aggarwal et al., Princeton University, 2023
+    </li>
+  </ol>
+</section>`;
+var blockquoteAttributionExample = `<blockquote>
+  <p>"Structured content with clear attribution is 3x more likely to be cited
+  by generative AI engines than unstructured prose."</p>
+  <footer>
+    \u2014 <cite>Dr. Jane Smith, AI Research Lead,
+    <a href="https://example.edu">Princeton University</a></cite>
+  </footer>
+</blockquote>`;
+var transitionWordsExample = `<!-- Before: abrupt transitions -->
+<p>AI engines extract structured content. Many pages have no structure.</p>
+<p>Adding headings and lists improves your score.</p>
+
+<!-- After: logical flow with transitions -->
+<p>AI engines extract structured content. <strong>However</strong>, many pages
+lack the organization needed for reliable extraction.</p>
+<p><strong>Therefore</strong>, adding headings and lists directly improves
+how AI engines process and cite your content.</p>`;
+var jargonReductionExample = `<!-- Before: jargon-heavy -->
+<p>Our RAG-based LLM pipeline leverages semantic chunking and vector embeddings
+to optimize retrieval latency for enterprise-scale deployments.</p>
+
+<!-- After: jargon defined on first use -->
+<p>Our AI pipeline uses Retrieval-Augmented Generation (RAG) \u2014 a technique that
+combines a language model with a searchable knowledge base \u2014 to deliver fast,
+accurate answers at enterprise scale.</p>`;
+var contactLinksExample = `<!-- In site navigation or footer -->
+<nav aria-label="Company">
+  <a href="/about">About Us</a>
+  <a href="/contact">Contact</a>
+</nav>
+
+<!-- Optional: contactPoint in your Organization JSON-LD -->
+"contactPoint": {
+  "@type": "ContactPoint",
+  "contactType": "customer support",
+  "url": "https://yoursite.com/contact"
+}`;
+var imageAltTextExample = `<!-- Informational image with alt text -->
+<img src="diagram.png" alt="Flowchart showing the three stages of AI content extraction">
+
+<!-- Image with caption using figure/figcaption -->
+<figure>
+  <img src="chart.png" alt="Bar chart comparing AI citation rates by content type">
+  <figcaption>AI engines cite structured content 3x more often than unstructured prose.</figcaption>
+</figure>
+
+<!-- Decorative image \u2014 empty alt tells screen readers to skip it -->
+<img src="divider.png" alt="">`;
+var answerCapsuleExample = `<!-- Before -->
+<h2>Benefits of AI SEO</h2>
+<p>There are many reasons companies are investing in AI SEO strategies today...</p>
+
+<!-- After (answer capsule pattern) -->
+<h2>What are the benefits of AI SEO?</h2>
+<p>AI SEO increases your content's visibility in AI-generated answers, driving qualified traffic from ChatGPT, Claude, and Perplexity.</p>
+<p>Companies investing in AI SEO see benefits across three areas...</p>`;
+
+// src/modules/recommendations/constants.ts
+function constantRecommendation(text) {
+  return () => ({ text });
+}
+var RECOMMENDATION_BUILDERS = {
+  "Fetch Success": constantRecommendation(
+    "Ensure the page returns HTTP 200 without excessive redirect chains. AI engines cannot extract content from pages that fail to load."
+  ),
+  "Text Extraction Quality": constantRecommendation(
+    "Improve the ratio of meaningful text content to markup. Pages with very low text density are harder for AI engines to extract useful content from."
+  ),
+  "Boilerplate Ratio": constantRecommendation(
+    "Reduce boilerplate content (navigation, footers, sidebars) relative to main content. Use semantic HTML elements like <main> and <article> to help engines isolate your content."
+  ),
+  "Word Count Adequacy": (rawData) => {
+    const count = rawData.wordCount;
+    if (count < 100) {
+      return {
+        text: `Your page has ${count} words, which is too thin for AI engines to reference. The ideal range is 300-3000 words.`
+      };
+    }
+    if (count < 300) {
+      return {
+        text: `Your page has ${count} words. AI engines prefer 300-3000 words for comprehensive coverage. Consider expanding your content.`
+      };
+    }
+    return {
+      text: `Your page has ${count} words, which exceeds the ideal 300-3000 word range. Consider splitting into multiple focused pages.`
+    };
+  },
+  "AI Crawler Access": (rawData) => {
+    const access2 = rawData.crawlerAccess;
+    if (!access2 || access2.blocked.length === 0) {
+      return {
+        text: "Ensure AI crawlers like GPTBot, ClaudeBot, and PerplexityBot are allowed in your robots.txt.",
+        steps: [
+          "Check your robots.txt for Disallow rules targeting AI crawlers",
+          "Add explicit Allow rules for each AI crawler you want to reach your content"
+        ],
+        learnMoreUrl: "https://developers.google.com/search/docs/crawling-indexing/robots/intro"
+      };
+    }
+    const blocked = access2.blocked;
+    const blockedList = blocked.join(", ");
+    const codeExample = `# Add these rules to your robots.txt:
+
+${blocked.map((c) => `User-agent: ${c}
+Allow: /`).join("\n\n")}`;
+    if (access2.allowed.length > 0) {
+      const allowed = access2.allowed.join(", ");
+      return {
+        text: `Your robots.txt is blocking ${blockedList}. ${allowed} ${access2.allowed.length === 1 ? "is" : "are"} allowed. Unblock all AI crawlers so your content can be discovered and cited.`,
+        steps: [
+          "Open your robots.txt file (usually at the site root)",
+          `Remove any Disallow rules for: ${blockedList}`,
+          "Add the Allow rules shown in the code example",
+          "Deploy and verify at yoursite.com/robots.txt"
+        ],
+        codeExample,
+        learnMoreUrl: "https://developers.google.com/search/docs/crawling-indexing/robots/intro"
+      };
+    }
+    return {
+      text: `Your robots.txt is blocking ${blockedList}. Blocking these crawlers means your content cannot be discovered or cited by AI engines.`,
+      steps: [
+        "Open your robots.txt file (usually at the site root)",
+        `Remove any Disallow rules for: ${blockedList}`,
+        "Add the Allow rules shown in the code example",
+        "Deploy and verify at yoursite.com/robots.txt"
+      ],
+      codeExample,
+      learnMoreUrl: "https://developers.google.com/search/docs/crawling-indexing/robots/intro"
+    };
+  },
+  "LLMs.txt Presence": (rawData) => {
+    const llms = rawData.llmsTxt;
+    const title = rawData.title || "Your Site Name";
+    const description = rawData.metaDescription || "Brief description of your site";
+    const missingFiles = [];
+    if (!llms?.llmsTxtExists) missingFiles.push("llms.txt");
+    if (!llms?.llmsFullTxtExists) missingFiles.push("llms-full.txt");
+    if (missingFiles.length === 0) {
+      return { text: "Both llms.txt and llms-full.txt are present." };
+    }
+    const isLlmsMissing = !llms?.llmsTxtExists;
+    const codeExample = isLlmsMissing ? `# llms.txt
+
+# ${title}
+
+> ${description}
+
+## Docs
+
+- [About](/about): Learn more about ${title}
+- [Documentation](/docs): Technical documentation` : `# llms-full.txt
+
+# ${title} \u2014 Full Documentation
+
+> ${description}
+
+This file provides comprehensive documentation for AI systems to understand and accurately reference ${title}.`;
+    const fileName = missingFiles[0];
+    if (llms?.llmsTxtExists && !llms?.llmsFullTxtExists) {
+      return {
+        text: "You have llms.txt but are missing llms-full.txt. Adding llms-full.txt provides AI systems with a comprehensive version of your site documentation for deeper ingestion.",
+        steps: [
+          "Create llms-full.txt at your domain root (e.g., yoursite.com/llms-full.txt)",
+          "Include your site's full documentation, purpose, key features, and FAQ",
+          "Deploy so the file is accessible via HTTP GET",
+          "Verify by visiting yoursite.com/llms-full.txt"
+        ],
+        codeExample,
+        learnMoreUrl: "https://llmstxt.org"
+      };
+    }
+    if (!llms?.llmsTxtExists && llms?.llmsFullTxtExists) {
+      return {
+        text: "You have llms-full.txt but are missing llms.txt. Adding llms.txt provides AI systems with a concise structured overview of your site's purpose and key pages.",
+        steps: [
+          "Create llms.txt at your domain root (e.g., yoursite.com/llms.txt)",
+          "Include your site's purpose, key pages, and documentation links (see code example)",
+          "Deploy so the file is accessible via HTTP GET",
+          "Verify by visiting yoursite.com/llms.txt"
+        ],
+        codeExample,
+        learnMoreUrl: "https://llmstxt.org"
+      };
+    }
+    return {
+      text: `Missing ${missingFiles.join(" and ")}. These files help AI systems understand and accurately cite your site.`,
+      steps: [
+        `Create ${fileName} at your domain root (e.g., yoursite.com/${fileName})`,
+        "Fill in your site's purpose, key pages, and documentation links (see code example)",
+        "Deploy so the file is accessible via HTTP GET",
+        `Verify by visiting yoursite.com/${fileName}`
+      ],
+      codeExample,
+      learnMoreUrl: "https://llmstxt.org"
+    };
+  },
+  "Image Accessibility": (rawData) => {
+    const images = rawData.imageAccessibility;
+    const altTextSteps = [
+      "Add a descriptive alt attribute to every <img> tag",
+      "Write alt text that describes what the image shows, not just its file name",
+      'Leave alt empty (alt="") for purely decorative images',
+      "Wrap images that need caption context in <figure> with a <figcaption>"
+    ];
+    if (!images || images.imageCount === 0) {
+      return {
+        text: "Add descriptive alt text to all images and use <figure> with <figcaption> for semantic image context.",
+        steps: altTextSteps,
+        codeExample: imageAltTextExample
+      };
+    }
+    const imagesWithoutAlt = images.imageCount - images.imagesWithAlt;
+    const altCoveragePercent = Math.round(
+      images.imagesWithAlt / images.imageCount * 100
+    );
+    let text = `${images.imagesWithAlt} of your ${images.imageCount} images have alt text (${altCoveragePercent}%). `;
+    if (imagesWithoutAlt > 0) {
+      text += `Add alt text to the remaining ${imagesWithoutAlt} image${imagesWithoutAlt === 1 ? "" : "s"}. `;
+    }
+    if (images.figcaptionCount === 0) {
+      text += "Consider using <figure> with <figcaption> for images that need descriptive context.";
+    }
+    return { text, steps: altTextSteps, codeExample: imageAltTextExample };
+  },
+  "Heading Hierarchy": (rawData) => {
+    const title = rawData.title || "Your Page Topic";
+    const topic = title.split(" ").slice(-2).join(" ");
+    return {
+      text: "Use a clear H1 > H2 > H3 heading hierarchy. Headings serve as structural anchors that AI engines use to segment and reuse content.",
+      steps: [
+        "Use exactly 1 H1 tag for the main page title",
+        "Use H2 tags for major sections (aim for 3+ sections)",
+        "Use H3 tags for subsections within each H2",
+        "Never skip levels (e.g., don't jump from H1 to H3)",
+        "Frame H2s as questions when possible for answer capsule compatibility"
+      ],
+      codeExample: `<!-- Recommended heading structure -->
+<h1>${title}</h1>
+
+<h2>What is ${topic}?</h2>
+<p>Definition and overview...</p>
+
+  <h3>Key Features</h3>
+  <p>Details...</p>
+
+<h2>Why Does ${topic} Matter?</h2>
+<p>Importance and context...</p>
+
+<h2>How to Get Started</h2>
+<p>Step-by-step guide...</p>`
+    };
+  },
+  "Lists Presence": () => ({
+    text: "Add bulleted or numbered lists to organize information. Lists are easily extracted and reused by AI engines.",
+    steps: [
+      "Identify prose that enumerates 3 or more items in a sentence",
+      "Convert those sentences into <ul> or <ol> list elements",
+      "Use <ol> for sequential steps and <ul> for unordered collections",
+      "Keep list items parallel \u2014 each starting with the same grammatical form"
+    ],
+    codeExample: listsConversionExample
+  }),
+  "Tables Presence": () => ({
+    text: "Consider adding data tables for comparative or structured data. Tables are highly parseable by AI engines.",
+    steps: [
+      "Identify any comparisons, pricing tiers, specs, or feature matrices in your content",
+      "Structure them as HTML <table> elements with a <thead> and <tbody>",
+      "Add a <caption> element describing what the table shows",
+      "Ensure every column has a clear <th> header so AI engines can map values to labels"
+    ],
+    codeExample: tablesMarkupExample
+  }),
+  "Paragraph Structure": constantRecommendation(
+    "Keep paragraphs between 30-150 words for optimal readability and extractability."
+  ),
+  Scannability: constantRecommendation(
+    "Use bold text, short paragraphs, and frequent headings to improve scannability for both humans and AI."
+  ),
+  "Section Length": (rawData) => {
+    const sections = rawData.sectionLengths;
+    if (!sections || sections.sectionCount === 0) {
+      return {
+        text: "Add headings to create distinct sections. Each headed section should be a self-contained unit that an AI engine could extract and reuse."
+      };
+    }
+    const avg = Math.round(sections.avgWordsPerSection);
+    if (avg < 120) {
+      return {
+        text: `Your sections average ${avg} words. The citation sweet spot is 120-180 words. Consider expanding sections with more detail rather than splitting into many short fragments.`
+      };
+    }
+    return {
+      text: `Your sections average ${avg} words. The citation sweet spot is 120-180 words. Consider adding more subheadings to break up long sections into self-contained units.`
+    };
+  },
+  "Definition Patterns": (rawData) => {
+    const detectedTopic = rawData.entities?.topics?.[0];
+    const primaryTerm = detectedTopic ?? "AI SEO";
+    const codeExample = `<!-- Inline definition on first use -->
+<p>${primaryTerm} is defined as [your one-sentence definition here].</p>
+
+<!-- Definition list for multiple terms -->
+<dl>
+  <dt>${primaryTerm}</dt>
+  <dd>[A clear, concise definition that AI engines can extract and reuse.]</dd>
+
+  <dt>[Second key term]</dt>
+  <dd>[The definition of your second most important concept.]</dd>
+</dl>`;
+    return {
+      text: 'Define key terms and concepts clearly (e.g., "X is defined as..." or "X refers to..."). Clear definitions are directly reusable by AI engines.',
+      steps: [
+        "Identify the 3 to 5 key terms central to your page topic",
+        "Add a one-sentence definition for each using the 'X is' or 'X refers to' pattern",
+        "Place each definition early in the section that first uses the term",
+        "Use a <dl> definition list when the page covers many terms"
+      ],
+      codeExample
+    };
+  },
+  "Direct Answer Statements": () => ({
+    text: "Start key sentences with direct statements that could serve as standalone answers.",
+    steps: [
+      "Find paragraphs where the main point is buried after qualifications or context",
+      "Move the core assertion to the first sentence of the paragraph",
+      "Write opening sentences so they can stand alone as a complete answer",
+      "Follow the direct statement with supporting detail, examples, and caveats"
+    ],
+    codeExample: directAnswerExample
+  }),
+  "Answer Capsules": (rawData) => {
+    const capsules = rawData.answerCapsules;
+    const detectedQuestion = rawData.questionsFound?.[0];
+    const steps = [
+      "Rewrite H2 headings as questions your audience would ask an AI (e.g., 'Benefits of X' \u2192 'What are the benefits of X?')",
+      "Place a 1-2 sentence direct answer (under 200 characters) as the first paragraph after each H2",
+      "Start the answer with a definitive statement, not a qualifier",
+      "Follow the capsule with detailed supporting content"
+    ];
+    const codeExample = detectedQuestion ? `<!-- Before -->
+<h2>${detectedQuestion.replace(/\?$/, "").replace(/^(what|how|why|when|where|who)\s+/i, (m) => m.charAt(0).toUpperCase() + m.slice(1))}</h2>
+<p>There are many reasons to consider this topic today...</p>
+
+<!-- After (answer capsule pattern) -->
+<h2>${detectedQuestion.endsWith("?") ? detectedQuestion : `${detectedQuestion}?`}</h2>
+<p>[Your direct, one-sentence answer here \u2014 under 200 characters.]</p>
+<p>[Supporting detail and context follows...]</p>` : answerCapsuleExample;
+    if (!capsules || capsules.total === 0) {
+      return {
+        text: "Frame your H2 headings as questions and place a concise answer (under 200 characters) in the first sentence. 72% of AI-cited content uses this pattern.",
+        steps,
+        codeExample
+      };
+    }
+    const missing = capsules.total - capsules.withCapsule;
+    return {
+      text: `${capsules.withCapsule} of your ${capsules.total} question-framed H2s have a concise answer capsule. Add a short, direct answer (under 200 characters) as the first sentence after the remaining ${missing}. 72% of AI-cited content uses this pattern.`,
+      steps,
+      codeExample
+    };
+  },
+  "Step-by-Step Content": constantRecommendation(
+    "Break down processes into clear, numbered steps. Step-by-step content is highly reusable by AI engines."
+  ),
+  "Q/A Patterns": (rawData) => {
+    const questions = rawData.questionsFound;
+    if (!questions || questions.length === 0) {
+      return {
+        text: 'Include and answer common questions your audience might have. Structure content to directly answer "what is", "how to" style queries.'
+      };
+    }
+    return {
+      text: `Found ${questions.length} question${questions.length === 1 ? "" : "s"} in your content. Add more question-and-answer patterns to cover the queries your audience asks AI engines.`
+    };
+  },
+  "Summary/Conclusion": () => ({
+    text: "Add a conclusion section with key takeaways or a summary. This helps AI engines quickly extract the main points.",
+    steps: [
+      "Add an H2 heading at the end of the page: 'Summary', 'Key Takeaways', or 'Conclusion'",
+      "List 3 to 5 bullet points covering the most important points from the page",
+      "Keep each bullet to one sentence \u2014 conclusion bullets are the most-cited part of a page",
+      "Optionally follow the summary with a 'Next Steps' or 'Learn More' section"
+    ],
+    codeExample: summaryStructureExample
+  }),
+  "Entity Richness": (rawData) => {
+    const entities = rawData.entities;
+    const minimumRecommendedEntities = 9;
+    const howToAddEntitiesSteps = [
+      "Name the key people, organizations, and places relevant to your topic",
+      "Link people and organizations to authoritative sources like Wikipedia or official sites",
+      "Add context for each entity: their role, location, or relevance to the topic",
+      `Aim for ${minimumRecommendedEntities} or more distinct named entities per page`
+    ];
+    if (!entities) {
+      return {
+        text: "Reference relevant experts, organizations, and places in your field. Named entities help AI engines understand context.",
+        steps: howToAddEntitiesSteps
+      };
+    }
+    const detectedEntityCount = entities.people.length + entities.organizations.length + entities.places.length + entities.topics.length;
+    const entityBreakdownParts = [];
+    if (entities.people.length > 0)
+      entityBreakdownParts.push(`${entities.people.length} people`);
+    if (entities.organizations.length > 0)
+      entityBreakdownParts.push(
+        `${entities.organizations.length} organizations`
+      );
+    if (entities.places.length > 0)
+      entityBreakdownParts.push(`${entities.places.length} places`);
+    if (entities.topics.length > 0)
+      entityBreakdownParts.push(`${entities.topics.length} topics`);
+    if (detectedEntityCount === 0) {
+      return {
+        text: "No named entities were detected. Reference specific people, organizations, and places to help AI engines understand what your content is about.",
+        steps: howToAddEntitiesSteps
+      };
+    }
+    return {
+      text: `Found ${detectedEntityCount} unique entities (${entityBreakdownParts.join(", ")}). AI engines perform best with ${minimumRecommendedEntities}+ distinct entities. Add more specific names, organizations, and places relevant to your topic.`,
+      steps: howToAddEntitiesSteps
+    };
+  },
+  "Topic Consistency": constantRecommendation(
+    "Align your main topics with your title and headings. Topic consistency helps AI engines understand what your page is about."
+  ),
+  "Entity Density": constantRecommendation(
+    "Ensure a balanced density of named entities (2-8 per 100 words). Too few makes content vague; too many makes it hard to parse."
+  ),
+  "External References": (rawData) => {
+    const externalLinks = rawData.externalLinks;
+    const linkCount = externalLinks?.length ?? 0;
+    const minimumRecommendedLinks = 6;
+    const howToAddReferenceSteps = [
+      "Identify factual claims that can be supported by an external source",
+      "Find authoritative sources: research papers, industry reports, official documentation",
+      "Wrap the linked text in a meaningful anchor \u2014 describe what you are linking to, not 'click here'",
+      `Aim for ${minimumRecommendedLinks} or more external links per page`
+    ];
+    const firstLink = externalLinks?.[0];
+    const linkedCitationExample = firstLink ? `<!-- Anchor an external reference to the claim it supports -->
+<p>
+  As referenced in <a href="${firstLink.url}"
+  rel="noopener">${firstLink.text || "this source"}</a>, [your claim here].
+</p>
+
+<!-- Add more references using the same pattern -->
+<p>
+  According to <a href="[source-url]" rel="noopener">[Source Name]</a>,
+  [another claim supported by evidence].
+</p>` : `<!-- Anchor an external reference to the claim it supports -->
+<p>
+  Structured content is cited 3x more often by AI engines,
+  according to <a href="https://arxiv.org/abs/2311.09735"
+  rel="noopener">Princeton's GEO research</a>.
+</p>`;
+    if (linkCount === 0) {
+      return {
+        text: "Add links to reputable external sources to ground your claims. AI engines use external references to verify and attribute information.",
+        steps: howToAddReferenceSteps,
+        codeExample: linkedCitationExample
+      };
+    }
+    return {
+      text: `Found ${linkCount} external link${linkCount === 1 ? "" : "s"}. AI engines prefer content with ${minimumRecommendedLinks}+ external references. Add more links to authoritative sources that support your claims.`,
+      steps: howToAddReferenceSteps,
+      codeExample: linkedCitationExample
+    };
+  },
+  "Citation Patterns": () => ({
+    text: 'Use formal citation patterns (e.g., [1], "according to") when referencing sources.',
+    steps: [
+      "Add in-text citation markers like [1] or (Author, Year) after specific claims",
+      "Include a 'References' or 'Sources' section at the bottom of the page",
+      "Use <cite> elements around titles of books, articles, or research papers",
+      "Link each citation marker to its corresponding reference entry"
+    ],
+    codeExample: citationMarkupExample
+  }),
+  "Numeric Claims": constantRecommendation(
+    "Include relevant statistics and data points to support your content with verifiable claims."
+  ),
+  "Attribution Indicators": () => ({
+    text: 'Attribute claims to specific sources or experts. Phrases like "according to" help AI engines trace information.',
+    steps: [
+      "Identify factual claims that currently have no source",
+      "Prepend 'According to [Source]' or 'Per [Organization]' before each claim",
+      "Link the source name to its original URL so AI engines can follow the reference",
+      "Add a citation marker (e.g., [1]) for formal references tied to a sources section"
+    ],
+    codeExample: attributionIndicatorExample
+  }),
+  "Quoted Attribution": () => ({
+    text: 'Add expert quotes with clear attribution. Use patterns like "Quote text" \u2014 Expert Name, or "Quote text," said Expert Name. Research shows quotation addition increased AI visibility by 30-40%.',
+    steps: [
+      "Find a relevant quote from an expert, publication, or research paper",
+      "Wrap it in a <blockquote> with a <footer> containing a <cite> attribution",
+      "Include the expert's full name, title, and organization",
+      "Link the attribution to the original source where possible"
+    ],
+    codeExample: blockquoteAttributionExample,
+    learnMoreUrl: "https://developer.mozilla.org/en-US/docs/Web/HTML/Element/blockquote"
+  }),
+  "Author Attribution": (rawData) => {
+    const authorName = rawData.entities?.people?.[0] || "Author Name";
+    const slug = authorName.toLowerCase().replace(/\s+/g, "-");
+    return {
+      text: "Add visible author information with a byline to establish content credibility and enable AI attribution.",
+      steps: [
+        "Add a visible byline near the top of the article (after the H1)",
+        `Link the author name to an about/bio page using rel="author"`,
+        "Add author information to your JSON-LD schema (see code example)"
+      ],
+      codeExample: `<!-- Add a visible byline -->
+<p class="byline">By <a href="/about/${slug}" rel="author">${authorName}</a></p>
+
+<!-- Add to your JSON-LD schema -->
+"author": {
+  "@type": "Person",
+  "name": "${authorName}",
+  "url": "https://yoursite.com/about/${slug}"
+}`,
+      learnMoreUrl: "https://schema.org/author"
+    };
+  },
+  "Organization Identity": (rawData) => {
+    const detectedOrgName = rawData.entities?.organizations?.[0] ?? "Your Organization";
+    return {
+      text: "Add Organization structured data or og:site_name to help engines identify the source.",
+      steps: [
+        "Add an og:site_name meta tag to every page's <head>",
+        "Add an Organization JSON-LD block to your site's global <head>",
+        "Ensure the organization name is identical across JSON-LD, og:site_name, and visible page content"
+      ],
+      codeExample: `<!-- og:site_name in <head> -->
+<meta property="og:site_name" content="${detectedOrgName}">
+
+<!-- Organization JSON-LD (add to global site header) -->
+<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "Organization",
+  "name": "${detectedOrgName}",
+  "url": "https://yoursite.com",
+  "logo": "https://yoursite.com/logo.png",
+  "sameAs": [
+    "https://twitter.com/yourhandle",
+    "https://linkedin.com/company/yourcompany"
+  ]
+}
+</script>`,
+      learnMoreUrl: "https://schema.org/Organization"
+    };
+  },
+  "Contact/About Links": () => ({
+    text: "Link to About and Contact pages to establish credibility and enable source verification.",
+    steps: [
+      "Add links to your About and Contact pages in the site navigation",
+      "Include them in the footer of every page",
+      "Ensure the links are reachable via plain anchor tags \u2014 not JavaScript-only interactions"
+    ],
+    codeExample: contactLinksExample
+  }),
+  "Publication Date": () => {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    return {
+      text: "Include publication and last-updated dates using proper HTML5 time elements or schema markup.",
+      steps: [
+        "Add a visible publication date near the article title or byline",
+        "Wrap the date in a <time> element with a machine-readable datetime attribute",
+        "Add datePublished and dateModified to your JSON-LD schema"
+      ],
+      codeExample: `<!-- Visible dates with <time> elements -->
+<p>Published: <time datetime="${today}" itemprop="datePublished">${today}</time></p>
+<p>Updated: <time datetime="${today}" itemprop="dateModified">${today}</time></p>
+
+<!-- In your JSON-LD schema -->
+"datePublished": "${today}",
+"dateModified": "${today}"`,
+      learnMoreUrl: "https://schema.org/datePublished"
+    };
+  },
+  "Content Freshness": (rawData) => {
+    const freshness = rawData.freshness;
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const codeExample = `<!-- Add/update in your HTML -->
+<time datetime="${today}" itemprop="dateModified">${today}</time>
+
+<!-- Add/update in your JSON-LD -->
+"dateModified": "${today}"`;
+    const steps = [
+      "Review and update your content with current information",
+      "Update the dateModified in both visible HTML and JSON-LD schema (see code example)",
+      "Set up a recurring reminder to review content every 6 months"
+    ];
+    if (!freshness || freshness.ageInMonths === null) {
+      return {
+        text: "Add a publication or modified date to your content. 65% of AI crawler hits target content less than 1 year old. Without a parseable date, AI engines may deprioritize your content.",
+        steps: [
+          "Add a <time> element with a datetime attribute to your page",
+          "Add datePublished and dateModified to your JSON-LD schema",
+          steps[2]
+        ],
+        codeExample
+      };
+    }
+    const months = Math.round(freshness.ageInMonths);
+    let text;
+    if (months > 24) {
+      text = `Your content was last updated ${months} months ago. AI engines strongly prefer content less than 12 months old. Consider updating with current information and refreshing the modified date.`;
+    } else if (months > 12) {
+      text = `Your content was last updated ${months} months ago. 65% of AI crawler hits target content less than 1 year old. Refresh your content and update the modified date.`;
+    } else if (!freshness.hasModifiedDate) {
+      text = `Your content has a publish date but no modified date. Adding a dateModified signal shows active maintenance and gives a freshness boost with AI engines.`;
+    } else {
+      text = "Update your content to include a recent publication or modified date. Content freshness acts as a hard gate for AI engine citations.";
+    }
+    return { text, steps, codeExample };
+  },
+  "Structured Data": (rawData) => {
+    const types = rawData.structuredDataTypes;
+    if (types && types.length > 0) {
+      return {
+        text: `Found ${types.join(", ")} schema${types.length === 1 ? "" : "s"}. Ensure you also have Open Graph tags (og:title, og:description, og:image) and a canonical URL for complete structured data coverage.`,
+        steps: [
+          "Verify all JSON-LD types have required properties (check Schema Completeness factor)",
+          `Add og:title, og:description, and og:image meta tags if missing`,
+          `Add a <link rel="canonical"> tag pointing to the preferred URL`
+        ],
+        learnMoreUrl: "https://schema.org/docs/gs.html"
+      };
+    }
+    const title = rawData.title || "Your Page Title";
+    const description = rawData.metaDescription || "Your page description";
+    const schemaType = rawData.questionsFound?.length ? "FAQPage" : "Article";
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    let codeExample;
+    if (schemaType === "FAQPage" && rawData.questionsFound?.length) {
+      const questions = rawData.questionsFound.slice(0, 3);
+      const faqEntries = questions.map(
+        (q) => `    {
+      "@type": "Question",
+      "name": "${q}",
+      "acceptedAnswer": {
+        "@type": "Answer",
+        "text": "Your answer here"
+      }
+    }`
+      ).join(",\n");
+      codeExample = `<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "FAQPage",
+  "mainEntity": [
+${faqEntries}
+  ]
+}
+</script>`;
+    } else {
+      codeExample = `<script type="application/ld+json">
+{
+  "@context": "https://schema.org",
+  "@type": "Article",
+  "headline": "${title}",
+  "description": "${description}",
+  "author": {
+    "@type": "Person",
+    "name": "Author Name"
+  },
+  "publisher": {
+    "@type": "Organization",
+    "name": "Your Organization"
+  },
+  "datePublished": "${today}",
+  "dateModified": "${today}"
+}
+</script>`;
+    }
+    return {
+      text: "Add JSON-LD structured data and Open Graph tags to provide machine-readable context.",
+      steps: [
+        `Add a ${schemaType} JSON-LD block to your <head> (see code example)`,
+        "Fill in author, publisher, and date fields with real values",
+        "Add og:title, og:description, and og:image <meta> tags",
+        `Add a <link rel="canonical"> pointing to the preferred URL`,
+        "Validate at https://search.google.com/test/rich-results"
+      ],
+      codeExample,
+      learnMoreUrl: "https://schema.org/docs/gs.html"
+    };
+  },
+  "Schema Completeness": (rawData) => {
+    const schema = rawData.schemaCompleteness;
+    if (!schema || schema.details.length === 0) {
+      return {
+        text: "Add JSON-LD schema with all recommended properties. Complete schemas help AI engines attribute and trust your content.",
+        learnMoreUrl: "https://schema.org/docs/gs.html"
+      };
+    }
+    const incomplete = schema.details.filter((d) => d.missing.length > 0);
+    if (incomplete.length === 0) {
+      return {
+        text: "Ensure your JSON-LD schema types include all recommended properties for maximum AI engine trust."
+      };
+    }
+    const summaries = incomplete.map(
+      (d) => `${d.type} is missing ${d.missing.join(", ")}`
+    );
+    const primary = incomplete[0];
+    const placeholders = {
+      headline: `"headline": "${rawData.title || "Your headline"}"`,
+      author: `"author": { "@type": "Person", "name": "Author Name" }`,
+      datePublished: `"datePublished": "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"`,
+      dateModified: `"dateModified": "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"`,
+      description: `"description": "${rawData.metaDescription || "Your description"}"`,
+      image: `"image": "https://yoursite.com/image.jpg"`,
+      publisher: `"publisher": { "@type": "Organization", "name": "Your Org" }`,
+      name: `"name": "${rawData.title || "Your Name"}"`,
+      url: `"url": "https://yoursite.com"`,
+      mainEntity: `"mainEntity": []`,
+      step: `"step": [{ "@type": "HowToStep", "text": "Step 1..." }]`,
+      address: `"address": { "@type": "PostalAddress", "streetAddress": "..." }`
+    };
+    const missingProps = primary.missing.map(
+      (prop) => placeholders[prop] || `"${prop}": "..."`
+    );
+    const codeExample = `// Add these properties to your existing ${primary.type} schema:
+{
+  ${missingProps.join(",\n  ")}
+}`;
+    return {
+      text: `Your ${summaries.join("; ")}. Adding these properties helps AI engines attribute and trust your content.`,
+      steps: incomplete.map(
+        (d) => `Add ${d.missing.join(", ")} to your ${d.type} schema`
+      ),
+      codeExample,
+      learnMoreUrl: `https://schema.org/${primary.type}`
+    };
+  },
+  "Entity Consistency": (rawData) => {
+    const ec = rawData.entityConsistency;
+    if (!ec || !ec.entityName) {
+      return {
+        text: "Add a consistent brand or organization name across your page title, OG tags, JSON-LD schema, and footer. Consistent entity signals help AI engines confidently attribute content to your brand."
+      };
+    }
+    return {
+      text: `"${ec.entityName}" was found on ${ec.surfacesFound} of ${ec.surfacesChecked} page surfaces. Ensure it appears consistently in the page title, OG tags, schema, and footer for strong brand attribution.`
+    };
+  },
+  "Sentence Length": (rawData) => {
+    const avg = rawData.avgSentenceLength;
+    if (avg === void 0) {
+      return {
+        text: "Aim for an average sentence length of 12-22 words for optimal readability and compressibility."
+      };
+    }
+    const rounded = Math.round(avg);
+    if (rounded > 22) {
+      return {
+        text: `Your average sentence is ${rounded} words. The ideal range for AI compression is 12-22 words. Break long sentences into shorter, more direct statements.`
+      };
+    }
+    if (rounded < 12) {
+      return {
+        text: `Your average sentence is ${rounded} words. While short sentences are readable, combining some into 12-22 word sentences provides better context for AI summarization.`
+      };
+    }
+    return {
+      text: `Your average sentence length is ${rounded} words. Fine-tune toward the 12-22 word sweet spot for optimal AI compression.`
+    };
+  },
+  Readability: (rawData) => {
+    const score = rawData.readabilityScore;
+    if (score === void 0) {
+      return {
+        text: "Simplify language where possible. A Flesch Reading Ease score of 60-70 is ideal for broad AI reusability."
+      };
+    }
+    const rounded = Math.round(score);
+    if (rounded < 30) {
+      return {
+        text: `Your Flesch Reading Ease score is ${rounded} (very difficult). A score of 60-70 is ideal. Shorten sentences, use simpler vocabulary, and break up complex ideas.`
+      };
+    }
+    if (rounded < 50) {
+      return {
+        text: `Your Flesch Reading Ease score is ${rounded} (difficult). A score of 60-70 is ideal for broad AI reusability. Simplify where possible without losing meaning.`
+      };
+    }
+    if (rounded < 60) {
+      return {
+        text: `Your Flesch Reading Ease score is ${rounded} (fairly difficult). You're close to the ideal 60-70 range. Minor simplification would improve AI compressibility.`
+      };
+    }
+    return {
+      text: `Your Flesch Reading Ease score is ${rounded}. A score of 60-70 is ideal for broad AI reusability.`
+    };
+  },
+  "Jargon Density": () => ({
+    text: "Define technical terms or replace with simpler alternatives. High jargon density reduces AI reusability.",
+    steps: [
+      "List the 5 most domain-specific terms on the page",
+      "For each term: either add a plain-English definition on first use, or replace with simpler language",
+      "Use the 'is defined as' or 'also known as' pattern for terms you must keep",
+      "Aim for a Flesch Reading Ease score of 60 to 70 by simplifying sentence structure"
+    ],
+    codeExample: jargonReductionExample
+  }),
+  "Transition Usage": () => ({
+    text: "Use transition words (however, therefore, additionally) to improve content flow and logical structure.",
+    steps: [
+      "Add contrast transitions between opposing ideas: 'however', 'although', 'on the other hand'",
+      "Add sequence transitions between steps or points: 'first', 'next', 'finally'",
+      "Add addition transitions to build on a point: 'additionally', 'furthermore', 'in addition'",
+      "Add conclusion transitions at the end of sections: 'therefore', 'as a result', 'in summary'"
+    ],
+    codeExample: transitionWordsExample
+  })
+};
+
+// src/modules/recommendations/service.ts
+function generateRecommendations(auditResult) {
+  const recommendations = [];
+  for (const category of Object.values(auditResult.categories)) {
+    for (const factor of category.factors) {
+      const pct = factor.maxScore > 0 ? factor.score / factor.maxScore : 1;
+      if (pct >= 0.7) continue;
+      const priority = pct < 0.3 ? "high" : pct < 0.5 ? "medium" : "low";
+      const builder = RECOMMENDATION_BUILDERS[factor.name];
+      const output = builder ? builder(auditResult.rawData) : {
+        text: `Review and improve "${factor.name}" based on best practices for AI search readiness.`
+      };
+      recommendations.push({
+        category: category.name,
+        factor: factor.name,
+        currentValue: factor.value,
+        priority,
+        recommendation: output.text,
+        ...output.steps && { steps: output.steps },
+        ...output.codeExample && { codeExample: output.codeExample },
+        ...output.learnMoreUrl && { learnMoreUrl: output.learnMoreUrl }
+      });
+    }
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  recommendations.sort((a, b) => {
+    const pd = priorityOrder[a.priority] - priorityOrder[b.priority];
+    if (pd !== 0) return pd;
+    return a.factor.localeCompare(b.factor);
+  });
+  return recommendations;
+}
+
+// src/modules/scoring/constants.ts
+var GRADE_THRESHOLDS = [
+  [93, "A"],
+  [90, "A-"],
+  [87, "B+"],
+  [83, "B"],
+  [80, "B-"],
+  [77, "C+"],
+  [73, "C"],
+  [70, "C-"],
+  [67, "D+"],
+  [63, "D"],
+  [60, "D-"],
+  [0, "F"]
+];
+
+// src/modules/scoring/service.ts
+function computeScore(categories, weights) {
+  const weightMap = {
+    contentExtractability: weights.contentExtractability,
+    contentStructure: weights.contentStructure,
+    answerability: weights.answerability,
+    entityClarity: weights.entityClarity,
+    groundingSignals: weights.groundingSignals,
+    authorityContext: weights.authorityContext,
+    readabilityForCompression: weights.readabilityForCompression
+  };
+  const totalWeight = Object.values(weightMap).reduce((sum, w) => sum + w, 0);
+  let totalPoints = 0;
+  let maxPoints = 0;
+  let weightedScore = 0;
+  for (const [key, category] of Object.entries(categories)) {
+    totalPoints += category.score;
+    maxPoints += category.maxScore;
+    const w = weightMap[key] ?? 1;
+    const normalizedWeight = totalWeight > 0 ? w / totalWeight : 1 / 7;
+    const categoryPct = category.maxScore > 0 ? category.score / category.maxScore * 100 : 0;
+    weightedScore += categoryPct * normalizedWeight;
+  }
+  const overallScore = Math.round(weightedScore);
+  const grade = computeGrade(overallScore);
+  return { overallScore, grade, totalPoints, maxPoints };
+}
+function computeGrade(score) {
+  for (const [threshold, grade] of GRADE_THRESHOLDS) {
+    if (score >= threshold) return grade;
+  }
+  return "F";
+}
+
+// src/modules/analyzer/service.ts
+async function fetchDomainSignals(url, timeout, userAgent) {
+  const cappedTimeout = Math.min(timeout, DOMAIN_SIGNAL_TIMEOUT_CAP);
+  const [robotsRes, llmsRes, llmsFullRes] = await Promise.allSettled([
+    httpGet({
+      url: `${url}/robots.txt`,
+      timeout: cappedTimeout,
+      userAgent
+    }),
+    httpHead({
+      url: `${url}/llms.txt`,
+      timeout: cappedTimeout,
+      userAgent
+    }),
+    httpHead({
+      url: `${url}/llms-full.txt`,
+      timeout: cappedTimeout,
+      userAgent
+    })
+  ]);
+  return {
+    signalsBase: url,
+    robotsTxt: robotsRes.status === "fulfilled" && robotsRes.value.status === 200 ? robotsRes.value.data : null,
+    llmsTxtExists: llmsRes.status === "fulfilled" && llmsRes.value.status === 200,
+    llmsFullTxtExists: llmsFullRes.status === "fulfilled" && llmsFullRes.value.status === 200
+  };
+}
+function buildResult(url, fetchResult, domainSignals, config) {
+  const page = extractPage(fetchResult.html, url);
+  const auditResult = runAudits(page, fetchResult, domainSignals);
+  const scoring = computeScore(auditResult.categories, config.weights);
+  const recommendations = generateRecommendations(auditResult);
+  return {
+    url,
+    signalsBase: domainSignals.signalsBase,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    overallScore: scoring.overallScore,
+    grade: scoring.grade,
+    totalPoints: scoring.totalPoints,
+    maxPoints: scoring.maxPoints,
+    categories: auditResult.categories,
+    recommendations,
+    rawData: auditResult.rawData,
+    meta: {
+      version: VERSION
+    }
+  };
+}
+async function analyzeUrlWithSignals(url, fetchResult, domainSignals, config) {
+  const startTime = Date.now();
+  const result = buildResult(url, fetchResult, domainSignals, config);
+  return {
+    ...result,
+    meta: { ...result.meta, analysisDurationMs: Date.now() - startTime }
+  };
+}
+async function analyzeUrl(options, config) {
+  const startTime = Date.now();
+  const url = normalizeUrl(options.url);
+  const timeout = options.timeout ?? config.timeout;
+  const userAgent = options.userAgent ?? config.userAgent;
+  const fetchResult = await fetchUrl({ url, timeout, userAgent });
+  const signalsBase = options.signalsBase ?? fetchResult.finalUrl ?? url;
+  const domainSignals = await fetchDomainSignals(
+    signalsBase,
+    timeout,
+    userAgent
+  );
+  const result = buildResult(url, fetchResult, domainSignals, config);
+  return {
+    ...result,
+    meta: { ...result.meta, analysisDurationMs: Date.now() - startTime }
+  };
+}
+
+// src/utils/fs.ts
+import { access, writeFile as fsWriteFile } from "fs/promises";
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeOutputFile(path, content) {
+  await fsWriteFile(path, content, "utf-8");
+}
+
+// src/modules/config/service.ts
+import { readFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+
+// src/modules/config/constants.ts
+var CONFIG_FILENAMES = [
+  "aiseo.config.json",
+  ".aiseo.config.json",
+  "aiseo-audit.config.json"
+];
+
+// src/modules/config/schema.ts
+import { z as z2 } from "zod";
+var DEFAULT_USER_AGENT = `AISEOAudit/${VERSION}`;
+var DEFAULT_WEIGHTS = {
+  contentExtractability: 1,
+  contentStructure: 1,
+  answerability: 1,
+  entityClarity: 1,
+  groundingSignals: 1,
+  authorityContext: 1,
+  readabilityForCompression: 1
+};
+var CategoryWeightSchema = z2.object({
+  contentExtractability: z2.number().min(0).default(1),
+  contentStructure: z2.number().min(0).default(1),
+  answerability: z2.number().min(0).default(1),
+  entityClarity: z2.number().min(0).default(1),
+  groundingSignals: z2.number().min(0).default(1),
+  authorityContext: z2.number().min(0).default(1),
+  readabilityForCompression: z2.number().min(0).default(1)
+}).default(DEFAULT_WEIGHTS);
+var AiseoConfigSchema = z2.object({
+  timeout: z2.number().positive().default(45e3),
+  userAgent: z2.string().default(DEFAULT_USER_AGENT),
+  format: z2.enum(["pretty", "json", "md", "html"]).default("pretty"),
+  failUnder: z2.number().min(0).max(100).optional(),
+  weights: CategoryWeightSchema
+}).default({
+  timeout: 45e3,
+  userAgent: DEFAULT_USER_AGENT,
+  format: "pretty",
+  weights: DEFAULT_WEIGHTS
+});
+
+// src/modules/config/service.ts
+async function findConfigFile(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    for (const filename of CONFIG_FILENAMES) {
+      const candidate = join(dir, filename);
+      if (await fileExists(candidate)) return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function loadConfig(configPath) {
+  if (configPath) {
+    const resolvedPath = resolve(configPath);
+    const content = await readFile(resolvedPath, "utf-8");
+    try {
+      return AiseoConfigSchema.parse(JSON.parse(content));
+    } catch (err) {
+      throw new Error(
+        `Invalid config file "${resolvedPath}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  const found = await findConfigFile(process.cwd());
+  if (found) {
+    const content = await readFile(found, "utf-8");
+    try {
+      return AiseoConfigSchema.parse(JSON.parse(content));
+    } catch (err) {
+      throw new Error(
+        `Invalid config file "${found}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return AiseoConfigSchema.parse({});
+}
+
+// src/modules/report/support/html.ts
+function scoreColorHex(pct) {
+  if (pct >= 90) return "#00cc66";
+  if (pct >= 50) return "#ffaa33";
+  return "#ff3333";
+}
+function scoreTextColorHex(pct) {
+  if (pct >= 90) return "#008800";
+  if (pct >= 50) return "#ffaa33";
+  return "#cc0000";
+}
+function scoreClass(pct) {
+  if (pct >= 90) return "pass";
+  if (pct >= 50) return "average";
+  return "fail";
+}
+function statusIcon(status) {
+  if (status === "good") return "&#10003;";
+  if (status === "neutral") return "&#8212;";
+  if (status === "needs_improvement") return "&#9650;";
+  return "&#10007;";
+}
+function statusClass(status) {
+  if (status === "good") return "good";
+  if (status === "neutral") return "neutral";
+  if (status === "needs_improvement") return "warn";
+  return "fail";
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildGaugeSvg(score) {
+  const pct = Math.max(0, Math.min(100, score));
+  const arcColor = scoreColorHex(pct);
+  const textColor = scoreTextColorHex(pct);
+  const radius = 56;
+  const circumference = 2 * Math.PI * radius;
+  const offset = circumference * (1 - pct / 100);
+  const dim = 64;
+  const fontSize = 22;
+  const strokeWidth = 7;
+  return `<svg class="gauge" viewBox="0 0 120 120" width="${dim}" height="${dim}">
+      <circle cx="60" cy="60" r="${radius}" fill="none" stroke="#e0e0e0" stroke-width="${strokeWidth}"/>
+      <circle cx="60" cy="60" r="${radius}" fill="none" stroke="${arcColor}" stroke-width="${strokeWidth}"
+        stroke-dasharray="${circumference}" stroke-dashoffset="${offset}"
+        stroke-linecap="round" transform="rotate(-90 60 60)"/>
+      <text x="60" y="${60 + fontSize * 0.35}" text-anchor="middle" font-size="${fontSize}" font-weight="700" fill="${textColor}">${score}</text>
+    </svg>`;
+}
+function buildMultiSegmentGauge(overallScore, grade, totalPoints, maxPoints, categories) {
+  const radius = 80;
+  const strokeWidth = 14;
+  const pad2 = 8;
+  const size = (radius + strokeWidth / 2 + pad2) * 2;
+  const cx = size / 2;
+  const cy = size / 2;
+  const circ = 2 * Math.PI * radius;
+  const textColor = scoreTextColorHex(overallScore);
+  const trackCircle = `<circle cx="${cx}" cy="${cy}" r="${radius}" fill="none" stroke="#e8e8e8" stroke-width="${strokeWidth}"/>`;
+  const arcs = [];
+  let consumed = 0;
+  let segIdx = 0;
+  for (const cat of categories) {
+    const catDeg = maxPoints > 0 ? cat.score / maxPoints * 360 : 0;
+    if (catDeg < 0.1) {
+      consumed += catDeg;
+      continue;
+    }
+    const catPct = cat.maxScore > 0 ? Math.round(cat.score / cat.maxScore * 100) : 0;
+    const color = scoreColorHex(catPct);
+    const arcLen = catDeg / 360 * circ;
+    const offset = circ * 0.25 - consumed / 360 * circ;
+    const catName = escapeHtml(cat.name);
+    const idx = segIdx;
+    arcs.push(
+      `<circle cx="${cx}" cy="${cy}" r="${radius}" fill="none"
+        stroke="${color}" stroke-width="${strokeWidth}"
+        stroke-dasharray="${arcLen.toFixed(2)} ${(circ - arcLen).toFixed(2)}"
+        stroke-dashoffset="${offset.toFixed(2)}"
+        class="seg-arc" data-idx="${idx}"
+        onmouseenter="document.getElementById('seg-pop-${idx}').style.display='flex'"
+        onmouseleave="document.getElementById('seg-pop-${idx}').style.display='none'"/>`
+    );
+    consumed += catDeg;
+    const divRad = consumed / 360 * 2 * Math.PI - Math.PI / 2;
+    const half = strokeWidth / 2 + 1;
+    const dx = Math.cos(divRad);
+    const dy = Math.sin(divRad);
+    arcs.push(
+      `<line x1="${(cx + (radius - half) * dx).toFixed(2)}" y1="${(cy + (radius - half) * dy).toFixed(2)}"
+        x2="${(cx + (radius + half) * dx).toFixed(2)}" y2="${(cy + (radius + half) * dy).toFixed(2)}"
+        stroke="#fff" stroke-width="2" pointer-events="none"/>`
+    );
+    segIdx++;
+  }
+  const popovers = categories.filter((cat) => cat.score > 0).map((cat, i) => {
+    const catPct = cat.maxScore > 0 ? Math.round(cat.score / cat.maxScore * 100) : 0;
+    const color = scoreColorHex(catPct);
+    return `<div id="seg-pop-${i}" class="seg-popover">
+        <span class="seg-popover-dot" style="background:${color}"></span>
+        <span class="seg-popover-name">${escapeHtml(cat.name)}</span>
+        <span class="seg-popover-score">${catPct}%</span>
+        <span class="seg-popover-pts">${cat.score}/${cat.maxScore} pts</span>
+      </div>`;
+  }).join("");
+  return `<div class="overall-gauge-wrap">
+    <svg class="gauge" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}">
+      ${trackCircle}
+      ${arcs.join("\n      ")}
+      <text x="${cx}" y="${cy - 8}" text-anchor="middle" font-size="40" font-weight="700" fill="${textColor}">${overallScore}</text>
+      <text x="${cx}" y="${cy + 14}" text-anchor="middle" font-size="14" font-weight="600" fill="${textColor}">${escapeHtml(grade)}</text>
+      <text x="${cx}" y="${cy + 30}" text-anchor="middle" font-size="11" fill="#999">${totalPoints}/${maxPoints} pts</text>
+    </svg>
+    <div class="seg-popovers">${popovers}</div>
+    <div class="score-scale">
+      <span class="scale-fail">0-49</span>
+      <span class="scale-average">50-89</span>
+      <span class="scale-pass">90-100</span>
+    </div>
+  </div>`;
+}
+function buildCategoryGauge(category) {
+  const pct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+  return `<a class="gauge-item" href="#cat-${escapeHtml(category.name.replace(/\s+/g, "-").toLowerCase())}">
+      ${buildGaugeSvg(pct)}
+      <span class="gauge-label">${escapeHtml(category.name)}</span>
+    </a>`;
+}
+function buildCategorySection(category) {
+  const pct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+  const cls = scoreClass(pct);
+  const id = category.name.replace(/\s+/g, "-").toLowerCase();
+  const factorRows = category.factors.map(
+    (f) => `
+          <div class="audit-row">
+            <span class="audit-icon ${statusClass(f.status)}">${statusIcon(f.status)}</span>
+            <span class="audit-name">${escapeHtml(f.name)}</span>
+            <span class="audit-detail">${escapeHtml(f.value)}</span>
+            <span class="audit-score">${f.score}/${f.maxScore}</span>
+          </div>`
+  ).join("");
+  return `
+    <div class="category" id="cat-${id}">
+      <div class="category-header">
+        <div class="category-title ${cls}">${escapeHtml(category.name)}</div>
+        <div class="category-score ${cls}">${pct}%</div>
+      </div>
+      <div class="audits">${factorRows}</div>
+    </div>`;
+}
+function buildRecommendationRow(rec) {
+  const cls = rec.priority === "high" ? "priority-high" : rec.priority === "medium" ? "priority-med" : "priority-low";
+  const label = rec.priority === "high" ? "HIGH" : rec.priority === "medium" ? "MED" : "LOW";
+  let detailHtml = "";
+  if (rec.steps || rec.codeExample || rec.learnMoreUrl) {
+    let inner = "";
+    if (rec.steps && rec.steps.length > 0) {
+      const items = rec.steps.map((s) => `<li>${escapeHtml(s)}</li>`).join("");
+      inner += `<ol class="rec-steps">${items}</ol>`;
+    }
+    if (rec.codeExample) {
+      inner += `<pre class="rec-code"><code>${escapeHtml(rec.codeExample)}</code></pre>`;
+    }
+    if (rec.learnMoreUrl) {
+      inner += `<a class="rec-learn-more" href="${escapeHtml(rec.learnMoreUrl)}" target="_blank" rel="noopener">Learn more &rarr;</a>`;
+    }
+    detailHtml = `<div class="rec-detail">${inner}</div>`;
+  }
+  return `
+      <div class="rec-row ${cls}">
+        <span class="rec-tag">${label}</span>
+        <span class="rec-factor">${escapeHtml(rec.factor)}</span>
+        <span class="rec-text">${escapeHtml(rec.recommendation)}</span>
+      </div>${detailHtml}`;
+}
+function buildRecommendationsByCategory(recommendations, categories) {
+  const categoryNames = Object.values(categories).map((c) => c.name);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const name of categoryNames) {
+    const recs = recommendations.filter((r) => r.category === name);
+    if (recs.length > 0) grouped.set(name, recs);
+  }
+  if (grouped.size === 0) return "";
+  let html = `<div class="recs-section">
+    <div class="recs-title">Recommendations</div>`;
+  for (const [categoryName, recs] of grouped) {
+    html += `<div class="rec-group">
+      <div class="rec-group-name">${escapeHtml(categoryName)}</div>`;
+    html += recs.map(buildRecommendationRow).join("");
+    html += `</div>`;
+  }
+  html += `</div>`;
+  return html;
+}
+function renderHtml(result) {
+  const categoryEntries = Object.entries(result.categories);
+  const categories = categoryEntries.map(([, c]) => c);
+  const categoriesWithKeys = categoryEntries.map(([key, c]) => ({
+    key,
+    name: c.name,
+    score: c.score,
+    maxScore: c.maxScore
+  }));
+  const gauges = categories.map(buildCategoryGauge).join("");
+  const sections = categories.map(buildCategorySection).join("");
+  const recsHtml = buildRecommendationsByCategory(
+    result.recommendations,
+    result.categories
+  );
+  const overallGauge = buildMultiSegmentGauge(
+    result.overallScore,
+    result.grade,
+    result.totalPoints,
+    result.maxPoints,
+    categoriesWithKeys
+  );
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>AI SEO Audit - ${escapeHtml(result.url)}</title>
+<style>
+:root {
+  --pass: #00cc66;
+  --pass-text: #008800;
+  --average: #ffaa33;
+  --average-text: #ffaa33;
+  --fail: #ff3333;
+  --fail-text: #cc0000;
+  --bg: #fff;
+  --surface: #fff;
+  --text: #212121;
+  --text-secondary: #757575;
+  --border: #e0e0e0;
+  --font: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, sans-serif;
+}
+
+* { margin: 0; padding: 0; box-sizing: border-box; }
+
+body {
+  font-family: var(--font);
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.6;
+  -webkit-font-smoothing: antialiased;
+}
+
+/* Topbar */
+.topbar {
+  display: flex;
+  align-items: center;
+  height: 40px;
+  padding: 0 16px;
+  background: var(--surface);
+  border-bottom: 1px solid var(--border);
+  font-size: 13px;
+}
+.topbar-title {
+  font-weight: 600;
+  margin-right: 12px;
+  white-space: nowrap;
+}
+.topbar-url {
+  color: var(--text-secondary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* Container */
+.report {
+  max-width: 960px;
+  margin: 0 auto;
+  padding: 0 32px;
+}
+
+/* Category gauges row */
+.gauges-row {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  align-items: flex-start;
+  gap: 12px;
+  padding: 24px 0;
+  border-bottom: 1px solid var(--border);
+}
+.gauge-item {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  width: 110px;
+  padding: 10px 6px 8px;
+  text-decoration: none;
+  color: var(--text);
+  border-radius: 8px;
+  transition: background 0.15s;
+}
+.gauge-item:hover {
+  background: #f5f5f5;
+}
+.gauge-item .gauge { display: block; }
+.gauge-label {
+  margin-top: 8px;
+  font-size: 11px;
+  font-weight: 500;
+  text-align: center;
+  color: var(--text-secondary);
+  line-height: 1.25;
+}
+
+/* Overall score */
+.overall {
+  display: flex;
+  align-items: center;
+  flex-direction: column;
+  padding: 32px 0 24px;
+  border-bottom: 1px solid var(--border);
+}
+.overall-gauge-wrap {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  position: relative;
+}
+.overall-gauge-wrap .gauge {
+  display: block;
+  overflow: visible;
+}
+.seg-arc {
+  cursor: pointer;
+  transition: stroke-width 0.15s ease, filter 0.15s ease;
+}
+.seg-arc:hover {
+  stroke-width: 20;
+  filter: brightness(1.1);
+}
+
+/* Segment popovers */
+.seg-popovers {
+  position: relative;
+  min-height: 36px;
+  display: flex;
+  justify-content: center;
+  margin-top: 4px;
+}
+.seg-popover {
+  display: none;
+  align-items: center;
+  gap: 8px;
+  background: #fff;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 8px 14px;
+  box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+  font-size: 13px;
+  white-space: nowrap;
+}
+.seg-popover-dot {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+.seg-popover-name { font-weight: 600; }
+.seg-popover-score { font-weight: 700; }
+.seg-popover-pts { color: var(--text-secondary); }
+
+/* Score scale legend */
+.score-scale {
+  display: flex;
+  justify-content: center;
+  gap: 16px;
+  margin-top: 12px;
+  font-size: 11px;
+  color: var(--text-secondary);
+}
+.score-scale span::before {
+  content: "";
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  margin-right: 4px;
+  vertical-align: middle;
+}
+.scale-fail::before { background: var(--fail); }
+.scale-average::before { background: var(--average); }
+.scale-pass::before { background: var(--pass); }
+
+/* Categories */
+.category {
+  padding: 24px 0 16px;
+  border-bottom: 1px solid var(--border);
+}
+.category:last-child { border-bottom: none; }
+.category-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  margin-bottom: 12px;
+}
+.category-title {
+  font-size: 18px;
+  font-weight: 600;
+}
+.category-title.pass { color: var(--pass-text); }
+.category-title.average { color: var(--average-text); }
+.category-title.fail { color: var(--fail-text); }
+.category-score {
+  font-size: 14px;
+  font-weight: 700;
+}
+.category-score.pass { color: var(--pass-text); }
+.category-score.average { color: var(--average-text); }
+.category-score.fail { color: var(--fail-text); }
+
+/* Audit rows */
+.audit-row {
+  display: flex;
+  align-items: baseline;
+  padding: 8px 0;
+  border-top: 1px solid #f0f0f0;
+  font-size: 13px;
+  gap: 8px;
+}
+.audit-icon {
+  width: 18px;
+  flex-shrink: 0;
+  text-align: center;
+  font-size: 12px;
+}
+.audit-icon.good { color: var(--pass); }
+.audit-icon.warn { color: var(--average); }
+.audit-icon.fail { color: var(--fail); }
+.audit-icon.neutral { color: var(--text-secondary); }
+.audit-name {
+  font-weight: 500;
+  min-width: 180px;
+  flex-shrink: 0;
+}
+.audit-detail {
+  flex: 1;
+  color: var(--text-secondary);
+}
+.audit-score {
+  color: var(--text-secondary);
+  white-space: nowrap;
+  text-align: right;
+  min-width: 44px;
+}
+
+/* Recommendations */
+.recs-section {
+  padding: 24px 0 16px;
+  border-top: 1px solid var(--border);
+}
+.recs-title {
+  font-size: 20px;
+  font-weight: 600;
+  margin-bottom: 20px;
+}
+.rec-group {
+  margin-bottom: 20px;
+}
+.rec-group-name {
+  font-size: 13px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.4px;
+  color: var(--text-secondary);
+  padding-bottom: 6px;
+  border-bottom: 1px solid var(--border);
+  margin-bottom: 2px;
+}
+.rec-row {
+  display: flex;
+  gap: 10px;
+  align-items: baseline;
+  padding: 8px 0;
+  border-bottom: 1px solid #f5f5f5;
+  font-size: 13px;
+}
+.rec-tag {
+  font-size: 9px;
+  font-weight: 700;
+  padding: 2px 5px;
+  border-radius: 3px;
+  white-space: nowrap;
+  flex-shrink: 0;
+  letter-spacing: 0.3px;
+}
+.priority-high .rec-tag { background: #fce8e6; color: var(--fail-text); }
+.priority-med .rec-tag { background: #fef7e0; color: var(--average-text); }
+.priority-low .rec-tag { background: #f1f3f4; color: var(--text-secondary); }
+.rec-factor {
+  font-weight: 600;
+  white-space: nowrap;
+  flex-shrink: 0;
+}
+.rec-text { color: var(--text-secondary); }
+.rec-detail {
+  padding: 8px 0 8px 16px;
+  border-bottom: 1px solid #f5f5f5;
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+.rec-steps {
+  margin: 0 0 8px 0;
+  padding-left: 20px;
+}
+.rec-steps li { margin-bottom: 3px; }
+.rec-code {
+  background: #f8f9fa;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  padding: 10px 12px;
+  font-size: 11px;
+  overflow-x: auto;
+  margin: 0 0 8px 0;
+  white-space: pre;
+}
+.rec-learn-more {
+  font-size: 11px;
+  color: var(--text-secondary);
+  text-decoration: none;
+}
+.rec-learn-more:hover { text-decoration: underline; }
+
+/* Footer */
+.footer {
+  padding: 16px 0;
+  border-top: 1px solid var(--border);
+  font-size: 11px;
+  color: var(--text-secondary);
+  display: flex;
+  justify-content: space-between;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+@media (max-width: 600px) {
+  .report { padding: 0 16px; }
+  .gauges-row { gap: 4px; }
+  .gauge-item { width: 80px; padding: 8px 4px; }
+  .audit-row { flex-wrap: wrap; }
+  .audit-name { min-width: 140px; }
+  .rec-row { flex-wrap: wrap; }
+}
+</style>
+</head>
+<body>
+
+<div class="topbar">
+  <span class="topbar-title">AI SEO Audit</span>
+  <span class="topbar-url">${escapeHtml(result.url)}</span>
+</div>
+
+<div class="report">
+  <div class="gauges-row">
+    ${gauges}
+  </div>
+
+  <div class="overall">
+    ${overallGauge}
+  </div>
+
+  ${sections}
+
+  ${recsHtml}
+
+  <div class="footer">
+    <span>Generated by aiseo-audit v${escapeHtml(result.meta.version)}</span>
+    <span>${escapeHtml(result.analyzedAt)} &middot; ${result.meta.analysisDurationMs}ms</span>
+    <span>Domain signals checked at: <code>${escapeHtml(result.signalsBase)}</code></span>
+    ${result.url.startsWith("http://") ? '<span style="color:#e8a735;margin-top:4px">Note: Audited over HTTP. Domain signals (robots.txt, llms.txt) may differ in production.</span>' : ""}
+  </div>
+</div>
+
+</body>
+</html>`;
+}
+function buildSitemapUrlSection(urlResult, index) {
+  if (urlResult.status === "failed") {
+    return `
+    <div class="sitemap-url-section failed">
+      <div class="sitemap-url-header">
+        <span class="sitemap-url-status fail">&#10007;</span>
+        <span class="sitemap-url-label">${escapeHtml(urlResult.url)}</span>
+      </div>
+      <div class="sitemap-url-error">Error: ${escapeHtml(urlResult.error)}</div>
+    </div>`;
+  }
+  const { result } = urlResult;
+  const pct = result.overallScore;
+  const scoreCol = scoreColorHex(pct);
+  const categoryEntries = Object.entries(result.categories);
+  const topRec = result.recommendations[0];
+  const categoryRows = categoryEntries.map(([, c]) => {
+    const catPct = c.maxScore > 0 ? Math.round(c.score / c.maxScore * 100) : 0;
+    const cls = scoreClass(catPct);
+    return `<div class="sitemap-cat-row">
+      <span class="sitemap-cat-name">${escapeHtml(c.name)}</span>
+      <span class="sitemap-cat-score ${cls}">${catPct}%</span>
+    </div>`;
+  }).join("");
+  const recHtml = topRec ? `<div class="sitemap-top-rec">Top recommendation: <strong>${escapeHtml(topRec.factor)}</strong> \u2014 ${escapeHtml(topRec.recommendation)}</div>` : "";
+  return `
+    <div class="sitemap-url-section" id="url-${index}">
+      <div class="sitemap-url-header">
+        <span class="sitemap-url-status" style="color:${scoreCol}">&#10003;</span>
+        <span class="sitemap-url-label">${escapeHtml(result.url)}</span>
+        <span class="sitemap-url-score" style="color:${scoreCol}">${result.overallScore}/100</span>
+        <span class="sitemap-url-grade" style="color:${scoreCol}">${escapeHtml(result.grade)}</span>
+      </div>
+      <div class="sitemap-url-body">
+        <div class="sitemap-cats">${categoryRows}</div>
+        ${recHtml}
+      </div>
+    </div>`;
+}
+function renderSitemapHtml(result) {
+  const avgTextColor = scoreTextColorHex(result.averageScore);
+  const hasHttpUrls = result.urlResults.some(
+    (r) => r.status === "success" && r.result.url.startsWith("http://")
+  );
+  const categoryAvgRows = Object.values(result.categoryAverages).map((avg) => {
+    const cls = scoreClass(avg.averagePct);
+    return `<div class="sitemap-cat-row">
+      <span class="sitemap-cat-name">${escapeHtml(avg.name)}</span>
+      <span class="sitemap-cat-score ${cls}">${avg.averagePct}%</span>
+    </div>`;
+  }).join("");
+  const urlSections = result.urlResults.map((r, i) => buildSitemapUrlSection(r, i)).join("");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>AI SEO Sitemap Audit - ${escapeHtml(result.sitemapUrl)}</title>
+<style>
+:root {
+  --pass: #00cc66;
+  --pass-text: #008800;
+  --average: #ffaa33;
+  --average-text: #ffaa33;
+  --fail: #ff3333;
+  --fail-text: #cc0000;
+  --bg: #fff;
+  --surface: #fff;
+  --text: #212121;
+  --text-secondary: #757575;
+  --border: #e0e0e0;
+  --font: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, sans-serif;
+}
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body { font-family: var(--font); background: var(--bg); color: var(--text); line-height: 1.6; -webkit-font-smoothing: antialiased; }
+.topbar { display: flex; align-items: center; height: 40px; padding: 0 16px; background: var(--surface); border-bottom: 1px solid var(--border); font-size: 13px; }
+.topbar-title { font-weight: 600; margin-right: 12px; white-space: nowrap; }
+.topbar-url { color: var(--text-secondary); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.report { max-width: 960px; margin: 0 auto; padding: 0 32px; }
+.summary { display: flex; gap: 32px; padding: 32px 0 24px; border-bottom: 1px solid var(--border); flex-wrap: wrap; }
+.summary-score { display: flex; flex-direction: column; align-items: center; }
+.summary-score-value { font-size: 64px; font-weight: 700; line-height: 1; }
+.summary-score-grade { font-size: 24px; font-weight: 600; }
+.summary-stats { display: flex; flex-direction: column; gap: 6px; font-size: 14px; justify-content: center; }
+.summary-stat { color: var(--text-secondary); }
+.summary-signals { font-size: 12px; color: var(--text-secondary); padding-top: 4px; }
+.category-averages { padding: 24px 0; border-bottom: 1px solid var(--border); }
+.category-averages-title { font-size: 18px; font-weight: 600; margin-bottom: 12px; }
+.sitemap-cat-row { display: flex; justify-content: space-between; align-items: center; padding: 6px 0; border-top: 1px solid #f0f0f0; font-size: 13px; }
+.sitemap-cat-name { color: var(--text); }
+.sitemap-cat-score { font-weight: 700; }
+.sitemap-cat-score.pass { color: var(--pass-text); }
+.sitemap-cat-score.average { color: var(--average-text); }
+.sitemap-cat-score.fail { color: var(--fail-text); }
+.url-results { padding: 24px 0; }
+.url-results-title { font-size: 18px; font-weight: 600; margin-bottom: 16px; }
+.sitemap-url-section { border: 1px solid var(--border); border-radius: 8px; margin-bottom: 12px; overflow: hidden; }
+.sitemap-url-section.failed { border-color: #fce8e6; }
+.sitemap-url-header { display: flex; align-items: center; gap: 10px; padding: 12px 16px; background: #fafafa; cursor: pointer; font-size: 13px; }
+.sitemap-url-status { font-size: 14px; flex-shrink: 0; }
+.sitemap-url-label { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-weight: 500; }
+.sitemap-url-score { font-weight: 700; white-space: nowrap; }
+.sitemap-url-grade { font-weight: 700; white-space: nowrap; }
+.sitemap-url-body { padding: 12px 16px; border-top: 1px solid var(--border); }
+.sitemap-url-error { padding: 12px 16px; color: var(--fail-text); font-size: 13px; }
+.sitemap-top-rec { font-size: 12px; color: var(--text-secondary); margin-top: 10px; padding-top: 10px; border-top: 1px solid #f0f0f0; }
+.footer { padding: 16px 0; border-top: 1px solid var(--border); font-size: 11px; color: var(--text-secondary); display: flex; justify-content: space-between; flex-wrap: wrap; gap: 8px; }
+.pass { color: var(--pass-text); }
+.average { color: var(--average-text); }
+.fail { color: var(--fail-text); }
+@media (max-width: 600px) {
+  .report { padding: 0 16px; }
+  .summary { flex-direction: column; gap: 16px; }
+}
+</style>
+</head>
+<body>
+
+<div class="topbar">
+  <span class="topbar-title">AI SEO Sitemap Audit</span>
+  <span class="topbar-url">${escapeHtml(result.sitemapUrl)}</span>
+</div>
+
+<div class="report">
+  <div class="summary">
+    <div class="summary-score">
+      <span class="summary-score-value" style="color:${avgTextColor}">${result.averageScore}</span>
+      <span class="summary-score-grade" style="color:${avgTextColor}">${escapeHtml(result.averageGrade)}</span>
+      <span style="font-size:12px;color:var(--text-secondary);margin-top:4px">Average Score</span>
+    </div>
+    <div class="summary-stats">
+      <div class="summary-stat">Total URLs: <strong>${result.totalUrls}</strong></div>
+      <div class="summary-stat">Audited: <strong style="color:var(--pass-text)">${result.succeededCount}</strong></div>
+      <div class="summary-stat">Failed: <strong style="color:${result.failedCount > 0 ? "var(--fail-text)" : "var(--text-secondary)"}">${result.failedCount}</strong></div>
+      <div class="summary-signals">Domain signals checked at: <code>${escapeHtml(result.signalsBase)}</code></div>
+    </div>
+  </div>
+
+  <div class="category-averages">
+    <div class="category-averages-title">Site-Wide Category Averages</div>
+    ${categoryAvgRows}
+  </div>
+
+  <div class="url-results">
+    <div class="url-results-title">URL Results</div>
+    ${urlSections}
+  </div>
+
+  <div class="footer">
+    <span>Generated by aiseo-audit v${escapeHtml(result.meta.version)}</span>
+    <span>${escapeHtml(result.analyzedAt)} &middot; ${result.meta.analysisDurationMs}ms</span>
+    ${hasHttpUrls ? '<span style="color:#e8a735;margin-top:4px">Note: Some URLs were audited over HTTP. Domain signals (robots.txt, llms.txt) may differ in production.</span>' : ""}
+  </div>
+</div>
+
+</body>
+</html>`;
+}
+
+// src/modules/report/support/json.ts
+function renderJson(result) {
+  const notes = [];
+  if (result.url.startsWith("http://")) {
+    notes.push(
+      "Audited over HTTP. Domain signals (robots.txt, llms.txt) may differ in production."
+    );
+  }
+  const output = notes.length > 0 ? { ...result, notes } : result;
+  return JSON.stringify(output, null, 2);
+}
+function renderSitemapJson(result) {
+  const notes = [];
+  const hasHttpUrls = result.urlResults.some(
+    (r) => r.status === "success" && r.result.url.startsWith("http://")
+  );
+  if (hasHttpUrls) {
+    notes.push(
+      "Some URLs were audited over HTTP. Domain signals (robots.txt, llms.txt) may differ in production."
+    );
+  }
+  const output = notes.length > 0 ? { ...result, notes } : result;
+  return JSON.stringify(output, null, 2);
+}
+
+// src/modules/report/support/markdown.ts
+function renderMarkdown(result) {
+  const lines = [];
+  lines.push(`# AI SEO Audit`);
+  lines.push("");
+  lines.push(`**URL:** ${result.url}`);
+  lines.push("");
+  lines.push(`**Domain signals checked at:** \`${result.signalsBase}\``);
+  lines.push("");
+  lines.push("| Category | Score | Percentage |");
+  lines.push("|----------|-------|------------|");
+  for (const category of Object.values(result.categories)) {
+    const pct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+    lines.push(
+      `| ${category.name} | ${category.score}/${category.maxScore} | ${pct}% |`
+    );
+  }
+  lines.push("");
+  lines.push(
+    `## Overall: ${result.overallScore}/100 (${result.grade}) - ${result.totalPoints}/${result.maxPoints} pts`
+  );
+  lines.push("");
+  for (const category of Object.values(result.categories)) {
+    const pct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+    lines.push(`### ${category.name} (${pct}%)`);
+    lines.push("");
+    lines.push("| Factor | Score | Status | Details |");
+    lines.push("|--------|-------|--------|---------|");
+    for (const factor of category.factors) {
+      const statusIcon2 = factor.status === "good" ? "pass" : factor.status === "neutral" ? "-" : factor.status === "needs_improvement" ? "warn" : "fail";
+      lines.push(
+        `| ${factor.name} | ${factor.score}/${factor.maxScore} | ${statusIcon2} | ${factor.value} |`
+      );
+    }
+    lines.push("");
+  }
+  if (result.recommendations.length > 0) {
+    lines.push("## Recommendations");
+    lines.push("");
+    const categoryNames = Object.values(result.categories).map((c) => c.name);
+    for (const categoryName of categoryNames) {
+      const categoryRecs = result.recommendations.filter(
+        (r) => r.category === categoryName
+      );
+      if (categoryRecs.length === 0) continue;
+      lines.push(`### ${categoryName}`);
+      lines.push("");
+      for (const rec of categoryRecs) {
+        const tag = rec.priority === "high" ? "**HIGH**" : rec.priority === "medium" ? "*MED*" : "LOW";
+        lines.push(`- [${tag}] **${rec.factor}**: ${rec.recommendation}`);
+        if (rec.steps && rec.steps.length > 0) {
+          rec.steps.forEach((step, idx) => {
+            lines.push(`  ${idx + 1}. ${step}`);
+          });
+        }
+        if (rec.codeExample) {
+          lines.push("");
+          lines.push("  ```");
+          rec.codeExample.split("\n").forEach((line) => {
+            lines.push(`  ${line}`);
+          });
+          lines.push("  ```");
+        }
+        if (rec.learnMoreUrl) {
+          lines.push("");
+          lines.push(`  [Learn more](${rec.learnMoreUrl})`);
+        }
+        if (rec.steps || rec.codeExample || rec.learnMoreUrl) {
+          lines.push("");
+        }
+      }
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push(
+    `*Generated by aiseo-audit v${result.meta.version} | ${result.analyzedAt} | ${result.meta.analysisDurationMs}ms*`
+  );
+  if (result.url.startsWith("http://")) {
+    lines.push("");
+    lines.push(
+      "> **Note:** Audited over HTTP. Domain signals (robots.txt, llms.txt) may differ in production."
+    );
+  }
+  return lines.join("\n");
+}
+function renderSitemapMarkdown(result) {
+  const lines = [];
+  lines.push("# AI SEO Sitemap Audit Report");
+  lines.push("");
+  lines.push(`**Sitemap:** ${result.sitemapUrl}`);
+  lines.push(`**Domain signals checked at:** \`${result.signalsBase}\``);
+  lines.push(`**Analyzed at:** ${result.analyzedAt}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Average Score | ${result.averageScore}/100 |`);
+  lines.push(`| Average Grade | ${result.averageGrade} |`);
+  lines.push(`| Total URLs | ${result.totalUrls} |`);
+  lines.push(`| Succeeded | ${result.succeededCount} |`);
+  lines.push(`| Failed | ${result.failedCount} |`);
+  lines.push("");
+  if (Object.keys(result.categoryAverages).length > 0) {
+    lines.push("## Site-Wide Category Averages");
+    lines.push("");
+    lines.push("| Category | Average Score |");
+    lines.push("|----------|---------------|");
+    for (const avg of Object.values(result.categoryAverages)) {
+      lines.push(`| ${avg.name} | ${avg.averagePct}% |`);
+    }
+    lines.push("");
+  }
+  lines.push("## URL Results");
+  lines.push("");
+  for (const urlResult of result.urlResults) {
+    if (urlResult.status === "failed") {
+      lines.push(`### \u274C ${urlResult.url}`);
+      lines.push("");
+      lines.push(`**Error:** ${urlResult.error}`);
+      lines.push("");
+      continue;
+    }
+    const { result: r } = urlResult;
+    lines.push(`### ${r.url}`);
+    lines.push("");
+    lines.push(
+      `**Score:** ${r.overallScore}/100 | **Grade:** ${r.grade} | **Points:** ${r.totalPoints}/${r.maxPoints}`
+    );
+    lines.push("");
+    lines.push("| Category | Score | Percentage |");
+    lines.push("|----------|-------|------------|");
+    for (const category of Object.values(r.categories)) {
+      const pct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+      lines.push(
+        `| ${category.name} | ${category.score}/${category.maxScore} | ${pct}% |`
+      );
+    }
+    lines.push("");
+    if (r.recommendations.length > 0) {
+      lines.push("**Recommendations:**");
+      lines.push("");
+      for (const rec of r.recommendations) {
+        const tag = rec.priority === "high" ? "**HIGH**" : rec.priority === "medium" ? "*MED*" : "LOW";
+        lines.push(`- [${tag}] **${rec.factor}**: ${rec.recommendation}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push(
+    `*Generated by aiseo-audit v${result.meta.version} | ${result.analyzedAt} | ${result.meta.analysisDurationMs}ms*`
+  );
+  const hasHttpUrls = result.urlResults.some(
+    (r) => r.status === "success" && r.result.url.startsWith("http://")
+  );
+  if (hasHttpUrls) {
+    lines.push("");
+    lines.push(
+      "> **Note:** Some URLs were audited over HTTP. Domain signals (robots.txt, llms.txt) may differ in production."
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/modules/report/support/pretty.ts
+import chalk from "chalk";
+function scoreColor(score, max) {
+  const pct = max > 0 ? score / max * 100 : 0;
+  if (pct >= 90) return chalk.green;
+  if (pct >= 50) return chalk.yellow;
+  return chalk.red;
+}
+function gradeColor(grade) {
+  if (grade.startsWith("A")) return chalk.green;
+  if (grade.startsWith("B") || grade.startsWith("C")) return chalk.yellow;
+  return chalk.red;
+}
+function pad(str, len) {
+  return str + " ".repeat(Math.max(0, len - str.length));
+}
+function dots(len) {
+  return chalk.dim(".".repeat(len));
+}
+function renderDomainSignalsBlock(lines, signalsBase, rawData) {
+  const robotsFound = rawData.crawlerAccess !== void 0;
+  const llmsFound = rawData.llmsTxt?.llmsTxtExists ?? false;
+  const llmsFullFound = rawData.llmsTxt?.llmsFullTxtExists ?? false;
+  lines.push(chalk.dim(`  Domain signals checked at: ${signalsBase}`));
+  lines.push(
+    chalk.dim(
+      `    robots.txt ........ ${robotsFound ? chalk.green("found") : chalk.red("not found")}`
+    )
+  );
+  lines.push(
+    chalk.dim(
+      `    llms.txt .......... ${llmsFound ? chalk.green("found") : chalk.red("not found")}`
+    )
+  );
+  lines.push(
+    chalk.dim(
+      `    llms-full.txt ..... ${llmsFullFound ? chalk.green("found") : chalk.red("not found")}`
+    )
+  );
+}
+function renderPretty(result) {
+  const lines = [];
+  const width = 60;
+  const divider = chalk.dim("=".repeat(width));
+  const thinDivider = chalk.dim("-".repeat(width));
+  lines.push("");
+  lines.push(divider);
+  lines.push(chalk.bold("  AI SEO Audit Report"));
+  lines.push(chalk.dim(`  ${result.url}`));
+  lines.push(divider);
+  lines.push("");
+  const overallScoreColor = scoreColor(result.overallScore, 100);
+  const overallGradeColor = gradeColor(result.grade);
+  lines.push(
+    `  Overall Score: ${overallScoreColor(`${result.overallScore}/100`)}  Grade: ${overallGradeColor(result.grade)}`
+  );
+  lines.push(chalk.dim(`  Points: ${result.totalPoints}/${result.maxPoints}`));
+  lines.push("");
+  renderDomainSignalsBlock(lines, result.signalsBase, result.rawData);
+  lines.push("");
+  lines.push(thinDivider);
+  for (const category of Object.values(result.categories)) {
+    const catColor = scoreColor(category.score, category.maxScore);
+    const catPct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+    const catName = pad(category.name, 38);
+    const catDots = dots(Math.max(2, 40 - category.name.length));
+    lines.push("");
+    lines.push(
+      `  ${chalk.bold(catName)} ${catDots} ${catColor(`${category.score}/${category.maxScore}`)} ${chalk.dim(`(${catPct}%)`)}`
+    );
+    for (const factor of category.factors) {
+      const fColor = scoreColor(factor.score, factor.maxScore);
+      const fName = pad(`  ${factor.name}`, 40);
+      const fDots = dots(Math.max(2, 42 - factor.name.length));
+      lines.push(
+        `  ${chalk.dim(fName)} ${fDots} ${fColor(`${factor.score}/${factor.maxScore}`)} ${chalk.dim(factor.value)}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(thinDivider);
+  if (result.recommendations.length > 0) {
+    lines.push("");
+    lines.push(chalk.bold("  Recommendations:"));
+    lines.push("");
+    for (let i = 0; i < result.recommendations.length; i++) {
+      const rec = result.recommendations[i];
+      const tag = rec.priority === "high" ? chalk.red(`[HIGH]`) : rec.priority === "medium" ? chalk.yellow(`[MED] `) : chalk.dim(`[LOW] `);
+      lines.push(`  ${i + 1}. ${tag} ${chalk.bold(rec.factor)}`);
+      lines.push(`     ${chalk.dim(rec.recommendation)}`);
+      if (rec.steps && rec.steps.length > 0) {
+        lines.push("");
+        lines.push(`     ${chalk.dim("Steps:")}`);
+        rec.steps.forEach((step, idx) => {
+          lines.push(`       ${chalk.dim(`${idx + 1}. ${step}`)}`);
+        });
+      }
+      if (rec.codeExample) {
+        lines.push("");
+        lines.push(`     ${chalk.dim("Example:")}`);
+        lines.push(`     ${chalk.dim("\u250C" + "\u2500".repeat(50))}`);
+        rec.codeExample.split("\n").forEach((line) => {
+          lines.push(`     ${chalk.dim("\u2502")} ${chalk.dim(line)}`);
+        });
+        lines.push(`     ${chalk.dim("\u2514" + "\u2500".repeat(50))}`);
+      }
+      if (rec.learnMoreUrl) {
+        lines.push("");
+        lines.push(`     ${chalk.dim(`Learn more: ${rec.learnMoreUrl}`)}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push(divider);
+  lines.push(chalk.dim(`  Analyzed at: ${result.analyzedAt}`));
+  lines.push(chalk.dim(`  Duration: ${result.meta.analysisDurationMs}ms`));
+  if (result.url.startsWith("http://")) {
+    lines.push(
+      chalk.yellow(
+        "  Note: Audited over HTTP. Domain signals (robots.txt, llms.txt) may differ in production."
+      )
+    );
+  }
+  lines.push(divider);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderSitemapPretty(result) {
+  const lines = [];
+  const width = 60;
+  const divider = chalk.dim("=".repeat(width));
+  const thinDivider = chalk.dim("-".repeat(width));
+  lines.push("");
+  lines.push(divider);
+  lines.push(chalk.bold("  AI SEO Sitemap Audit Report"));
+  lines.push(chalk.dim(`  ${result.sitemapUrl}`));
+  lines.push(divider);
+  lines.push("");
+  const averageScoreColor = scoreColor(result.averageScore, 100);
+  const averageGradeColor = gradeColor(result.averageGrade);
+  lines.push(
+    `  Average Score: ${averageScoreColor(`${result.averageScore}/100`)}  Grade: ${averageGradeColor(result.averageGrade)}`
+  );
+  lines.push(
+    chalk.dim(
+      `  URLs: ${result.succeededCount} audited, ${result.failedCount} failed, ${result.totalUrls} total`
+    )
+  );
+  lines.push("");
+  lines.push(chalk.dim(`  Domain signals checked at: ${result.signalsBase}`));
+  lines.push("");
+  lines.push(thinDivider);
+  if (Object.keys(result.categoryAverages).length > 0) {
+    lines.push("");
+    lines.push(chalk.bold("  Site-Wide Category Averages:"));
+    lines.push("");
+    for (const avg of Object.values(result.categoryAverages)) {
+      const color = scoreColor(avg.averagePct, 100);
+      const name = pad(avg.name, 38);
+      const dts = dots(Math.max(2, 40 - avg.name.length));
+      lines.push(`  ${chalk.bold(name)} ${dts} ${color(`${avg.averagePct}%`)}`);
+    }
+    lines.push("");
+    lines.push(thinDivider);
+  }
+  lines.push("");
+  lines.push(chalk.bold("  URL Results:"));
+  lines.push("");
+  for (const urlResult of result.urlResults) {
+    if (urlResult.status === "failed") {
+      lines.push(`  ${chalk.red("\u2717")} ${chalk.dim(urlResult.url)}`);
+      lines.push(`    ${chalk.red(`Error: ${urlResult.error}`)}`);
+      lines.push("");
+      continue;
+    }
+    const { result: r } = urlResult;
+    const urlScoreColor = scoreColor(r.overallScore, 100);
+    const urlGradeColor = gradeColor(r.grade);
+    const topRec = r.recommendations[0];
+    lines.push(`  ${chalk.green("\u2713")} ${chalk.dim(r.url)}`);
+    lines.push(
+      `    Score: ${urlScoreColor(`${r.overallScore}/100`)}  Grade: ${urlGradeColor(r.grade)}`
+    );
+    if (topRec) {
+      lines.push(
+        `    ${chalk.dim(`Top rec: ${topRec.factor} \u2014 ${topRec.recommendation}`)}`
+      );
+    }
+    lines.push("");
+  }
+  lines.push(divider);
+  lines.push(chalk.dim(`  Analyzed at: ${result.analyzedAt}`));
+  lines.push(chalk.dim(`  Duration: ${result.meta.analysisDurationMs}ms`));
+  const hasHttpUrls = result.urlResults.some(
+    (r) => r.status === "success" && r.result.url.startsWith("http://")
+  );
+  if (hasHttpUrls) {
+    lines.push(
+      chalk.yellow(
+        "  Note: Some URLs were audited over HTTP. Domain signals (robots.txt, llms.txt) may differ in production."
+      )
+    );
+  }
+  lines.push(divider);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/modules/report/service.ts
+function renderReport(result, options) {
+  switch (options.format) {
+    case "json":
+      return renderJson(result);
+    case "md":
+      return renderMarkdown(result);
+    case "html":
+      return renderHtml(result);
+    case "pretty":
+    default:
+      return renderPretty(result);
+  }
+}
+function renderSitemapReport(result, options) {
+  switch (options.format) {
+    case "json":
+      return renderSitemapJson(result);
+    case "md":
+      return renderSitemapMarkdown(result);
+    case "html":
+      return renderSitemapHtml(result);
+    case "pretty":
+    default:
+      return renderSitemapPretty(result);
+  }
+}
+
+// src/modules/sitemap/service.ts
+import { scaffold } from "xml-to-html-converter";
+function stripCdata(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("<![CDATA[") && trimmed.endsWith("]]>")) {
+    return trimmed.slice(9, -3);
+  }
+  return trimmed;
+}
+function collectLocText(nodes, urls) {
+  for (const node of nodes) {
+    if (node.xmlTag === "loc" && node.children) {
+      const text = node.children.filter((c) => c.role === "textLeaf").map((c) => stripCdata(c.raw)).join("").trim();
+      if (text) urls.push(text);
+    }
+    if (node.children) collectLocText(node.children, urls);
+  }
+}
+function extractLocUrls(xml) {
+  const nodes = scaffold(xml);
+  const urls = [];
+  collectLocText(nodes, urls);
+  return urls;
+}
+function hasSitemapIndexNode(nodes) {
+  for (const node of nodes) {
+    if (node.xmlTag === "sitemapindex") return true;
+    if (node.children && hasSitemapIndexNode(node.children)) return true;
+  }
+  return false;
+}
+async function fetchSitemapUrls(sitemapUrl, timeout, userAgent) {
+  const response = await httpGet({
+    url: sitemapUrl,
+    timeout,
+    userAgent
+  });
+  if (response.status !== 200) {
+    throw new Error(`Failed to fetch sitemap: HTTP ${response.status}`);
+  }
+  const nodes = scaffold(response.data);
+  if (hasSitemapIndexNode(nodes)) {
+    return fetchSitemapIndexUrls(response.data, timeout, userAgent);
+  }
+  const urls = [];
+  collectLocText(nodes, urls);
+  return urls;
+}
+async function fetchSitemapIndexUrls(xml, timeout, userAgent) {
+  const childSitemapUrls = extractLocUrls(xml);
+  const allUrls = [];
+  for (const childUrl of childSitemapUrls) {
+    const response = await httpGet({
+      url: childUrl,
+      timeout,
+      userAgent
+    });
+    if (response.status === 200) {
+      allUrls.push(...extractLocUrls(response.data));
+    }
+  }
+  return allUrls;
+}
+function computeCategoryAverages(urlResults) {
+  const successResults = urlResults.filter((r) => r.status === "success").map(
+    (r) => r.result
+  );
+  if (successResults.length === 0) return {};
+  const categoryTotals = {};
+  for (const result of successResults) {
+    for (const [key, category] of Object.entries(result.categories)) {
+      const pct = category.maxScore > 0 ? category.score / category.maxScore * 100 : 0;
+      if (!categoryTotals[key]) {
+        categoryTotals[key] = { name: category.name, totalPct: 0, count: 0 };
+      }
+      categoryTotals[key].totalPct += pct;
+      categoryTotals[key].count += 1;
+    }
+  }
+  const averages = {};
+  for (const [key, totals] of Object.entries(categoryTotals)) {
+    averages[key] = {
+      name: totals.name,
+      averagePct: Math.round(totals.totalPct / totals.count)
+    };
+  }
+  return averages;
+}
+async function analyzeSitemap(options, config) {
+  const startTime = Date.now();
+  const timeout = options.timeout ?? config.timeout;
+  const userAgent = options.userAgent ?? config.userAgent;
+  const urls = await fetchSitemapUrls(options.sitemapUrl, timeout, userAgent);
+  const sitemapDir = options.sitemapUrl.substring(
+    0,
+    options.sitemapUrl.lastIndexOf("/")
+  );
+  const signalsBase = options.signalsBase ?? sitemapDir;
+  const domainSignals = await fetchDomainSignals(
+    signalsBase,
+    timeout,
+    userAgent
+  );
+  const urlResults = [];
+  for (const rawUrl of urls) {
+    const url = normalizeUrl(rawUrl);
+    try {
+      const fetchResult = await fetchUrl({ url, timeout, userAgent });
+      const result = await analyzeUrlWithSignals(
+        url,
+        fetchResult,
+        domainSignals,
+        config
+      );
+      urlResults.push({ status: "success", result });
+    } catch (error) {
+      urlResults.push({
+        status: "failed",
+        url,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const successResults = urlResults.filter((r) => r.status === "success").map(
+    (r) => r.result
+  );
+  const succeededCount = successResults.length;
+  const failedCount = urlResults.length - succeededCount;
+  const averageScore = succeededCount > 0 ? Math.round(
+    successResults.reduce((sum, r) => sum + r.overallScore, 0) / succeededCount
+  ) : 0;
+  const averageGrade = computeGrade(averageScore);
+  const categoryAverages = computeCategoryAverages(urlResults);
+  return {
+    sitemapUrl: options.sitemapUrl,
+    signalsBase: domainSignals.signalsBase,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalUrls: urlResults.length,
+    succeededCount,
+    failedCount,
+    averageScore,
+    averageGrade,
+    categoryAverages,
+    urlResults,
+    meta: {
+      version: VERSION,
+      analysisDurationMs: Date.now() - startTime
+    }
+  };
+}
+
+export {
+  VERSION,
+  FetchError,
+  isValidUrl,
+  analyzeUrl,
+  writeOutputFile,
+  loadConfig,
+  renderReport,
+  renderSitemapReport,
+  analyzeSitemap
+};
+//# sourceMappingURL=chunk-2BXVAEAS.mjs.map