aeorank 1.3.0 → 1.5.0

package/README.md

@@ -24,6 +24,8 @@ npx aeorank example.com --summary       # Human-readable scorecard
 npx aeorank example.com --html          # Standalone HTML report
 npx aeorank example.com --ci --threshold 80  # CI gate
 npx aeorank site-a.com site-b.com       # Side-by-side comparison
+npx aeorank example.com --full-crawl    # Crawl all discoverable pages
+npx aeorank example.com --full-crawl --max-pages 50  # Limit to 50 pages
 ```
 
 ### Programmatic
@@ -84,6 +86,9 @@ Options:
   --threshold <N>     Score threshold for --ci (default: 70)
   --no-headless       Skip Puppeteer SPA rendering
   --no-multi-page     Skip extra page discovery (faster)
+  --full-crawl        BFS crawl all discoverable pages
+  --max-pages <N>     Max pages for --full-crawl (default: 200)
+  --concurrency <N>   Parallel fetches for --full-crawl (default: 5)
   --version           Print version
   --help              Show help
 ```
@@ -114,13 +119,13 @@ Or use `npx` directly:
 Run a complete audit. Returns `AuditResult` with:
 
 - `overallScore` - 0-100 weighted score
-- `scorecard` - 23 `ScoreCardItem` entries (criterion, score 0-10, status, key findings)
+- `scorecard` - 26 `ScoreCardItem` entries (criterion, score 0-10, status, key findings)
 - `detailedFindings` - Per-criterion findings with severity
 - `opportunities` - Prioritized improvements with effort/impact
 - `pitchNumbers` - Key metrics (schema types, AI crawler access, etc.)
 - `verdict` - Human-readable summary paragraph
 - `bottomLine` - Actionable recommendation
-- `pagesReviewed` - Per-page analysis with issues and strengths
+- `pagesReviewed` - Per-page analysis with issues, strengths, and AEO score (0-100)
 - `elapsed` - Wall-clock seconds
 
 **Options:**
@@ -130,6 +135,20 @@ Run a complete audit. Returns `AuditResult` with:
 | `noHeadless` | `boolean` | `false` | Skip Puppeteer SPA rendering |
 | `noMultiPage` | `boolean` | `false` | Homepage + blog only |
 | `timeout` | `number` | `15000` | Fetch timeout in ms |
+| `fullCrawl` | `boolean` | `false` | BFS crawl all discoverable pages |
+| `maxPages` | `number` | `200` | Max pages for full crawl |
+| `concurrency` | `number` | `5` | Parallel fetches for full crawl |
+
+### `scorePage(html, url?)`
+
+Score a single HTML page against 14 per-page AEO criteria. Returns `PageScoreResult` with:
+
+- `aeoScore` - 0-100 weighted score
+- `criterionScores` - 14 `PageCriterionScore` entries (criterion, score 0-10, weight)
+
+### `scoreAllPages(siteData)`
+
+Batch-score all pages (homepage + blogSample) from a `SiteData` object. Returns `PageScoreResult[]`.
 
 ### Advanced API
 
@@ -144,6 +163,8 @@ import {
   buildDetailedFindings,
   generateVerdict,
   generateOpportunities,
+  scorePage,
+  scoreAllPages,
   isSpaShell,
   fetchWithHeadless,
 } from 'aeorank';
@@ -165,6 +186,78 @@ npm install puppeteer
 
 Use `--no-headless` to skip SPA rendering (faster but may produce lower scores for SPAs).
 
