aeorank 1.5.0 → 1.6.0

package/README.md

@@ -150,6 +150,55 @@ Score a single HTML page against 14 per-page AEO criteria. Returns `PageScoreRes
 
 Batch-score all pages (homepage + blogSample) from a `SiteData` object. Returns `PageScoreResult[]`.
 
+### `buildLinkGraph(pages, domain, homepageUrl)`
+
+Analyze internal linking structure from crawled pages. Returns `LinkGraph` with:
+
+- `nodes` - Map of URL to `PageNode` (in/out degree, depth, pillar/hub/orphan flags)
+- `edges` - Array of `LinkEdge` (from, to, anchor text)
+- `stats` - `LinkGraphStats` (total pages, orphans, pillars, hubs, avg depth, clusters)
+- `clusters` - `TopicCluster[]` (pillar URL, spoke URLs, cohesion score)
+
+```ts
+import { crawlFullSite, prefetchSiteData, buildLinkGraph } from 'aeorank';
+
+const siteData = await prefetchSiteData('example.com');
+const crawl = await crawlFullSite(siteData, { maxPages: 200 });
+const graph = buildLinkGraph(crawl.pages, 'example.com', 'https://example.com');
+
+console.log(graph.stats.orphanPages);   // Pages with no inbound links
+console.log(graph.stats.pillarPages);   // High-authority hub pages
+console.log(graph.clusters);            // Topic clusters detected
+```
+
+### `generateFixPlan(domain, score, criteria, pages?, linkGraph?)`
+
+Generate a phased fix plan from audit results. Returns `FixPlan` with:
+
+- `phases` - 4 phases (Foundation, Content, Authority, Architecture) with prioritized `FixAction[]`
+- `quickWins` - Low-effort, high-impact fixes
+- `projectedScore` - Estimated score after applying all fixes
+- `summary` - Counts by impact level, top opportunity, estimated effort
+
+Each `FixAction` includes: title, description, impact/effort levels, step-by-step instructions, code examples, affected pages, and dependency ordering.
+
+```ts
+import { audit, generateFixPlan } from 'aeorank';
+
+const result = await audit('example.com');
+const plan = generateFixPlan(
+  'example.com',
+  result.overallScore,
+  result.criterionResults,
+  result.pagesReviewed,
+);
+
+console.log(plan.projectedScore);           // e.g. 82
+console.log(plan.quickWins[0].title);       // e.g. "Add llms.txt file"
+console.log(plan.quickWins[0].impactScore); // e.g. 10
+console.log(plan.phases[0].fixes.length);   // Foundation phase fixes
+```
+
 ### Advanced API
 
 For custom pipelines, import individual stages:
@@ -165,6 +214,8 @@ import {
   generateOpportunities,
   scorePage,
   scoreAllPages,
+  buildLinkGraph,
+  generateFixPlan,
   isSpaShell,
   fetchWithHeadless,
 } from 'aeorank';
@@ -174,6 +225,24 @@ const results = auditSiteFromData(siteData);
 const score = calculateOverallScore(results);
 ```
 
+### Browser Entry Point
+
+For browser environments (Chrome extensions, web apps), import from `aeorank/browser` to avoid Node.js dependencies (Puppeteer, fs):
+
+```ts
+import {
+  prefetchSiteData,
+  auditSiteFromData,
+  calculateOverallScore,
+  buildLinkGraph,
+  generateFixPlan,
+  analyzeAllPages,
+  crawlFullSite,
+} from 'aeorank/browser';
+```
+
+The browser entry exports everything except `headless-fetch` (Puppeteer), `html-report` (Node fs), `audit` orchestrator, and CLI.
+
 ## SPA Support
 
 Sites that use client-side rendering (React, Vue, Angular) return empty HTML shells to regular HTTP requests. AEORank detects these automatically and re-renders them with Puppeteer if available.
