@agentimization/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2507 @@
+// node_modules/@agentimization/shared/dist/types.js
+import { z } from "zod";
+var CHECK_STATUSES = ["pass", "warn", "fail", "skip", "info"];
+var CHECK_CATEGORIES = [
+  "content-discoverability",
+  "markdown-availability",
+  "content-structure",
+  "page-size",
+  "url-stability",
+  "authentication",
+  "geo-signals",
+  "agent-protocols"
+];
+var CheckResultSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  category: z.enum(CHECK_CATEGORIES),
+  status: z.enum(CHECK_STATUSES),
+  message: z.string(),
+  details: z.string().optional(),
+  suggestion: z.string().optional(),
+  score: z.number().min(0).max(1).optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+var AuditResultSchema = z.object({
+  url: z.string(),
+  timestamp: z.string(),
+  overall_score: z.number().min(0).max(100),
+  grade: z.enum(["A+", "A", "B", "C", "D", "F"]),
+  checks: z.array(CheckResultSchema),
+  summary: z.object({
+    total: z.number(),
+    passed: z.number(),
+    warned: z.number(),
+    failed: z.number(),
+    skipped: z.number()
+  }),
+  categories: z.record(z.object({
+    score: z.number().min(0).max(100),
+    checks: z.number(),
+    passed: z.number()
+  })),
+  latency_ms: z.number()
+});
+var DEFAULT_CONFIG = {
+  sampleSize: 10,
+  timeout: 1e4,
+  concurrency: 5,
+  userAgent: "Agentimization/0.1 (GEO Audit; +https://github.com/antlio/agentimization)",
+  categories: [...CHECK_CATEGORIES],
+  onEvent: () => {
+  }
+};
+
+// src/checks/content-discoverability.ts
+var llmsTxtExists = {
+  id: "llms-txt-exists",
+  name: "llms.txt Exists",
+  category: "content-discoverability",
+  description: "Checks if llms.txt is present at the site root",
+  weight: 1,
+  run: async (ctx) => {
+    if (ctx.llmsTxt) {
+      return {
+        id: "llms-txt-exists",
+        name: "llms.txt Exists",
+        category: "content-discoverability",
+        status: "pass",
+        message: ctx.mode === "local" ? "llms.txt found in project root" : `llms.txt found at ${ctx.baseUrl.origin}/llms.txt`
+      };
+    }
+    return {
+      id: "llms-txt-exists",
+      name: "llms.txt Exists",
+      category: "content-discoverability",
+      status: "fail",
+      message: "No llms.txt found at site root",
+      suggestion: "Create a /llms.txt file that describes your site for AI agents. See https://llmstxt.org for the specification."
+    };
+  }
+};
+var llmsTxtValid = {
+  id: "llms-txt-valid",
+  name: "llms.txt Valid Structure",
+  category: "content-discoverability",
+  description: "Checks if llms.txt follows the proposed structure (H1, blockquote, heading-delimited link sections)",
+  weight: 0.8,
+  run: async (ctx) => {
+    if (!ctx.llmsTxt) {
+      return {
+        id: "llms-txt-valid",
+        name: "llms.txt Valid Structure",
+        category: "content-discoverability",
+        status: "skip",
+        message: "Skipped \u2014 no llms.txt found"
+      };
+    }
+    const issues = [];
+    const lines = ctx.llmsTxt.split("\n");
+    const hasH1 = lines.some((l) => /^#\s+/.test(l));
+    if (!hasH1) issues.push("Missing H1 title");
+    const hasBlockquote = lines.some((l) => /^>\s+/.test(l));
+    if (!hasBlockquote) issues.push("Missing blockquote description");
+    const hasHeadingSections = lines.some((l) => /^##\s+/.test(l));
+    if (!hasHeadingSections) issues.push("Missing ## section headings");
+    const hasLinks = /\[.+\]\(.+\)/.test(ctx.llmsTxt);
+    if (!hasLinks) issues.push("No markdown links found");
+    if (issues.length === 0) {
+      return {
+        id: "llms-txt-valid",
+        name: "llms.txt Valid Structure",
+        category: "content-discoverability",
+        status: "pass",
+        message: "llms.txt follows the proposed structure (H1, blockquote, heading-delimited link sections)"
+      };
+    }
+    return {
+      id: "llms-txt-valid",
+      name: "llms.txt Valid Structure",
+      category: "content-discoverability",
+      status: issues.length <= 1 ? "warn" : "fail",
+      message: `llms.txt structure issues: ${issues.join(", ")}`,
+      suggestion: "Follow the llms.txt spec: start with # Title, > Description, then ## Sections with [links](url)."
+    };
+  }
+};
+var llmsTxtSize = {
+  id: "llms-txt-size",
+  name: "llms.txt Size",
+  category: "content-discoverability",
+  description: "Checks if llms.txt is under the 50,000 character threshold",
+  weight: 0.5,
+  run: async (ctx) => {
+    if (!ctx.llmsTxt) {
+      return {
+        id: "llms-txt-size",
+        name: "llms.txt Size",
+        category: "content-discoverability",
+        status: "skip",
+        message: "Skipped \u2014 no llms.txt found"
+      };
+    }
+    const size = ctx.llmsTxt.length;
+    if (size <= 5e4) {
+      return {
+        id: "llms-txt-size",
+        name: "llms.txt Size",
+        category: "content-discoverability",
+        status: "pass",
+        message: `llms.txt is ${size.toLocaleString()} characters (under 50,000 threshold)`,
+        metadata: { size }
+      };
+    }
+    return {
+      id: "llms-txt-size",
+      name: "llms.txt Size",
+      category: "content-discoverability",
+      status: "warn",
+      message: `llms.txt is ${size.toLocaleString()} characters (over 50,000 threshold)`,
+      suggestion: "Consider splitting into llms.txt (summary) and llms-full.txt (complete reference).",
+      metadata: { size }
+    };
+  }
+};
+var llmsTxtFreshness = {
+  id: "llms-txt-freshness",
+  name: "llms.txt Coverage",
+  category: "content-discoverability",
+  description: "Checks how many sitemap pages are referenced in llms.txt",
+  weight: 0.7,
+  run: async (ctx) => {
+    if (!ctx.llmsTxt) {
+      return {
+        id: "llms-txt-freshness",
+        name: "llms.txt Coverage",
+        category: "content-discoverability",
+        status: "skip",
+        message: "Skipped \u2014 no llms.txt found"
+      };
+    }
+    if (ctx.sitemapUrls.length === 0) {
+      return {
+        id: "llms-txt-freshness",
+        name: "llms.txt Coverage",
+        category: "content-discoverability",
+        status: "info",
+        message: "No sitemap found to compare coverage against"
+      };
+    }
+    const sharedRegistrable = (a, b) => {
+      if (a === b) return true;
+      const aParts = a.split(".");
+      const bParts = b.split(".");
+      const tail = (parts) => parts.slice(-2).join(".");
+      return aParts.length >= 2 && bParts.length >= 2 && tail(aParts) === tail(bParts);
+    };
+    const keyFor = (raw) => {
+      try {
+        const u = new URL(raw, ctx.baseUrl.origin);
+        if (!sharedRegistrable(u.hostname, ctx.baseUrl.hostname)) return null;
+        let path = u.pathname.length > 1 ? u.pathname.replace(/\/+$/, "") : u.pathname;
+        path = path.replace(/\.(md|mdx|markdown)$/i, "");
+        return path.toLowerCase();
+      } catch {
+        return null;
+      }
+    };
+    const linkRegex = /\[.+?\]\(([^)]+)\)/g;
+    const llmsKeys = /* @__PURE__ */ new Set();
+    let match;
+    while ((match = linkRegex.exec(ctx.llmsTxt)) !== null) {
+      const k = keyFor(match[1]);
+      if (k) llmsKeys.add(k);
+    }
+    const sitemapKeys = /* @__PURE__ */ new Set();
+    for (const u of ctx.sitemapUrls) {
+      const k = keyFor(u);
+      if (k) sitemapKeys.add(k);
+    }
+    if (sitemapKeys.size === 0 || llmsKeys.size === 0) {
+      return {
+        id: "llms-txt-freshness",
+        name: "llms.txt Coverage",
+        category: "content-discoverability",
+        status: "skip",
+        message: "Not enough same-origin pages to compare llms.txt and sitemap"
+      };
+    }
+    const llmsInSitemap = [...llmsKeys].filter((k) => sitemapKeys.has(k)).length;
+    const sitemapInLlms = [...sitemapKeys].filter((k) => llmsKeys.has(k)).length;
+    const freshnessPct = Math.round(llmsInSitemap / llmsKeys.size * 100);
+    const coveragePct = Math.round(sitemapInLlms / sitemapKeys.size * 100);
+    const message = `llms.txt covers ${coveragePct}% of ${sitemapKeys.size} sitemap pages; ${freshnessPct}% of llms.txt links resolve in sitemap`;
+    if (coveragePct >= 70 && freshnessPct >= 90) {
+      return {
+        id: "llms-txt-freshness",
+        name: "llms.txt Coverage",
+        category: "content-discoverability",
+        status: "pass",
+        message,
+        metadata: { coveragePct, freshnessPct, llmsCount: llmsKeys.size, sitemapCount: sitemapKeys.size }
+      };
+    }
+    const missingFromLlms = sitemapKeys.size - sitemapInLlms;
+    const staleInLlms = llmsKeys.size - llmsInSitemap;
+    return {
+      id: "llms-txt-freshness",
+      name: "llms.txt Coverage",
+      category: "content-discoverability",
+      status: coveragePct >= 40 || freshnessPct >= 70 ? "warn" : "fail",
+      message: `${message}${missingFromLlms > 0 ? ` \xB7 ${missingFromLlms} sitemap pages not in llms.txt` : ""}${staleInLlms > 0 ? ` \xB7 ${staleInLlms} llms.txt links not in sitemap` : ""}`,
+      suggestion: coveragePct < freshnessPct ? "Add missing sitemap pages to llms.txt to improve AI agent discoverability." : "Some llms.txt links aren't in the sitemap \u2014 they may be stale or your sitemap may be incomplete.",
+      metadata: {
+        coveragePct,
+        freshnessPct,
+        llmsCount: llmsKeys.size,
+        sitemapCount: sitemapKeys.size,
+        missingFromLlms,
+        staleInLlms
+      }
+    };
+  }
+};
+var llmsTxtLinksResolve = {
+  id: "llms-txt-links-resolve",
+  name: "llms.txt Links Resolve",
+  category: "content-discoverability",
+  description: "Checks if links in llms.txt return 200 OK",
+  weight: 0.8,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    if (!ctx.llmsTxt) {
+      return {
+        id: "llms-txt-links-resolve",
+        name: "llms.txt Links Resolve",
+        category: "content-discoverability",
+        status: "skip",
+        message: "Skipped \u2014 no llms.txt found"
+      };
+    }
+    const linkRegex = /\[.+?\]\(([^)]+)\)/g;
+    const urls = [];
+    let match;
+    while ((match = linkRegex.exec(ctx.llmsTxt)) !== null) {
+      try {
+        const resolved2 = new URL(match[1], ctx.baseUrl.origin);
+        if (resolved2.origin === ctx.baseUrl.origin) {
+          urls.push(resolved2.href);
+        }
+      } catch {
+      }
+    }
+    if (urls.length === 0) {
+      return {
+        id: "llms-txt-links-resolve",
+        name: "llms.txt Links Resolve",
+        category: "content-discoverability",
+        status: "info",
+        message: "No same-origin links found in llms.txt"
+      };
+    }
+    const sampled = urls.slice(0, 10);
+    const results = await Promise.allSettled(
+      sampled.map(async (url) => {
+        const resp = await fetch(url, { method: "HEAD", redirect: "follow" });
+        return { url, status: resp.status };
+      })
+    );
+    const resolved = results.filter(
+      (r) => r.status === "fulfilled" && r.value.status >= 200 && r.value.status < 400
+    ).length;
+    if (resolved === sampled.length) {
+      return {
+        id: "llms-txt-links-resolve",
+        name: "llms.txt Links Resolve",
+        category: "content-discoverability",
+        status: "pass",
+        message: `All ${resolved} sampled same-origin links resolve (${urls.length} total links)`,
+        metadata: { resolved, sampled: sampled.length, total: urls.length }
+      };
+    }
+    return {
+      id: "llms-txt-links-resolve",
+      name: "llms.txt Links Resolve",
+      category: "content-discoverability",
+      status: "fail",
+      message: `${resolved}/${sampled.length} sampled links resolve \u2014 ${sampled.length - resolved} broken`,
+      suggestion: "Fix broken links in llms.txt. AI agents will fail to fetch these pages.",
+      metadata: { resolved, sampled: sampled.length, total: urls.length }
+    };
+  }
+};
+var llmsTxtLinksMarkdown = {
+  id: "llms-txt-links-markdown",
+  name: "llms.txt Links Markdown",
+  category: "content-discoverability",
+  description: "Checks how many links in llms.txt point to .md URLs (or markdown-able paths)",
+  weight: 0.6,
+  run: async (ctx) => {
+    if (!ctx.llmsTxt) {
+      return {
+        id: "llms-txt-links-markdown",
+        name: "llms.txt Links Markdown",
+        category: "content-discoverability",
+        status: "skip",
+        message: "Skipped \u2014 no llms.txt found"
+      };
+    }
+    const linkRegex = /\[.+?\]\(([^)]+)\)/g;
+    const urls = [];
+    let m;
+    while ((m = linkRegex.exec(ctx.llmsTxt)) !== null) {
+      urls.push(m[1]);
+    }
+    if (urls.length === 0) {
+      return {
+        id: "llms-txt-links-markdown",
+        name: "llms.txt Links Markdown",
+        category: "content-discoverability",
+        status: "info",
+        message: "No links found in llms.txt"
+      };
+    }
+    const isMd = (u) => {
+      try {
+        const parsed = new URL(u, ctx.baseUrl.origin);
+        const path = parsed.pathname.toLowerCase();
+        return path.endsWith(".md") || path.endsWith(".mdx") || path.endsWith(".markdown");
+      } catch {
+        return /\.mdx?$/i.test(u);
+      }
+    };
+    const mdLinks = urls.filter(isMd).length;
+    const pct = Math.round(mdLinks / urls.length * 100);
+    if (pct >= 80) {
+      return {
+        id: "llms-txt-links-markdown",
+        name: "llms.txt Links Markdown",
+        category: "content-discoverability",
+        status: "pass",
+        message: `${mdLinks}/${urls.length} llms.txt links point to .md URLs (${pct}%)`,
+        metadata: { mdLinks, total: urls.length, pct }
+      };
+    }
+    if (pct >= 30) {
+      return {
+        id: "llms-txt-links-markdown",
+        name: "llms.txt Links Markdown",
+        category: "content-discoverability",
+        status: "warn",
+        message: `${mdLinks}/${urls.length} llms.txt links point to .md URLs (${pct}%)`,
+        suggestion: "Point llms.txt links to .md URLs (or markdown-able paths) so agents fetch parseable content directly instead of HTML they have to scrape.",
+        metadata: { mdLinks, total: urls.length, pct }
+      };
+    }
+    return {
+      id: "llms-txt-links-markdown",
+      name: "llms.txt Links Markdown",
+      category: "content-discoverability",
+      status: "fail",
+      message: `Only ${mdLinks}/${urls.length} llms.txt links point to .md URLs (${pct}%)`,
+      suggestion: "Most llms.txt links are HTML-only. Serve a markdown version at .md URLs and link to those \u2014 agents get cleaner content and fewer parse failures.",
+      metadata: { mdLinks, total: urls.length, pct }
+    };
+  }
+};
+var sitemapExists = {
+  id: "sitemap-exists",
+  name: "Sitemap Exists",
+  category: "content-discoverability",
+  description: "Checks if sitemap.xml is present",
+  weight: 0.7,
+  run: async (ctx) => {
+    if (ctx.sitemapXml) {
+      return {
+        id: "sitemap-exists",
+        name: "Sitemap Exists",
+        category: "content-discoverability",
+        status: "pass",
+        message: `sitemap.xml found with ${ctx.sitemapUrls.length} URLs`,
+        metadata: { urlCount: ctx.sitemapUrls.length }
+      };
+    }
+    return {
+      id: "sitemap-exists",
+      name: "Sitemap Exists",
+      category: "content-discoverability",
+      status: "fail",
+      message: "No sitemap.xml found",
+      suggestion: "Create a /sitemap.xml to help AI agents discover all pages on your site."
+    };
+  }
+};
+var robotsTxtAgentRules = {
+  id: "robots-txt-agent-rules",
+  name: "robots.txt AI Agent Rules",
+  category: "content-discoverability",
+  description: "Checks if robots.txt has specific rules for AI agents/crawlers",
+  weight: 0.6,
+  run: async (ctx) => {
+    if (!ctx.robotsTxt) {
+      return {
+        id: "robots-txt-agent-rules",
+        name: "robots.txt AI Agent Rules",
+        category: "content-discoverability",
+        status: "warn",
+        message: "No robots.txt found",
+        suggestion: "Create a /robots.txt. Without it, AI agents may not know what they're allowed to crawl."
+      };
+    }
+    const aiAgents = [
+      "GPTBot",
+      "ChatGPT-User",
+      "Claude-Web",
+      "ClaudeBot",
+      "Anthropic",
+      "Google-Extended",
+      "PerplexityBot",
+      "Bytespider",
+      "CCBot",
+      "cohere-ai"
+    ];
+    const blocked = [];
+    const allowed = [];
+    const lines = ctx.robotsTxt.split("\n");
+    let currentAgent = "";
+    for (const line of lines) {
+      const agentMatch = line.match(/^User-agent:\s*(.+)/i);
+      if (agentMatch) {
+        currentAgent = agentMatch[1].trim();
+        continue;
+      }
+      const matchedAgent = aiAgents.find(
+        (a) => currentAgent === a || currentAgent === "*"
+      );
+      if (!matchedAgent) continue;
+      if (/^Disallow:\s*\/\s*$/i.test(line) && currentAgent !== "*") {
+        blocked.push(currentAgent);
+      } else if (/^Allow:\s*\//i.test(line) && currentAgent !== "*") {
+        allowed.push(currentAgent);
+      }
+    }
+    if (blocked.length > 0) {
+      return {
+        id: "robots-txt-agent-rules",
+        name: "robots.txt AI Agent Rules",
+        category: "content-discoverability",
+        status: "warn",
+        message: `AI agents blocked: ${blocked.join(", ")}`,
+        suggestion: "Consider allowing AI agents to crawl your site for better GEO visibility. Blocked agents can't index your content for AI-powered search.",
+        metadata: { blocked, allowed }
+      };
+    }
+    return {
+      id: "robots-txt-agent-rules",
+      name: "robots.txt AI Agent Rules",
+      category: "content-discoverability",
+      status: "pass",
+      message: `robots.txt present. No AI agents explicitly blocked.${allowed.length > 0 ? ` Explicitly allowed: ${allowed.join(", ")}` : ""}`,
+      metadata: { blocked, allowed }
+    };
+  }
+};
+var contentDiscoverabilityChecks = [
+  llmsTxtExists,
+  llmsTxtValid,
+  llmsTxtSize,
+  llmsTxtFreshness,
+  llmsTxtLinksResolve,
+  llmsTxtLinksMarkdown,
+  sitemapExists,
+  robotsTxtAgentRules
+];
+
+// src/utils/fetch.ts
+var makeHeaders = (config) => ({
+  "User-Agent": config.userAgent ?? DEFAULT_CONFIG.userAgent,
+  Accept: "text/html,application/xhtml+xml,text/markdown,text/plain,*/*"
+});
+var fetchPage = async (url, config = {}) => {
+  const timeout = config.timeout ?? DEFAULT_CONFIG.timeout;
+  const start = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      headers: makeHeaders(config),
+      signal: controller.signal,
+      redirect: "follow"
+    });
+    const html = await response.text();
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      url,
+      html,
+      statusCode: response.status,
+      headers,
+      fetchTime: Date.now() - start
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var fetchText = async (url, config = {}) => {
+  try {
+    const result = await fetchPage(url, config);
+    return { text: result.html, statusCode: result.statusCode, headers: result.headers };
+  } catch {
+    return null;
+  }
+};
+var fetchWithContentNegotiation = async (url, accept, config = {}) => {
+  const timeout = config.timeout ?? DEFAULT_CONFIG.timeout;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": config.userAgent ?? DEFAULT_CONFIG.userAgent,
+        Accept: accept
+      },
+      signal: controller.signal,
+      redirect: "follow"
+    });
+    const text = await response.text();
+    return {
+      text,
+      statusCode: response.status,
+      contentType: response.headers.get("content-type") ?? ""
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var fetchMany = async (urls, config = {}) => {
+  const concurrency = config.concurrency ?? DEFAULT_CONFIG.concurrency;
+  const results = [];
+  for (let i = 0; i < urls.length; i += concurrency) {
+    const chunk = urls.slice(i, i + concurrency);
+    const chunkResults = await Promise.allSettled(
+      chunk.map((url) => fetchPage(url, config))
+    );
+    for (const result of chunkResults) {
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      }
+    }
+  }
+  return results;
+};
+
+// src/checks/markdown-availability.ts
+var markdownUrlSupport = {
+  id: "markdown-url-support",
+  name: "Markdown URL Support",
+  category: "markdown-availability",
+  description: "Checks if pages serve markdown when .md is appended to the URL",
+  weight: 0.8,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "markdown-url-support",
+        name: "Markdown URL Support",
+        category: "markdown-availability",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    let supported = 0;
+    for (const page of pages) {
+      const mdUrl = page.url.replace(/\/?$/, ".md");
+      const result = await fetchWithContentNegotiation(mdUrl, "text/markdown");
+      if (result && result.statusCode === 200 && result.text.length > 50) {
+        supported++;
+      }
+    }
+    const pct = Math.round(supported / pages.length * 100);
+    if (supported === pages.length) {
+      return {
+        id: "markdown-url-support",
+        name: "Markdown URL Support",
+        category: "markdown-availability",
+        status: "pass",
+        message: `${supported}/${pages.length} sampled pages support .md URLs (${pct}%)`,
+        metadata: { supported, total: pages.length }
+      };
+    }
+    return {
+      id: "markdown-url-support",
+      name: "Markdown URL Support",
+      category: "markdown-availability",
+      status: supported > 0 ? "warn" : "fail",
+      message: `${supported}/${pages.length} sampled pages support .md URLs (${pct}%)`,
+      suggestion: "Serve markdown versions of pages at {url}.md \u2014 this makes content easily consumable by AI agents without HTML parsing.",
+      metadata: { supported, total: pages.length }
+    };
+  }
+};
+var contentNegotiation = {
+  id: "content-negotiation",
+  name: "Content Negotiation",
+  category: "markdown-availability",
+  description: "Checks if pages serve markdown when Accept: text/markdown is sent",
+  weight: 0.7,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "content-negotiation",
+        name: "Content Negotiation",
+        category: "markdown-availability",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    let supported = 0;
+    for (const page of pages) {
+      const result = await fetchWithContentNegotiation(page.url, "text/markdown");
+      if (result && result.statusCode === 200 && (result.contentType.includes("text/markdown") || result.contentType.includes("text/plain"))) {
+        supported++;
+      }
+    }
+    const pct = Math.round(supported / pages.length * 100);
+    if (supported === pages.length) {
+      return {
+        id: "content-negotiation",
+        name: "Content Negotiation",
+        category: "markdown-availability",
+        status: "pass",
+        message: `${supported}/${pages.length} sampled pages support content negotiation (${pct}%)`,
+        metadata: { supported, total: pages.length }
+      };
+    }
+    return {
+      id: "content-negotiation",
+      name: "Content Negotiation",
+      category: "markdown-availability",
+      status: supported > 0 ? "warn" : "info",
+      message: `${supported}/${pages.length} sampled pages support content negotiation (${pct}%)`,
+      suggestion: "Implement content negotiation: when an AI agent sends Accept: text/markdown, respond with a markdown version of the page.",
+      metadata: { supported, total: pages.length }
+    };
+  }
+};
+var markdownContentParity = {
+  id: "markdown-content-parity",
+  name: "Markdown Content Parity",
+  category: "markdown-availability",
+  description: "Checks if markdown versions contain equivalent content to HTML versions",
+  weight: 0.6,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    const pagesWithMarkdown = pages.filter((p) => p.markdown);
+    if (pagesWithMarkdown.length === 0) {
+      return {
+        id: "markdown-content-parity",
+        name: "Markdown Content Parity",
+        category: "markdown-availability",
+        status: "skip",
+        message: "No pages with markdown versions found"
+      };
+    }
+    let totalMissing = 0;
+    let checked = 0;
+    for (const page of pagesWithMarkdown) {
+      if (!page.markdown) continue;
+      checked++;
+      const htmlText = page.html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+      const htmlWords = new Set(htmlText.toLowerCase().split(/\s+/).filter((w) => w.length > 3));
+      const mdWords = new Set(page.markdown.toLowerCase().split(/\s+/).filter((w) => w.length > 3));
+      const missingWords = [...htmlWords].filter((w) => !mdWords.has(w));
+      const missingPct = htmlWords.size > 0 ? missingWords.length / htmlWords.size * 100 : 0;
+      totalMissing += missingPct;
+    }
+    const avgMissing = checked > 0 ? Math.round(totalMissing / checked) : 0;
+    if (avgMissing <= 5) {
+      return {
+        id: "markdown-content-parity",
+        name: "Markdown Content Parity",
+        category: "markdown-availability",
+        status: "pass",
+        message: `All ${checked} pages have equivalent markdown and HTML content (avg ${avgMissing}% missing)`,
+        metadata: { checked, avgMissing }
+      };
+    }
+    return {
+      id: "markdown-content-parity",
+      name: "Markdown Content Parity",
+      category: "markdown-availability",
+      status: avgMissing <= 15 ? "warn" : "fail",
+      message: `Markdown versions are missing ~${avgMissing}% of HTML content on average`,
+      suggestion: "Ensure markdown versions include all meaningful content from the HTML page. Missing content means AI agents get an incomplete picture.",
+      metadata: { checked, avgMissing }
+    };
+  }
+};
+var markdownAvailabilityChecks = [
+  markdownUrlSupport,
+  contentNegotiation,
+  markdownContentParity
+];
+
+// src/utils/html.ts
+var stripHtml = (html) => html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+var extractLinks = (html, baseUrl) => {
+  const links = [];
+  const linkRegex = /<a[^>]+href=["']([^"']+)["']/gi;
+  let match;
+  while ((match = linkRegex.exec(html)) !== null) {
+    try {
+      const resolved = new URL(match[1], baseUrl).href;
+      links.push(resolved);
+    } catch {
+    }
+  }
+  return links;
+};
+var extractMetaTags = (html) => {
+  const meta = {};
+  const metaRegex = /<meta[^>]+(?:name|property)=["']([^"']+)["'][^>]+content=["']([^"']+)["']/gi;
+  let match;
+  while ((match = metaRegex.exec(html)) !== null) {
+    meta[match[1]] = match[2];
+  }
+  const metaRegex2 = /<meta[^>]+content=["']([^"']+)["'][^>]+(?:name|property)=["']([^"']+)["']/gi;
+  while ((match = metaRegex2.exec(html)) !== null) {
+    meta[match[2]] = match[1];
+  }
+  return meta;
+};
+var extractJsonLd = (html) => {
+  const results = [];
+  const regex = /<script[^>]+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    try {
+      results.push(JSON.parse(match[1]));
+    } catch {
+    }
+  }
+  return results;
+};
+var extractHeadings = (html) => {
+  const headings = [];
+  const regex = /<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi;
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    headings.push({
+      level: parseInt(match[1], 10),
+      text: stripHtml(match[2]).trim()
+    });
+  }
+  return headings;
+};
+var hasServerRenderedContent = (html) => {
+  const withoutScripts = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "");
+  const textContent = stripHtml(withoutScripts);
+  return textContent.length > 100;
+};
+var findContentStartPosition = (html) => {
+  const markers = [
+    /<main[\s>]/i,
+    /<article[\s>]/i,
+    /id=["']content["']/i,
+    /id=["']main["']/i,
+    /class=["'][^"']*content[^"']*["']/i,
+    /role=["']main["']/i
+  ];
+  for (const marker of markers) {
+    const match = html.search(marker);
+    if (match >= 0) {
+      return match / html.length;
+    }
+  }
+  const firstP = html.search(/<p[\s>]/i);
+  if (firstP >= 0) {
+    return firstP / html.length;
+  }
+  return 0.5;
+};
+var extractCodeFences = (markdown) => {
+  const fences = [];
+  const lines = markdown.split("\n");
+  let inFence = false;
+  let currentLang = "";
+  for (const line of lines) {
+    const openMatch = line.match(/^```(\w*)/);
+    if (openMatch && !inFence) {
+      inFence = true;
+      currentLang = openMatch[1] ?? "";
+    } else if (line.trim() === "```" && inFence) {
+      fences.push({ lang: currentLang, closed: true });
+      inFence = false;
+      currentLang = "";
+    }
+  }
+  if (inFence) {
+    fences.push({ lang: currentLang, closed: false });
+  }
+  return fences;
+};
+var parseSitemapUrls = (xml) => {
+  const urls = [];
+  const regex = /<loc>([^<]+)<\/loc>/gi;
+  let match;
+  while ((match = regex.exec(xml)) !== null) {
+    urls.push(match[1].trim());
+  }
+  return urls;
+};
+
+// src/checks/page-size.ts
+var MAX_HTML_CHARS = 5e4;
+var MAX_MD_CHARS = 5e4;
+var renderingStrategy = {
+  id: "rendering-strategy",
+  name: "Rendering Strategy",
+  category: "page-size",
+  description: "Checks if pages contain server-rendered content (vs client-side only)",
+  weight: 1,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "rendering-strategy",
+        name: "Rendering Strategy",
+        category: "page-size",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    let ssrCount = 0;
+    for (const page of pages) {
+      if (hasServerRenderedContent(page.html)) ssrCount++;
+    }
+    if (ssrCount === pages.length) {
+      return {
+        id: "rendering-strategy",
+        name: "Rendering Strategy",
+        category: "page-size",
+        status: "pass",
+        message: `All ${pages.length} sampled pages contain server-rendered content`
+      };
+    }
+    const csrCount = pages.length - ssrCount;
+    return {
+      id: "rendering-strategy",
+      name: "Rendering Strategy",
+      category: "page-size",
+      status: csrCount > pages.length / 2 ? "fail" : "warn",
+      message: `${csrCount}/${pages.length} pages appear to be client-side rendered only`,
+      suggestion: "AI agents and crawlers can't execute JavaScript. Use SSR, SSG, or pre-rendering to ensure your content is in the initial HTML response."
+    };
+  }
+};
+var pageSizeHtml = {
+  id: "page-size-html",
+  name: "Page Size (HTML)",
+  category: "page-size",
+  description: "Checks if HTML pages convert to under 50K characters of text content",
+  weight: 0.6,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "page-size-html",
+        name: "Page Size (HTML)",
+        category: "page-size",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    const sizes = pages.map((p) => {
+      const textContent = stripHtml(p.html);
+      const boilerplate = Math.round((1 - textContent.length / Math.max(p.html.length, 1)) * 100);
+      return { url: p.url, htmlSize: p.html.length, textSize: textContent.length, boilerplate };
+    });
+    const overLimit = sizes.filter((s) => s.textSize > MAX_HTML_CHARS);
+    const median = sizes.map((s) => s.textSize).sort((a, b) => a - b)[Math.floor(sizes.length / 2)];
+    const avgBoilerplate = Math.round(sizes.reduce((sum, s) => sum + s.boilerplate, 0) / sizes.length);
+    if (overLimit.length === 0) {
+      return {
+        id: "page-size-html",
+        name: "Page Size (HTML)",
+        category: "page-size",
+        status: "pass",
+        message: `All ${pages.length} sampled pages convert under ${(MAX_HTML_CHARS / 1e3).toFixed(0)}K chars (median ${(median / 1e3).toFixed(0)}K, ${avgBoilerplate}% boilerplate)`,
+        metadata: { median, avgBoilerplate }
+      };
+    }
+    return {
+      id: "page-size-html",
+      name: "Page Size (HTML)",
+      category: "page-size",
+      status: "warn",
+      message: `${overLimit.length}/${pages.length} pages exceed ${(MAX_HTML_CHARS / 1e3).toFixed(0)}K chars of content`,
+      suggestion: "Large pages may be truncated by AI agents. Consider splitting into smaller, focused pages or providing a table of contents.",
+      metadata: { overLimit: overLimit.length, median, avgBoilerplate }
+    };
+  }
+};
+var pageSizeMarkdown = {
+  id: "page-size-markdown",
+  name: "Page Size (Markdown)",
+  category: "page-size",
+  description: "Checks if markdown versions are under 50K characters",
+  weight: 0.5,
+  run: async (ctx) => {
+    const pagesWithMd = ctx.sampledPages.filter((p) => p.markdown).slice(0, 10);
+    if (pagesWithMd.length === 0) {
+      return {
+        id: "page-size-markdown",
+        name: "Page Size (Markdown)",
+        category: "page-size",
+        status: "skip",
+        message: "No markdown versions available"
+      };
+    }
+    const sizes = pagesWithMd.map((p) => ({ url: p.url, size: p.markdown.length }));
+    const overLimit = sizes.filter((s) => s.size > MAX_MD_CHARS);
+    const median = sizes.map((s) => s.size).sort((a, b) => a - b)[Math.floor(sizes.length / 2)];
+    const max = Math.max(...sizes.map((s) => s.size));
+    if (overLimit.length === 0) {
+      return {
+        id: "page-size-markdown",
+        name: "Page Size (Markdown)",
+        category: "page-size",
+        status: "pass",
+        message: `All ${pagesWithMd.length} pages under ${(MAX_MD_CHARS / 1e3).toFixed(0)}K chars (median ${(median / 1e3).toFixed(0)}K, max ${(max / 1e3).toFixed(0)}K)`,
+        metadata: { median, max }
+      };
+    }
+    return {
+      id: "page-size-markdown",
+      name: "Page Size (Markdown)",
+      category: "page-size",
+      status: "warn",
+      message: `${overLimit.length}/${pagesWithMd.length} markdown pages exceed ${(MAX_MD_CHARS / 1e3).toFixed(0)}K chars`,
+      suggestion: "Split large markdown pages into smaller sections to avoid AI agent context window truncation."
+    };
+  }
+};
+var contentStartPosition = {
+  id: "content-start-position",
+  name: "Content Start Position",
+  category: "page-size",
+  description: "Checks if main content starts within the first 10% of the HTML",
+  weight: 0.5,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "content-start-position",
+        name: "Content Start Position",
+        category: "page-size",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    const positions = pages.map((p) => ({
+      url: p.url,
+      position: findContentStartPosition(p.html)
+    }));
+    const earlyStart = positions.filter((p) => p.position <= 0.1);
+    const medianPct = Math.round(
+      positions.map((p) => p.position).sort((a, b) => a - b)[Math.floor(positions.length / 2)] * 100
+    );
+    if (earlyStart.length === pages.length) {
+      return {
+        id: "content-start-position",
+        name: "Content Start Position",
+        category: "page-size",
+        status: "pass",
+        message: `Content starts within first 10% on all ${pages.length} sampled pages (median ${medianPct}%)`,
+        metadata: { medianPct }
+      };
+    }
+    return {
+      id: "content-start-position",
+      name: "Content Start Position",
+      category: "page-size",
+      status: "warn",
+      message: `Content starts late on ${pages.length - earlyStart.length}/${pages.length} pages (median ${medianPct}%)`,
+      suggestion: "Move main content higher in the HTML. AI agents may waste context window tokens on navigation, headers, and boilerplate before reaching actual content.",
+      metadata: { medianPct, earlyStart: earlyStart.length }
+    };
+  }
+};
+var pageSizeChecks = [
+  renderingStrategy,
+  pageSizeHtml,
+  pageSizeMarkdown,
+  contentStartPosition
+];
+
+// src/checks/content-structure.ts
+var markdownCodeFenceValidity = {
+  id: "markdown-code-fence-validity",
+  name: "Markdown Code Fence Validity",
+  category: "content-structure",
+  description: "Checks if all code fences in markdown content are properly closed",
+  weight: 0.5,
+  run: async (ctx) => {
+    const pagesWithMd = ctx.sampledPages.filter((p) => p.markdown);
+    if (pagesWithMd.length === 0) {
+      let totalFences2 = 0;
+      let unclosed2 = 0;
+      for (const page of ctx.sampledPages.slice(0, 10)) {
+        const codeBlockRegex = /<code[\s\S]*?<\/code>/gi;
+        const matches = page.html.match(codeBlockRegex);
+        if (matches) totalFences2 += matches.length;
+      }
+      if (totalFences2 === 0) {
+        return {
+          id: "markdown-code-fence-validity",
+          name: "Markdown Code Fence Validity",
+          category: "content-structure",
+          status: "info",
+          message: "No code blocks detected"
+        };
+      }
+      return {
+        id: "markdown-code-fence-validity",
+        name: "Markdown Code Fence Validity",
+        category: "content-structure",
+        status: "pass",
+        message: `All ${totalFences2} code blocks properly closed across ${ctx.sampledPages.length} pages`
+      };
+    }
+    let totalFences = 0;
+    let unclosed = 0;
+    for (const page of pagesWithMd) {
+      const fences = extractCodeFences(page.markdown);
+      totalFences += fences.length;
+      unclosed += fences.filter((f) => !f.closed).length;
+    }
+    if (unclosed === 0) {
+      return {
+        id: "markdown-code-fence-validity",
+        name: "Markdown Code Fence Validity",
+        category: "content-structure",
+        status: "pass",
+        message: `All ${totalFences} code fences properly closed across ${pagesWithMd.length} pages`
+      };
+    }
+    return {
+      id: "markdown-code-fence-validity",
+      name: "Markdown Code Fence Validity",
+      category: "content-structure",
+      status: "fail",
+      message: `${unclosed} unclosed code fence(s) found across ${pagesWithMd.length} pages`,
+      suggestion: "Unclosed code fences cause AI agents to misparse content. Ensure every ``` has a matching closing ```."
+    };
+  }
+};
+var sectionHeaderQuality = {
+  id: "section-header-quality",
+  name: "Section Header Quality",
+  category: "content-structure",
+  description: "Checks if pages have a logical heading hierarchy (H1 \u2192 H2 \u2192 H3, no skips)",
+  weight: 0.6,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "section-header-quality",
+        name: "Section Header Quality",
+        category: "content-structure",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    let goodPages = 0;
+    const issues = [];
+    for (const page of pages) {
+      const headings = extractHeadings(page.html);
+      if (headings.length === 0) continue;
+      let pageGood = true;
+      const hasH1 = headings.some((h) => h.level === 1);
+      if (!hasH1) {
+        pageGood = false;
+      }
+      const h1Count = headings.filter((h) => h.level === 1).length;
+      if (h1Count > 1) {
+        pageGood = false;
+      }
+      for (let i = 1; i < headings.length; i++) {
+        const prev = headings[i - 1].level;
+        const curr = headings[i].level;
+        if (curr > prev + 1) {
+          pageGood = false;
+          break;
+        }
+      }
+      if (pageGood) goodPages++;
+    }
+    if (goodPages === pages.length) {
+      return {
+        id: "section-header-quality",
+        name: "Section Header Quality",
+        category: "content-structure",
+        status: "pass",
+        message: `All ${pages.length} pages have proper heading hierarchy`
+      };
+    }
+    return {
+      id: "section-header-quality",
+      name: "Section Header Quality",
+      category: "content-structure",
+      status: "warn",
+      message: `${pages.length - goodPages}/${pages.length} pages have heading hierarchy issues (skipped levels, missing H1, or multiple H1s)`,
+      suggestion: "Use a single H1 per page and don't skip heading levels (e.g., H1 \u2192 H3). AI agents use heading hierarchy to understand page structure and section boundaries."
+    };
+  }
+};
+var tabbedContentSerialization = {
+  id: "tabbed-content-serialization",
+  name: "Tabbed Content Serialization",
+  category: "content-structure",
+  description: "Checks if tabbed/accordion content is properly serialized in HTML",
+  weight: 0.4,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let pagesWithTabs = 0;
+    let pagesWithHiddenContent = 0;
+    for (const page of pages) {
+      const hasTabs = /role=["']tabpanel["']|data-tab|tab-content|tabs-container/i.test(page.html);
+      if (hasTabs) {
+        pagesWithTabs++;
+        const hiddenPanels = (page.html.match(/hidden|display:\s*none|aria-hidden=["']true["']/gi) ?? []).length;
+        if (hiddenPanels > 2) {
+          pagesWithHiddenContent++;
+        }
+      }
+    }
+    if (pagesWithTabs === 0) {
+      return {
+        id: "tabbed-content-serialization",
+        name: "Tabbed Content Serialization",
+        category: "content-structure",
+        status: "info",
+        message: `No tabbed content detected across ${pages.length} sampled pages`
+      };
+    }
+    if (pagesWithHiddenContent === 0) {
+      return {
+        id: "tabbed-content-serialization",
+        name: "Tabbed Content Serialization",
+        category: "content-structure",
+        status: "pass",
+        message: `${pagesWithTabs} pages with tabbed content \u2014 all tabs are server-rendered`
+      };
+    }
+    return {
+      id: "tabbed-content-serialization",
+      name: "Tabbed Content Serialization",
+      category: "content-structure",
+      status: "warn",
+      message: `${pagesWithHiddenContent}/${pagesWithTabs} tabbed pages have hidden content that AI agents may miss`,
+      suggestion: "Serialize all tab content in the HTML even if it's visually hidden. AI agents can't click tabs \u2014 they only see the initial HTML."
+    };
+  }
+};
+var contentStructureChecks = [
+  markdownCodeFenceValidity,
+  sectionHeaderQuality,
+  tabbedContentSerialization
+];
+
+// src/checks/url-stability.ts
+var httpStatusCodes = {
+  id: "http-status-codes",
+  name: "HTTP Status Codes",
+  category: "url-stability",
+  description: "Checks if the site returns proper 404 for bad URLs (vs soft 404s)",
+  weight: 0.6,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    const testUrls = [
+      `${ctx.baseUrl.origin}/this-page-definitely-does-not-exist-${Date.now()}`,
+      `${ctx.baseUrl.origin}/404-test-agentimization-audit`
+    ];
+    let proper404 = 0;
+    for (const url of testUrls) {
+      try {
+        const resp = await fetch(url, { method: "GET", redirect: "follow" });
+        if (resp.status === 404) proper404++;
+      } catch {
+      }
+    }
+    if (proper404 === testUrls.length) {
+      return {
+        id: "http-status-codes",
+        name: "HTTP Status Codes",
+        category: "url-stability",
+        status: "pass",
+        message: `All ${ctx.sampledPages.length} sampled pages return proper error codes for bad URLs`
+      };
+    }
+    return {
+      id: "http-status-codes",
+      name: "HTTP Status Codes",
+      category: "url-stability",
+      status: "warn",
+      message: "Site may be returning soft 404s (200 status for non-existent pages)",
+      suggestion: "Return proper 404 status codes for non-existent pages. Soft 404s confuse AI agents and waste their context on error pages."
+    };
+  }
+};
+var redirectBehavior = {
+  id: "redirect-behavior",
+  name: "Redirect Behavior",
+  category: "url-stability",
+  description: "Checks if sampled pages have clean redirect behavior (no excessive chains)",
+  weight: 0.4,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let redirected = 0;
+    for (const page of pages) {
+      if (page.headers["location"]) {
+        redirected++;
+      }
+    }
+    if (redirected === 0) {
+      return {
+        id: "redirect-behavior",
+        name: "Redirect Behavior",
+        category: "url-stability",
+        status: "pass",
+        message: `No redirects detected across ${pages.length} sampled pages`
+      };
+    }
+    return {
+      id: "redirect-behavior",
+      name: "Redirect Behavior",
+      category: "url-stability",
+      status: "warn",
+      message: `${redirected}/${pages.length} sampled pages involve redirects`,
+      suggestion: "Minimize redirects. Each redirect adds latency for AI agents and some agents may not follow redirect chains properly."
+    };
+  }
+};
+var cacheHeaderHygiene = {
+  id: "cache-header-hygiene",
+  name: "Cache Header Hygiene",
+  category: "url-stability",
+  description: "Checks if pages have appropriate cache headers for AI agent crawling",
+  weight: 0.4,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let withCacheHeaders = 0;
+    for (const page of pages) {
+      const hasCacheControl = !!page.headers["cache-control"];
+      const hasETag = !!page.headers["etag"];
+      const hasLastModified = !!page.headers["last-modified"];
+      if (hasCacheControl || hasETag || hasLastModified) {
+        withCacheHeaders++;
+      }
+    }
+    if (withCacheHeaders === pages.length) {
+      return {
+        id: "cache-header-hygiene",
+        name: "Cache Header Hygiene",
+        category: "url-stability",
+        status: "pass",
+        message: `All ${pages.length + 1} endpoints have appropriate cache headers`
+      };
+    }
+    return {
+      id: "cache-header-hygiene",
+      name: "Cache Header Hygiene",
+      category: "url-stability",
+      status: "warn",
+      message: `${pages.length - withCacheHeaders}/${pages.length} pages missing cache headers`,
+      suggestion: "Add Cache-Control, ETag, or Last-Modified headers. This helps AI agents efficiently re-crawl your content without re-fetching unchanged pages."
+    };
+  }
+};
+var urlStabilityChecks = [
+  httpStatusCodes,
+  redirectBehavior,
+  cacheHeaderHygiene
+];
+
+// src/checks/authentication.ts
+var authGateDetection = {
+  id: "auth-gate-detection",
+  name: "Auth Gate Detection",
+  category: "authentication",
+  description: "Checks if pages are publicly accessible without authentication",
+  weight: 0.9,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let gated = 0;
+    const gatedUrls = [];
+    for (const page of pages) {
+      const isGated = page.statusCode === 401 || page.statusCode === 403 || /login|sign.?in|authenticate/i.test(page.html.slice(0, 5e3)) && page.html.length < 5e3;
+      if (isGated) {
+        gated++;
+        gatedUrls.push(page.url);
+      }
+    }
+    if (gated === 0) {
+      return {
+        id: "auth-gate-detection",
+        name: "Auth Gate Detection",
+        category: "authentication",
+        status: "pass",
+        message: `All ${pages.length} sampled pages are publicly accessible`
+      };
+    }
+    return {
+      id: "auth-gate-detection",
+      name: "Auth Gate Detection",
+      category: "authentication",
+      status: "fail",
+      message: `${gated}/${pages.length} pages are behind an auth gate`,
+      suggestion: "AI agents can't authenticate. Move content you want discoverable to public pages, or provide an alternative access method (API, llms.txt summary).",
+      metadata: { gatedUrls }
+    };
+  }
+};
+var authAlternativeAccess = {
+  id: "auth-alternative-access",
+  name: "Auth Alternative Access",
+  category: "authentication",
+  description: "Checks if gated content has alternative access paths for AI agents",
+  weight: 0.5,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    const gated = pages.filter(
+      (p) => p.statusCode === 401 || p.statusCode === 403
+    );
+    if (gated.length === 0) {
+      return {
+        id: "auth-alternative-access",
+        name: "Auth Alternative Access",
+        category: "authentication",
+        status: "pass",
+        message: "All docs pages are publicly accessible; no alternative access paths needed"
+      };
+    }
+    const hasAlternative = ctx.llmsTxt && ctx.llmsTxt.length > 100;
+    if (hasAlternative) {
+      return {
+        id: "auth-alternative-access",
+        name: "Auth Alternative Access",
+        category: "authentication",
+        status: "warn",
+        message: `${gated.length} pages are gated but llms.txt provides alternative content summary`,
+        suggestion: "Consider expanding llms.txt to cover all gated content with sufficient detail for AI agents."
+      };
+    }
+    return {
+      id: "auth-alternative-access",
+      name: "Auth Alternative Access",
+      category: "authentication",
+      status: "fail",
+      message: `${gated.length} pages are gated with no alternative access for AI agents`,
+      suggestion: "Provide a public llms.txt or API endpoint that summarizes gated content. AI agents need some way to understand what's behind the auth wall."
+    };
+  }
+};
+var authenticationChecks = [
+  authGateDetection,
+  authAlternativeAccess
+];
+
+// src/checks/geo-signals.ts
+var detectFramework = (pages) => {
+  for (const page of pages) {
+    const xpb = (page.headers["x-powered-by"] ?? "").toLowerCase();
+    if (xpb.includes("next.js")) return "next";
+    if (xpb.includes("nuxt")) return "nuxt";
+    const html = page.html;
+    if (/\/_next\/static\//.test(html) || /<script[^>]+id="__NEXT_DATA__"/.test(html)) return "next";
+    if (/__NUXT__\s*=/.test(html) || /\/_nuxt\//.test(html)) return "nuxt";
+    if (/data-sveltekit-/.test(html)) return "sveltekit";
+    if (/<meta\s+name="generator"\s+content="Astro/i.test(html)) return "astro";
+    if (/<meta\s+name="generator"\s+content="WordPress/i.test(html)) return "wordpress";
+    if (/\/build\/_assets\/.*\.js/.test(html) && /window\.__remixContext/.test(html)) return "remix";
+  }
+  return null;
+};
+var FRAMEWORK_DOCS = {
+  next: "https://nextjs.org/docs/app/guides/json-ld",
+  nuxt: "https://nuxt.com/modules/schema-org",
+  sveltekit: "https://kit.svelte.dev/docs/seo#manual-setup-structured-data",
+  astro: "https://docs.astro.build/en/guides/integrations-guide/sitemap/#structured-data",
+  remix: "https://remix.run/docs/en/main/route/meta",
+  wordpress: "https://yoast.com/structured-data-with-schema-org-the-ultimate-guide/"
+};
+var frameworkHint = (fw) => {
+  if (fw && FRAMEWORK_DOCS[fw]) return ` See: ${FRAMEWORK_DOCS[fw]}`;
+  return " See: https://schema.org/docs/gs.html";
+};
+var structuredDataCoverage = {
+  id: "structured-data-coverage",
+  name: "Structured Data Coverage",
+  category: "geo-signals",
+  description: "Checks for schema.org / JSON-LD structured data on pages",
+  weight: 0.8,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let withStructuredData = 0;
+    const types = [];
+    for (const page of pages) {
+      const jsonLd = extractJsonLd(page.html);
+      if (jsonLd.length > 0) {
+        withStructuredData++;
+        for (const item of jsonLd) {
+          const type = item?.["@type"];
+          if (typeof type === "string") types.push(type);
+        }
+      }
+    }
+    const uniqueTypes = [...new Set(types)];
+    if (withStructuredData === pages.length) {
+      return {
+        id: "structured-data-coverage",
+        name: "Structured Data Coverage",
+        category: "geo-signals",
+        status: "pass",
+        message: `All ${pages.length} pages have structured data. Types: ${uniqueTypes.join(", ") || "detected"}`,
+        metadata: { withStructuredData, types: uniqueTypes }
+      };
+    }
+    const fw = detectFramework(pages);
+    if (withStructuredData > 0) {
+      return {
+        id: "structured-data-coverage",
+        name: "Structured Data Coverage",
+        category: "geo-signals",
+        status: "warn",
+        message: `${withStructuredData}/${pages.length} pages have structured data${uniqueTypes.length > 0 ? ` (${uniqueTypes.join(", ")})` : ""}`,
+        suggestion: `Add JSON-LD structured data (schema.org) to all pages. This helps generative engines understand your content type, authorship, and relationships.${frameworkHint(fw)}`,
+        metadata: { withStructuredData, types: uniqueTypes, framework: fw }
+      };
+    }
+    return {
+      id: "structured-data-coverage",
+      name: "Structured Data Coverage",
+      category: "geo-signals",
+      status: "fail",
+      message: "No structured data (JSON-LD / schema.org) found on any sampled page",
+      suggestion: `Add JSON-LD structured data to your pages. At minimum use Article, WebPage, or Organization schema. This is a strong GEO signal \u2014 generative engines use it to decide what to cite.${frameworkHint(fw)}`,
+      metadata: { framework: fw }
+    };
+  }
+};
+var citationWorthiness = {
+  id: "citation-worthiness",
+  name: "Citation Worthiness",
+  category: "geo-signals",
+  description: "Checks for content signals that make pages citable by AI (stats, data points, quotes, definitions)",
+  weight: 0.7,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let citablePages = 0;
+    const signals = {
+      withStats: 0,
+      withDefinitions: 0,
+      withQuotes: 0,
+      withLists: 0,
+      withTables: 0
+    };
+    for (const page of pages) {
+      const html = page.html;
+      let pageCitable = false;
+      if (/\d+%|\d+x|[0-9,]+\s+(users|customers|companies|downloads)/i.test(html)) {
+        signals.withStats++;
+        pageCitable = true;
+      }
+      if (/<dfn|<dt|"is a |"refers to |"means /i.test(html)) {
+        signals.withDefinitions++;
+        pageCitable = true;
+      }
+      if (/<blockquote/i.test(html)) {
+        signals.withQuotes++;
+        pageCitable = true;
+      }
+      if (/<table[\s\S]*?<\/table>/i.test(html)) {
+        signals.withTables++;
+        pageCitable = true;
+      }
+      if (/<ol[\s\S]*?<\/ol>/i.test(html)) {
+        signals.withLists++;
+        pageCitable = true;
+      }
+      if (pageCitable) citablePages++;
+    }
+    if (citablePages >= pages.length * 0.7) {
+      return {
+        id: "citation-worthiness",
+        name: "Citation Worthiness",
+        category: "geo-signals",
+        status: "pass",
+        message: `${citablePages}/${pages.length} pages contain citable content (stats, definitions, tables, structured data)`,
+        metadata: signals
+      };
+    }
+    return {
+      id: "citation-worthiness",
+      name: "Citation Worthiness",
+      category: "geo-signals",
+      status: citablePages > 0 ? "warn" : "fail",
+      message: `Only ${citablePages}/${pages.length} pages contain citable content signals`,
+      suggestion: "Add concrete data points, statistics, definitions, and structured information. Generative engines prefer citing content with specific, verifiable claims over vague prose.",
+      metadata: signals
+    };
+  }
+};
+var topicalAuthoritySignals = {
+  id: "topical-authority-signals",
+  name: "Topical Authority Signals",
+  category: "geo-signals",
+  description: "Checks internal linking depth and content clustering as authority signals",
+  weight: 0.6,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let totalInternalLinks = 0;
+    let pagesWithGoodLinking = 0;
+    for (const page of pages) {
+      const links = extractLinks(page.html, ctx.baseUrl.origin);
+      const internalLinks = ctx.mode === "local" ? links.filter((l) => !l.startsWith("http://") && !l.startsWith("https://")) : links.filter((l) => {
+        try {
+          return new URL(l).origin === ctx.baseUrl.origin;
+        } catch {
+          return false;
+        }
+      });
+      totalInternalLinks += internalLinks.length;
+      if (internalLinks.length >= 3) pagesWithGoodLinking++;
+    }
+    const avgLinks = pages.length > 0 ? Math.round(totalInternalLinks / pages.length) : 0;
+    if (avgLinks >= 5 && pagesWithGoodLinking >= pages.length * 0.7) {
+      return {
+        id: "topical-authority-signals",
+        name: "Topical Authority Signals",
+        category: "geo-signals",
+        status: "pass",
+        message: `Strong internal linking: avg ${avgLinks} internal links/page, ${pagesWithGoodLinking}/${pages.length} pages well-connected`,
+        metadata: { avgLinks, pagesWithGoodLinking }
+      };
+    }
+    return {
+      id: "topical-authority-signals",
+      name: "Topical Authority Signals",
+      category: "geo-signals",
+      status: avgLinks >= 2 ? "warn" : "fail",
+      message: `Weak internal linking: avg ${avgLinks} internal links/page`,
+      suggestion: "Increase internal linking between related pages. Generative engines use link density and clustering to assess topical authority \u2014 well-linked content is more likely to be cited.",
+      metadata: { avgLinks, pagesWithGoodLinking }
+    };
+  }
+};
+var contentFreshness = {
+  id: "content-freshness",
+  name: "Content Freshness",
+  category: "geo-signals",
+  description: "Checks for date signals (last-modified headers, published dates, updated dates)",
+  weight: 0.5,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let withDateSignals = 0;
+    for (const page of pages) {
+      const hasLastModified = !!page.headers["last-modified"];
+      const meta = extractMetaTags(page.html);
+      const hasDateMeta = !!meta["article:published_time"] || !!meta["article:modified_time"] || !!meta["date"] || !!meta["last-modified"];
+      const jsonLd = extractJsonLd(page.html);
+      const hasDateJsonLd = jsonLd.some((item) => {
+        const obj = item;
+        return !!obj?.datePublished || !!obj?.dateModified;
+      });
+      if (hasLastModified || hasDateMeta || hasDateJsonLd) {
+        withDateSignals++;
+      }
+    }
+    if (withDateSignals >= pages.length * 0.8) {
+      return {
+        id: "content-freshness",
+        name: "Content Freshness",
+        category: "geo-signals",
+        status: "pass",
+        message: `${withDateSignals}/${pages.length} pages have date/freshness signals`,
+        metadata: { withDateSignals }
+      };
+    }
+    return {
+      id: "content-freshness",
+      name: "Content Freshness",
+      category: "geo-signals",
+      status: "warn",
+      message: `Only ${withDateSignals}/${pages.length} pages have date/freshness signals`,
+      suggestion: "Add Last-Modified headers, article:modified_time meta tags, or dateModified in JSON-LD. Generative engines favor fresh content and use date signals to assess relevance.",
+      metadata: { withDateSignals }
+    };
+  }
+};
+var eeatSignals = {
+  id: "eeat-signals",
+  name: "E-E-A-T Signals",
+  category: "geo-signals",
+  description: "Checks for author attribution, expertise markers, and trust signals",
+  weight: 0.6,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let withAuthor = 0;
+    let withExpertise = 0;
+    for (const page of pages) {
+      const meta = extractMetaTags(page.html);
+      const jsonLd = extractJsonLd(page.html);
+      const hasAuthorMeta = !!meta["author"] || !!meta["article:author"];
+      const hasAuthorJsonLd = jsonLd.some((item) => {
+        const obj = item;
+        return !!obj?.author;
+      });
+      const hasAuthorHtml = /class=["'][^"']*author[^"']*["']|rel=["']author["']/i.test(page.html);
+      if (hasAuthorMeta || hasAuthorJsonLd || hasAuthorHtml) withAuthor++;
+      const hasCredentials = /Ph\.?D|M\.?D|CPA|certified|licensed|expert|specialist/i.test(page.html);
+      const hasAboutPage = extractLinks(page.html, ctx.baseUrl.origin).some((l) => /about|team|author/i.test(l));
+      if (hasCredentials || hasAboutPage) withExpertise++;
+    }
+    const score = (withAuthor + withExpertise) / (pages.length * 2);
+    if (score >= 0.6) {
+      return {
+        id: "eeat-signals",
+        name: "E-E-A-T Signals",
+        category: "geo-signals",
+        status: "pass",
+        message: `Good E-E-A-T: ${withAuthor}/${pages.length} pages with author attribution, ${withExpertise}/${pages.length} with expertise markers`,
+        metadata: { withAuthor, withExpertise }
+      };
+    }
+    return {
+      id: "eeat-signals",
+      name: "E-E-A-T Signals",
+      category: "geo-signals",
+      status: score >= 0.3 ? "warn" : "info",
+      message: `Weak E-E-A-T: ${withAuthor}/${pages.length} author attributions, ${withExpertise}/${pages.length} expertise markers`,
+      suggestion: "Add author names and credentials to content. Link to about/team pages. Generative engines assess source credibility through E-E-A-T signals when deciding what to cite.",
+      metadata: { withAuthor, withExpertise }
+    };
+  }
+};
+var faqSchema = {
+  id: "faq-schema",
+  name: "FAQ / Q&A Schema",
+  category: "geo-signals",
+  description: "Checks for FAQ or Q&A structured data \u2014 highly cited by generative engines",
+  weight: 0.5,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let withFaq = 0;
+    for (const page of pages) {
+      const jsonLd = extractJsonLd(page.html);
+      const hasFaqSchema = jsonLd.some((item) => {
+        const type = item?.["@type"];
+        return type === "FAQPage" || type === "QAPage";
+      });
+      const hasFaqHtml = /<details|<summary|class=["'][^"']*faq[^"']*["']|id=["'][^"']*faq[^"']*["']/i.test(page.html);
+      if (hasFaqSchema || hasFaqHtml) withFaq++;
+    }
+    if (withFaq > 0) {
+      return {
+        id: "faq-schema",
+        name: "FAQ / Q&A Schema",
+        category: "geo-signals",
+        status: "pass",
+        message: `${withFaq}/${pages.length} pages contain FAQ/Q&A content`,
+        metadata: { withFaq }
+      };
+    }
+    return {
+      id: "faq-schema",
+      name: "FAQ / Q&A Schema",
+      category: "geo-signals",
+      status: "info",
+      message: "No FAQ/Q&A schema or FAQ-like content detected",
+      suggestion: "Add FAQPage schema or Q&A sections to relevant pages. FAQ-formatted content is heavily cited by generative engines because it directly maps to user questions.",
+      metadata: { withFaq }
+    };
+  }
+};
+var canonicalUrlConsistency = {
+  id: "canonical-url-consistency",
+  name: "Canonical URL Consistency",
+  category: "geo-signals",
+  description: "Checks if pages have consistent canonical URLs",
+  weight: 0.5,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let withCanonical = 0;
+    let selfReferencing = 0;
+    for (const page of pages) {
+      const canonicalMatch = page.html.match(/<link[^>]+rel=["']canonical["'][^>]+href=["']([^"']+)["']/i);
+      if (canonicalMatch) {
+        withCanonical++;
+        try {
+          const canonical = new URL(canonicalMatch[1], ctx.baseUrl.origin).href;
+          const pageUrl = new URL(page.url).href;
+          if (canonical === pageUrl || canonical === pageUrl.replace(/\/$/, "")) {
+            selfReferencing++;
+          }
+        } catch {
+        }
+      }
+    }
+    if (withCanonical === pages.length && selfReferencing === pages.length) {
+      return {
+        id: "canonical-url-consistency",
+        name: "Canonical URL Consistency",
+        category: "geo-signals",
+        status: "pass",
+        message: `All ${pages.length} pages have self-referencing canonical URLs`
+      };
+    }
+    if (withCanonical === 0) {
+      return {
+        id: "canonical-url-consistency",
+        name: "Canonical URL Consistency",
+        category: "geo-signals",
+        status: "warn",
+        message: "No canonical URLs found on sampled pages",
+        suggestion: 'Add <link rel="canonical"> to every page. This prevents duplicate content issues when AI agents discover the same page through different URLs.'
+      };
+    }
+    return {
+      id: "canonical-url-consistency",
+      name: "Canonical URL Consistency",
+      category: "geo-signals",
+      status: "warn",
+      message: `${withCanonical}/${pages.length} pages have canonical URLs (${selfReferencing} self-referencing)`,
+      suggestion: "Ensure every page has a self-referencing canonical URL to avoid confusing AI agents about the authoritative version.",
+      metadata: { withCanonical, selfReferencing }
+    };
+  }
+};
+var geoSignalChecks = [
+  structuredDataCoverage,
+  citationWorthiness,
+  topicalAuthoritySignals,
+  contentFreshness,
+  eeatSignals,
+  faqSchema,
+  canonicalUrlConsistency
+];
+
+// src/checks/agent-protocols.ts
+var mcpServerCard = {
+  id: "mcp-server-card",
+  name: "MCP Server Card",
+  category: "agent-protocols",
+  description: "Checks for a Model Context Protocol server card at .well-known/mcp/server-card.json",
+  weight: 0.8,
+  run: async (ctx) => {
+    if (!ctx.mcpServerCard) {
+      return {
+        id: "mcp-server-card",
+        name: "MCP Server Card",
+        category: "agent-protocols",
+        status: "fail",
+        message: "No MCP server card found at /.well-known/mcp/server-card.json",
+        suggestion: "Add a server-card.json at /.well-known/mcp/server-card.json describing your MCP server's tools, authentication, and capabilities. This lets AI agents discover what they can do with your site before connecting."
+      };
+    }
+    try {
+      const card = JSON.parse(ctx.mcpServerCard);
+      const hasName = typeof card.name === "string";
+      const hasTools = Array.isArray(card.tools) || Array.isArray(card.capabilities?.tools);
+      const hasDescription = typeof card.description === "string";
+      if (!hasName && !hasDescription) {
+        return {
+          id: "mcp-server-card",
+          name: "MCP Server Card",
+          category: "agent-protocols",
+          status: "warn",
+          message: "MCP server card found but missing name and description fields",
+          suggestion: "Add at minimum a 'name' and 'description' to your server card so agents understand what your MCP server does.",
+          metadata: { fields: Object.keys(card) }
+        };
+      }
+      const toolCount = Array.isArray(card.tools) ? card.tools.length : Array.isArray(card.capabilities?.tools) ? card.capabilities.tools.length : 0;
+      return {
+        id: "mcp-server-card",
+        name: "MCP Server Card",
+        category: "agent-protocols",
+        status: "pass",
+        message: `MCP server card found: "${card.name ?? "unnamed"}"${toolCount > 0 ? ` with ${toolCount} tools` : ""}`,
+        metadata: { name: card.name, toolCount, hasDescription }
+      };
+    } catch {
+      return {
+        id: "mcp-server-card",
+        name: "MCP Server Card",
+        category: "agent-protocols",
+        status: "warn",
+        message: "MCP server card found but contains invalid JSON",
+        suggestion: "Fix the JSON syntax in your /.well-known/mcp/server-card.json file."
+      };
+    }
+  }
+};
+var apiCatalog = {
+  id: "api-catalog",
+  name: "API Catalog (RFC 9727)",
+  category: "agent-protocols",
+  description: "Checks for an API catalog at .well-known/api-catalog per RFC 9727",
+  weight: 0.5,
+  run: async (ctx) => {
+    if (!ctx.apiCatalog) {
+      return {
+        id: "api-catalog",
+        name: "API Catalog (RFC 9727)",
+        category: "agent-protocols",
+        status: "info",
+        message: "No API catalog found at /.well-known/api-catalog",
+        suggestion: "If your site exposes APIs, add an api-catalog at /.well-known/api-catalog (RFC 9727). This gives agents a single location to discover all your APIs, their specs, docs, and status endpoints."
+      };
+    }
+    try {
+      const catalog = JSON.parse(ctx.apiCatalog);
+      const apis = Array.isArray(catalog.apis) ? catalog.apis : [];
+      if (apis.length === 0) {
+        return {
+          id: "api-catalog",
+          name: "API Catalog (RFC 9727)",
+          category: "agent-protocols",
+          status: "warn",
+          message: "API catalog found but contains no API entries",
+          suggestion: "Add API entries to your api-catalog with links to specs, documentation, and status endpoints."
+        };
+      }
+      return {
+        id: "api-catalog",
+        name: "API Catalog (RFC 9727)",
+        category: "agent-protocols",
+        status: "pass",
+        message: `API catalog found with ${apis.length} API${apis.length === 1 ? "" : "s"} listed`,
+        metadata: { apiCount: apis.length }
+      };
+    } catch {
+      const hasLinks = ctx.apiCatalog.includes("http") || ctx.apiCatalog.includes("<");
+      if (hasLinks) {
+        return {
+          id: "api-catalog",
+          name: "API Catalog (RFC 9727)",
+          category: "agent-protocols",
+          status: "pass",
+          message: "API catalog found (non-JSON format)"
+        };
+      }
+      return {
+        id: "api-catalog",
+        name: "API Catalog (RFC 9727)",
+        category: "agent-protocols",
+        status: "warn",
+        message: "API catalog found but could not parse content",
+        suggestion: "Ensure your api-catalog returns valid JSON or CoRE Link Format per RFC 9727."
+      };
+    }
+  }
+};
+var contentSignals = {
+  id: "content-signals",
+  name: "Content Signals (AI Usage Declarations)",
+  category: "agent-protocols",
+  description: "Checks for AI-specific content signals in robots.txt (ai-train, ai-input, search directives)",
+  weight: 0.6,
+  run: async (ctx) => {
+    if (!ctx.robotsTxt) {
+      return {
+        id: "content-signals",
+        name: "Content Signals (AI Usage Declarations)",
+        category: "agent-protocols",
+        status: "info",
+        message: "No robots.txt found \u2014 cannot check for content signals",
+        suggestion: "Add a robots.txt with Content Signals directives to declare how AI agents may use your content (ai-train, ai-input, search)."
+      };
+    }
+    const text = ctx.robotsTxt.toLowerCase();
+    const signals = [];
+    if (/ai[-_]?train/i.test(ctx.robotsTxt)) signals.push("ai-train");
+    if (/ai[-_]?input/i.test(ctx.robotsTxt)) signals.push("ai-input");
+    if (/content[-_]?signals?/i.test(ctx.robotsTxt)) signals.push("content-signals");
+    const hasGPTBot = text.includes("gptbot");
+    const hasClaudeBot = text.includes("claudebot") || text.includes("claude-web");
+    const hasGoogleExtended = text.includes("google-extended");
+    const hasPerplexityBot = text.includes("perplexitybot");
+    const hasCCBot = text.includes("ccbot");
+    const hasBytespider = text.includes("bytespider");
+    const namedBots = [
+      hasGPTBot && "GPTBot",
+      hasClaudeBot && "ClaudeBot",
+      hasGoogleExtended && "Google-Extended",
+      hasPerplexityBot && "PerplexityBot",
+      hasCCBot && "CCBot",
+      hasBytespider && "Bytespider"
+    ].filter(Boolean);
+    if (signals.length > 0) {
+      return {
+        id: "content-signals",
+        name: "Content Signals (AI Usage Declarations)",
+        category: "agent-protocols",
+        status: "pass",
+        message: `Content signals found: ${signals.join(", ")}${namedBots.length > 0 ? `. AI bot rules for: ${namedBots.join(", ")}` : ""}`,
+        metadata: { signals, namedBots }
+      };
+    }
+    if (namedBots.length >= 2) {
+      return {
+        id: "content-signals",
+        name: "Content Signals (AI Usage Declarations)",
+        category: "agent-protocols",
+        status: "warn",
+        message: `No content signals directives, but has AI bot rules for: ${namedBots.join(", ")}`,
+        suggestion: "Consider adding Content Signals directives (ai-train, ai-input) for more granular control over how AI agents use your content, beyond simple allow/disallow.",
+        metadata: { signals, namedBots }
+      };
+    }
+    return {
+      id: "content-signals",
+      name: "Content Signals (AI Usage Declarations)",
+      category: "agent-protocols",
+      status: "info",
+      message: "No AI-specific content signals or bot directives found in robots.txt",
+      suggestion: "Add Content Signals directives to robots.txt to explicitly declare how AI agents may use your content. This gives you granular control over training, citations, and search indexing."
+    };
+  }
+};
+var linkHeaders = {
+  id: "link-headers",
+  name: "Link Headers (RFC 8288)",
+  category: "agent-protocols",
+  description: "Checks for Link HTTP headers that help agents discover related resources",
+  weight: 0.4,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    let withLinkHeaders = 0;
+    const relTypes = /* @__PURE__ */ new Set();
+    for (const page of pages) {
+      const linkHeader = page.headers["link"];
+      if (linkHeader) {
+        withLinkHeaders++;
+        const relMatches = linkHeader.matchAll(/rel="([^"]+)"/gi);
+        for (const match of relMatches) {
+          for (const rel of match[1].split(/\s+/)) {
+            relTypes.add(rel);
+          }
+        }
+      }
+    }
+    if (withLinkHeaders === 0) {
+      return {
+        id: "link-headers",
+        name: "Link Headers (RFC 8288)",
+        category: "agent-protocols",
+        status: "info",
+        message: "No Link HTTP headers found on sampled pages",
+        suggestion: "Add Link headers (RFC 8288) to responses with rel=alternate, rel=canonical, or rel=describedby. This lets AI agents discover alternative representations (markdown, JSON) without parsing HTML."
+      };
+    }
+    const hasAlternate = relTypes.has("alternate");
+    const hasCanonical = relTypes.has("canonical");
+    const hasDescribedBy = relTypes.has("describedby");
+    const agentUseful = hasAlternate || hasDescribedBy;
+    if (agentUseful) {
+      return {
+        id: "link-headers",
+        name: "Link Headers (RFC 8288)",
+        category: "agent-protocols",
+        status: "pass",
+        message: `Link headers found on ${withLinkHeaders}/${pages.length} pages (rel types: ${[...relTypes].join(", ")})`,
+        metadata: { withLinkHeaders, relTypes: [...relTypes] }
+      };
+    }
+    return {
+      id: "link-headers",
+      name: "Link Headers (RFC 8288)",
+      category: "agent-protocols",
+      status: "warn",
+      message: `Link headers found on ${withLinkHeaders}/${pages.length} pages but missing agent-useful rel types`,
+      suggestion: "Add rel=alternate (to point to markdown/JSON versions) and rel=describedby Link headers. These help AI agents find the best representation of your content.",
+      metadata: { withLinkHeaders, relTypes: [...relTypes] }
+    };
+  }
+};
+var agentSkillsIndex = {
+  id: "agent-skills-index",
+  name: "Agent Skills Index",
+  category: "agent-protocols",
+  description: "Checks for an agent skills index at .well-known/agent-skills/index.json",
+  weight: 0.4,
+  run: async (ctx) => {
+    if (!ctx.agentSkillsIndex) {
+      return {
+        id: "agent-skills-index",
+        name: "Agent Skills Index",
+        category: "agent-protocols",
+        status: "info",
+        message: "No agent skills index found at /.well-known/agent-skills/index.json",
+        suggestion: "Add an agent-skills/index.json at /.well-known/ to declare what capabilities agents can use on your site. This is an emerging standard for agentic web interactions."
+      };
+    }
+    try {
+      const skills = JSON.parse(ctx.agentSkillsIndex);
+      const skillList = Array.isArray(skills) ? skills : Array.isArray(skills.skills) ? skills.skills : [];
+      if (skillList.length === 0) {
+        return {
+          id: "agent-skills-index",
+          name: "Agent Skills Index",
+          category: "agent-protocols",
+          status: "warn",
+          message: "Agent skills index found but contains no skills",
+          suggestion: "Add skill definitions to your agent-skills index describing what actions agents can perform on your site."
+        };
+      }
+      return {
+        id: "agent-skills-index",
+        name: "Agent Skills Index",
+        category: "agent-protocols",
+        status: "pass",
+        message: `Agent skills index found with ${skillList.length} skill${skillList.length === 1 ? "" : "s"} declared`,
+        metadata: { skillCount: skillList.length }
+      };
+    } catch {
+      return {
+        id: "agent-skills-index",
+        name: "Agent Skills Index",
+        category: "agent-protocols",
+        status: "warn",
+        message: "Agent skills index found but contains invalid JSON",
+        suggestion: "Fix the JSON syntax in your /.well-known/agent-skills/index.json file."
+      };
+    }
+  }
+};
+var agentsMd = {
+  id: "agents-md",
+  name: "AGENTS.md",
+  category: "agent-protocols",
+  description: "Checks for an AGENTS.md or AGENT.md file that guides coding agents on how to work with the project",
+  weight: 0.7,
+  run: async (ctx) => {
+    if (ctx.mode === "remote") {
+      return {
+        id: "agents-md",
+        name: "AGENTS.md",
+        category: "agent-protocols",
+        status: "skip",
+        message: "AGENTS.md is a repo-root file (run on a local path to check it)"
+      };
+    }
+    if (!ctx.agentsMd) {
+      return {
+        id: "agents-md",
+        name: "AGENTS.md",
+        category: "agent-protocols",
+        status: "fail",
+        message: "No AGENTS.md or AGENT.md found",
+        suggestion: "Add an AGENTS.md at the project root. This is the universal agent configuration file \u2014 a README for AI coding agents. Include build/test commands, architecture overview, conventions, and any gotchas. Used by 60k+ open-source projects."
+      };
+    }
+    const content = ctx.agentsMd;
+    const lines = content.split("\n").filter((l) => l.trim().length > 0);
+    const headings = content.match(/^#{1,3}\s+.+$/gm) ?? [];
+    const hasBuildInfo = /\b(build|compile|install|setup)\b/i.test(content);
+    const hasTestInfo = /\b(test|spec|jest|vitest|pytest|cargo test)\b/i.test(content);
+    const hasArchInfo = /\b(architecture|structure|directory|folder|module|package)\b/i.test(content);
+    const hasConventions = /\b(convention|style|pattern|rule|guideline|lint)\b/i.test(content);
+    const hasCodeBlocks = /```/.test(content);
+    const signals = [
+      hasBuildInfo && "build",
+      hasTestInfo && "test",
+      hasArchInfo && "architecture",
+      hasConventions && "conventions",
+      hasCodeBlocks && "code examples"
+    ].filter(Boolean);
+    if (lines.length < 5) {
+      return {
+        id: "agents-md",
+        name: "AGENTS.md",
+        category: "agent-protocols",
+        status: "warn",
+        message: `AGENTS.md found but very short (${lines.length} lines)`,
+        suggestion: "Expand your AGENTS.md with build/test commands, architecture overview, code conventions, and common gotchas. The more context you give coding agents, the better they'll work with your project.",
+        metadata: { lines: lines.length, headings: headings.length }
+      };
+    }
+    if (signals.length < 2) {
+      return {
+        id: "agents-md",
+        name: "AGENTS.md",
+        category: "agent-protocols",
+        status: "warn",
+        message: `AGENTS.md found (${lines.length} lines, ${headings.length} sections) but missing key info`,
+        suggestion: `Your AGENTS.md covers ${signals.length > 0 ? signals.join(", ") : "limited topics"}. Consider adding: ${[!hasBuildInfo && "build commands", !hasTestInfo && "test instructions", !hasArchInfo && "architecture overview", !hasConventions && "code conventions"].filter(Boolean).join(", ")}.`,
+        metadata: { lines: lines.length, headings: headings.length, signals }
+      };
+    }
+    return {
+      id: "agents-md",
+      name: "AGENTS.md",
+      category: "agent-protocols",
+      status: "pass",
+      message: `AGENTS.md found (${lines.length} lines, ${headings.length} sections) covering: ${signals.join(", ")}`,
+      metadata: { lines: lines.length, headings: headings.length, signals }
+    };
+  }
+};
+var agentProtocolChecks = [
+  mcpServerCard,
+  apiCatalog,
+  contentSignals,
+  linkHeaders,
+  agentSkillsIndex,
+  agentsMd
+];
+
+// src/checks/index.ts
+var ALL_CHECKS = [
+  ...contentDiscoverabilityChecks,
+  ...markdownAvailabilityChecks,
+  ...pageSizeChecks,
+  ...contentStructureChecks,
+  ...urlStabilityChecks,
+  ...authenticationChecks,
+  ...geoSignalChecks,
+  ...agentProtocolChecks
+];
+
+// src/utils/local.ts
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { join, relative, extname } from "path";
+var walkDir = (dir, extensions, maxDepth = 10) => {
+  if (maxDepth <= 0) return [];
+  const results = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        results.push(...walkDir(fullPath, extensions, maxDepth - 1));
+      } else if (entry.isFile() && extensions.has(extname(entry.name).toLowerCase())) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+};
+var readIfExists = (path) => {
+  try {
+    if (existsSync(path)) {
+      return readFileSync(path, "utf-8");
+    }
+  } catch {
+  }
+  return void 0;
+};
+var buildLocalContext = (dirPath, config) => {
+  const baseUrl = new URL(`file://${dirPath}`);
+  const robotsTxt = readIfExists(join(dirPath, "robots.txt"));
+  const llmsTxt = readIfExists(join(dirPath, "llms.txt"));
+  const llmsFullTxt = readIfExists(join(dirPath, "llms-full.txt"));
+  const sitemapXml = readIfExists(join(dirPath, "sitemap.xml"));
+  const mcpServerCard2 = readIfExists(join(dirPath, ".well-known", "mcp", "server-card.json"));
+  const apiCatalog2 = readIfExists(join(dirPath, ".well-known", "api-catalog"));
+  const agentSkillsIndex2 = readIfExists(join(dirPath, ".well-known", "agent-skills", "index.json"));
+  const agentsMd2 = readIfExists(join(dirPath, "AGENTS.md")) ?? readIfExists(join(dirPath, "AGENT.md"));
+  const sitemapUrls = sitemapXml ? parseSitemapUrls(sitemapXml) : [];
+  if (!sitemapXml && robotsTxt) {
+    const sitemapMatch = robotsTxt.match(/Sitemap:\s*(.+)/i);
+    if (sitemapMatch) {
+      const sitemapPath = sitemapMatch[1].trim();
+      const localSitemapPath = sitemapPath.startsWith("http") ? null : join(dirPath, sitemapPath.replace(/^\//, ""));
+      if (localSitemapPath) {
+        const altSitemap = readIfExists(localSitemapPath);
+        if (altSitemap) {
+          sitemapUrls.push(...parseSitemapUrls(altSitemap));
+        }
+      }
+    }
+  }
+  const htmlFiles = walkDir(dirPath, /* @__PURE__ */ new Set([".html", ".htm"]));
+  const mdFiles = walkDir(dirPath, /* @__PURE__ */ new Set([".md", ".mdx"]));
+  const allFiles = [...htmlFiles, ...mdFiles];
+  const sampled = allFiles.slice(0, config.sampleSize);
+  const sampledPages = sampled.map((filePath) => {
+    const content = readFileSync(filePath, "utf-8");
+    const relPath = relative(dirPath, filePath);
+    const ext = extname(filePath).toLowerCase();
+    const isMarkdown = ext === ".md" || ext === ".mdx";
+    const url = `file://${filePath}`;
+    return {
+      url,
+      html: isMarkdown ? wrapMarkdownAsHtml(content, relPath) : content,
+      statusCode: 200,
+      headers: {},
+      markdown: isMarkdown ? content : void 0,
+      fetchTime: 0
+    };
+  });
+  return {
+    mode: "local",
+    targetUrl: dirPath,
+    baseUrl,
+    sitemapUrls,
+    sampledPages,
+    robotsTxt,
+    llmsTxt,
+    llmsFullTxt,
+    sitemapXml,
+    allUrls: sampled.map((f) => `file://${f}`),
+    mcpServerCard: mcpServerCard2,
+    apiCatalog: apiCatalog2,
+    agentSkillsIndex: agentSkillsIndex2,
+    agentsMd: agentsMd2
+  };
+};
+var wrapMarkdownAsHtml = (md, title) => {
+  let html = md;
+  html = html.replace(/^#{6}\s+(.+)$/gm, "<h6>$1</h6>");
+  html = html.replace(/^#{5}\s+(.+)$/gm, "<h5>$1</h5>");
+  html = html.replace(/^#{4}\s+(.+)$/gm, "<h4>$1</h4>");
+  html = html.replace(/^#{3}\s+(.+)$/gm, "<h3>$1</h3>");
+  html = html.replace(/^#{2}\s+(.+)$/gm, "<h2>$1</h2>");
+  html = html.replace(/^#{1}\s+(.+)$/gm, "<h1>$1</h1>");
+  html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  html = html.replace(/^>\s+(.+)$/gm, "<blockquote>$1</blockquote>");
+  html = html.replace(/```(\w*)\n([\s\S]*?)```/g, '<pre><code class="language-$1">$2</code></pre>');
+  html = html.replace(/`([^`]+)`/g, "<code>$1</code>");
+  html = html.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  html = html.replace(/^[-*]\s+(.+)$/gm, "<li>$1</li>");
+  html = html.replace(/^\d+\.\s+(.+)$/gm, "<li>$1</li>");
+  html = html.replace(/^([^<\n].+)$/gm, "<p>$1</p>");
+  return `<!DOCTYPE html><html><head><title>${title}</title></head><body><main>${html}</main></body></html>`;
+};
+
+// src/index.ts
+var computeGrade = (score) => {
+  if (score >= 95) return "A+";
+  if (score >= 85) return "A";
+  if (score >= 70) return "B";
+  if (score >= 55) return "C";
+  if (score >= 40) return "D";
+  return "F";
+};
+var buildRemoteContext = async (targetUrl, config) => {
+  const emit = config.onEvent ?? (() => {
+  });
+  emit({ type: "phase", phase: "fetching" });
+  const baseUrl = new URL(targetUrl);
+  const origin = baseUrl.origin;
+  const [
+    robotsResult,
+    llmsResult,
+    llmsFullResult,
+    sitemapResult,
+    mcpCardResult,
+    apiCatalogResult,
+    agentSkillsResult
+  ] = await Promise.allSettled([
+    fetchText(`${origin}/robots.txt`, config),
+    fetchText(`${origin}/llms.txt`, config),
+    fetchText(`${origin}/llms-full.txt`, config),
+    fetchText(`${origin}/sitemap.xml`, config),
+    fetchText(`${origin}/.well-known/mcp/server-card.json`, config),
+    fetchText(`${origin}/.well-known/api-catalog`, config),
+    fetchText(`${origin}/.well-known/agent-skills/index.json`, config)
+  ]);
+  const robotsTxt = robotsResult.status === "fulfilled" && robotsResult.value?.statusCode === 200 ? robotsResult.value.text : void 0;
+  const llmsTxt = llmsResult.status === "fulfilled" && llmsResult.value?.statusCode === 200 ? llmsResult.value.text : void 0;
+  const llmsFullTxt = llmsFullResult.status === "fulfilled" && llmsFullResult.value?.statusCode === 200 ? llmsFullResult.value.text : void 0;
+  const sitemapXml = sitemapResult.status === "fulfilled" && sitemapResult.value?.statusCode === 200 ? sitemapResult.value.text : void 0;
+  const mcpServerCard2 = mcpCardResult.status === "fulfilled" && mcpCardResult.value?.statusCode === 200 ? mcpCardResult.value.text : void 0;
+  const apiCatalog2 = apiCatalogResult.status === "fulfilled" && apiCatalogResult.value?.statusCode === 200 ? apiCatalogResult.value.text : void 0;
+  const agentSkillsIndex2 = agentSkillsResult.status === "fulfilled" && agentSkillsResult.value?.statusCode === 200 ? agentSkillsResult.value.text : void 0;
+  const agentsMd2 = void 0;
+  const sitemapUrls = sitemapXml ? parseSitemapUrls(sitemapXml) : [];
+  if (!sitemapXml && robotsTxt) {
+    const sitemapMatch = robotsTxt.match(/Sitemap:\s*(.+)/i);
+    if (sitemapMatch) {
+      const altSitemap = await fetchText(sitemapMatch[1].trim(), config);
+      if (altSitemap?.statusCode === 200) {
+        sitemapUrls.push(...parseSitemapUrls(altSitemap.text));
+      }
+    }
+  }
+  let pagesToSample = [];
+  if (sitemapUrls.length > 0) {
+    const shuffled = [...sitemapUrls].sort(() => Math.random() - 0.5);
+    pagesToSample = shuffled.slice(0, config.sampleSize);
+  } else {
+    const mainPage = await fetchPage(targetUrl, config);
+    const linkRegex = /<a[^>]+href=["']([^"'#]+)["']/gi;
+    const links = [];
+    let match;
+    while ((match = linkRegex.exec(mainPage.html)) !== null) {
+      try {
+        const resolved = new URL(match[1], origin);
+        if (resolved.origin === origin && !links.includes(resolved.href)) {
+          links.push(resolved.href);
+        }
+      } catch {
+      }
+    }
+    pagesToSample = [targetUrl, ...links.slice(0, config.sampleSize - 1)];
+  }
+  if (!pagesToSample.includes(targetUrl)) {
+    pagesToSample.unshift(targetUrl);
+  }
+  const sampledPages = await fetchMany(pagesToSample, config);
+  emit({ type: "context-ready", pageCount: sampledPages.length });
+  for (const page of sampledPages) {
+    const mdResult = await fetchWithContentNegotiation(page.url, "text/markdown", config);
+    if (mdResult && mdResult.statusCode === 200 && (mdResult.contentType.includes("text/markdown") || mdResult.contentType.includes("text/plain"))) {
+      page.markdown = mdResult.text;
+    }
+  }
+  return {
+    mode: "remote",
+    targetUrl,
+    baseUrl,
+    sitemapUrls,
+    sampledPages,
+    robotsTxt,
+    llmsTxt,
+    llmsFullTxt,
+    sitemapXml,
+    allUrls: pagesToSample,
+    mcpServerCard: mcpServerCard2,
+    apiCatalog: apiCatalog2,
+    agentSkillsIndex: agentSkillsIndex2,
+    agentsMd: agentsMd2
+  };
+};
+var stripUndefined = (obj) => {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+};
+var runAudit = async (ctx, config, start) => {
+  const emit = config.onEvent ?? (() => {
+  });
+  emit({ type: "phase", phase: "checking" });
+  const allCategoryCount = CHECK_CATEGORIES.length;
+  let checks = config.categories.length < allCategoryCount ? ALL_CHECKS.filter((c) => config.categories.includes(c.category)) : ALL_CHECKS;
+  if (ctx.mode === "local") {
+    checks = checks.filter((c) => !c.requiresNetwork);
+  }
+  const results = [];
+  for (const check of checks) {
+    emit({ type: "check-start", check: { id: check.id, name: check.name, category: check.category } });
+    try {
+      const result = await check.run(ctx);
+      results.push(result);
+      emit({ type: "check-complete", result });
+    } catch (error) {
+      const result = {
+        id: check.id,
+        name: check.name,
+        category: check.category,
+        status: "skip",
+        message: `Check failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+      results.push(result);
+      emit({ type: "check-complete", result });
+    }
+  }
+  emit({ type: "phase", phase: "scoring" });
+  const passed = results.filter((r) => r.status === "pass").length;
+  const warned = results.filter((r) => r.status === "warn").length;
+  const failed = results.filter((r) => r.status === "fail").length;
+  const skipped = results.filter((r) => r.status === "skip" || r.status === "info").length;
+  const total = results.length;
+  const scorable = results.filter((r) => r.status !== "skip" && r.status !== "info");
+  const checkWeights = checks.reduce((acc, c) => ({ ...acc, [c.id]: c.weight }), {});
+  let weightedSum = 0;
+  let totalWeight = 0;
+  for (const result of scorable) {
+    const weight = checkWeights[result.id] ?? 0.5;
+    const score = result.status === "pass" ? 1 : result.status === "warn" ? 0.5 : 0;
+    weightedSum += score * weight;
+    totalWeight += weight;
+  }
+  let overallScore = totalWeight > 0 ? Math.round(weightedSum / totalWeight * 100) : 0;
+  const authGate = results.find((r) => r.id === "auth-gate-detection");
+  if (authGate?.status === "fail" && overallScore > 50) {
+    overallScore = 50;
+  }
+  const categories = {};
+  const activeCategories = config.categories.filter(
+    (cat) => results.some((r) => r.category === cat)
+  );
+  for (const cat of activeCategories) {
+    const catResults = results.filter((r) => r.category === cat);
+    const catScorable = catResults.filter((r) => r.status !== "skip" && r.status !== "info");
+    const catPassed = catResults.filter((r) => r.status === "pass").length;
+    let catWeightedSum = 0;
+    let catTotalWeight = 0;
+    for (const result of catScorable) {
+      const weight = checkWeights[result.id] ?? 0.5;
+      const score = result.status === "pass" ? 1 : result.status === "warn" ? 0.5 : 0;
+      catWeightedSum += score * weight;
+      catTotalWeight += weight;
+    }
+    categories[cat] = {
+      score: catTotalWeight > 0 ? Math.round(catWeightedSum / catTotalWeight * 100) : 0,
+      checks: catResults.length,
+      passed: catPassed
+    };
+  }
+  return {
+    url: ctx.targetUrl,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    overall_score: overallScore,
+    grade: computeGrade(overallScore),
+    checks: results,
+    summary: { total, passed, warned, failed, skipped },
+    categories,
+    latency_ms: Date.now() - start
+  };
+};
+var audit = async (targetUrl, config = {}) => {
+  const start = Date.now();
+  const fullConfig = { ...DEFAULT_CONFIG, ...stripUndefined(config) };
+  const ctx = await buildRemoteContext(targetUrl, fullConfig);
+  return runAudit(ctx, fullConfig, start);
+};
+var auditLocal = async (dirPath, config = {}) => {
+  const start = Date.now();
+  const fullConfig = { ...DEFAULT_CONFIG, ...stripUndefined(config) };
+  const emit = fullConfig.onEvent ?? (() => {
+  });
+  emit({ type: "phase", phase: "fetching" });
+  const ctx = buildLocalContext(dirPath, fullConfig);
+  emit({ type: "context-ready", pageCount: ctx.sampledPages.length });
+  return runAudit(ctx, fullConfig, start);
+};
+export {
+  ALL_CHECKS,
+  audit,
+  auditLocal,
+  buildLocalContext
+};