@rankcli/agent-runtime 0.0.13 → 0.0.14

package/dist/index.js

@@ -3306,9 +3306,12 @@ __export(index_exports, {
   LOCATION_CODES: () => LOCATION_CODES,
   OG_IMAGE_SPECS: () => OG_IMAGE_SPECS,
   PRIORITY_WEIGHTS: () => PRIORITY_WEIGHTS,
+  RankTracker: () => RankTracker,
   SEO_SCOPES: () => SEO_SCOPES,
   SITE_PROFILE_QUESTIONS: () => SITE_PROFILE_QUESTIONS,
   Schemas: () => Schemas,
+  SerpClient: () => SerpClient,
+  TIER_LIMITS: () => TIER_LIMITS,
   addTrackingResult: () => addTrackingResult,
   analyzeAnchorText: () => analyzeAnchorText,
   analyzeCanonicalAdvanced: () => analyzeCanonicalAdvanced,
@@ -8085,7 +8088,13 @@ async function analyzeSecurityHeaders(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;
@@ -8157,10 +8166,17 @@ async function analyzeSecurityHeaders(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,
@@ -12199,17 +12215,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(
@@ -12217,7 +12233,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(
@@ -12241,7 +12257,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",
@@ -12282,7 +12298,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,
@@ -20207,20 +20223,26 @@ 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);
   }
@@ -37315,6 +37337,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, {
@@ -38506,9 +39066,12 @@ if (typeof globalThis !== "undefined") {
   LOCATION_CODES,
   OG_IMAGE_SPECS,
   PRIORITY_WEIGHTS,
+  RankTracker,
   SEO_SCOPES,
   SITE_PROFILE_QUESTIONS,
   Schemas,
+  SerpClient,
+  TIER_LIMITS,
   addTrackingResult,
   analyzeAnchorText,
   analyzeCanonicalAdvanced,