+## Full-Site Crawl
+
+By default, AEORank audits the homepage plus ~20 discovered pages. For deeper analysis, enable `--full-crawl` to BFS-crawl every discoverable page:
+
+```bash
+npx aeorank example.com --full-crawl                    # Up to 200 pages
+npx aeorank example.com --full-crawl --max-pages 50     # Limit to 50
+npx aeorank example.com --full-crawl --concurrency 10   # 10 parallel fetches
+```
+
+The crawler seeds from sitemap URLs and homepage links, then follows internal links on each fetched page. It respects `robots.txt` Disallow rules, skips resource files, and tags each page with a category (blog, about, pricing, services, docs, faq, etc.).
+
+Programmatic usage:
+
+```ts
+import { audit } from 'aeorank';
+
+const result = await audit('example.com', {
+  fullCrawl: true,
+  maxPages: 100,
+  concurrency: 5,
+});
+```
+
+Or use the crawler directly:
+
+```ts
+import { crawlFullSite, prefetchSiteData } from 'aeorank';
+
+const siteData = await prefetchSiteData('example.com');
+const crawlResult = await crawlFullSite(siteData, { maxPages: 200 });
+console.log(crawlResult.pages.length);         // Pages fetched
+console.log(crawlResult.discoveredUrls.length); // Total URLs found
+```
+
+## Per-Page Scoring
+
+AEORank scores each individual page (0-100) against the 14 criteria that apply at page level. Instead of only seeing "your site scores 62," you get "your /about page scores 45, your /blog/guide scores 78."
+
+The 14 per-page criteria: Schema.org Structured Data, Q&A Content Format, Clean Crawlable HTML, FAQ Section Content, Original Data & Expert Content, Query-Answer Alignment, Content Freshness Signals, Table & List Extractability, Direct Answer Paragraphs, Semantic HTML5 & Accessibility, Fact & Data Density, Definition Patterns, Canonical URL Strategy, Visible Date Signal.
+
+The remaining 12 criteria (llms.txt, robots.txt, sitemap, RSS, entity consistency, internal linking, content licensing, author schema, content velocity, schema coverage, speakable schema, content cannibalization) are site-level only.
+
+### CLI Output
+
+Per-page scores appear in the pages section:
+
+```
+Pages reviewed (47):
+  Homepage  https://example.com                      0 issues [AEO: 72]
+  Blog      https://example.com/blog/post            2 issues [AEO: 58]
+
+  Average page AEO score: 62/100
+  Top:    /blog/medicare-walkers-guide (92)
+  Bottom: /thank-you (23)
+```
+
+### Programmatic API
+
+```ts
+import { scorePage, scoreAllPages } from 'aeorank';
+import type { PageScoreResult, PageCriterionScore } from 'aeorank';
+
+// Score a single page
+const result = scorePage(html, url);
+console.log(result.aeoScore);         // 0-100
+console.log(result.criterionScores);  // 14 per-criterion scores
+
+// Score all pages from site data
+const allScores = scoreAllPages(siteData);
+```
+
 ## Scoring
 
 Each criterion is scored 0-10 by deterministic checks (regex, HTML parsing, HTTP headers). The overall score is a weighted average normalized to 0-100.
@@ -223,7 +316,7 @@ console.log(result.comparison.tied);              // Criteria with equal scores
 
 ## Benchmark Dataset
 
-The `data/` directory contains the largest open dataset of AI visibility scores - **13,619 domains** scored across 23 criteria, including **4,328 Y Combinator startups** across 48 batches (W06-W26):
+The `data/` directory contains the largest open dataset of AI visibility scores - **13,619 domains** scored across 26 criteria, including **4,328 Y Combinator startups** across 48 batches (W06-W26):
 
 | File | Contents |
 |------|----------|

package/dist/chunk-3IJISYWT.js