@@ -258,6 +327,70 @@ console.log(result.criterionScores);  // 14 per-criterion scores
 const allScores = scoreAllPages(siteData);
 ```
 
+## Link Graph Analysis
+
+Analyze your site's internal linking structure to find orphan pages, identify pillar content, and detect topic clusters:
+
+```bash
+npx aeorank example.com --full-crawl --json | jq '.linkGraph.stats'
+```
+
+```ts
+import { crawlFullSite, prefetchSiteData, buildLinkGraph, serializeLinkGraph } from 'aeorank';
+
+const siteData = await prefetchSiteData('example.com');
+const crawl = await crawlFullSite(siteData, { maxPages: 200 });
+const graph = buildLinkGraph(crawl.pages, 'example.com', 'https://example.com');
+
+// Orphan pages (no inbound links - invisible to crawlers)
+const orphans = [...graph.nodes.values()].filter(n => n.isOrphan);
+
+// Pillar pages (high authority, many inbound links)
+const pillars = [...graph.nodes.values()].filter(n => n.isPillar);
+
+// Topic clusters (pillar + spoke pages with high cohesion)
+graph.clusters.forEach(c => {
+  console.log(`${c.pillarTitle}: ${c.spokes.length} spokes, cohesion ${c.cohesion}`);
+});
+
+// Serialize for storage/transport (Map -> plain object)
+const json = serializeLinkGraph(graph);
+```
+
+## Fix Plan Engine
+
+Generate actionable, phased fix plans from audit results. Each fix includes step-by-step instructions, code examples, effort/impact ratings, and dependency ordering:
+
+```bash
+npx aeorank example.com --full-crawl --json | jq '.fixPlan'
+```
+
+```ts
+import { audit, generateFixPlan } from 'aeorank';
+
+const result = await audit('example.com', { fullCrawl: true });
+const plan = generateFixPlan(
+  'example.com',
+  result.overallScore,
+  result.criterionResults,
+  result.pagesReviewed,
+  result.linkGraph,  // optional - enables link-aware fixes
+);
+
+// 4 phases: Foundation -> Content -> Authority -> Architecture
+plan.phases.forEach(phase => {
+  console.log(`${phase.title}: ${phase.fixes.length} fixes`);
+});
+
+// Quick wins: low effort + high impact
+plan.quickWins.forEach(qw => {
+  console.log(`${qw.title} (+${qw.impactScore} pts) - ${qw.effort} effort`);
+  qw.steps.forEach(s => console.log(`  - ${s}`));
+});
+
+console.log(`Current: ${plan.overallScore} -> Projected: ${plan.projectedScore}`);
+```
+
 ## 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.

package/dist/browser.d.ts

@@ -0,0 +1,524 @@
+/**
+ * Link graph analysis for full-site AEO audits.
+ * Builds an internal link graph, detects orphan pages, pillar pages,
+ * hub pages, and topic clusters from crawled page data.
+ */
+
+interface LinkEdge {
+    source: string;
+    target: string;
+    anchorText: string;
+}
+interface PageNode {
+    url: string;
+    title: string;
+    wordCount: number;
+    category: PageCategory;
+    inDegree: number;
+    outDegree: number;
+    depth: number;
+    isPillar: boolean;
+    isHub: boolean;
+    isOrphan: boolean;
+}
+interface TopicCluster {
+    pillarUrl: string;
+    pillarTitle: string;
+    spokes: string[];
+    cohesion: number;
+}
+interface LinkGraphStats {
+    totalPages: number;
+    totalEdges: number;
+    orphanPages: number;
+    pillarPages: number;
+    hubPages: number;
+    avgDepth: number;
+    maxDepth: number;
+    clusters: number;
+}
+interface LinkGraph {
+    nodes: Map<string, PageNode>;
+    edges: LinkEdge[];
+    stats: LinkGraphStats;
+    clusters: TopicCluster[];
+}
+interface SerializedLinkGraph {
+    nodes: PageNode[];
+    stats: LinkGraphStats;
+    clusters: TopicCluster[];
+}
+declare function serializeLinkGraph(graph: LinkGraph): SerializedLinkGraph;
+/**
+ * Extract internal links from HTML with their anchor text.
+ * Similar to extractInternalLinks in full-site-crawler.ts but returns LinkEdge[].
+ */
+declare function extractLinksWithAnchors(html: string, sourceUrl: string, domain: string): LinkEdge[];
+/**
+ * Build a link graph from crawled pages.
+ * @param pages - Array of FetchResult from full-site crawl
+ * @param domain - The site domain
+ * @param homepageUrl - Full URL of the homepage (e.g. https://example.com)
+ */
+declare function buildLinkGraph(pages: FetchResult[], domain: string, homepageUrl: string): LinkGraph;
+
+/**
+ * AEORank type definitions.
+ * Inlined from @aeo/shared to keep the package zero-dependency.
+ */
+type Status = 'MISSING' | 'NEARLY EMPTY' | 'POOR' | 'WEAK' | 'PARTIAL' | 'MODERATE' | 'GOOD' | 'STRONG';
+type Severity = 'WORKING' | 'GOOD' | 'GOOD PATTERN' | 'PARTIAL' | 'MISSING' | 'ADD' | 'FIX' | 'FIX IMMEDIATELY' | 'REWRITE' | 'CONFUSING' | 'INCONSISTENT' | 'SPARSE' | 'PERFORMANCE' | 'CLUTTER' | 'PLATFORM LIMIT' | 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'BIG OPPORTUNITY' | 'AEO GOLDMINE' | 'AEO CORE' | 'CORE AEO' | 'AEO deliverable' | 'QUICK WIN' | 'MEASUREMENT';
+type FindingType = 'Test' | 'Good' | 'Bad' | 'Missing' | 'Critical' | 'Issue' | 'Fix' | 'Exists' | 'Calc' | 'Present' | 'Note' | 'Current' | 'Volume' | 'Bonus' | 'Impact';
+type ImpactLevel = 'QUICK WIN' | 'CRITICAL' | 'HIGH' | 'CORE AEO' | 'MEDIUM' | 'LOW' | 'MEASUREMENT' | 'BIG OPPORTUNITY';
+interface ScoreCardItem {
+    id: number;
+    criterion: string;
+    score: number;
+    status: Status;
+    keyFindings: string;
+}
+interface DetailedFinding {
+    type: FindingType;
+    description: string;
+    severity: Severity;
+}
+interface CriterionDetail {
+    id: number;
+    name: string;
+    findings: DetailedFinding[];
+}
+interface Deliverable {
+    id: number;
+    name: string;
+    description: string;
+    effort: string;
+    impact: ImpactLevel;
+}
+interface PitchMetric {
+    metric: string;
+    value: string;
+    significance: string;
+}
+type PageCategory$1 = 'homepage' | 'blog' | 'about' | 'pricing' | 'services' | 'contact' | 'team' | 'resources' | 'docs' | 'cases' | 'faq' | 'content';
+interface PageCriterionScore$1 {
+    criterion: string;
+    criterion_label: string;
+    score: number;
+    weight: number;
+}
+interface PageIssue {
+    check: string;
+    label: string;
+    severity: 'error' | 'warning' | 'info';
+}
+interface PageReview {
+    url: string;
+    title: string;
+    category: PageCategory$1;
+    wordCount: number;
+    issues: PageIssue[];
+    strengths: PageIssue[];
+    aeoScore?: number;
+    criterionScores?: PageCriterionScore$1[];
+}
+interface AuditData {
+    site: string;
+    auditDate: string;
+    auditor: string;
+    engine?: string;
+    overallScore: number;
+    verdict: string;
+    scorecard: ScoreCardItem[];
+    detailedFindings: CriterionDetail[];
+    opportunities: Deliverable[];
+    pitchNumbers: PitchMetric[];
+    bottomLine: string;
+    pagesReviewed?: PageReview[];
+}
+type AuditStatus = 'pass' | 'fail' | 'partial' | 'not_found';
+type Priority = 'P0' | 'P1' | 'P2' | 'P3';
+type FindingSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+interface AuditFinding {
+    severity: FindingSeverity;
+    detail: string;
+    fix?: string;
+}
+
+interface CriterionResult {
+    criterion: string;
+    criterion_label: string;
+    score: number;
+    status: AuditStatus;
+    findings: AuditFinding[];
+    fix_priority: Priority;
+}
+type PageCategory = 'homepage' | 'blog' | 'about' | 'pricing' | 'services' | 'contact' | 'team' | 'resources' | 'docs' | 'cases' | 'faq' | 'content';
+interface FetchResult {
+    text: string;
+    status: number;
+    finalUrl?: string;
+    category?: PageCategory;
+}
+interface SiteData {
+    domain: string;
+    protocol: 'https' | 'http' | null;
+    homepage: FetchResult | null;
+    llmsTxt: FetchResult | null;
+    robotsTxt: FetchResult | null;
+    faqPage: FetchResult | null;
+    sitemapXml: FetchResult | null;
+    rssFeed: FetchResult | null;
+    aiTxt: FetchResult | null;
+    /** Set when homepage redirects to a different (non-brand) domain */
+    redirectedTo: string | null;
+    /** Set when homepage is a parked/for-sale/lost domain */
+    parkedReason: string | null;
+    /** Sampled blog/content pages from sitemap (up to 5) */
+    blogSample?: FetchResult[];
+    /** Full-crawl statistics (set when --full-crawl is used) */
+    crawlStats?: {
+        discovered: number;
+        fetched: number;
+        skipped: number;
+        elapsed: number;
+    };
+    /** Link graph from full-site crawl */
+    linkGraph?: LinkGraph;
+}
+interface RawDataSummary {
+    domain: string;
+    protocol: 'https' | 'http' | null;
+    homepage_length: number;
+    homepage_text_length: number;
+    has_https: boolean;
+    llms_txt_status: number | null;
+    llms_txt_length: number;
+    robots_txt_status: number | null;
+    robots_txt_snippet: string;
+    robots_txt_ai_crawlers: string[];
+    robots_txt_blocked_crawlers: string[];
+    schema_types_found: string[];
+    schema_block_count: number;
+    faq_page_status: number | null;
+    faq_page_length: number;
+    sitemap_status: number | null;
+    internal_link_count: number;
+    external_link_count: number;
+    question_headings_count: number;
+    h1_count: number;
+    has_meta_description: boolean;
+    has_title: boolean;
+    has_phone: boolean;
+    has_address: boolean;
+    has_org_schema: boolean;
+    has_social_links: boolean;
+    semantic_elements_found: string[];
+    img_count: number;
+    img_with_alt_count: number;
+    has_lang_attr: boolean;
+    has_aria: boolean;
+    has_breadcrumbs: boolean;
+    has_nav: boolean;
+    has_footer: boolean;
+    has_case_studies: boolean;
+    has_statistics: boolean;
+    has_expert_attribution: boolean;
+    has_blog_section: boolean;
+    has_date_modified_schema: boolean;
+    time_element_count: number;
+    sitemap_url_count: number;
+    has_rss_feed: boolean;
+    table_count: number;
+    ordered_list_count: number;
+    unordered_list_count: number;
+    definition_pattern_count: number;
+    has_ai_txt: boolean;
+    has_person_schema: boolean;
+    fact_data_point_count: number;
+    has_canonical: boolean;
+    has_license_schema: boolean;
+    sitemap_recent_lastmod_count: number;
+    rendered_with_headless?: boolean;
+    has_speakable_schema: boolean;
+    speakable_selector_count: number;
+    blog_sample_count: number;
+    blog_sample_urls: string[];
+    blog_sample_schema_types: string[];
+    blog_sample_question_headings: number;
+    blog_sample_faq_schema_found: boolean;
+    question_heading_answer_rate: number;
+    question_heading_total: number;
+    cannibalizing_pairs_count: number;
+    page_titles_sampled: number;
+    has_visible_date: boolean;
+    has_schema_date_in_ld: boolean;
+    date_modified_recency_days: number | null;
+    crawl_discovered: number;
+    crawl_fetched: number;
+    crawl_skipped: number;
+}
+/**
+ * Fetches all site data in parallel with HTTPS/HTTP fallback.
+ * Single entry point for all HTTP requests - no redundant fetches.
+ */
+declare function prefetchSiteData(domain: string): Promise<SiteData>;
+declare function extractRawDataSummary(data: SiteData): RawDataSummary;
+/**
+ * Run all 26 criteria checks using pre-fetched site data.
+ * All functions are synchronous (no HTTP calls) - data was already fetched.
+ */
+declare function auditSiteFromData(data: SiteData): CriterionResult[];
+
+declare function calculateOverallScore(criteria: CriterionResult[]): number;
+
+/**
+ * Shared scorecard building functions.
+ * Extracted from cli/pre-crawl.ts for reuse in instant-audit and other consumers.
+ */
+
+declare const CRITERION_LABELS: Record<string, string>;
+declare function scoreToStatus(score: number): Status;
+declare function buildScorecard(results: CriterionResult[]): ScoreCardItem[];
+declare function buildDetailedFindings(results: CriterionResult[]): CriterionDetail[];
+
+/**
+ * Deterministic narrative generation from scorecard data.
+ * Produces verdict, opportunities, pitchNumbers, and bottomLine
+ * without any LLM calls - pure template-based generation.
+ */
+
+declare function generateVerdict(score: number, scorecard: ScoreCardItem[], rawData: RawDataSummary, domain: string): string;
+declare function generateOpportunities(scorecard: ScoreCardItem[], criterionResults: CriterionResult[]): Deliverable[];
+declare function generatePitchNumbers(score: number, rawData: RawDataSummary, scorecard: ScoreCardItem[]): PitchMetric[];
+declare function generateBottomLine(score: number, opportunities: Deliverable[], scorecard: ScoreCardItem[], domain: string): string;
+
+/**
+ * Extended page discovery for instant audit.
+ * Fetches additional pages beyond what prefetchSiteData provides,
+ * including nav-linked pages, common paths, and content pages from sitemap.
+ */
+
+/**
+ * Extract internal page paths from <nav> elements in homepage HTML.
+ * Returns deduplicated absolute paths (e.g. ['/about', '/pricing']).
+ */
+declare function extractNavLinks(html: string, domain: string): string[];
+/**
+ * Extract non-blog deep content pages from sitemap XML.
+ * Targets service pages, product pages, etc. (not blog/article posts).
+ */
+declare function extractContentPagesFromSitemap(sitemapText: string, domain: string, limit?: number): string[];
+interface MultiPageOptions {
+    timeoutMs?: number;
+}
+/**
+ * Fetch additional pages beyond what prefetchSiteData provides.
+ * Discovers pages from nav links + common path variants + sitemap content pages.
+ * All fetched pages are appended to siteData.blogSample so existing
+ * getCombinedHtml() and criteria checks pick them up automatically.
+ *
+ * Mutates siteData in place and returns the count of new pages added.
+ */
+declare function fetchMultiPageData(siteData: SiteData, options?: MultiPageOptions): Promise<number>;
+
+/**
+ * Full-site crawler for deep AEO audits.
+ * BFS crawl that discovers all internal pages up to a configurable limit.
+ */
+
+interface CrawlOptions {
+    /** Maximum pages to fetch (default 200) */
+    maxPages?: number;
+    /** Per-page fetch timeout in ms (default 10000) */
+    timeoutMs?: number;
+    /** Parallel fetches (default 5) */
+    concurrency?: number;
+    /** Honor robots.txt Disallow rules (default true) */
+    respectRobots?: boolean;
+    /** Include asset files — skipped by default */
+    includeAssets?: boolean;
+}
+interface CrawlResult {
+    pages: FetchResult[];
+    discoveredUrls: string[];
+    fetchedUrls: string[];
+    skippedUrls: string[];
+    elapsed: number;
+}
+/**
+ * Extract all page URLs from sitemap XML (handles sitemapindex with sub-sitemaps).
+ * Filters to same domain only, skips resource files.
+ */
+declare function extractAllUrlsFromSitemap(sitemapText: string, domain: string, timeoutMs?: number): Promise<string[]>;
+/**
+ * Extract ALL internal links from HTML (not just nav).
+ * Returns deduplicated full URLs for the same domain.
+ */
+declare function extractInternalLinks(html: string, domain: string): string[];
+/**
+ * Infer PageCategory from URL path patterns.
+ */
+declare function inferCategory(url: string): PageCategory;
+/**
+ * BFS crawl of a site, discovering all internal pages up to maxPages.
+ * Seeds from sitemap URLs + homepage internal links.
+ * Skips URLs already in siteData.blogSample and homepage.
+ */
+declare function crawlFullSite(siteData: SiteData, options?: CrawlOptions): Promise<CrawlResult>;
+
+/**
+ * Per-page analysis for instant audit.
+ * Runs 12 deterministic checks on each crawled page (no LLM).
+ */
+
+declare function analyzePage(html: string, url: string, category: PageCategory): PageReview;
+declare function analyzeAllPages(siteData: SiteData): PageReview[];
+
+/**
+ * Per-page AEO scoring.
+ * Evaluates 14 of 26 criteria that apply at individual page level.
+ * Produces a 0-100 AEO score per page.
+ */
+
+interface PageCriterionScore {
+    criterion: string;
+    criterion_label: string;
+    score: number;
+    weight: number;
+}
+interface PageScoreResult {
+    aeoScore: number;
+    criterionScores: PageCriterionScore[];
+}
+/**
+ * Score a single page against 14 AEO criteria.
+ * Returns a 0-100 AEO score and individual criterion scores.
+ */
+declare function scorePage(html: string, url?: string): PageScoreResult;
+/**
+ * Score all crawled pages (homepage + blogSample).
+ */
+declare function scoreAllPages(siteData: SiteData): PageScoreResult[];
+
+/**
+ * Fix Plan Engine - generates actionable, phased fix plans from audit scores.
+ * Runs alongside the existing opportunities system (no breaking changes).
+ * Uses criterion scores, optional per-page data, and optional link graph
+ * to produce structured fix plans with code examples and dependency ordering.
+ */
+
+interface FixAction {
+    id: string;
+    criterion: string;
+    criterionId: string;
+    title: string;
+    description: string;
+    impact: 'critical' | 'high' | 'medium' | 'low';
+    effort: 'trivial' | 'low' | 'medium' | 'high';
+    impactScore: number;
+    category: 'content' | 'structure' | 'discovery' | 'trust';
+    steps: string[];
+    codeExample?: string;
+    successCriteria: string;
+    dependsOn?: string[];
+    affectedPages?: string[];
+    pageCount?: number;
+}
+interface FixPhase {
+    phase: number;
+    title: string;
+    description: string;
+    fixes: FixAction[];
+    estimatedImpact: number;
+}
+interface FixPlanSummary {
+    criticalCount: number;
+    highCount: number;
+    mediumCount: number;
+    lowCount: number;
+    quickWinCount: number;
+    topOpportunity: string;
+    estimatedTotalEffort: string;
+}
+interface FixPlan {
+    domain: string;
+    generatedAt: string;
+    overallScore: number;
+    projectedScore: number;
+    totalFixes: number;
+    phases: FixPhase[];
+    quickWins: FixAction[];
+    summary: FixPlanSummary;
+}
+declare function generateFixPlan(domain: string, overallScore: number, criteria: CriterionResult[], pagesReviewed?: PageReview[], linkGraph?: LinkGraph): FixPlan;
+
+/**
+ * Parked domain detection.
+ * Vendored from @aeo/queue/redirect-check (pure functions, no network).
+ */
+interface ParkedDomainResult {
+    isParked: boolean;
+    reason?: string;
+}
+/**
+ * Detect if a page is a parked/lost/for-sale domain.
+ * Pure function - no network calls.
+ */
+declare function detectParkedDomain(bodySnippet: string): ParkedDomainResult;
+
+/**
+ * Programmatic audit API.
+ * Runs the full 7-phase AEO audit pipeline and returns structured results.
+ */
+
+interface AuditOptions {
+    /** Skip Puppeteer SPA rendering (default: false) */
+    noHeadless?: boolean;
+    /** Homepage + blog only, skip extra page discovery (default: false) */
+    noMultiPage?: boolean;
+    /** Fetch timeout in ms (default: 15000) */
+    timeout?: number;
+    /** Enable full-site BFS crawl (default: false) */
+    fullCrawl?: boolean;
+    /** Max pages for full crawl (default: 200) */
+    maxPages?: number;
+    /** Parallel fetch concurrency for full crawl (default: 5) */
+    concurrency?: number;
+}
+interface AuditResult extends AuditData {
+    /** True if headless browser was used for SPA rendering */
+    renderedWithHeadless?: boolean;
+    /** Wall-clock seconds */
+    elapsed: number;
+}
+
+/**
+ * Comparison mode - run two audits in parallel and compute per-criterion deltas.
+ */
+
+interface CriterionComparison {
+    id: number;
+    criterion: string;
+    scoreA: number;
+    scoreB: number;
+    delta: number;
+    statusA: string;
+    statusB: string;
+}
+interface ComparisonResult {
+    siteA: AuditResult;
+    siteB: AuditResult;
+    comparison: {
+        scoreDelta: number;
+        criteria: CriterionComparison[];
+        siteAAdvantages: string[];
+        siteBAdvantages: string[];
+        tied: string[];
+    };
+}
+/**
+ * Audit two domains in parallel and build a per-criterion comparison.
+ */
+declare function compare(domainA: string, domainB: string, options?: AuditOptions): Promise<ComparisonResult>;
+
+export { type AuditData, type AuditFinding, type AuditStatus, CRITERION_LABELS, type ComparisonResult, type CrawlOptions, type CrawlResult, type CriterionComparison, type CriterionDetail, type CriterionResult, type Deliverable, type DetailedFinding, type FetchResult, type FindingSeverity, type FindingType, type FixAction, type FixPhase, type FixPlan, type FixPlanSummary, type ImpactLevel, type LinkEdge, type LinkGraph, type LinkGraphStats, type PageCategory$1 as PageCategory, type PageCriterionScore$1 as PageCriterionScore, type PageIssue, type PageNode, type PageReview, type PageScoreResult, type ParkedDomainResult, type PitchMetric, type Priority, type RawDataSummary, type ScoreCardItem, type SerializedLinkGraph, type Severity, type SiteData, type Status, type TopicCluster, analyzeAllPages, analyzePage, auditSiteFromData, buildDetailedFindings, buildLinkGraph, buildScorecard, calculateOverallScore, compare, crawlFullSite, detectParkedDomain, extractAllUrlsFromSitemap, extractContentPagesFromSitemap, extractInternalLinks, extractLinksWithAnchors, extractNavLinks, extractRawDataSummary, fetchMultiPageData, generateBottomLine, generateFixPlan, generateOpportunities, generatePitchNumbers, generateVerdict, inferCategory, prefetchSiteData, scoreAllPages, scorePage, scoreToStatus, serializeLinkGraph };