@rankcli/agent-runtime 0.0.13 → 0.0.15

package/dist/index.mjs

@@ -919,6 +919,24 @@ var ISSUE_DEFINITIONS = {
     impact: "Your content will not be used for Bard/Gemini AI training (regular search unaffected).",
     howToFix: 'Remove "User-agent: Google-Extended Disallow: /" if you want Google AI visibility.'
   },
+  CLOUDFLARE_AI_CRAWLER_GATE_AMBIGUOUS: {
+    code: "CLOUDFLARE_AI_CRAWLER_GATE_AMBIGUOUS",
+    severity: "warning",
+    category: "ai-readiness",
+    title: "No explicit AI crawler rules on a Cloudflare-fronted site",
+    description: 'This site appears to be served through Cloudflare but robots.txt has no explicit Allow/Disallow rules for AI crawlers. Cloudflare blocks "mixed-use" AI crawlers by default on ad-hosting zones starting September 15, 2026, and is rolling out Pay Per Crawl / Pay Per Use gating beyond that.',
+    impact: "Without an explicit rule, whether AI crawlers (and future citation opportunities in ChatGPT, Claude, Perplexity, etc.) can reach this site now depends on Cloudflare account-level bot-management defaults, not on this codebase \u2014 a silent, invisible-to-git failure mode.",
+    howToFix: "Add explicit User-agent rules for GPTBot, Claude-Web/ClaudeBot, PerplexityBot, and Google-Extended in robots.txt, and confirm the matching allow/block posture in the Cloudflare dashboard under Bot Management \u2192 AI Crawl Control. If you'd rather charge than block, Cloudflare's Pay Per Crawl (AI Crawl Control \u2192 Payments tab) lets you set a per-crawl price instead of a flat allow/deny \u2014 worth a look if you get meaningful AI-crawler traffic."
+  },
+  NO_AGENT_EXPERIENCE_SURFACE: {
+    code: "NO_AGENT_EXPERIENCE_SURFACE",
+    severity: "notice",
+    category: "ai-readiness",
+    title: "No agent-facing discovery surface found",
+    description: "None of the emerging AI-agent discovery conventions were found: llms-full.txt, SKILL.md, a discoverable MCP server, or an OpenAPI spec. This is a genuinely new, low-adoption category as of 2026 \u2014 most sites have none of these yet \u2014 so this is an opportunity, not a compliance failure.",
+    impact: "AI agents (not just chatbots answering questions, but agents that browse and act on a user's behalf) increasingly prefer sites that expose machine-readable capabilities over ones that require scraping and guessing at HTML structure. Being an early, discoverable site in this space is a low-competition differentiator right now.",
+    howToFix: "Start with whichever fits your site: llms-full.txt (a single Markdown dump of your key content \u2014 measured as fetched roughly 2x more than plain llms.txt), a SKILL.md capability manifest, or an OpenAPI spec at /openapi.json if you already have an API. A discoverable MCP server is the highest-effort, highest-payoff option if your product has one to expose."
+  },
   HIGH_JS_RENDERING_RATIO: {
     code: "HIGH_JS_RENDERING_RATIO",
     severity: "warning",
@@ -3854,6 +3872,61 @@ async function checkInternalRedirects(internalLinks, batchSize = 10) {
 
 // src/audit/checks/ai-readiness.ts
 import * as cheerio13 from "cheerio";
+
+// src/audit/checks/agent-experience.ts
+var SIGNAL_PATHS = [
+  { path: "/llms-full.txt", description: "Full-site content dump for AI agents \u2014 the fuller sibling of llms.txt, measured as fetched roughly 2x more often" },
+  { path: "/skill.md", description: "SKILL.md capability manifest (Anthropic Agent Skills convention)" },
+  { path: "/mcp", description: "MCP (Model Context Protocol) server, discoverable at a conventional path" },
+  { path: "/.well-known/mcp.json", description: "MCP server descriptor at the .well-known convention" },
+  { path: "/openapi.json", description: "OpenAPI spec \u2014 lets an agent discover and call your API directly instead of scraping HTML" },
+  { path: "/.well-known/ai-plugin.json", description: "AI plugin manifest (older but still-referenced convention for agent tool discovery)" }
+];
+async function fetchBody(baseUrl, path3) {
+  try {
+    const url = new URL(path3, baseUrl).href;
+    const response = await httpGet(url, {
+      timeout: 8e3,
+      validateStatus: () => true
+    });
+    return { status: response.status, body: String(response.data ?? "") };
+  } catch {
+    return null;
+  }
+}
+async function pathExists(baseUrl, path3, fallbackBody) {
+  const result = await fetchBody(baseUrl, path3);
+  if (!result) return false;
+  if (result.status === 404) return false;
+  if (result.status < 200 || result.status >= 400) return false;
+  if (fallbackBody != null && result.body === fallbackBody) return false;
+  return true;
+}
+async function checkAgentExperience(baseUrl) {
+  const issues = [];
+  const probePath = `/__rankcli_ax_probe_${Math.random().toString(36).slice(2)}`;
+  const baseline = await fetchBody(baseUrl, probePath);
+  const fallbackBody = baseline && baseline.status >= 200 && baseline.status < 400 ? baseline.body : null;
+  const signals = await Promise.all(
+    SIGNAL_PATHS.map(async ({ path: path3, description }) => ({
+      path: path3,
+      description,
+      present: await pathExists(baseUrl, path3, fallbackBody)
+    }))
+  );
+  const presentCount = signals.filter((s) => s.present).length;
+  const score = Math.round(presentCount / signals.length * 100);
+  if (presentCount === 0) {
+    issues.push({
+      ...ISSUE_DEFINITIONS.NO_AGENT_EXPERIENCE_SURFACE,
+      affectedUrls: [baseUrl],
+      details: { checkedPaths: SIGNAL_PATHS.map((s) => s.path) }
+    });
+  }
+  return { issues, data: { signals, score } };
+}
+
+// src/audit/checks/ai-readiness.ts
 var AI_BOTS = {
   GPTBot: "GPTBot",
   "ChatGPT-User": "ChatGPT-User",
@@ -4074,6 +4147,32 @@ function checkJSRenderingRatio(html, url) {
     data: { ratio, staticWordCount }
   };
 }
+async function checkCloudflareAICrawlerGate(baseUrl, botBlocking) {
+  const issues = [];
+  let behindCloudflare = false;
+  try {
+    const response = await httpGet(baseUrl, {
+      timeout: 1e4,
+      validateStatus: () => true
+    });
+    const server = response.headers["server"] || "";
+    behindCloudflare = server.toLowerCase().includes("cloudflare") || "cf-ray" in response.headers;
+  } catch {
+    behindCloudflare = false;
+  }
+  const hasExplicitAIRules = botBlocking.robotsExists && botBlocking.blockedBots.length > 0;
+  const ambiguous = behindCloudflare && !hasExplicitAIRules;
+  if (ambiguous) {
+    issues.push({
+      ...ISSUE_DEFINITIONS.CLOUDFLARE_AI_CRAWLER_GATE_AMBIGUOUS,
+      affectedUrls: [baseUrl]
+    });
+  }
+  return {
+    issues,
+    data: { behindCloudflare, hasExplicitAIRules, ambiguous }
+  };
+}
 async function runAIReadinessChecks(baseUrl, html) {
   const allIssues = [];
   const llmsResult = await checkLlmsTxt(baseUrl);
@@ -4082,12 +4181,18 @@ async function runAIReadinessChecks(baseUrl, html) {
   allIssues.push(...botResult.issues);
   const jsResult = checkJSRenderingRatio(html, baseUrl);
   allIssues.push(...jsResult.issues);
+  const cfGateResult = await checkCloudflareAICrawlerGate(baseUrl, botResult.data);
+  allIssues.push(...cfGateResult.issues);
+  const agentExperienceResult = await checkAgentExperience(baseUrl);
+  allIssues.push(...agentExperienceResult.issues);
   return {
     issues: allIssues,
     data: {
       llmsTxt: llmsResult.data,
       botBlocking: botResult.data,
-      jsRenderingRatio: jsResult.data.ratio
+      jsRenderingRatio: jsResult.data.ratio,
+      cloudflareAIGate: cfGateResult.data,
+      agentExperience: agentExperienceResult.data
     }
   };
 }
@@ -4552,7 +4657,13 @@ async function analyzeSecurityHeaders2(url) {
       maxRedirects: 5
     });
     const headers = response.headers;
-    const isHttps = url.startsWith("https://");
+    let isHttps = false;
+    try {
+      const parsedUrl = new URL(url);
+      isHttps = parsedUrl.protocol === "https:";
+    } catch {
+      isHttps = url.toLowerCase().startsWith("https://");
+    }
     const getHeader = (name) => {
       const key = Object.keys(headers).find((k) => k.toLowerCase() === name.toLowerCase());
       return key ? headers[key] : null;
@@ -4624,10 +4735,17 @@ async function analyzeSecurityHeaders2(url) {
       }
     };
   } catch (error) {
+    let isHttps = false;
+    try {
+      const parsedUrl = new URL(url);
+      isHttps = parsedUrl.protocol === "https:";
+    } catch {
+      isHttps = url.toLowerCase().startsWith("https://");
+    }
     return {
       issues,
       data: {
-        https: url.startsWith("https://"),
+        https: isHttps,
         headers: {
           hsts: null,
           csp: null,
@@ -8661,17 +8779,17 @@ function generateRecommendations2(renderingMethod, hasContentInHTML, charCount,
     );
     if (framework === "React") {
       recommendations.push(
-        'Quick fix: Add react-snap to pre-render pages at build time (npm install -D react-snap, add "postbuild": "react-snap" to scripts)'
+        "Quick fix: Use Vike (vike.dev) for SSR/SSG - works with Vite, minimal config needed"
       );
       recommendations.push(
-        "Alternative: Use Vike (vite-plugin-ssr) for SSR/SSG without changing frameworks"
+        "Alternative: Migrate to Next.js or Remix for built-in SSR/SSG support"
       );
     } else if (framework === "Vue") {
       recommendations.push(
-        "Quick fix: Add prerender-spa-plugin to pre-render pages at build time"
+        "Quick fix: Use Vike (vike.dev) for SSR/SSG - works with Vite, minimal config needed"
       );
       recommendations.push(
-        "Alternative: Use Vike (vite-plugin-ssr) for SSR/SSG without changing frameworks"
+        "Alternative: Migrate to Nuxt for built-in SSR/SSG support"
       );
     } else if (framework === "Angular Universal") {
       recommendations.push(
@@ -8679,7 +8797,7 @@ function generateRecommendations2(renderingMethod, hasContentInHTML, charCount,
       );
     } else {
       recommendations.push(
-        "Quick fix: Use a pre-rendering tool like react-snap or prerender-spa-plugin"
+        "Quick fix: Use Vike (vike.dev) for SSR/SSG with any Vite-based framework"
       );
     }
     recommendations.push(
@@ -8703,7 +8821,7 @@ function analyzeClientRendering(html, url) {
   const issues = [];
   const analysis = analyzeRendering(html);
   if (analysis.renderingMethod === "csr" && analysis.confidence !== "low") {
-    const howToFixByFramework = analysis.frameworkDetected === "React" ? 'Add react-snap to pre-render pages: npm install -D react-snap, then add "postbuild": "react-snap" to package.json scripts. No code changes needed.' : analysis.frameworkDetected === "Vue" ? "Add prerender-spa-plugin to pre-render pages at build time. Alternatively, use Vike for SSR/SSG." : "Pre-render your pages using react-snap, prerender-spa-plugin, or similar build-time tools.";
+    const howToFixByFramework = analysis.frameworkDetected === "React" ? "Use Vike (vike.dev) to add SSR/SSG to your Vite React app: npm install vike vike-react, then follow the setup guide. Alternatively, migrate to Next.js or Remix." : analysis.frameworkDetected === "Vue" ? "Use Vike (vike.dev) to add SSR/SSG to your Vite Vue app: npm install vike vike-vue, then follow the setup guide. Alternatively, migrate to Nuxt." : "Use Vike (vike.dev) for SSR/SSG with Vite-based frameworks, or use a framework with built-in SSR support (Next.js, Nuxt, Remix, SvelteKit).";
     issues.push({
       code: "CLIENT_SIDE_RENDERING",
       severity: "error",
@@ -8744,7 +8862,7 @@ function analyzeClientRendering(html, url) {
       title: `${analysis.frameworkDetected} detected without SSR markers`,
       description: `This appears to be a ${analysis.frameworkDetected} SPA without server-side rendering enabled.`,
       impact: "Single Page Applications without SSR have slower time-to-content for search crawlers.",
-      howToFix: analysis.frameworkDetected === "React" ? "Quick fix: Add react-snap (npm install -D react-snap) to pre-render at build time. Alternative: Use Vike for SSR/SSG." : "Quick fix: Add prerender-spa-plugin to pre-render at build time. Alternative: Use Vike for SSR/SSG.",
+      howToFix: analysis.frameworkDetected === "React" ? "Add SSR/SSG using Vike (vike.dev): npm install vike vike-react. Alternative: migrate to Next.js or Remix." : "Add SSR/SSG using Vike (vike.dev): npm install vike vike-vue. Alternative: migrate to Nuxt.",
       affectedUrls: [url],
       details: {
         framework: analysis.frameworkDetected,
@@ -12521,8 +12639,94 @@ function analyzeAIContentStructure(html, url) {
   };
 }
 
-// src/audit/checks/citation-quality.ts
+// src/audit/checks/rag-chunk-readiness.ts
 import * as cheerio44 from "cheerio";
+var MIN_GOOD_WORDS = 150;
+var MAX_GOOD_WORDS = 450;
+var TOKENS_PER_WORD = 1.33;
+var DANGLING_OPENERS = /^(this|it|these|that|they|such|those|the former|the latter)\b/i;
+function classifySize(wordCount) {
+  if (wordCount < MIN_GOOD_WORDS) return "too-short";
+  if (wordCount > MAX_GOOD_WORDS) return "too-long";
+  return "good";
+}
+function extractSections($) {
+  const elements = $("h1, h2, h3, p, li, blockquote").toArray();
+  const sections = [];
+  let current = null;
+  for (const el of elements) {
+    const tag = el.tagName?.toLowerCase();
+    if (tag === "h1" || tag === "h2" || tag === "h3") {
+      if (current) sections.push(current);
+      current = { heading: $(el).text().trim(), headingLevel: parseInt(tag.slice(1), 10), text: "" };
+    } else if (current) {
+      current.text += " " + $(el).text();
+    }
+  }
+  if (current) sections.push(current);
+  return sections;
+}
+function analyzeRAGChunkReadiness(html, url) {
+  const issues = [];
+  const $ = cheerio44.load(html);
+  $("nav, footer, aside, script, style, noscript, header").remove();
+  const rawSections = extractSections($);
+  const sections = rawSections.map((s) => {
+    const words = s.text.trim().split(/\s+/).filter(Boolean);
+    const wordCount = words.length;
+    const estimatedTokens = Math.round(wordCount * TOKENS_PER_WORD);
+    const firstSentence = s.text.trim().split(/[.!?]/)[0] || "";
+    return {
+      heading: s.heading,
+      headingLevel: s.headingLevel,
+      wordCount,
+      estimatedTokens,
+      sizeQuality: classifySize(wordCount),
+      startsWithDanglingReference: DANGLING_OPENERS.test(firstSentence.trim())
+    };
+  });
+  const totalSections = sections.length;
+  const wellSizedSectionCount = sections.filter((s) => s.sizeQuality === "good").length;
+  const danglingReferenceCount = sections.filter((s) => s.startsWithDanglingReference).length;
+  const chunkReadinessScore = totalSections === 0 ? 0 : Math.round(
+    (wellSizedSectionCount / totalSections * 0.7 + (totalSections - danglingReferenceCount) / totalSections * 0.3) * 100
+  );
+  if (totalSections >= 3 && wellSizedSectionCount / totalSections < 0.5) {
+    const tooLong = sections.filter((s) => s.sizeQuality === "too-long").length;
+    const tooShort = sections.filter((s) => s.sizeQuality === "too-short").length;
+    issues.push({
+      code: "RAG_CHUNK_SIZE_MISMATCH",
+      severity: "notice",
+      category: "ai-readiness",
+      title: "Most sections are poorly sized for AI retrieval chunking",
+      description: `${wellSizedSectionCount} of ${totalSections} sections fall in a well-sized range for RAG retrieval (roughly 150-450 words); ${tooLong} are too long and likely to get split mid-thought, ${tooShort} are too short and likely to get merged with unrelated neighbors.`,
+      impact: "When an AI answer engine retrieves a chunk of this page in response to a query, oversized sections risk being cut off mid-point and undersized ones risk losing standalone context \u2014 both reduce the odds the retrieved chunk reads coherently in an AI-generated answer.",
+      howToFix: "Break up long sections (450+ words) with an additional H2/H3 subheading roughly every 300-400 words. Merge very short sections (under 150 words) into a neighboring section or expand them with enough context to stand alone.",
+      affectedUrls: [url],
+      details: { wellSizedSectionCount, totalSections, tooLong, tooShort }
+    });
+  }
+  if (totalSections >= 3 && danglingReferenceCount / totalSections > 0.3) {
+    issues.push({
+      code: "RAG_CHUNK_DANGLING_REFERENCES",
+      severity: "notice",
+      category: "ai-readiness",
+      title: "Several sections open with a reference to prior context",
+      description: `${danglingReferenceCount} of ${totalSections} sections start with a pronoun or demonstrative ("This...", "It...", "These...") that depends on the previous section to make sense.`,
+      impact: "A RAG system that retrieves one of these sections on its own \u2014 which is exactly how retrieval works, one chunk at a time \u2014 surfaces a sentence whose subject is undefined, reading as broken or confusing in an AI-generated answer.",
+      howToFix: 'Open each section by naming its actual subject instead of referring back to the previous one \u2014 e.g. "This approach reduces cost" becomes "Caching reduces cost."',
+      affectedUrls: [url],
+      details: { danglingReferenceCount, totalSections }
+    });
+  }
+  return {
+    issues,
+    data: { sections, totalSections, wellSizedSectionCount, danglingReferenceCount, chunkReadinessScore }
+  };
+}
+
+// src/audit/checks/citation-quality.ts
+import * as cheerio45 from "cheerio";
 var REPUTABLE_SOURCES = {
   academic: [
     "scholar.google.com",
@@ -12589,7 +12793,7 @@ var REPUTABLE_SOURCES = {
 };
 function analyzeCitationQuality(html, url) {
   const issues = [];
-  const $ = cheerio44.load(html);
+  const $ = cheerio45.load(html);
   const parsedUrl = new URL(url);
   const currentDomain = parsedUrl.hostname;
   const $content = $("body").clone();
@@ -12818,12 +13022,12 @@ function analyzeCitationQuality(html, url) {
 }
 
 // src/audit/checks/answer-conciseness.ts
-import * as cheerio45 from "cheerio";
+import * as cheerio46 from "cheerio";
 var IDEAL_ANSWER_LENGTH = { min: 40, max: 150 };
 var MAX_FIRST_SENTENCE = 200;
 function analyzeAnswerConciseness(html, url) {
   const issues = [];
-  const $ = cheerio45.load(html);
+  const $ = cheerio46.load(html);
   $("nav, footer, aside, script, style, noscript, header").remove();
   const headings = $("h1, h2, h3, h4, h5, h6");
   let totalHeadings = 0;
@@ -13014,7 +13218,7 @@ function analyzeAnswerConciseness(html, url) {
 }
 
 // src/audit/checks/brand-mention-optimization.ts
-import * as cheerio46 from "cheerio";
+import * as cheerio47 from "cheerio";
 var BRAND_DEFINITION_PATTERNS = [
   /(?:we are|we're|is a|is the|is an)\s+(?:leading|premier|top|best|trusted|innovative|professional)/i,
   /(?:our mission|our vision|we help|we provide|we offer|we specialize)/i,
@@ -13052,7 +13256,7 @@ var REVIEW_PLATFORMS = [
 ];
 function analyzeBrandMentionOptimization(html, url) {
   const issues = [];
-  const $ = cheerio46.load(html);
+  const $ = cheerio47.load(html);
   const parsedUrl = new URL(url);
   const $content = $("body").clone();
   $content.find("nav, footer, script, style, noscript").remove();
@@ -13244,7 +13448,7 @@ function analyzeBrandMentionOptimization(html, url) {
 }
 
 // src/audit/checks/ai-citation-worthiness.ts
-import * as cheerio47 from "cheerio";
+import * as cheerio48 from "cheerio";
 var ORIGINAL_DATA_PATTERNS = [
   /(?:our data|our research|our study|our analysis|we found|we discovered)/i,
   /(?:survey of|surveyed|interviewed|analyzed)\s+\d+/i,
@@ -13291,7 +13495,7 @@ var STOCK_IMAGE_DOMAINS = [
 ];
 function analyzeAICitationWorthiness(html, url) {
   const issues = [];
-  const $ = cheerio47.load(html);
+  const $ = cheerio48.load(html);
   const $content = $("body").clone();
   $content.find("nav, footer, script, style, noscript, aside").remove();
   const bodyText = $content.text();
@@ -13516,7 +13720,7 @@ function analyzeAICitationWorthiness(html, url) {
 }
 
 // src/audit/checks/review-ecosystem.ts
-import * as cheerio48 from "cheerio";
+import * as cheerio49 from "cheerio";
 var REVIEW_PLATFORMS2 = {
   general: [
     { name: "Google Business", domain: "google.com/maps", aliases: ["goo.gl/maps", "maps.google"] },
@@ -13576,7 +13780,7 @@ var TRUST_BADGE_PATTERNS2 = [
 ];
 function analyzeReviewEcosystem(html, url) {
   const issues = [];
-  const $ = cheerio48.load(html);
+  const $ = cheerio49.load(html);
   const allLinks = $("a[href]").map((_, a) => $(a).attr("href") || "").get();
   const allLinksLower = allLinks.map((l) => l.toLowerCase());
   const linkedPlatforms = [];
@@ -14258,10 +14462,10 @@ function analyzeStructure(content) {
 }
 
 // src/audit/checks/html-compliance.ts
-import * as cheerio49 from "cheerio";
+import * as cheerio50 from "cheerio";
 async function analyzeHtmlCompliance(html, url, headers) {
   const issues = [];
-  const $ = cheerio49.load(html);
+  const $ = cheerio50.load(html);
   const parsedUrl = new URL(url);
   const doctypeMatch = html.match(/<!DOCTYPE\s+([^>]+)>/i);
   const hasDoctype = doctypeMatch !== null;
@@ -14825,7 +15029,7 @@ function getAssetType(url) {
 }
 
 // src/audit/checks/dom-size.ts
-import * as cheerio50 from "cheerio";
+import * as cheerio51 from "cheerio";
 var THRESHOLDS = {
   totalElements: {
     warning: 1500,
@@ -14842,7 +15046,7 @@ var THRESHOLDS = {
 };
 function analyzeDomSize(html, url) {
   const issues = [];
-  const $ = cheerio50.load(html);
+  const $ = cheerio51.load(html);
   const allElements = $("*");
   const totalElements = allElements.length;
   let maxDepth = 0;
@@ -14998,10 +15202,10 @@ function getDomReductionSuggestions(breakdown) {
 }
 
 // src/audit/checks/image-dimensions.ts
-import * as cheerio51 from "cheerio";
+import * as cheerio52 from "cheerio";
 function analyzeImageDimensions(html, url) {
   const issues = [];
-  const $ = cheerio51.load(html);
+  const $ = cheerio52.load(html);
   const images = $("img");
   const totalImages = images.length;
   let withDimensions = 0;
@@ -15112,7 +15316,7 @@ function truncateSrc(src) {
 }
 
 // src/audit/checks/color-contrast.ts
-import * as cheerio52 from "cheerio";
+import * as cheerio53 from "cheerio";
 var KNOWN_LOW_CONTRAST_PAIRS = [
   { fg: "#999999", bg: "#ffffff", ratio: 2.85 },
   { fg: "#888888", bg: "#ffffff", ratio: 3.54 },
@@ -15147,7 +15351,7 @@ var NAMED_COLORS = {
 };
 function analyzeColorContrast(html, url) {
   const issues = [];
-  const $ = cheerio52.load(html);
+  const $ = cheerio53.load(html);
   const potentialIssues = [];
   let elementsAnalyzed = 0;
   let passedChecks = 0;
@@ -15345,7 +15549,7 @@ function calculateContrastRatio(fg, bg) {
 }
 
 // src/audit/checks/asset-minification.ts
-import * as cheerio53 from "cheerio";
+import * as cheerio54 from "cheerio";
 function isMinified(content, type) {
   const lines = content.split("\n");
   const totalLines = lines.length;
@@ -15373,7 +15577,7 @@ function isMinified(content, type) {
   };
 }
 function extractAssetUrls(html, baseUrl) {
-  const $ = cheerio53.load(html);
+  const $ = cheerio54.load(html);
   const base = new URL(baseUrl);
   const css = [];
   const js = [];
@@ -15519,10 +15723,10 @@ async function analyzeAssetMinification(html, url) {
 }
 
 // src/audit/checks/page-resources.ts
-import * as cheerio54 from "cheerio";
+import * as cheerio55 from "cheerio";
 function analyzePageResources(html, url) {
   const issues = [];
-  const $ = cheerio54.load(html);
+  const $ = cheerio55.load(html);
   const baseUrl = new URL(url);
   const baseHostname = baseUrl.hostname;
   const stylesheets = [];
@@ -15722,7 +15926,7 @@ function analyzePageResources(html, url) {
 }
 
 // src/audit/checks/responsive-css.ts
-import * as cheerio55 from "cheerio";
+import * as cheerio56 from "cheerio";
 function extractMediaQueries(css) {
   const mediaQueries = [];
   const regex = /@media\s*([^{]+)/g;
@@ -15772,7 +15976,7 @@ function classifyBreakpoints(mediaQueries) {
 }
 async function analyzeResponsiveCss(html, url) {
   const issues = [];
-  const $ = cheerio55.load(html);
+  const $ = cheerio56.load(html);
   const baseUrl = new URL(url);
   const viewportMeta = $('meta[name="viewport"]').attr("content");
   const hasViewport = !!viewportMeta;
@@ -16509,10 +16713,10 @@ var urlSafetyDatabase = {
 };
 
 // src/audit/checks/tracking-verification.ts
-import * as cheerio56 from "cheerio";
+import * as cheerio57 from "cheerio";
 function analyzeTrackingVerification(html, url) {
   const issues = [];
-  const $ = cheerio56.load(html);
+  const $ = cheerio57.load(html);
   const ga4Match = html.match(/gtag\s*\(\s*['"]config['"]\s*,\s*['"](G-[A-Z0-9]+)['"]/i) || html.match(/googletagmanager\.com\/gtag\/js\?id=(G-[A-Z0-9]+)/i);
   const hasGa4 = !!ga4Match;
   const ga4MeasurementId = ga4Match ? ga4Match[1] : void 0;
@@ -16646,10 +16850,10 @@ async function runFullAudit(options) {
   const runExtendedChecks = tier !== "free";
   const parsedUrl = new URL(url);
   const domain = parsedUrl.hostname;
-  console.log(`
+  console.error(`
 \u{1F50D} Running comprehensive SEO audit on ${url}...
 `);
-  console.log("\u{1F4CB} Phase 1: Crawlability checks + page fetch (parallel)...");
+  console.error("\u{1F4CB} Phase 1: Crawlability checks + page fetch (parallel)...");
   const [crawlabilityResult, fetchResult] = await Promise.all([
     runCrawlabilityChecks(url).catch((err) => {
       console.error("Crawlability check failed:", err);
@@ -16659,26 +16863,32 @@ async function runFullAudit(options) {
       timeout: 3e4,
       validateStatus: () => true
     }).catch((err) => {
+      console.error("Main page fetch failed:", err instanceof Error ? { message: err.message, cause: err.cause } : err);
       return { error: err, data: "", headers: {} };
     })
   ]);
   allIssues.push(...crawlabilityResult);
   if ("error" in fetchResult) {
+    const err = fetchResult.error;
+    const errorMsg = err instanceof Error ? err.message : "Unknown error";
+    const errorCause = err instanceof Error && err.cause ? ` (${String(err.cause)})` : "";
     allIssues.push({
       code: "FETCH_ERROR",
       severity: "error",
-      category: "crawlability",
-      title: "Failed to fetch page",
-      description: `Could not fetch the page: ${fetchResult.error instanceof Error ? fetchResult.error.message : "Unknown error"}`,
-      impact: "Cannot perform full audit without page content.",
-      howToFix: "Ensure the URL is accessible and the server is responding.",
-      affectedUrls: [url]
+      category: "indexability",
+      // Not crawlability - robots/sitemap checks may have succeeded
+      title: "Page fetch failed",
+      description: `Could not load page content: ${errorMsg}${errorCause}. Only robots.txt and sitemap checks were performed.`,
+      impact: "Cannot perform full SEO audit without page HTML content.",
+      howToFix: "Verify the URL is accessible, the server is responding, and there are no firewall/geo blocks.",
+      affectedUrls: [url],
+      details: { error: errorMsg, cause: errorCause || void 0 }
     });
     return createReport(url, domain, allIssues, pages);
   }
   const html = fetchResult.data;
   const headers = fetchResult.headers;
-  console.log(`\u{1F4DD} Phase 2: Running synchronous HTML checks (tier: ${tier}, limit: ${checksLimit})...`);
+  console.error(`\u{1F4DD} Phase 2: Running synchronous HTML checks (tier: ${tier}, limit: ${checksLimit})...`);
   const onPageResult = analyzeOnPage(html, url);
   const structuredDataResult = analyzeStructuredData2(html, url);
   const mobileResult = analyzeMobile(html, url);
@@ -16718,6 +16928,7 @@ async function runFullAudit(options) {
   const entityResult = runPremiumChecks ? analyzeEntitySEO(html, url) : { issues: [], data: {} };
   const qdfFreshnessResult = runPremiumChecks ? analyzeFreshnessSignals(html, url) : { issues: [], data: {} };
   const aiContentStructureResult = runPremiumChecks ? analyzeAIContentStructure(html, url) : { issues: [], data: {} };
+  const ragChunkReadinessResult = runPremiumChecks ? analyzeRAGChunkReadiness(html, url) : { issues: [], data: {} };
   const citationQualityResult = runPremiumChecks ? analyzeCitationQuality(html, url) : { issues: [], data: {} };
   const answerConcisenessResult = runPremiumChecks ? analyzeAnswerConciseness(html, url) : { issues: [], data: {} };
   const brandMentionResult = runPremiumChecks ? analyzeBrandMentionOptimization(html, url) : { issues: [], data: {} };
@@ -16756,6 +16967,7 @@ async function runFullAudit(options) {
     ...entityResult.issues,
     ...qdfFreshnessResult.issues,
     ...aiContentStructureResult.issues,
+    ...ragChunkReadinessResult.issues,
     ...citationQualityResult.issues,
     ...answerConcisenessResult.issues,
     ...brandMentionResult.issues,
@@ -16779,7 +16991,7 @@ async function runFullAudit(options) {
       };
     }
   }
-  console.log("\u{1F517} Phase 3: Running async checks (parallel)...");
+  console.error("\u{1F517} Phase 3: Running async checks (parallel)...");
   const safeAsync = async (name, fn, timeoutMs = 1e4) => {
     try {
       const resultPromise = fn();
@@ -16892,7 +17104,7 @@ async function runFullAudit(options) {
     loadTime: perfData.loadTime,
     issues: allIssues.map((i) => i.code)
   });
-  console.log("\n\u2705 Audit complete!\n");
+  console.error("\n\u2705 Audit complete!\n");
   return createReport(url, domain, allIssues, pages);
 }
 function createReport(url, domain, issues, pages) {
@@ -17053,10 +17265,10 @@ function groupIssuesByCategory(issues) {
 }
 
 // src/audit/checks/duplicate-content.ts
-import * as cheerio57 from "cheerio";
+import * as cheerio58 from "cheerio";
 import { createHash } from "crypto";
 function extractContentHash(html, url) {
-  const $ = cheerio57.load(html);
+  const $ = cheerio58.load(html);
   $("script, style, nav, header, footer, aside, .nav, .header, .footer, .sidebar").remove();
   const title = $("title").text().trim();
   const bodyText = $("body").text().replace(/\s+/g, " ").trim();
@@ -18284,7 +18496,7 @@ var PRIORITY_WEIGHTS = {
 };
 
 // src/keywords/engine.ts
-import * as cheerio59 from "cheerio";
+import * as cheerio60 from "cheerio";
 
 // src/keywords/prioritizer.ts
 function prioritizeKeywords(keywords, siteProfile, existingMeta) {
@@ -18578,7 +18790,7 @@ function enrichKeywordsWithEstimates(keywords) {
 }
 
 // src/keywords/sources/free-sources.ts
-import * as cheerio58 from "cheerio";
+import * as cheerio59 from "cheerio";
 var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36";
 async function getPeopleAlsoAsk(query) {
   try {
@@ -18587,7 +18799,7 @@ async function getPeopleAlsoAsk(query) {
       headers: { "User-Agent": USER_AGENT },
       timeout: 1e4
     });
-    const $ = cheerio58.load(response.data);
+    const $ = cheerio59.load(response.data);
     const questions = [];
     $("[data-sgrd]").each((_, el) => {
       const text = $(el).text().trim();
@@ -18613,7 +18825,7 @@ async function getRelatedSearches(query) {
       headers: { "User-Agent": USER_AGENT },
       timeout: 1e4
     });
-    const $ = cheerio58.load(response.data);
+    const $ = cheerio59.load(response.data);
     const related = [];
     $("div[data-ved] a").each((_, el) => {
       const href = $(el).attr("href");
@@ -18703,7 +18915,7 @@ async function analyzeCompetitorTitles(query) {
       headers: { "User-Agent": USER_AGENT },
       timeout: 1e4
     });
-    const $ = cheerio58.load(response.data);
+    const $ = cheerio59.load(response.data);
     const titles = [];
     const keywords = /* @__PURE__ */ new Set();
     $("h3").each((_, el) => {
@@ -19035,7 +19247,7 @@ async function fetchPageMeta(url) {
     const response = await httpGet(url, {
       timeout: 1e4
     });
-    const $ = cheerio59.load(response.data);
+    const $ = cheerio60.load(response.data);
     return {
       url,
       title: $("title").text().trim() || void 0,
@@ -19166,7 +19378,7 @@ async function extractSeedKeywords(url) {
     const response = await httpGet(url, {
       timeout: 1e4
     });
-    const $ = cheerio59.load(response.data);
+    const $ = cheerio60.load(response.data);
     const seeds = /* @__PURE__ */ new Set();
     const title = $("title").text().toLowerCase();
     const titleWords = title.split(/[\s\-|:]+/).filter((w) => w.length > 3);
@@ -19188,7 +19400,7 @@ async function extractSeedKeywords(url) {
 }
 
 // src/keywords/site-crawler.ts
-import * as cheerio60 from "cheerio";
+import * as cheerio61 from "cheerio";
 var EXCLUDED_PATHS = [
   "/cdn-cgi/",
   "/wp-admin/",
@@ -19300,7 +19512,7 @@ async function crawlPage(url, timeout) {
     validateStatus: (status) => status === 200
   });
   const html = response.data;
-  const $ = cheerio60.load(html);
+  const $ = cheerio61.load(html);
   $('script, style, noscript, iframe, nav, footer, header, aside, [role="navigation"]').remove();
   const title = $("title").text().trim();
   const description = $('meta[name="description"]').attr("content")?.trim() || "";
@@ -21957,7 +22169,7 @@ function getDateRange(days = 28) {
 }
 
 // src/keywords/sources/competitor-analysis.ts
-import * as cheerio61 from "cheerio";
+import * as cheerio62 from "cheerio";
 var USER_AGENT2 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36";
 async function discoverCompetitorKeywords(yourDomain, seedKeywords, competitors) {
   const yourKeywords = /* @__PURE__ */ new Set();
@@ -22054,7 +22266,7 @@ async function analyzeSERP(query) {
       headers: { "User-Agent": USER_AGENT2 },
       timeout: 1e4
     });
-    const $ = cheerio61.load(response.data);
+    const $ = cheerio62.load(response.data);
     const results = [];
     const relatedSearches = [];
     const peopleAlsoAsk = [];
@@ -33755,6 +33967,544 @@ function getAIVisibilitySummary(results) {
   };
 }
 
+// src/ranking/types.ts
+var TIER_LIMITS = {
+  free: {
+    maxKeywords: 10,
+    checksPerDay: 1,
+    serpFeatures: false,
+    competitorTracking: false,
+    historyDays: 7
+  },
+  solo: {
+    maxKeywords: 100,
+    checksPerDay: 1,
+    serpFeatures: true,
+    competitorTracking: false,
+    historyDays: 30
+  },
+  pro: {
+    maxKeywords: 500,
+    checksPerDay: 2,
+    serpFeatures: true,
+    competitorTracking: true,
+    historyDays: 90
+  },
+  agency: {
+    maxKeywords: 2e3,
+    checksPerDay: 4,
+    serpFeatures: true,
+    competitorTracking: true,
+    historyDays: 365
+  }
+};
+
+// src/ranking/serp-client.ts
+var SerpClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Check ranking for a single keyword
+   */
+  async checkRank(options) {
+    const results = [];
+    for (const keyword of options.keywords) {
+      try {
+        const result = await this.checkSingleKeyword({
+          ...options,
+          keyword
+        });
+        results.push(result);
+      } catch (error) {
+        console.error(`Error checking rank for "${keyword}":`, error);
+        results.push({
+          keyword,
+          position: null,
+          url: null,
+          serpFeatures: [],
+          topResults: [],
+          checkedAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    return results;
+  }
+  async checkSingleKeyword(options) {
+    switch (this.config.provider) {
+      case "valueserp":
+        return this.checkViaValueSerp(options);
+      case "serpapi":
+        return this.checkViaSerpApi(options);
+      case "direct":
+      default:
+        return this.checkViaDirect(options);
+    }
+  }
+  /**
+   * ValueSERP API implementation
+   * Docs: https://www.valueserp.com/docs
+   */
+  async checkViaValueSerp(options) {
+    if (!this.config.apiKey) {
+      throw new Error("ValueSERP API key required");
+    }
+    const params = new URLSearchParams({
+      api_key: this.config.apiKey,
+      q: options.keyword,
+      location: options.country || "United States",
+      google_domain: options.country === "US" ? "google.com" : `google.${options.country?.toLowerCase() || "com"}`,
+      gl: options.country || "us",
+      hl: options.language || "en",
+      device: options.device || "desktop",
+      num: "100"
+      // Get top 100 results
+    });
+    const response = await fetch(`https://api.valueserp.com/search?${params}`);
+    if (!response.ok) {
+      throw new Error(`ValueSERP API error: ${response.status}`);
+    }
+    const data = await response.json();
+    return this.parseValueSerpResponse(data, options.domain, options.keyword);
+  }
+  /**
+   * SerpAPI implementation (alternative)
+   * Docs: https://serpapi.com/search-api
+   */
+  async checkViaSerpApi(options) {
+    if (!this.config.apiKey) {
+      throw new Error("SerpAPI key required");
+    }
+    const params = new URLSearchParams({
+      api_key: this.config.apiKey,
+      q: options.keyword,
+      location: options.country === "US" ? "United States" : options.country || "United States",
+      gl: options.country?.toLowerCase() || "us",
+      hl: options.language || "en",
+      device: options.device || "desktop",
+      num: "100"
+    });
+    const response = await fetch(`https://serpapi.com/search?${params}`);
+    if (!response.ok) {
+      throw new Error(`SerpAPI error: ${response.status}`);
+    }
+    const data = await response.json();
+    return this.parseSerpApiResponse(data, options.domain, options.keyword);
+  }
+  /**
+   * Direct scraping fallback (rate-limited, use with caution)
+   */
+  async checkViaDirect(options) {
+    const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(options.keyword)}&num=100`;
+    const headers = {
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "Accept-Language": options.language || "en-US,en;q=0.9"
+    };
+    const response = await fetch(searchUrl, { headers });
+    if (!response.ok) {
+      throw new Error(`Direct search failed: ${response.status}`);
+    }
+    const html = await response.text();
+    return this.parseDirectSearchResults(html, options.domain, options.keyword);
+  }
+  parseValueSerpResponse(data, domain, keyword) {
+    const topResults = [];
+    const serpFeatures = [];
+    let position = null;
+    let url = null;
+    if (data.organic_results) {
+      for (let i = 0; i < data.organic_results.length; i++) {
+        const result = data.organic_results[i];
+        const resultDomain = this.extractDomain(result.link);
+        topResults.push({
+          position: i + 1,
+          url: result.link,
+          domain: resultDomain,
+          title: result.title
+        });
+        if (this.domainMatches(resultDomain, domain) && position === null) {
+          position = i + 1;
+          url = result.link;
+        }
+      }
+    }
+    if (data.answer_box) {
+      serpFeatures.push({
+        type: "featured_snippet",
+        position: 0,
+        hasOwnSite: this.domainMatches(this.extractDomain(data.answer_box.link || ""), domain)
+      });
+    }
+    if (data.people_also_ask) {
+      serpFeatures.push({
+        type: "people_also_ask",
+        hasOwnSite: data.people_also_ask.some(
+          (paa) => this.domainMatches(this.extractDomain(paa.link || ""), domain)
+        )
+      });
+    }
+    if (data.local_results) {
+      serpFeatures.push({ type: "local_pack" });
+    }
+    if (data.knowledge_graph) {
+      serpFeatures.push({ type: "knowledge_panel" });
+    }
+    return {
+      keyword,
+      position,
+      url,
+      serpFeatures,
+      topResults: topResults.slice(0, 10),
+      checkedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  parseSerpApiResponse(data, domain, keyword) {
+    const topResults = [];
+    const serpFeatures = [];
+    let position = null;
+    let url = null;
+    if (data.organic_results) {
+      for (let i = 0; i < data.organic_results.length; i++) {
+        const result = data.organic_results[i];
+        const resultDomain = this.extractDomain(result.link);
+        topResults.push({
+          position: result.position || i + 1,
+          url: result.link,
+          domain: resultDomain,
+          title: result.title
+        });
+        if (this.domainMatches(resultDomain, domain) && position === null) {
+          position = result.position || i + 1;
+          url = result.link;
+        }
+      }
+    }
+    if (data.answer_box) {
+      serpFeatures.push({
+        type: "featured_snippet",
+        position: 0
+      });
+    }
+    if (data.related_questions) {
+      serpFeatures.push({ type: "people_also_ask" });
+    }
+    return {
+      keyword,
+      position,
+      url,
+      serpFeatures,
+      topResults: topResults.slice(0, 10),
+      checkedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  parseDirectSearchResults(html, domain, keyword) {
+    const topResults = [];
+    let position = null;
+    let url = null;
+    const linkRegex = /<a[^>]+href="\/url\?q=([^"&]+)/g;
+    let match;
+    let index = 0;
+    while ((match = linkRegex.exec(html)) !== null && index < 100) {
+      try {
+        const decodedUrl = decodeURIComponent(match[1]);
+        const resultDomain = this.extractDomain(decodedUrl);
+        if (resultDomain.includes("google.com") || resultDomain.includes("gstatic.com")) {
+          continue;
+        }
+        index++;
+        topResults.push({
+          position: index,
+          url: decodedUrl,
+          domain: resultDomain
+        });
+        if (this.domainMatches(resultDomain, domain) && position === null) {
+          position = index;
+          url = decodedUrl;
+        }
+      } catch {
+      }
+    }
+    return {
+      keyword,
+      position,
+      url,
+      serpFeatures: [],
+      // Direct scraping doesn't easily extract SERP features
+      topResults: topResults.slice(0, 10),
+      checkedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  extractDomain(url) {
+    try {
+      const parsed = new URL(url);
+      return parsed.hostname.replace(/^www\./, "");
+    } catch {
+      return "";
+    }
+  }
+  domainMatches(resultDomain, targetDomain) {
+    const normalizedResult = resultDomain.toLowerCase().replace(/^www\./, "");
+    const normalizedTarget = targetDomain.toLowerCase().replace(/^www\./, "");
+    return normalizedResult === normalizedTarget || normalizedResult.endsWith(`.${normalizedTarget}`);
+  }
+};
+
+// src/ranking/tracker.ts
+var RankTracker = class {
+  supabase;
+  serpClient;
+  constructor(config) {
+    this.supabase = config.supabase;
+    this.serpClient = new SerpClient(config.serpConfig);
+  }
+  /**
+   * Add keywords to track for a project
+   */
+  async addKeywords(projectId, keywords, options) {
+    const keywordRecords = keywords.map((keyword) => ({
+      project_id: projectId,
+      keyword: keyword.toLowerCase().trim(),
+      search_engine: options?.searchEngine || "google",
+      country: options?.country || "US",
+      language: options?.language || "en",
+      track_url: options?.trackUrl,
+      is_active: true
+    }));
+    const { data, error } = await this.supabase.from("keywords").upsert(keywordRecords, {
+      onConflict: "project_id,keyword",
+      ignoreDuplicates: false
+    }).select();
+    if (error) {
+      throw new Error(`Failed to add keywords: ${error.message}`);
+    }
+    return (data || []).map(this.mapKeyword);
+  }
+  /**
+   * Remove keywords from tracking
+   */
+  async removeKeywords(projectId, keywords) {
+    const normalizedKeywords = keywords.map((k) => k.toLowerCase().trim());
+    const { error } = await this.supabase.from("keywords").update({ is_active: false }).eq("project_id", projectId).in("keyword", normalizedKeywords);
+    if (error) {
+      throw new Error(`Failed to remove keywords: ${error.message}`);
+    }
+  }
+  /**
+   * Get all tracked keywords for a project
+   */
+  async getKeywords(projectId, includeInactive = false) {
+    let query = this.supabase.from("keywords").select("*").eq("project_id", projectId);
+    if (!includeInactive) {
+      query = query.eq("is_active", true);
+    }
+    const { data, error } = await query;
+    if (error) {
+      throw new Error(`Failed to get keywords: ${error.message}`);
+    }
+    return (data || []).map(this.mapKeyword);
+  }
+  /**
+   * Check rankings for all active keywords in a project
+   */
+  async checkRankings(projectId, domain) {
+    const keywords = await this.getKeywords(projectId);
+    if (keywords.length === 0) {
+      return [];
+    }
+    const groups = this.groupKeywords(keywords);
+    const results = [];
+    for (const group of groups) {
+      const checkResults = await this.serpClient.checkRank({
+        keywords: group.keywords.map((k) => k.keyword),
+        domain,
+        searchEngine: group.searchEngine,
+        country: group.country,
+        language: group.language
+      });
+      for (const result of checkResults) {
+        const keyword = group.keywords.find((k) => k.keyword === result.keyword);
+        if (!keyword) continue;
+        await this.saveRanking(keyword.id, result);
+        results.push({
+          keywordId: keyword.id,
+          keyword: result.keyword,
+          position: result.position,
+          url: result.url,
+          serpFeatures: result.serpFeatures,
+          competitorUrls: result.topResults,
+          checkedAt: result.checkedAt
+        });
+      }
+    }
+    await this.supabase.from("projects").update({ last_rank_check_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", projectId);
+    return results;
+  }
+  /**
+   * Save a ranking result to the database
+   */
+  async saveRanking(keywordId, result) {
+    const { data: currentKeyword } = await this.supabase.from("keywords").select("current_position, best_position").eq("id", keywordId).single();
+    const previousPosition = currentKeyword?.current_position;
+    const bestPosition = currentKeyword?.best_position;
+    const newBestPosition = result.position !== null && (bestPosition === null || result.position < bestPosition) ? result.position : bestPosition;
+    const { error: updateError } = await this.supabase.from("keywords").update({
+      previous_position: previousPosition,
+      current_position: result.position,
+      best_position: newBestPosition,
+      last_checked: result.checkedAt.toISOString()
+    }).eq("id", keywordId);
+    if (updateError) {
+      console.error(`Failed to save ranking for ${result.keyword}:`, updateError);
+    }
+  }
+  /**
+   * Get ranking history for a keyword
+   * Note: Full history requires keyword_ranking_history table with keyword_ranking_id
+   * For now, returns current state as single history entry
+   */
+  async getHistory(keywordId, _days = 30) {
+    const { data, error } = await this.supabase.from("keywords").select("current_position, target_url, last_checked").eq("id", keywordId).single();
+    if (error || !data) {
+      return [];
+    }
+    return [{
+      position: data.current_position,
+      url: data.target_url,
+      serpFeatures: [],
+      recordedAt: data.last_checked ? new Date(data.last_checked) : /* @__PURE__ */ new Date()
+    }];
+  }
+  /**
+   * Get keyword trends for a project
+   */
+  async getTrends(projectId) {
+    const { data, error } = await this.supabase.from("keyword_rank_trends").select("*").eq("project_id", projectId);
+    if (error) {
+      return this.calculateTrends(projectId);
+    }
+    return (data || []).map((row) => ({
+      keywordId: row.keyword_id,
+      keyword: row.keyword,
+      currentPosition: row.current_position,
+      bestPosition: row.best_position,
+      positionChange: row.position_change || 0,
+      avgPosition: row.avg_position || 0,
+      dataPoints: row.data_points || 0
+    }));
+  }
+  /**
+   * Manual trend calculation fallback
+   */
+  async calculateTrends(projectId) {
+    const keywords = await this.getKeywords(projectId);
+    const trends = [];
+    for (const keyword of keywords) {
+      const history = await this.getHistory(keyword.id, 30);
+      if (history.length === 0) {
+        trends.push({
+          keywordId: keyword.id,
+          keyword: keyword.keyword,
+          currentPosition: keyword.currentPosition,
+          bestPosition: keyword.bestPosition,
+          positionChange: 0,
+          avgPosition: keyword.currentPosition || 0,
+          dataPoints: 0
+        });
+        continue;
+      }
+      const positions = history.filter((h) => h.position !== null).map((h) => h.position);
+      const avgPosition = positions.length > 0 ? positions.reduce((a, b) => a + b, 0) / positions.length : 0;
+      const positionChange = keyword.previousPosition && keyword.currentPosition ? keyword.previousPosition - keyword.currentPosition : 0;
+      trends.push({
+        keywordId: keyword.id,
+        keyword: keyword.keyword,
+        currentPosition: keyword.currentPosition,
+        bestPosition: keyword.bestPosition,
+        positionChange,
+        avgPosition,
+        dataPoints: history.length
+      });
+    }
+    return trends;
+  }
+  /**
+   * Export ranking data as CSV
+   */
+  async exportCSV(projectId, days = 30) {
+    const keywords = await this.getKeywords(projectId);
+    const rows = ["Keyword,Current Position,Best Position,Last Checked,Trend"];
+    for (const keyword of keywords) {
+      const history = await this.getHistory(keyword.id, days);
+      const trend = this.calculatePositionTrend(history);
+      rows.push([
+        `"${keyword.keyword}"`,
+        keyword.currentPosition?.toString() || "N/A",
+        keyword.bestPosition?.toString() || "N/A",
+        keyword.lastChecked?.toISOString() || "Never",
+        trend
+      ].join(","));
+    }
+    return rows.join("\n");
+  }
+  /**
+   * Calculate position trend from history
+   */
+  calculatePositionTrend(history) {
+    if (history.length < 2) return "\u2192";
+    const recent = history[0]?.position;
+    const older = history[history.length - 1]?.position;
+    if (recent === null || older === null) return "\u2192";
+    if (recent < older) return "\u2191";
+    if (recent > older) return "\u2193";
+    return "\u2192";
+  }
+  /**
+   * Group keywords by search engine and country
+   */
+  groupKeywords(keywords) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const keyword of keywords) {
+      const key = `${keyword.searchEngine}:${keyword.country}:${keyword.language}`;
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key).push(keyword);
+    }
+    return Array.from(groups.entries()).map(([key, keywords2]) => {
+      const [searchEngine, country, language] = key.split(":");
+      return {
+        searchEngine,
+        country,
+        language,
+        keywords: keywords2
+      };
+    });
+  }
+  /**
+   * Map database row to TrackedKeyword
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  mapKeyword(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      keyword: row.keyword,
+      searchEngine: row.search_engine || "google",
+      country: row.country || "US",
+      language: row.language || "en",
+      currentPosition: row.current_position,
+      previousPosition: row.previous_position,
+      bestPosition: row.best_position,
+      trackUrl: row.track_url,
+      isActive: row.is_active,
+      lastChecked: row.last_checked ? new Date(row.last_checked) : null,
+      createdAt: new Date(row.created_at)
+    };
+  }
+};
+
 // src/analyzers/index.ts
 var analyzers_exports = {};
 __export(analyzers_exports, {
@@ -34937,9 +35687,12 @@ export {
   LOCATION_CODES,
   OG_IMAGE_SPECS,
   PRIORITY_WEIGHTS,
+  RankTracker,
   SEO_SCOPES,
   SITE_PROFILE_QUESTIONS,
   Schemas,
+  SerpClient,
+  TIER_LIMITS,
   addTrackingResult,
   analyzeAnchorText,
   analyzeCanonicalAdvanced,