@@ -0,0 +1,291 @@
+// src/full-site-crawler.ts
+var RESOURCE_EXTENSIONS = /\.(js|css|png|jpg|jpeg|gif|svg|ico|pdf|xml|txt|woff|woff2|ttf|eot|mp4|mp3|webp|avif|zip|gz|tar|json)$/i;
+var SKIP_PATH_PATTERNS = /^\/(api|wp-admin|wp-json|static|assets|_next|auth|login|signup|cart|checkout|admin|feed|xmlrpc)\b/i;
+function parseRobotsTxt(robotsText) {
+  const lines = robotsText.split("\n");
+  const rules = { disallow: [], allow: [] };
+  let inRelevantSection = false;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const uaMatch = line.match(/^user-agent:\s*(.+)/i);
+    if (uaMatch) {
+      const agent = uaMatch[1].trim().toLowerCase();
+      inRelevantSection = agent === "*" || agent === "aeo-visibility-bot";
+      continue;
+    }
+    if (!inRelevantSection) continue;
+    const disallowMatch = line.match(/^disallow:\s*(.*)/i);
+    if (disallowMatch) {
+      const path = disallowMatch[1].trim();
+      if (path) rules.disallow.push(path);
+      continue;
+    }
+    const allowMatch = line.match(/^allow:\s*(.*)/i);
+    if (allowMatch) {
+      const path = allowMatch[1].trim();
+      if (path) rules.allow.push(path);
+    }
+  }
+  return rules;
+}
+function isDisallowedByRobots(urlPath, rules) {
+  let longestAllow = 0;
+  let longestDisallow = 0;
+  for (const pattern of rules.allow) {
+    if (urlPath.startsWith(pattern) && pattern.length > longestAllow) {
+      longestAllow = pattern.length;
+    }
+  }
+  for (const pattern of rules.disallow) {
+    if (urlPath.startsWith(pattern) && pattern.length > longestDisallow) {
+      longestDisallow = pattern.length;
+    }
+  }
+  if (longestAllow === 0 && longestDisallow === 0) return false;
+  return longestDisallow > longestAllow;
+}
+async function fetchPage(url, timeoutMs = 1e4) {
+  try {
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { "User-Agent": "AEO-Visibility-Bot/1.0" },
+      redirect: "follow"
+    });
+    if (res.status !== 200) return null;
+    const text = await res.text();
+    if (text.length < 200) return null;
+    return { text: text.slice(0, 5e5), status: res.status, finalUrl: res.url };
+  } catch {
+    return null;
+  }
+}
+async function fetchSitemapXml(url, timeoutMs = 1e4) {
+  try {
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { "User-Agent": "AEO-Visibility-Bot/1.0" },
+      redirect: "follow"
+    });
+    if (res.status !== 200) return null;
+    return await res.text();
+  } catch {
+    return null;
+  }
+}
+async function extractAllUrlsFromSitemap(sitemapText, domain, timeoutMs = 1e4) {
+  const cleanDomain = domain.replace(/^www\./, "").toLowerCase();
+  const urls = /* @__PURE__ */ new Set();
+  const subSitemapLocs = sitemapText.match(/<sitemap>[\s\S]*?<loc>([^<]+)<\/loc>[\s\S]*?<\/sitemap>/gi) || [];
+  if (subSitemapLocs.length > 0) {
+    const subUrls = [];
+    for (const block of subSitemapLocs) {
+      const locMatch = block.match(/<loc>([^<]+)<\/loc>/i);
+      if (locMatch) subUrls.push(locMatch[1].trim());
+    }
+    const fetches = subUrls.slice(0, 10).map((u) => fetchSitemapXml(u, timeoutMs));
+    const results = await Promise.all(fetches);
+    for (const text of results) {
+      if (text) {
+        extractLocsFromXml(text, cleanDomain, urls);
+      }
+    }
+  }
+  extractLocsFromXml(sitemapText, cleanDomain, urls);
+  return Array.from(urls);
+}
+function extractLocsFromXml(xml, cleanDomain, urls) {
+  const locMatches = xml.match(/<url>[\s\S]*?<loc>([^<]+)<\/loc>[\s\S]*?<\/url>/gi) || [];
+  for (const block of locMatches) {
+    const locMatch = block.match(/<loc>([^<]+)<\/loc>/i);
+    if (!locMatch) continue;
+    const url = locMatch[1].trim();
+    try {
+      const parsed = new URL(url);
+      const urlDomain = parsed.hostname.replace(/^www\./, "").toLowerCase();
+      if (urlDomain !== cleanDomain) continue;
+      if (RESOURCE_EXTENSIONS.test(parsed.pathname)) continue;
+      urls.add(url);
+    } catch {
+      continue;
+    }
+  }
+}
+function extractInternalLinks(html, domain) {
+  const cleanDomain = domain.replace(/^www\./, "").toLowerCase();
+  const hrefMatches = html.match(/href="([^"]*)"/gi) || [];
+  const urls = /* @__PURE__ */ new Set();
+  for (const match of hrefMatches) {
+    const href = match.match(/href="([^"]*)"/i)?.[1];
+    if (!href || !href.trim()) continue;
+    let fullUrl;
+    if (href.startsWith("//")) {
+      fullUrl = `https:${href}`;
+    } else if (href.startsWith("/")) {
+      if (href === "/" || href.startsWith("/#")) continue;
+      fullUrl = `https://${domain}${href}`;
+    } else if (href.startsWith("http")) {
+      fullUrl = href;
+    } else if (href.startsWith("#") || href.startsWith("?") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("javascript:")) {
+      continue;
+    } else {
+      fullUrl = `https://${domain}/${href}`;
+    }
+    try {
+      const parsed = new URL(fullUrl);
+      const linkDomain = parsed.hostname.replace(/^www\./, "").toLowerCase();
+      if (linkDomain !== cleanDomain) continue;
+      parsed.hash = "";
+      const path = parsed.pathname;
+      if (path === "/" || path === "") continue;
+      if (RESOURCE_EXTENSIONS.test(path)) continue;
+      if (SKIP_PATH_PATTERNS.test(path)) continue;
+      const normalized = parsed.origin + path.replace(/\/+$/, "") + parsed.search;
+      urls.add(normalized);
+    } catch {
+      continue;
+    }
+  }
+  return Array.from(urls);
+}
+var CATEGORY_PATTERNS = [
+  [/\/(blog|articles?|posts?|news|insights|guides)\b/i, "blog"],
+  [/\/(about|about-us|company|who-we-are)\b/i, "about"],
+  [/\/(pricing|plans|packages)\b/i, "pricing"],
+  [/\/(services?|features?|solutions?|products?|what-we-do|offerings?)\b/i, "services"],
+  [/\/(contact|contact-us|get-in-touch)\b/i, "contact"],
+  [/\/(team|our-team|authors?|people|leadership|staff)\b/i, "team"],
+  [/\/(resources?|resource-center|library|downloads?)\b/i, "resources"],
+  [/\/(docs?|documentation|help|help-center|support|knowledge-base)\b/i, "docs"],
+  [/\/(case-stud\w*|cases|customers?|success-stor\w*|testimonials?)\b/i, "cases"],
+  [/\/(faq|frequently-asked|questions)\b/i, "faq"]
+];
+function inferCategory(url) {
+  try {
+    const path = new URL(url).pathname;
+    for (const [pattern, category] of CATEGORY_PATTERNS) {
+      if (pattern.test(path)) return category;
+    }
+  } catch {
+  }
+  return "content";
+}
+async function crawlFullSite(siteData, options) {
+  const startTime = Date.now();
+  const maxPages = options?.maxPages ?? 200;
+  const timeoutMs = options?.timeoutMs ?? 1e4;
+  const concurrency = options?.concurrency ?? 5;
+  const respectRobots = options?.respectRobots ?? true;
+  const pages = [];
+  const discoveredUrls = /* @__PURE__ */ new Set();
+  const fetchedUrls = /* @__PURE__ */ new Set();
+  const skippedUrls = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  let robotsRules = { disallow: [], allow: [] };
+  if (respectRobots && siteData.robotsTxt?.text) {
+    robotsRules = parseRobotsTxt(siteData.robotsTxt.text);
+  }
+  const baseUrl = `${siteData.protocol}://${siteData.domain}`;
+  visited.add(normalizeUrl(baseUrl));
+  visited.add(normalizeUrl(baseUrl + "/"));
+  if (siteData.blogSample) {
+    for (const page of siteData.blogSample) {
+      if (page.finalUrl) visited.add(normalizeUrl(page.finalUrl));
+    }
+  }
+  const queue = [];
+  if (siteData.sitemapXml?.text) {
+    const sitemapUrls = await extractAllUrlsFromSitemap(
+      siteData.sitemapXml.text,
+      siteData.domain,
+      timeoutMs
+    );
+    for (const url of sitemapUrls) {
+      const norm = normalizeUrl(url);
+      if (!visited.has(norm)) {
+        discoveredUrls.add(url);
+        if (!queue.includes(url)) queue.push(url);
+      }
+    }
+  }
+  if (siteData.homepage?.text) {
+    const homeLinks = extractInternalLinks(siteData.homepage.text, siteData.domain);
+    for (const url of homeLinks) {
+      const norm = normalizeUrl(url);
+      if (!visited.has(norm) && !discoveredUrls.has(url)) {
+        discoveredUrls.add(url);
+        if (!queue.includes(url)) queue.push(url);
+      }
+    }
+  }
+  while (queue.length > 0 && fetchedUrls.size < maxPages) {
+    const batchSize = Math.min(concurrency, maxPages - fetchedUrls.size, queue.length);
+    const batch = [];
+    while (batch.length < batchSize && queue.length > 0) {
+      const url = queue.shift();
+      const norm = normalizeUrl(url);
+      if (visited.has(norm)) continue;
+      visited.add(norm);
+      if (respectRobots) {
+        try {
+          const path = new URL(url).pathname;
+          if (isDisallowedByRobots(path, robotsRules)) {
+            skippedUrls.add(url);
+            continue;
+          }
+        } catch {
+          continue;
+        }
+      }
+      batch.push(url);
+    }
+    if (batch.length === 0) continue;
+    const results = await Promise.all(batch.map((url) => fetchPage(url, timeoutMs)));
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const url = batch[i];
+      fetchedUrls.add(url);
+      if (!result) continue;
+      result.category = inferCategory(url);
+      pages.push(result);
+      const newLinks = extractInternalLinks(result.text, siteData.domain);
+      for (const link of newLinks) {
+        const norm = normalizeUrl(link);
+        if (!visited.has(norm) && !discoveredUrls.has(link)) {
+          discoveredUrls.add(link);
+          queue.push(link);
+        }
+      }
+    }
+  }
+  for (const url of queue) {
+    if (!fetchedUrls.has(url)) {
+      skippedUrls.add(url);
+    }
+  }
+  return {
+    pages,
+    discoveredUrls: Array.from(discoveredUrls),
+    fetchedUrls: Array.from(fetchedUrls),
+    skippedUrls: Array.from(skippedUrls),
+    elapsed: Math.round((Date.now() - startTime) / 100) / 10
+  };
+}
+function normalizeUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return (parsed.origin + parsed.pathname.replace(/\/+$/, "") + parsed.search).toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+}
+
+export {
+  parseRobotsTxt,
+  isDisallowedByRobots,
+  extractAllUrlsFromSitemap,
+  extractInternalLinks,
+  inferCategory,
+  crawlFullSite
+};
+//# sourceMappingURL=chunk-3IJISYWT.js.map

package/dist/chunk-3IJISYWT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/full-site-crawler.ts"],"sourcesContent":["/**\n * Full-site crawler for deep AEO audits.\n * BFS crawl that discovers all internal pages up to a configurable limit.\n */\n\nimport type { FetchResult, SiteData, PageCategory } from './site-crawler.js';\n\n// ─── Types ──────────────────────────────────────────────────────────────────\n\nexport interface CrawlOptions {\n  /** Maximum pages to fetch (default 200) */\n  maxPages?: number;\n  /** Per-page fetch timeout in ms (default 10000) */\n  timeoutMs?: number;\n  /** Parallel fetches (default 5) */\n  concurrency?: number;\n  /** Honor robots.txt Disallow rules (default true) */\n  respectRobots?: boolean;\n  /** Include asset files — skipped by default */\n  includeAssets?: boolean;\n}\n\nexport interface CrawlResult {\n  pages: FetchResult[];\n  discoveredUrls: string[];\n  fetchedUrls: string[];\n  skippedUrls: string[];\n  elapsed: number;\n}\n\n// ─── Resource file extensions to skip ────────────────────────────────────────\n\nconst RESOURCE_EXTENSIONS = /\\.(js|css|png|jpg|jpeg|gif|svg|ico|pdf|xml|txt|woff|woff2|ttf|eot|mp4|mp3|webp|avif|zip|gz|tar|json)$/i;\n\nconst SKIP_PATH_PATTERNS = /^\\/(api|wp-admin|wp-json|static|assets|_next|auth|login|signup|cart|checkout|admin|feed|xmlrpc)\\b/i;\n\n// ─── Robots.txt parsing ─────────────────────────────────────────────────────\n\ninterface RobotsRules {\n  disallow: string[];\n  allow: string[];\n}\n\nexport function parseRobotsTxt(robotsText: string): RobotsRules {\n  const lines = robotsText.split('\\n');\n  const rules: RobotsRules = { disallow: [], allow: [] };\n\n  // Collect rules for User-agent: * and User-agent: AEO-Visibility-Bot\n  let inRelevantSection = false;\n\n  for (const rawLine of lines) {\n    const line = rawLine.trim();\n    if (!line || line.startsWith('#')) continue;\n\n    const uaMatch = line.match(/^user-agent:\\s*(.+)/i);\n    if (uaMatch) {\n      const agent = uaMatch[1].trim().toLowerCase();\n      inRelevantSection = agent === '*' || agent === 'aeo-visibility-bot';\n      continue;\n    }\n\n    if (!inRelevantSection) continue;\n\n    const disallowMatch = line.match(/^disallow:\\s*(.*)/i);\n    if (disallowMatch) {\n      const path = disallowMatch[1].trim();\n      if (path) rules.disallow.push(path);\n      continue;\n    }\n\n    const allowMatch = line.match(/^allow:\\s*(.*)/i);\n    if (allowMatch) {\n      const path = allowMatch[1].trim();\n      if (path) rules.allow.push(path);\n    }\n  }\n\n  return rules;\n}\n\nexport function isDisallowedByRobots(urlPath: string, rules: RobotsRules): boolean {\n  // Check allow rules first — more specific (longer) rules take precedence\n  let longestAllow = 0;\n  let longestDisallow = 0;\n\n  for (const pattern of rules.allow) {\n    if (urlPath.startsWith(pattern) && pattern.length > longestAllow) {\n      longestAllow = pattern.length;\n    }\n  }\n\n  for (const pattern of rules.disallow) {\n    if (urlPath.startsWith(pattern) && pattern.length > longestDisallow) {\n      longestDisallow = pattern.length;\n    }\n  }\n\n  // More specific (longer) rule wins; if equal length, allow wins\n  if (longestAllow === 0 && longestDisallow === 0) return false;\n  return longestDisallow > longestAllow;\n}\n\n// ─── Fetch helper (matches multi-page-fetcher.ts fetchPage) ──────────────────\n\nasync function fetchPage(url: string, timeoutMs = 10000): Promise<FetchResult | null> {\n  try {\n    const res = await fetch(url, {\n      signal: AbortSignal.timeout(timeoutMs),\n      headers: { 'User-Agent': 'AEO-Visibility-Bot/1.0' },\n      redirect: 'follow',\n    });\n    if (res.status !== 200) return null;\n    const text = await res.text();\n    if (text.length < 200) return null;\n    return { text: text.slice(0, 500_000), status: res.status, finalUrl: res.url };\n  } catch {\n    return null;\n  }\n}\n\nasync function fetchSitemapXml(url: string, timeoutMs = 10000): Promise<string | null> {\n  try {\n    const res = await fetch(url, {\n      signal: AbortSignal.timeout(timeoutMs),\n      headers: { 'User-Agent': 'AEO-Visibility-Bot/1.0' },\n      redirect: 'follow',\n    });\n    if (res.status !== 200) return null;\n    return await res.text();\n  } catch {\n    return null;\n  }\n}\n\n// ─── Sitemap parsing ────────────────────────────────────────────────────────\n\n/**\n * Extract all page URLs from sitemap XML (handles sitemapindex with sub-sitemaps).\n * Filters to same domain only, skips resource files.\n */\nexport async function extractAllUrlsFromSitemap(\n  sitemapText: string,\n  domain: string,\n  timeoutMs = 10000,\n): Promise<string[]> {\n  const cleanDomain = domain.replace(/^www\\./, '').toLowerCase();\n  const urls = new Set<string>();\n\n  // Check for sitemapindex — fetch sub-sitemaps\n  const subSitemapLocs = sitemapText.match(/<sitemap>[\\s\\S]*?<loc>([^<]+)<\\/loc>[\\s\\S]*?<\\/sitemap>/gi) || [];\n  if (subSitemapLocs.length > 0) {\n    const subUrls: string[] = [];\n    for (const block of subSitemapLocs) {\n      const locMatch = block.match(/<loc>([^<]+)<\\/loc>/i);\n      if (locMatch) subUrls.push(locMatch[1].trim());\n    }\n\n    // Fetch sub-sitemaps in parallel (limit to 10)\n    const fetches = subUrls.slice(0, 10).map(u => fetchSitemapXml(u, timeoutMs));\n    const results = await Promise.all(fetches);\n    for (const text of results) {\n      if (text) {\n        extractLocsFromXml(text, cleanDomain, urls);\n      }\n    }\n  }\n\n  // Also extract <url><loc> from the main sitemap text (could be a regular sitemap)\n  extractLocsFromXml(sitemapText, cleanDomain, urls);\n\n  return Array.from(urls);\n}\n\nfunction extractLocsFromXml(xml: string, cleanDomain: string, urls: Set<string>): void {\n  const locMatches = xml.match(/<url>[\\s\\S]*?<loc>([^<]+)<\\/loc>[\\s\\S]*?<\\/url>/gi) || [];\n  for (const block of locMatches) {\n    const locMatch = block.match(/<loc>([^<]+)<\\/loc>/i);\n    if (!locMatch) continue;\n    const url = locMatch[1].trim();\n\n    try {\n      const parsed = new URL(url);\n      const urlDomain = parsed.hostname.replace(/^www\\./, '').toLowerCase();\n      if (urlDomain !== cleanDomain) continue;\n      if (RESOURCE_EXTENSIONS.test(parsed.pathname)) continue;\n      urls.add(url);\n    } catch {\n      continue;\n    }\n  }\n}\n\n// ─── Internal link extraction ───────────────────────────────────────────────\n\n/**\n * Extract ALL internal links from HTML (not just nav).\n * Returns deduplicated full URLs for the same domain.\n */\nexport function extractInternalLinks(html: string, domain: string): string[] {\n  const cleanDomain = domain.replace(/^www\\./, '').toLowerCase();\n  const hrefMatches = html.match(/href=\"([^\"]*)\"/gi) || [];\n  const urls = new Set<string>();\n\n  for (const match of hrefMatches) {\n    const href = match.match(/href=\"([^\"]*)\"/i)?.[1];\n    if (!href || !href.trim()) continue;\n\n    let fullUrl: string;\n\n    if (href.startsWith('//')) {\n      fullUrl = `https:${href}`;\n    } else if (href.startsWith('/')) {\n      // Skip fragment-only, query-only, and anchor links\n      if (href === '/' || href.startsWith('/#')) continue;\n      fullUrl = `https://${domain}${href}`;\n    } else if (href.startsWith('http')) {\n      fullUrl = href;\n    } else if (href.startsWith('#') || href.startsWith('?') || href.startsWith('mailto:') || href.startsWith('tel:') || href.startsWith('javascript:')) {\n      continue;\n    } else {\n      // Relative path\n      fullUrl = `https://${domain}/${href}`;\n    }\n\n    try {\n      const parsed = new URL(fullUrl);\n      const linkDomain = parsed.hostname.replace(/^www\\./, '').toLowerCase();\n      if (linkDomain !== cleanDomain) continue;\n\n      // Strip hash and normalize\n      parsed.hash = '';\n      const path = parsed.pathname;\n\n      if (path === '/' || path === '') continue;\n      if (RESOURCE_EXTENSIONS.test(path)) continue;\n      if (SKIP_PATH_PATTERNS.test(path)) continue;\n\n      // Normalize: strip trailing slash\n      const normalized = parsed.origin + path.replace(/\\/+$/, '') + parsed.search;\n      urls.add(normalized);\n    } catch {\n      continue;\n    }\n  }\n\n  return Array.from(urls);\n}\n\n// ─── Category inference ─────────────────────────────────────────────────────\n\nconst CATEGORY_PATTERNS: Array<[RegExp, PageCategory]> = [\n  [/\\/(blog|articles?|posts?|news|insights|guides)\\b/i, 'blog'],\n  [/\\/(about|about-us|company|who-we-are)\\b/i, 'about'],\n  [/\\/(pricing|plans|packages)\\b/i, 'pricing'],\n  [/\\/(services?|features?|solutions?|products?|what-we-do|offerings?)\\b/i, 'services'],\n  [/\\/(contact|contact-us|get-in-touch)\\b/i, 'contact'],\n  [/\\/(team|our-team|authors?|people|leadership|staff)\\b/i, 'team'],\n  [/\\/(resources?|resource-center|library|downloads?)\\b/i, 'resources'],\n  [/\\/(docs?|documentation|help|help-center|support|knowledge-base)\\b/i, 'docs'],\n  [/\\/(case-stud\\w*|cases|customers?|success-stor\\w*|testimonials?)\\b/i, 'cases'],\n  [/\\/(faq|frequently-asked|questions)\\b/i, 'faq'],\n];\n\n/**\n * Infer PageCategory from URL path patterns.\n */\nexport function inferCategory(url: string): PageCategory {\n  try {\n    const path = new URL(url).pathname;\n    for (const [pattern, category] of CATEGORY_PATTERNS) {\n      if (pattern.test(path)) return category;\n    }\n  } catch {\n    // Fall through to default\n  }\n  return 'content';\n}\n\n// ─── Main crawler ───────────────────────────────────────────────────────────\n\n/**\n * BFS crawl of a site, discovering all internal pages up to maxPages.\n * Seeds from sitemap URLs + homepage internal links.\n * Skips URLs already in siteData.blogSample and homepage.\n */\nexport async function crawlFullSite(\n  siteData: SiteData,\n  options?: CrawlOptions,\n): Promise<CrawlResult> {\n  const startTime = Date.now();\n  const maxPages = options?.maxPages ?? 200;\n  const timeoutMs = options?.timeoutMs ?? 10000;\n  const concurrency = options?.concurrency ?? 5;\n  const respectRobots = options?.respectRobots ?? true;\n\n  const pages: FetchResult[] = [];\n  const discoveredUrls = new Set<string>();\n  const fetchedUrls = new Set<string>();\n  const skippedUrls = new Set<string>();\n  const visited = new Set<string>();\n\n  // Parse robots.txt rules\n  let robotsRules: RobotsRules = { disallow: [], allow: [] };\n  if (respectRobots && siteData.robotsTxt?.text) {\n    robotsRules = parseRobotsTxt(siteData.robotsTxt.text);\n  }\n\n  const baseUrl = `${siteData.protocol}://${siteData.domain}`;\n\n  // Mark already-fetched URLs as visited\n  visited.add(normalizeUrl(baseUrl));\n  visited.add(normalizeUrl(baseUrl + '/'));\n  if (siteData.blogSample) {\n    for (const page of siteData.blogSample) {\n      if (page.finalUrl) visited.add(normalizeUrl(page.finalUrl));\n    }\n  }\n\n  // Seed the queue from sitemap\n  const queue: string[] = [];\n  if (siteData.sitemapXml?.text) {\n    const sitemapUrls = await extractAllUrlsFromSitemap(\n      siteData.sitemapXml.text,\n      siteData.domain,\n      timeoutMs,\n    );\n    for (const url of sitemapUrls) {\n      const norm = normalizeUrl(url);\n      if (!visited.has(norm)) {\n        discoveredUrls.add(url);\n        if (!queue.includes(url)) queue.push(url);\n      }\n    }\n  }\n\n  // Seed from homepage internal links\n  if (siteData.homepage?.text) {\n    const homeLinks = extractInternalLinks(siteData.homepage.text, siteData.domain);\n    for (const url of homeLinks) {\n      const norm = normalizeUrl(url);\n      if (!visited.has(norm) && !discoveredUrls.has(url)) {\n        discoveredUrls.add(url);\n        if (!queue.includes(url)) queue.push(url);\n      }\n    }\n  }\n\n  // BFS loop\n  while (queue.length > 0 && fetchedUrls.size < maxPages) {\n    // Take a batch\n    const batchSize = Math.min(concurrency, maxPages - fetchedUrls.size, queue.length);\n    const batch: string[] = [];\n\n    while (batch.length < batchSize && queue.length > 0) {\n      const url = queue.shift()!;\n      const norm = normalizeUrl(url);\n\n      if (visited.has(norm)) continue;\n      visited.add(norm);\n\n      // Check robots.txt\n      if (respectRobots) {\n        try {\n          const path = new URL(url).pathname;\n          if (isDisallowedByRobots(path, robotsRules)) {\n            skippedUrls.add(url);\n            continue;\n          }\n        } catch {\n          // Skip malformed URLs\n          continue;\n        }\n      }\n\n      batch.push(url);\n    }\n\n    if (batch.length === 0) continue;\n\n    // Fetch batch in parallel\n    const results = await Promise.all(batch.map(url => fetchPage(url, timeoutMs)));\n\n    for (let i = 0; i < results.length; i++) {\n      const result = results[i];\n      const url = batch[i];\n      fetchedUrls.add(url);\n\n      if (!result) continue;\n\n      result.category = inferCategory(url);\n      pages.push(result);\n\n      // Extract new internal links from fetched page\n      const newLinks = extractInternalLinks(result.text, siteData.domain);\n      for (const link of newLinks) {\n        const norm = normalizeUrl(link);\n        if (!visited.has(norm) && !discoveredUrls.has(link)) {\n          discoveredUrls.add(link);\n          queue.push(link);\n        }\n      }\n    }\n  }\n\n  // Any remaining queued URLs count as discovered but skipped\n  for (const url of queue) {\n    if (!fetchedUrls.has(url)) {\n      skippedUrls.add(url);\n    }\n  }\n\n  return {\n    pages,\n    discoveredUrls: Array.from(discoveredUrls),\n    fetchedUrls: Array.from(fetchedUrls),\n    skippedUrls: Array.from(skippedUrls),\n    elapsed: Math.round((Date.now() - startTime) / 100) / 10,\n  };\n}\n\nfunction normalizeUrl(url: string): string {\n  try {\n    const parsed = new URL(url);\n    // Normalize: lowercase host, strip trailing slash, strip hash\n    return (parsed.origin + parsed.pathname.replace(/\\/+$/, '') + parsed.search).toLowerCase();\n  } catch {\n    return url.toLowerCase();\n  }\n}\n"],"mappings":"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","names":[]}