lintpage 0.1.1 → 0.1.2

package/dist/cli.mjs

@@ -1,12 +1,2618 @@
 // src/cli.ts
 import cac from "cac";
 import chalk2 from "chalk";
-import {
-  auditPage,
-  loadConfig,
-  createDefaultConfig
-} from "@lintpage/core";
-import { loadProPlugin, validateLicense } from "@lintpage/pro";
+
+// ../core/dist/index.mjs
+import { JSDOM } from "jsdom";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+var titleRule = {
+  meta: {
+    id: "title",
+    name: "Page Title",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for the presence and length of the <title> tag"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const titleElement = document.querySelector("title");
+    const value = titleElement?.textContent?.trim() || "";
+    const length = value.length;
+    if (!value) {
+      results.push({
+        ruleId: "title",
+        ruleName: "Page Title",
+        message: "Missing title tag",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: "Add a <title>Your Page Title</title> tag inside your <head> element. Keep it 50-60 characters.",
+        data: { value, length }
+      });
+    } else if (length < 30) {
+      results.push({
+        ruleId: "title",
+        ruleName: "Page Title",
+        message: "Title is too short (recommended: 50-60 characters)",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: "Expand your title to 50-60 characters. Include your primary keyword and make it compelling for click-through.",
+        data: { value, length }
+      });
+    } else if (length > 60) {
+      results.push({
+        ruleId: "title",
+        ruleName: "Page Title",
+        message: "Title is too long (recommended: 50-60 characters)",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: "Shorten your title to under 60 characters to prevent truncation in search results.",
+        data: { value, length }
+      });
+    }
+    return results;
+  }
+};
+var metaDescriptionRule = {
+  meta: {
+    id: "meta-description",
+    name: "Meta Description",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for the presence and length of the meta description tag"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const metaDesc = document.querySelector('meta[name="description"]');
+    const value = metaDesc?.getAttribute("content")?.trim() || "";
+    const length = value.length;
+    if (!value) {
+      results.push({
+        ruleId: "meta-description",
+        ruleName: "Meta Description",
+        message: "Missing meta description",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Add <meta name="description" content="Your description here" /> to your <head> tag. Aim for 150-160 characters.',
+        data: { value, length }
+      });
+    } else if (length < 120) {
+      results.push({
+        ruleId: "meta-description",
+        ruleName: "Meta Description",
+        message: "Meta description is too short (recommended: 150-160 characters)",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: "Expand your meta description to 150-160 characters. Include a compelling summary with your target keyword.",
+        data: { value, length }
+      });
+    } else if (length > 160) {
+      results.push({
+        ruleId: "meta-description",
+        ruleName: "Meta Description",
+        message: "Meta description is too long (recommended: 150-160 characters)",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: "Shorten your meta description to under 160 characters to prevent truncation in search results.",
+        data: { value, length }
+      });
+    }
+    return results;
+  }
+};
+var ogTitleRule = {
+  meta: {
+    id: "og-title",
+    name: "Open Graph Title",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for the og:title meta tag"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const ogTitle = document.querySelector('meta[property="og:title"]');
+    if (!ogTitle?.getAttribute("content")) {
+      results.push({
+        ruleId: "og-title",
+        ruleName: "Open Graph Title",
+        message: "Missing og:title tag - social media shares will have no title preview",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Add <meta property="og:title" content="Your Page Title" /> to your <head> tag.'
+      });
+    }
+    return results;
+  }
+};
+var ogDescriptionRule = {
+  meta: {
+    id: "og-description",
+    name: "Open Graph Description",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for the og:description meta tag"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const ogDesc = document.querySelector('meta[property="og:description"]');
+    if (!ogDesc?.getAttribute("content")) {
+      results.push({
+        ruleId: "og-description",
+        ruleName: "Open Graph Description",
+        message: "Missing og:description tag - social media shares will have no description preview",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Add <meta property="og:description" content="Your description" /> to your <head> tag.'
+      });
+    }
+    return results;
+  }
+};
+var ogImageRule = {
+  meta: {
+    id: "og-image",
+    name: "Open Graph Image",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for the og:image meta tag"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const ogImage = document.querySelector('meta[property="og:image"]');
+    if (!ogImage?.getAttribute("content")) {
+      results.push({
+        ruleId: "og-image",
+        ruleName: "Open Graph Image",
+        message: "Missing og:image tag - social media shares will have no image preview",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Add <meta property="og:image" content="https://yoursite.com/image.jpg" /> to your <head> tag.'
+      });
+    }
+    return results;
+  }
+};
+var ogUrlRule = {
+  meta: {
+    id: "og-url",
+    name: "Open Graph URL",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for the og:url meta tag"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const ogUrl = document.querySelector('meta[property="og:url"]');
+    if (!ogUrl?.getAttribute("content")) {
+      results.push({
+        ruleId: "og-url",
+        ruleName: "Open Graph URL",
+        message: "Missing og:url tag - social media may not show the correct URL",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Add <meta property="og:url" content="https://yoursite.com/page" /> to your <head> tag.'
+      });
+    }
+    return results;
+  }
+};
+var twitterCardRule = {
+  meta: {
+    id: "twitter-card",
+    name: "Twitter Card",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for Twitter Card meta tags"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const twitterCard = document.querySelector('meta[name="twitter:card"]');
+    if (!twitterCard?.getAttribute("content")) {
+      results.push({
+        ruleId: "twitter-card",
+        ruleName: "Twitter Card",
+        message: "Missing Twitter Card tags - tweets with your URL will have no preview card",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Add <meta name="twitter:card" content="summary_large_image" />, <meta name="twitter:title" content="..." />, and <meta name="twitter:image" content="..." /> to your <head>.'
+      });
+    }
+    return results;
+  }
+};
+var canonicalUrlRule = {
+  meta: {
+    id: "canonical-url",
+    name: "Canonical URL",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for a canonical link tag and validates the URL"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const canonical = document.querySelector('link[rel="canonical"]');
+    const value = canonical?.getAttribute("href") || void 0;
+    if (!canonical) {
+      results.push({
+        ruleId: "canonical-url",
+        ruleName: "Canonical URL",
+        message: "No canonical link found (recommended for SEO)",
+        severity: "INFO",
+        category: "SEO",
+        tier: "free",
+        fix: 'Add <link rel="canonical" href="https://yoursite.com/this-page" /> to your <head> tag to prevent duplicate content issues.',
+        data: { present: false }
+      });
+    } else if (value && !value.startsWith("http")) {
+      results.push({
+        ruleId: "canonical-url",
+        ruleName: "Canonical URL",
+        message: "Canonical URL should be absolute (include protocol and domain)",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Change your canonical href to an absolute URL starting with https:// (e.g., href="https://yoursite.com/page").',
+        data: { present: true, value }
+      });
+    }
+    return results;
+  }
+};
+var robotsNoindexRule = {
+  meta: {
+    id: "robots-noindex",
+    name: "Robots Noindex",
+    category: "Pre-Launch",
+    tier: "free",
+    description: "Checks for noindex/nofollow in the robots meta tag"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const metaRobots = document.querySelector('meta[name="robots"]');
+    const content = metaRobots?.getAttribute("content") || "";
+    if (content.includes("noindex")) {
+      results.push({
+        ruleId: "robots-noindex",
+        ruleName: "Robots Noindex",
+        message: "Page has noindex meta tag - WILL NOT BE INDEXED by search engines! Remove this before launch or you'll get ZERO organic traffic.",
+        severity: "CRITICAL",
+        category: "Pre-Launch",
+        tier: "free",
+        fix: 'Remove the <meta name="robots" content="noindex" /> tag from your <head>, or change it to content="index, follow".',
+        data: { metaRobots: content }
+      });
+    }
+    if (content.includes("nofollow")) {
+      results.push({
+        ruleId: "robots-noindex",
+        ruleName: "Robots Noindex",
+        message: "Page has nofollow meta tag - links will not be followed",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Remove "nofollow" from your <meta name="robots"> content if you want search engines to follow your links.',
+        data: { metaRobots: content }
+      });
+    }
+    return results;
+  }
+};
+var headingStructureRule = {
+  meta: {
+    id: "heading-structure",
+    name: "Heading Structure",
+    category: "SEO",
+    tier: "free",
+    description: "Validates H1 tag presence, count, and heading hierarchy"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const h1Elements = document.querySelectorAll("h1");
+    const count = h1Elements.length;
+    const values = Array.from(h1Elements).map(
+      (h1) => h1.textContent?.trim() || ""
+    );
+    if (count === 0) {
+      results.push({
+        ruleId: "heading-structure",
+        ruleName: "Heading Structure",
+        message: "No H1 tag found",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: "Add a single <h1> tag to your page with a clear, descriptive heading that includes your primary keyword.",
+        data: { h1Count: count }
+      });
+    } else if (count > 1) {
+      results.push({
+        ruleId: "heading-structure",
+        ruleName: "Heading Structure",
+        message: `Multiple H1 tags found (${count}). Recommended: 1 per page`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: "Keep only one <h1> tag per page. Use <h2>-<h6> for subheadings.",
+        data: { h1Count: count, h1Values: values }
+      });
+    }
+    values.forEach((value, index) => {
+      if (!value) {
+        results.push({
+          ruleId: "heading-structure",
+          ruleName: "Heading Structure",
+          message: `H1 #${index + 1} is empty`,
+          severity: "WARNING",
+          category: "SEO",
+          tier: "free",
+          fix: "Add descriptive text content to your <h1> tag."
+        });
+      } else if (value.length > 70) {
+        results.push({
+          ruleId: "heading-structure",
+          ruleName: "Heading Structure",
+          message: `H1 #${index + 1} is too long (${value.length} characters)`,
+          severity: "INFO",
+          category: "SEO",
+          tier: "free",
+          fix: "Shorten your H1 to under 70 characters for better readability and SEO."
+        });
+      }
+    });
+    const headings = document.querySelectorAll("h1, h2, h3, h4, h5, h6");
+    let lastLevel = 0;
+    Array.from(headings).forEach((heading) => {
+      const level = Number.parseInt(heading.tagName[1] ?? "1", 10);
+      if (level - lastLevel > 1) {
+        const text = heading.textContent?.trim().substring(0, 40) || "...";
+        results.push({
+          ruleId: "heading-structure",
+          ruleName: "Heading Structure",
+          message: `${heading.tagName} skips heading level from h${lastLevel} (content: "${text}")`,
+          severity: "INFO",
+          category: "SEO",
+          tier: "free",
+          fix: `Don't skip heading levels. Use h${lastLevel + 1} instead of ${heading.tagName} to maintain proper hierarchy.`
+        });
+      }
+      lastLevel = level;
+    });
+    return results;
+  }
+};
+var htmlLangRule = {
+  meta: {
+    id: "html-lang",
+    name: "HTML Lang Attribute",
+    category: "Accessibility",
+    tier: "free",
+    description: "Checks for the lang attribute on the <html> tag"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const html = document.documentElement;
+    const lang = html.getAttribute("lang");
+    if (!lang) {
+      results.push({
+        ruleId: "html-lang",
+        ruleName: "HTML Lang Attribute",
+        message: "Missing lang attribute on <html> tag",
+        severity: "WARNING",
+        category: "Accessibility",
+        tier: "free",
+        fix: 'Add lang="en" (or your language code) to your <html> tag: <html lang="en">.',
+        data: { present: false }
+      });
+    }
+    return results;
+  }
+};
+var viewportRule = {
+  meta: {
+    id: "viewport",
+    name: "Viewport Meta Tag",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for the viewport meta tag for mobile responsiveness"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const viewport = document.querySelector('meta[name="viewport"]');
+    if (!viewport) {
+      results.push({
+        ruleId: "viewport",
+        ruleName: "Viewport Meta Tag",
+        message: "Missing viewport meta tag - page will not render properly on mobile devices",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Add <meta name="viewport" content="width=device-width, initial-scale=1" /> to your <head> tag.',
+        data: { present: false }
+      });
+    }
+    return results;
+  }
+};
+var faviconRule = {
+  meta: {
+    id: "favicon",
+    name: "Favicon",
+    category: "SEO",
+    tier: "free",
+    description: "Checks for the presence of a favicon link tag"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const favicon = document.querySelector('link[rel*="icon"]');
+    if (!favicon) {
+      results.push({
+        ruleId: "favicon",
+        ruleName: "Favicon",
+        message: "No favicon found - browsers will show a default icon in tabs and bookmarks",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "free",
+        fix: 'Add <link rel="icon" href="/favicon.ico" /> to your <head> tag. Include multiple sizes for best results.',
+        data: { present: false }
+      });
+    }
+    return results;
+  }
+};
+var coreRules = [
+  titleRule,
+  metaDescriptionRule,
+  ogTitleRule,
+  ogDescriptionRule,
+  ogImageRule,
+  ogUrlRule,
+  twitterCardRule,
+  canonicalUrlRule,
+  robotsNoindexRule,
+  headingStructureRule,
+  htmlLangRule,
+  viewportRule,
+  faviconRule
+];
+var ruleRegistry = new Map(
+  coreRules.map((rule) => [rule.meta.id, rule])
+);
+async function fetchPage(url) {
+  const fetchStart = Date.now();
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "LintPage-Bot/1.0"
+    },
+    signal: AbortSignal.timeout(3e4)
+  });
+  const ttfbMs = Date.now() - fetchStart;
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch URL: ${response.status} ${response.statusText}`
+    );
+  }
+  const html = await response.text();
+  const dom = new JSDOM(html);
+  return {
+    document: dom.window.document,
+    response,
+    html,
+    ttfbMs
+  };
+}
+var CATEGORY_WEIGHTS = {
+  "Pre-Launch": 30,
+  SEO: 35,
+  Accessibility: 20,
+  Performance: 15
+};
+function calculateCategoryScores(results) {
+  const categoryIssues = {};
+  for (const category of Object.keys(CATEGORY_WEIGHTS)) {
+    categoryIssues[category] = { critical: 0, warning: 0, info: 0 };
+  }
+  for (const result of results) {
+    const cat = result.category;
+    if (!categoryIssues[cat]) {
+      categoryIssues[cat] = { critical: 0, warning: 0, info: 0 };
+    }
+    if (result.severity === "CRITICAL") categoryIssues[cat].critical++;
+    else if (result.severity === "WARNING") categoryIssues[cat].warning++;
+    else categoryIssues[cat].info++;
+  }
+  const scores = {};
+  for (const [category, weight] of Object.entries(CATEGORY_WEIGHTS)) {
+    const counts = categoryIssues[category] || {
+      critical: 0,
+      warning: 0,
+      info: 0
+    };
+    const deductionPercent = Math.min(
+      100,
+      counts.critical * 30 + counts.warning * 5 + counts.info * 1
+    );
+    scores[category] = {
+      score: Math.round(weight * (1 - deductionPercent / 100) * 10) / 10,
+      max: weight,
+      deductionPercent
+    };
+  }
+  return scores;
+}
+function runRules(rules, context, config) {
+  const results = [];
+  for (const rule of rules) {
+    if (config?.rules) {
+      const ruleConfig = config.rules[rule.meta.id];
+      if (ruleConfig === false) continue;
+      if (typeof ruleConfig === "object" && ruleConfig.enabled === false)
+        continue;
+    }
+    try {
+      const ruleResults = rule.run(context);
+      results.push(...ruleResults);
+    } catch (err) {
+      console.warn(
+        `[lintpage] Rule "${rule.meta.id}" threw an error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return results;
+}
+async function runStandaloneRules(rules, url, config) {
+  const results = [];
+  for (const rule of rules) {
+    if (config?.rules) {
+      const ruleConfig = config.rules[rule.meta.id];
+      if (ruleConfig === false) continue;
+      if (typeof ruleConfig === "object" && ruleConfig.enabled === false)
+        continue;
+    }
+    try {
+      const ruleResults = await rule.run(url);
+      results.push(...ruleResults);
+    } catch (err) {
+      console.warn(
+        `[lintpage] Standalone rule "${rule.meta.id}" threw an error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return results;
+}
+async function auditPage(url, options) {
+  const { document, response, ttfbMs } = await fetchPage(url);
+  const isHttps = url.startsWith("https://");
+  const context = {
+    document,
+    url,
+    response,
+    isHttps
+  };
+  const allRules = [...coreRules];
+  const allStandaloneRules = [];
+  if (options?.plugins) {
+    for (const plugin of options.plugins) {
+      allRules.push(...plugin.rules);
+      if (plugin.standaloneRules) {
+        allStandaloneRules.push(...plugin.standaloneRules);
+      }
+    }
+  }
+  const results = runRules(allRules, context, options?.config);
+  if (allStandaloneRules.length > 0) {
+    const standaloneResults = await runStandaloneRules(
+      allStandaloneRules,
+      url,
+      options?.config
+    );
+    results.push(...standaloneResults);
+  }
+  if (ttfbMs > 2e3) {
+    results.push({
+      ruleId: "ttfb",
+      ruleName: "Time to First Byte",
+      message: `Slow server response time (TTFB: ${ttfbMs}ms) - aim for under 800ms`,
+      severity: "WARNING",
+      category: "Performance",
+      tier: "free",
+      fix: "Optimize server response time: enable caching, use a CDN, optimize database queries, or upgrade hosting.",
+      data: { ms: ttfbMs }
+    });
+  } else if (ttfbMs > 800) {
+    results.push({
+      ruleId: "ttfb",
+      ruleName: "Time to First Byte",
+      message: `Server response time could be improved (TTFB: ${ttfbMs}ms) - aim for under 800ms`,
+      severity: "INFO",
+      category: "Performance",
+      tier: "free",
+      fix: "Consider enabling server-side caching or using a CDN to reduce response time.",
+      data: { ms: ttfbMs }
+    });
+  }
+  const categoryScores = calculateCategoryScores(results);
+  const score = Object.values(categoryScores).reduce(
+    (sum, cat) => sum + cat.score,
+    0
+  );
+  const hasCritical = results.some((r) => r.severity === "CRITICAL");
+  return {
+    url,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    results,
+    score: Math.round(score),
+    overallStatus: hasCritical ? "FAIL" : "PASS",
+    categoryScores
+  };
+}
+var CONFIG_FILES = [
+  ".lintpagerc.json",
+  ".lintpagerc",
+  "lintpage.config.json"
+];
+function loadConfig(cwd) {
+  const dir = cwd || process.cwd();
+  for (const file of CONFIG_FILES) {
+    const path = join(dir, file);
+    if (existsSync(path)) {
+      try {
+        const content = readFileSync(path, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function createDefaultConfig() {
+  return {
+    rules: {}
+  };
+}
+
+// ../pro/dist/index.mjs
+import * as jose from "jose";
+var sslRule = {
+  meta: {
+    id: "ssl",
+    name: "SSL / HTTPS",
+    category: "Pre-Launch",
+    tier: "pro",
+    description: "Checks that the site is served over HTTPS"
+  },
+  run(context) {
+    const results = [];
+    if (!context.isHttps) {
+      results.push({
+        ruleId: "ssl",
+        ruleName: "SSL / HTTPS",
+        message: "Site is not using HTTPS \u2014 required for SEO and user trust. Search engines penalize HTTP sites.",
+        severity: "CRITICAL",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: "Install an SSL certificate and redirect all HTTP traffic to HTTPS. Most hosting providers offer free SSL via Let's Encrypt."
+      });
+    }
+    return results;
+  }
+};
+var robotsTxtCheckRule = {
+  meta: {
+    id: "robots-txt-check",
+    name: "robots.txt Check",
+    category: "Pre-Launch",
+    tier: "pro",
+    description: "Fetches and validates robots.txt for proper directives"
+  },
+  async run(url) {
+    const results = [];
+    try {
+      const robotsUrl = new URL("/robots.txt", url).href;
+      const response = await fetch(robotsUrl, {
+        headers: { "User-Agent": "LintPage-Bot/1.0" }
+      });
+      if (!response.ok) {
+        results.push({
+          ruleId: "robots-txt-check",
+          ruleName: "robots.txt Check",
+          message: "No robots.txt file found \u2014 recommended to have one",
+          severity: "WARNING",
+          category: "Pre-Launch",
+          tier: "pro",
+          fix: 'Create a robots.txt file at your site root with at least "User-Agent: *" and "Allow: /" directives.'
+        });
+        return results;
+      }
+      const content = await response.text();
+      const lines = content.split("\n").map((line) => line.trim());
+      const rules = /* @__PURE__ */ new Map();
+      let currentUserAgent = "*";
+      for (const line of lines) {
+        if (!line || line.startsWith("#")) continue;
+        const [directive, ...valueParts] = line.split(":").map((part) => part.trim());
+        const value = valueParts.join(":").trim();
+        if (!directive || !value) continue;
+        const upper = directive.toUpperCase();
+        if (upper === "USER-AGENT") {
+          currentUserAgent = value;
+          if (!rules.has(currentUserAgent)) {
+            rules.set(currentUserAgent, { disallow: [], allow: [] });
+          }
+        } else if (upper === "DISALLOW") {
+          const r = rules.get(currentUserAgent) || {
+            disallow: [],
+            allow: []
+          };
+          r.disallow.push(value);
+          rules.set(currentUserAgent, r);
+        } else if (upper === "ALLOW") {
+          const r = rules.get(currentUserAgent) || {
+            disallow: [],
+            allow: []
+          };
+          r.allow.push(value);
+          rules.set(currentUserAgent, r);
+        }
+      }
+      const wildcard = rules.get("*");
+      if (wildcard && wildcard.disallow.includes("/")) {
+        results.push({
+          ruleId: "robots-txt-check",
+          ruleName: "robots.txt Check",
+          message: 'robots.txt contains "Disallow: /" for User-Agent: * \u2014 this blocks ALL search engines from crawling your entire site!',
+          severity: "CRITICAL",
+          category: "Pre-Launch",
+          tier: "pro",
+          fix: 'Change "Disallow: /" to "Allow: /" in your robots.txt, or remove the Disallow directive entirely.'
+        });
+      }
+      if (!content.toLowerCase().includes("sitemap")) {
+        results.push({
+          ruleId: "robots-txt-check",
+          ruleName: "robots.txt Check",
+          message: "robots.txt does not reference sitemap.xml \u2014 consider adding a Sitemap directive",
+          severity: "INFO",
+          category: "Pre-Launch",
+          tier: "pro",
+          fix: 'Add "Sitemap: https://yoursite.com/sitemap.xml" to the end of your robots.txt file.'
+        });
+      }
+      const hasMalformedLines = lines.some((line) => {
+        if (!line || line.startsWith("#")) return false;
+        return !line.includes(":") && line.length > 0;
+      });
+      if (hasMalformedLines) {
+        results.push({
+          ruleId: "robots-txt-check",
+          ruleName: "robots.txt Check",
+          message: 'robots.txt may have syntax errors \u2014 ensure each directive follows "Directive: value" format',
+          severity: "WARNING",
+          category: "Pre-Launch",
+          tier: "pro",
+          fix: 'Review each line in robots.txt. Every directive must follow the "Directive: value" format (e.g., "User-Agent: *").'
+        });
+      }
+      if (rules.size === 0 || rules.size === 1 && !rules.has("*")) {
+        results.push({
+          ruleId: "robots-txt-check",
+          ruleName: "robots.txt Check",
+          message: "robots.txt exists but has no rules defined \u2014 add User-Agent and Disallow/Allow directives",
+          severity: "INFO",
+          category: "Pre-Launch",
+          tier: "pro",
+          fix: 'Add at minimum "User-Agent: *" followed by "Allow: /" to your robots.txt.'
+        });
+      }
+    } catch {
+      results.push({
+        ruleId: "robots-txt-check",
+        ruleName: "robots.txt Check",
+        message: "Could not fetch robots.txt \u2014 ensure it exists at root domain",
+        severity: "WARNING",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: "Create a robots.txt file at your domain root (e.g., https://yoursite.com/robots.txt)."
+      });
+    }
+    return results;
+  }
+};
+var sitemapPresenceRule = {
+  meta: {
+    id: "sitemap-presence",
+    name: "Sitemap Presence",
+    category: "Pre-Launch",
+    tier: "pro",
+    description: "Checks for the existence and validity of sitemap.xml"
+  },
+  async run(url) {
+    const results = [];
+    try {
+      const sitemapUrl = new URL("/sitemap.xml", url).href;
+      const response = await fetch(sitemapUrl, {
+        headers: { "User-Agent": "LintPage-Bot/1.0" }
+      });
+      if (!response.ok) {
+        results.push({
+          ruleId: "sitemap-presence",
+          ruleName: "Sitemap Presence",
+          message: "No sitemap.xml found \u2014 recommended for search engines to discover your pages",
+          severity: "WARNING",
+          category: "Pre-Launch",
+          tier: "pro",
+          fix: "Generate a sitemap.xml and place it at your domain root. Most frameworks (Next.js, WordPress) have built-in sitemap generation."
+        });
+        return results;
+      }
+      const content = await response.text();
+      if (!content.includes("<?xml") || !content.includes("<urlset")) {
+        results.push({
+          ruleId: "sitemap-presence",
+          ruleName: "Sitemap Presence",
+          message: "sitemap.xml exists but may not be valid XML format",
+          severity: "WARNING",
+          category: "Pre-Launch",
+          tier: "pro",
+          fix: 'Ensure your sitemap.xml starts with <?xml version="1.0"?> and uses the <urlset> element with proper namespace.'
+        });
+      }
+      const urlMatches = content.match(/<loc>/g);
+      const urlCount = urlMatches ? urlMatches.length : 0;
+      if (urlCount === 0) {
+        results.push({
+          ruleId: "sitemap-presence",
+          ruleName: "Sitemap Presence",
+          message: "sitemap.xml is empty \u2014 add URLs to help search engines discover content",
+          severity: "WARNING",
+          category: "Pre-Launch",
+          tier: "pro",
+          fix: "Add <url><loc>https://yoursite.com/page</loc></url> entries to your sitemap for each page you want indexed."
+        });
+      }
+    } catch {
+      results.push({
+        ruleId: "sitemap-presence",
+        ruleName: "Sitemap Presence",
+        message: "Could not fetch sitemap.xml \u2014 create one at /sitemap.xml",
+        severity: "WARNING",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: "Create a sitemap.xml at your domain root. Use a sitemap generator or your framework's built-in sitemap feature."
+      });
+    }
+    return results;
+  }
+};
+var trackingRule = {
+  meta: {
+    id: "tracking",
+    name: "Analytics Tracking",
+    category: "Pre-Launch",
+    tier: "pro",
+    description: "Checks for Google Analytics, Google Tag Manager, or Facebook Pixel"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    let foundGA = false;
+    let foundGTM = false;
+    const scripts = document.querySelectorAll("script");
+    scripts.forEach((script) => {
+      const src = script.getAttribute("src") || "";
+      const content = script.textContent || "";
+      if (src.includes("googletagmanager.com/gtag/js") || content.includes("gtag(")) {
+        foundGA = true;
+      }
+      if (src.includes("googletagmanager.com/gtm.js") || content.includes("GTM-")) {
+        foundGTM = true;
+      }
+    });
+    if (!foundGA && !foundGTM) {
+      results.push({
+        ruleId: "tracking",
+        ruleName: "Analytics Tracking",
+        message: "No Google Analytics or Tag Manager found \u2014 you won't be able to track traffic after launch",
+        severity: "WARNING",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: "Add Google Analytics (gtag.js) or Google Tag Manager script to your <head> tag. Get your tracking ID from analytics.google.com.",
+        data: { googleAnalytics: foundGA, googleTagManager: foundGTM }
+      });
+    }
+    return results;
+  }
+};
+var xRobotsTagRule = {
+  meta: {
+    id: "x-robots-tag",
+    name: "X-Robots-Tag Header",
+    category: "Pre-Launch",
+    tier: "pro",
+    description: "Checks the X-Robots-Tag HTTP header for noindex/nofollow"
+  },
+  run(context) {
+    const { response } = context;
+    const results = [];
+    const value = response.headers.get("x-robots-tag");
+    if (!value) return results;
+    const lower = value.toLowerCase();
+    if (lower.includes("noindex")) {
+      results.push({
+        ruleId: "x-robots-tag",
+        ruleName: "X-Robots-Tag Header",
+        message: 'X-Robots-Tag HTTP header contains "noindex" \u2014 page will NOT be indexed by search engines!',
+        severity: "CRITICAL",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: 'Remove the X-Robots-Tag header from your server configuration, or change its value to "index, follow".',
+        data: { value }
+      });
+    }
+    if (lower.includes("nofollow")) {
+      results.push({
+        ruleId: "x-robots-tag",
+        ruleName: "X-Robots-Tag Header",
+        message: 'X-Robots-Tag HTTP header contains "nofollow" \u2014 links will not be followed by search engines',
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Remove "nofollow" from the X-Robots-Tag header if you want search engines to follow your links.',
+        data: { value }
+      });
+    }
+    return results;
+  }
+};
+var thinContentRule = {
+  meta: {
+    id: "thin-content",
+    name: "Thin Content",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks that the page has sufficient text content for search engines"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const bodyText = document.body?.textContent || "";
+    const wordCount = bodyText.trim().split(/\s+/).filter(Boolean).length;
+    if (wordCount < 300) {
+      results.push({
+        ruleId: "thin-content",
+        ruleName: "Thin Content",
+        message: `Page has thin content (${wordCount} words) \u2014 search engines prefer pages with substantial content (300+ words)`,
+        severity: "INFO",
+        category: "SEO",
+        tier: "pro",
+        fix: "Add more meaningful text content to the page. Search engines rank pages with substantial, relevant content higher.",
+        data: { wordCount }
+      });
+    }
+    return results;
+  }
+};
+var duplicateMetaRule = {
+  meta: {
+    id: "duplicate-meta",
+    name: "Duplicate Meta Tags",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks for duplicate title, meta description, and canonical tags"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const titleTags = document.querySelectorAll("title");
+    if (titleTags.length > 1) {
+      results.push({
+        ruleId: "duplicate-meta",
+        ruleName: "Duplicate Meta Tags",
+        message: `Found ${titleTags.length} <title> tags \u2014 should have exactly one`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Remove duplicate <title> tags. Keep only one in your <head> element.",
+        data: { count: titleTags.length, tag: "title" }
+      });
+    }
+    const descriptionTags = document.querySelectorAll(
+      'meta[name="description"]'
+    );
+    if (descriptionTags.length > 1) {
+      results.push({
+        ruleId: "duplicate-meta",
+        ruleName: "Duplicate Meta Tags",
+        message: `Found ${descriptionTags.length} meta description tags \u2014 should have exactly one`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Remove duplicate <meta name="description"> tags. Keep only one in your <head> element.',
+        data: { count: descriptionTags.length, tag: "meta-description" }
+      });
+    }
+    const canonicalTags = document.querySelectorAll('link[rel="canonical"]');
+    if (canonicalTags.length > 1) {
+      results.push({
+        ruleId: "duplicate-meta",
+        ruleName: "Duplicate Meta Tags",
+        message: `Found ${canonicalTags.length} canonical link tags \u2014 should have exactly one`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Remove duplicate <link rel="canonical"> tags. Keep only one in your <head> element.',
+        data: { count: canonicalTags.length, tag: "canonical" }
+      });
+    }
+    return results;
+  }
+};
+var structuredDataRule = {
+  meta: {
+    id: "structured-data",
+    name: "Structured Data",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks for the presence and validity of JSON-LD structured data"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const jsonLdScripts = document.querySelectorAll(
+      'script[type="application/ld+json"]'
+    );
+    const types = [];
+    jsonLdScripts.forEach((script) => {
+      try {
+        const data = JSON.parse(script.textContent || "");
+        if (data["@type"]) {
+          types.push(data["@type"]);
+        }
+      } catch {
+        results.push({
+          ruleId: "structured-data",
+          ruleName: "Structured Data",
+          message: "Invalid JSON-LD structured data found",
+          severity: "WARNING",
+          category: "SEO",
+          tier: "pro",
+          fix: "Validate your JSON-LD using Google's Rich Results Test tool and fix any JSON syntax errors."
+        });
+      }
+    });
+    if (types.length === 0) {
+      results.push({
+        ruleId: "structured-data",
+        ruleName: "Structured Data",
+        message: "No structured data (JSON-LD) found",
+        severity: "INFO",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Add a <script type="application/ld+json"> block with Organization, WebPage, or other relevant schema.org types.',
+        data: { types }
+      });
+    }
+    return results;
+  }
+};
+var charsetRule = {
+  meta: {
+    id: "charset",
+    name: "Character Encoding",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks for a proper charset/encoding declaration"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const charsetMeta = document.querySelector("meta[charset]");
+    const httpEquivMeta = document.querySelector(
+      'meta[http-equiv="Content-Type"]'
+    );
+    if (!charsetMeta && !httpEquivMeta) {
+      results.push({
+        ruleId: "charset",
+        ruleName: "Character Encoding",
+        message: "Missing character encoding declaration \u2014 may cause rendering issues with special characters",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Add <meta charset="utf-8" /> as the first element in your <head> tag.'
+      });
+    }
+    return results;
+  }
+};
+var imageAltTextRule = {
+  meta: {
+    id: "image-alt-text",
+    name: "Image Alt Text",
+    category: "Accessibility",
+    tier: "pro",
+    description: "Checks that all images have alt attributes"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const images = document.querySelectorAll("img");
+    let missingAlt = 0;
+    images.forEach((img) => {
+      const alt = img.getAttribute("alt");
+      if (alt === null || alt === void 0) {
+        missingAlt++;
+      }
+    });
+    if (missingAlt > 0) {
+      results.push({
+        ruleId: "image-alt-text",
+        ruleName: "Image Alt Text",
+        message: `${missingAlt} of ${images.length} images missing alt attributes`,
+        severity: "WARNING",
+        category: "Accessibility",
+        tier: "pro",
+        fix: 'Add descriptive alt attributes to all images. Screen readers use alt text to describe images to visually impaired users. Use alt="" for decorative images.',
+        data: { total: images.length, missingAlt }
+      });
+    }
+    return results;
+  }
+};
+var accessibilityRule = {
+  meta: {
+    id: "accessibility",
+    name: "Accessibility & ARIA",
+    category: "Accessibility",
+    tier: "pro",
+    description: "Checks buttons, links, inputs, and ARIA attributes for accessibility"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const buttons = document.querySelectorAll("button");
+    let inaccessibleButtons = 0;
+    buttons.forEach((button) => {
+      const hasText = button.textContent?.trim();
+      const hasAriaLabel = button.getAttribute("aria-label");
+      const hasAriaLabelledBy = button.getAttribute("aria-labelledby");
+      if (!hasText && !hasAriaLabel && !hasAriaLabelledBy) {
+        inaccessibleButtons++;
+      }
+    });
+    if (inaccessibleButtons > 0) {
+      results.push({
+        ruleId: "accessibility",
+        ruleName: "Accessibility & ARIA",
+        message: `${inaccessibleButtons} button(s) missing accessible name (no text, aria-label, or aria-labelledby)`,
+        severity: "WARNING",
+        category: "Accessibility",
+        tier: "pro",
+        fix: "Add visible text content, an aria-label, or aria-labelledby attribute to each button.",
+        data: { inaccessibleButtons }
+      });
+    }
+    const links = document.querySelectorAll("a");
+    let inaccessibleLinks = 0;
+    links.forEach((link) => {
+      const hasText = link.textContent?.trim();
+      const hasAriaLabel = link.getAttribute("aria-label");
+      if (!hasText && !hasAriaLabel) {
+        inaccessibleLinks++;
+      }
+    });
+    if (inaccessibleLinks > 0) {
+      results.push({
+        ruleId: "accessibility",
+        ruleName: "Accessibility & ARIA",
+        message: `${inaccessibleLinks} link(s) missing accessible name (no text or aria-label)`,
+        severity: "WARNING",
+        category: "Accessibility",
+        tier: "pro",
+        fix: "Add descriptive text content or an aria-label attribute to each link so screen readers can identify it.",
+        data: { inaccessibleLinks }
+      });
+    }
+    const inputs = document.querySelectorAll("input:not([type='hidden'])");
+    let unlabeledInputs = 0;
+    inputs.forEach((input) => {
+      const id = input.getAttribute("id");
+      const ariaLabel = input.getAttribute("aria-label");
+      const ariaLabelledBy = input.getAttribute("aria-labelledby");
+      const hasLabel = id && document.querySelector(`label[for="${id}"]`);
+      if (!hasLabel && !ariaLabel && !ariaLabelledBy) {
+        unlabeledInputs++;
+      }
+    });
+    if (unlabeledInputs > 0) {
+      results.push({
+        ruleId: "accessibility",
+        ruleName: "Accessibility & ARIA",
+        message: `${unlabeledInputs} input(s) missing associated label`,
+        severity: "WARNING",
+        category: "Accessibility",
+        tier: "pro",
+        fix: 'Add a <label for="inputId"> element, or add an aria-label attribute to each input.',
+        data: { unlabeledInputs }
+      });
+    }
+    const divButtons = document.querySelectorAll(
+      "div[onclick], span[onclick]"
+    );
+    let missingRoles = 0;
+    divButtons.forEach((el) => {
+      if (!el.getAttribute("role")) missingRoles++;
+    });
+    if (missingRoles > 0) {
+      results.push({
+        ruleId: "accessibility",
+        ruleName: "Accessibility & ARIA",
+        message: `${missingRoles} interactive div/span element(s) missing role attribute`,
+        severity: "WARNING",
+        category: "Accessibility",
+        tier: "pro",
+        fix: 'Use a <button> element instead, or add role="button" and an aria-label to interactive elements.',
+        data: { missingRoles }
+      });
+    }
+    const navElements = document.querySelectorAll(
+      'nav, [role="navigation"]'
+    );
+    let unlabeledNav = 0;
+    navElements.forEach((nav) => {
+      const ariaLabel = nav.getAttribute("aria-label");
+      const ariaLabelledBy = nav.getAttribute("aria-labelledby");
+      if (!ariaLabel && !ariaLabelledBy) unlabeledNav++;
+    });
+    if (unlabeledNav > 0) {
+      results.push({
+        ruleId: "accessibility",
+        ruleName: "Accessibility & ARIA",
+        message: `${unlabeledNav} navigation element(s) missing aria-label or aria-labelledby`,
+        severity: "INFO",
+        category: "Accessibility",
+        tier: "pro",
+        fix: 'Add aria-label="Main navigation" (or similar descriptive label) to your <nav> elements.',
+        data: { unlabeledNav }
+      });
+    }
+    return results;
+  }
+};
+var semanticStructureRule = {
+  meta: {
+    id: "semantic-structure",
+    name: "Semantic Structure",
+    category: "Accessibility",
+    tier: "pro",
+    description: "Checks for proper semantic HTML: landmarks, lists, tables, articles"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const main = document.querySelector("main");
+    if (!main) {
+      results.push({
+        ruleId: "semantic-structure",
+        ruleName: "Semantic Structure",
+        message: "Missing <main> element \u2014 should wrap primary page content for better structure",
+        severity: "WARNING",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: "Wrap your primary page content in a <main> element. There should be exactly one per page."
+      });
+    }
+    const semanticElements = document.querySelectorAll(
+      "main, section, article, aside, nav"
+    );
+    if (semanticElements.length === 0) {
+      results.push({
+        ruleId: "semantic-structure",
+        ruleName: "Semantic Structure",
+        message: "Missing semantic page regions \u2014 use <main>, <section>, <article>, <nav>, <aside> instead of generic divs",
+        severity: "WARNING",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: "Replace generic <div> containers with semantic elements: <main>, <nav>, <section>, <article>, <aside>."
+      });
+    }
+    const listItems = document.querySelectorAll("li");
+    let orphanedLi = 0;
+    listItems.forEach((li) => {
+      const parent = li.parentElement;
+      if (parent?.tagName !== "UL" && parent?.tagName !== "OL") {
+        orphanedLi++;
+      }
+    });
+    if (orphanedLi > 0) {
+      results.push({
+        ruleId: "semantic-structure",
+        ruleName: "Semantic Structure",
+        message: `${orphanedLi} <li> element(s) found outside of <ul> or <ol> \u2014 breaks semantic structure`,
+        severity: "WARNING",
+        category: "Accessibility",
+        tier: "pro",
+        fix: "Wrap <li> elements inside a <ul> (unordered) or <ol> (ordered) list element.",
+        data: { orphanedLi }
+      });
+    }
+    const tables = document.querySelectorAll("table");
+    let tablesWithoutThead = 0;
+    tables.forEach((table) => {
+      if (!table.querySelector("thead")) tablesWithoutThead++;
+    });
+    if (tablesWithoutThead > 0) {
+      results.push({
+        ruleId: "semantic-structure",
+        ruleName: "Semantic Structure",
+        message: `${tablesWithoutThead} table(s) missing <thead> element`,
+        severity: "INFO",
+        category: "Accessibility",
+        tier: "pro",
+        fix: "Add a <thead> element with <th> cells to define table column headers.",
+        data: { tablesWithoutThead }
+      });
+    }
+    const articles = document.querySelectorAll("article");
+    let articlesWithoutHeading = 0;
+    articles.forEach((article) => {
+      if (!article.querySelector("h1, h2, h3, h4, h5, h6")) {
+        articlesWithoutHeading++;
+      }
+    });
+    if (articlesWithoutHeading > 0) {
+      results.push({
+        ruleId: "semantic-structure",
+        ruleName: "Semantic Structure",
+        message: `${articlesWithoutHeading} <article> element(s) without a heading`,
+        severity: "INFO",
+        category: "Accessibility",
+        tier: "pro",
+        fix: "Add a heading (h2-h6) inside each <article> element to provide context.",
+        data: { articlesWithoutHeading }
+      });
+    }
+    return results;
+  }
+};
+var performanceRule = {
+  meta: {
+    id: "performance",
+    name: "Performance Hints",
+    category: "Performance",
+    tier: "pro",
+    description: "Checks for inline styles, lazy loading, and script count"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const inlineStyles = document.querySelectorAll("[style]");
+    if (inlineStyles.length > 10) {
+      results.push({
+        ruleId: "performance",
+        ruleName: "Performance Hints",
+        message: `Reduce inline styles (${inlineStyles.length} elements) \u2014 use CSS classes instead`,
+        severity: "INFO",
+        category: "Performance",
+        tier: "pro",
+        fix: "Move inline styles to CSS classes for better cacheability and maintainability.",
+        data: { inlineStyleCount: inlineStyles.length }
+      });
+    }
+    const images = document.querySelectorAll("img");
+    let noLazyLoad = 0;
+    images.forEach((img) => {
+      if (!img.getAttribute("loading")) noLazyLoad++;
+    });
+    if (noLazyLoad > 3) {
+      results.push({
+        ruleId: "performance",
+        ruleName: "Performance Hints",
+        message: `${noLazyLoad} images without loading attribute \u2014 add lazy loading`,
+        severity: "INFO",
+        category: "Performance",
+        tier: "pro",
+        fix: 'Add loading="lazy" to images below the fold to defer loading until they are near the viewport.',
+        data: { noLazyLoad, totalImages: images.length }
+      });
+    }
+    const scripts = document.querySelectorAll("script[src]");
+    if (scripts.length > 10) {
+      results.push({
+        ruleId: "performance",
+        ruleName: "Performance Hints",
+        message: `Consider reducing external scripts (${scripts.length} found) for better performance`,
+        severity: "INFO",
+        category: "Performance",
+        tier: "pro",
+        fix: "Audit your scripts and remove unused ones. Consider bundling or deferring non-critical scripts.",
+        data: { scriptCount: scripts.length }
+      });
+    }
+    return results;
+  }
+};
+var imageDimensionsRule = {
+  meta: {
+    id: "image-dimensions",
+    name: "Image Dimensions",
+    category: "Performance",
+    tier: "pro",
+    description: "Checks that images have explicit width and height to prevent layout shift (CLS)"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const images = document.querySelectorAll("img");
+    let missingCount = 0;
+    images.forEach((img) => {
+      const hasWidth = img.getAttribute("width");
+      const hasHeight = img.getAttribute("height");
+      if (!hasWidth || !hasHeight) missingCount++;
+    });
+    if (missingCount > 0) {
+      results.push({
+        ruleId: "image-dimensions",
+        ruleName: "Image Dimensions",
+        message: `${missingCount} image${missingCount !== 1 ? "s" : ""} missing explicit width/height attributes \u2014 causes layout shift (CLS)`,
+        severity: "INFO",
+        category: "Performance",
+        tier: "pro",
+        fix: "Add width and height attributes to <img> tags to reserve space and prevent layout shift.",
+        data: { missingCount, totalImages: images.length }
+      });
+    }
+    return results;
+  }
+};
+var ttfbRule = {
+  meta: {
+    id: "ttfb-pro",
+    name: "Time to First Byte (Pro)",
+    category: "Performance",
+    tier: "pro",
+    description: "Measures server response time (TTFB) with detailed thresholds"
+  },
+  async run(url) {
+    const results = [];
+    try {
+      const start = Date.now();
+      await fetch(url, {
+        headers: { "User-Agent": "LintPage-Bot/1.0" }
+      });
+      const ttfbMs = Date.now() - start;
+      if (ttfbMs > 2e3) {
+        results.push({
+          ruleId: "ttfb-pro",
+          ruleName: "Time to First Byte (Pro)",
+          message: `Slow server response time (TTFB: ${ttfbMs}ms) \u2014 aim for under 800ms`,
+          severity: "WARNING",
+          category: "Performance",
+          tier: "pro",
+          fix: "Optimize server response time: enable caching, use a CDN, optimize database queries, or upgrade hosting.",
+          data: { ms: ttfbMs }
+        });
+      } else if (ttfbMs > 800) {
+        results.push({
+          ruleId: "ttfb-pro",
+          ruleName: "Time to First Byte (Pro)",
+          message: `Server response time could be improved (TTFB: ${ttfbMs}ms) \u2014 aim for under 800ms`,
+          severity: "INFO",
+          category: "Performance",
+          tier: "pro",
+          fix: "Consider enabling server-side caching or using a CDN to reduce response time.",
+          data: { ms: ttfbMs }
+        });
+      }
+    } catch {
+      results.push({
+        ruleId: "ttfb-pro",
+        ruleName: "Time to First Byte (Pro)",
+        message: "Could not measure TTFB \u2014 server may be unreachable",
+        severity: "WARNING",
+        category: "Performance",
+        tier: "pro",
+        fix: "Ensure your server is accessible and responding to requests."
+      });
+    }
+    return results;
+  }
+};
+var mixedContentRule = {
+  meta: {
+    id: "mixed-content",
+    name: "Mixed Content",
+    category: "Pre-Launch",
+    tier: "pro",
+    description: "Checks for HTTP resources loaded on an HTTPS page (mixed content)"
+  },
+  run(context) {
+    const { document, isHttps } = context;
+    const results = [];
+    if (!isHttps) return results;
+    const selectors = [
+      'img[src^="http:"]',
+      'script[src^="http:"]',
+      'link[href^="http:"]',
+      'iframe[src^="http:"]',
+      'video[src^="http:"]',
+      'audio[src^="http:"]'
+    ];
+    let count = 0;
+    selectors.forEach((selector) => {
+      count += document.querySelectorAll(selector).length;
+    });
+    if (count > 0) {
+      results.push({
+        ruleId: "mixed-content",
+        ruleName: "Mixed Content",
+        message: `Found ${count} mixed content resource${count !== 1 ? "s" : ""} (HTTP on HTTPS page) \u2014 browsers may block these`,
+        severity: "WARNING",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: "Change all resource URLs from http:// to https:// or use protocol-relative URLs (//).",
+        data: { count }
+      });
+    }
+    return results;
+  }
+};
+var securityHeadersRule = {
+  meta: {
+    id: "security-headers",
+    name: "Security Headers",
+    category: "Performance",
+    tier: "pro",
+    description: "Checks for important security headers (CSP, HSTS, X-Content-Type-Options, X-Frame-Options)"
+  },
+  run(context) {
+    const { response } = context;
+    const results = [];
+    const headers = [
+      { name: "content-security-policy", label: "Content-Security-Policy" },
+      {
+        name: "strict-transport-security",
+        label: "Strict-Transport-Security (HSTS)"
+      },
+      { name: "x-content-type-options", label: "X-Content-Type-Options" },
+      { name: "x-frame-options", label: "X-Frame-Options" }
+    ];
+    const missing = [];
+    headers.forEach(({ name, label }) => {
+      if (!response.headers.get(name)) missing.push(label);
+    });
+    if (missing.length > 0) {
+      results.push({
+        ruleId: "security-headers",
+        ruleName: "Security Headers",
+        message: `Missing security headers: ${missing.join(", ")}`,
+        severity: "INFO",
+        category: "Performance",
+        tier: "pro",
+        fix: "Configure your server or hosting provider to send these security headers. Most can be set in next.config.js headers() or your CDN settings.",
+        data: { missing }
+      });
+    }
+    return results;
+  }
+};
+var ogImageSizeRule = {
+  meta: {
+    id: "og-image-size",
+    name: "OG Image Size",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks that the og:image URL exists and advises on recommended dimensions (1200x630)"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const ogImage = document.querySelector('meta[property="og:image"]');
+    const imageUrl = ogImage?.getAttribute("content")?.trim();
+    if (!imageUrl) return results;
+    const ogWidth = document.querySelector('meta[property="og:image:width"]');
+    const ogHeight = document.querySelector(
+      'meta[property="og:image:height"]'
+    );
+    const width = Number.parseInt(
+      ogWidth?.getAttribute("content") || "",
+      10
+    );
+    const height = Number.parseInt(
+      ogHeight?.getAttribute("content") || "",
+      10
+    );
+    if (!ogWidth || !ogHeight || Number.isNaN(width) || Number.isNaN(height)) {
+      results.push({
+        ruleId: "og-image-size",
+        ruleName: "OG Image Size",
+        message: "Missing og:image:width and og:image:height meta tags \u2014 social platforms may crop your image incorrectly",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Add <meta property="og:image:width" content="1200" /> and <meta property="og:image:height" content="630" /> to your <head>.'
+      });
+      return results;
+    }
+    if (width < 1200 || height < 630) {
+      results.push({
+        ruleId: "og-image-size",
+        ruleName: "OG Image Size",
+        message: `OG image dimensions (${width}x${height}) are below recommended 1200x630 \u2014 may appear blurry on social platforms`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Use an image at least 1200x630 pixels for best display on Facebook, LinkedIn, and other social platforms.",
+        data: { width, height }
+      });
+    }
+    return results;
+  }
+};
+var SUPPORTED_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".webp"
+]);
+var ogImageTypeRule = {
+  meta: {
+    id: "og-image-type",
+    name: "OG Image Type",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks that the og:image type is a widely-supported format (JPEG, PNG, GIF, WebP)"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const ogImage = document.querySelector('meta[property="og:image"]');
+    const imageUrl = ogImage?.getAttribute("content")?.trim();
+    if (!imageUrl) return results;
+    const ogType = document.querySelector('meta[property="og:image:type"]')?.getAttribute("content")?.trim();
+    if (ogType && !SUPPORTED_TYPES.has(ogType.toLowerCase())) {
+      results.push({
+        ruleId: "og-image-type",
+        ruleName: "OG Image Type",
+        message: `OG image type "${ogType}" may not be supported by all social platforms`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Use JPEG or PNG for og:image. These formats are supported by all social platforms.",
+        data: { type: ogType }
+      });
+      return results;
+    }
+    if (!ogType) {
+      try {
+        const url = new URL(imageUrl, "https://example.com");
+        const ext = url.pathname.substring(url.pathname.lastIndexOf(".")).toLowerCase();
+        if (ext && !SUPPORTED_EXTENSIONS.has(ext)) {
+          results.push({
+            ruleId: "og-image-type",
+            ruleName: "OG Image Type",
+            message: `OG image URL has extension "${ext}" which may not be supported by all social platforms`,
+            severity: "INFO",
+            category: "SEO",
+            tier: "pro",
+            fix: 'Use JPEG or PNG for og:image, and add <meta property="og:image:type" content="image/jpeg" /> to your <head>.',
+            data: { extension: ext }
+          });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+};
+var twitterImageRule = {
+  meta: {
+    id: "twitter-image",
+    name: "Twitter/X Image",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks for twitter:image meta tag for rich card previews on X/Twitter"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const twitterCard = document.querySelector('meta[name="twitter:card"]');
+    if (!twitterCard) return results;
+    const twitterImage = document.querySelector(
+      'meta[name="twitter:image"]'
+    );
+    const ogImage = document.querySelector('meta[property="og:image"]');
+    if (!twitterImage && !ogImage) {
+      results.push({
+        ruleId: "twitter-image",
+        ruleName: "Twitter/X Image",
+        message: "Twitter card present but no twitter:image or og:image found \u2014 tweets will have no image preview",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Add <meta name="twitter:image" content="https://yoursite.com/image.png" /> to your <head>.'
+      });
+    } else if (!twitterImage && ogImage) {
+      results.push({
+        ruleId: "twitter-image",
+        ruleName: "Twitter/X Image",
+        message: "No explicit twitter:image \u2014 falling back to og:image. Consider adding twitter:image for optimal display.",
+        severity: "INFO",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Add <meta name="twitter:image" content="..." /> for more control over how your image appears on X/Twitter.'
+      });
+    }
+    return results;
+  }
+};
+var socialPreviewRenderRule = {
+  meta: {
+    id: "social-preview-render",
+    name: "Social Preview Completeness",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks that all essential meta tags for social sharing previews are present and consistent"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const ogTitle = document.querySelector('meta[property="og:title"]')?.getAttribute("content");
+    const ogDesc = document.querySelector('meta[property="og:description"]')?.getAttribute("content");
+    const ogImage = document.querySelector('meta[property="og:image"]')?.getAttribute("content");
+    const ogUrl = document.querySelector('meta[property="og:url"]')?.getAttribute("content");
+    const ogType = document.querySelector('meta[property="og:type"]')?.getAttribute("content");
+    const title = document.querySelector("title")?.textContent?.trim();
+    const metaDesc = document.querySelector('meta[name="description"]')?.getAttribute("content");
+    if (!ogType) {
+      results.push({
+        ruleId: "social-preview-render",
+        ruleName: "Social Preview Completeness",
+        message: "Missing og:type meta tag \u2014 social platforms may not render the preview correctly",
+        severity: "INFO",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Add <meta property="og:type" content="website" /> (or "article" for blog posts) to your <head>.'
+      });
+    }
+    if (ogTitle && title && ogTitle.length > 0 && title.length > 0) {
+      if (ogTitle.length > 70) {
+        results.push({
+          ruleId: "social-preview-render",
+          ruleName: "Social Preview Completeness",
+          message: `og:title is ${ogTitle.length} characters \u2014 may be truncated on social platforms (recommended: under 70)`,
+          severity: "INFO",
+          category: "SEO",
+          tier: "pro",
+          fix: "Keep og:title under 70 characters for best display on social platforms.",
+          data: { ogTitleLength: ogTitle.length }
+        });
+      }
+    }
+    if (ogDesc && ogDesc.length > 200) {
+      results.push({
+        ruleId: "social-preview-render",
+        ruleName: "Social Preview Completeness",
+        message: `og:description is ${ogDesc.length} characters \u2014 may be truncated on social platforms (recommended: under 200)`,
+        severity: "INFO",
+        category: "SEO",
+        tier: "pro",
+        fix: "Keep og:description under 200 characters for best display on social platforms.",
+        data: { ogDescLength: ogDesc.length }
+      });
+    }
+    if (ogUrl && !ogUrl.startsWith("http")) {
+      results.push({
+        ruleId: "social-preview-render",
+        ruleName: "Social Preview Completeness",
+        message: "og:url should be an absolute URL starting with https://",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Change og:url to an absolute URL (e.g., https://yoursite.com/page)."
+      });
+    }
+    if (ogImage && !ogImage.startsWith("http")) {
+      results.push({
+        ruleId: "social-preview-render",
+        ruleName: "Social Preview Completeness",
+        message: "og:image should be an absolute URL starting with https://",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Change og:image to an absolute URL (e.g., https://yoursite.com/image.png)."
+      });
+    }
+    return results;
+  }
+};
+var titleKeywordStuffingRule = {
+  meta: {
+    id: "title-keyword-stuffing",
+    name: "Title Keyword Stuffing",
+    category: "SEO",
+    tier: "pro",
+    description: "Detects potential keyword stuffing in the page title"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const title = document.querySelector("title")?.textContent?.trim();
+    if (!title) return results;
+    const words = title.toLowerCase().split(/[\s\-|:,]+/).filter((w) => w.length > 3);
+    const wordCounts = /* @__PURE__ */ new Map();
+    for (const word of words) {
+      wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
+    }
+    const stuffedWords = [];
+    for (const [word, count] of wordCounts) {
+      if (count >= 3) stuffedWords.push(`"${word}" (${count}x)`);
+    }
+    if (stuffedWords.length > 0) {
+      results.push({
+        ruleId: "title-keyword-stuffing",
+        ruleName: "Title Keyword Stuffing",
+        message: `Potential keyword stuffing in title: ${stuffedWords.join(", ")}`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Write a natural, readable title. Avoid repeating the same keyword more than twice. Search engines may penalize keyword stuffing.",
+        data: { title, stuffedWords }
+      });
+    }
+    const separatorCount = (title.match(/[|–—]/g) || []).length;
+    if (separatorCount >= 3) {
+      results.push({
+        ruleId: "title-keyword-stuffing",
+        ruleName: "Title Keyword Stuffing",
+        message: `Title has ${separatorCount} separators \u2014 may appear spammy to search engines`,
+        severity: "INFO",
+        category: "SEO",
+        tier: "pro",
+        fix: "Simplify your title. Use at most one separator (|, \u2013 or \u2014) to separate the page name from your brand.",
+        data: { separatorCount }
+      });
+    }
+    return results;
+  }
+};
+var contentToHtmlRatioRule = {
+  meta: {
+    id: "content-to-html-ratio",
+    name: "Content-to-HTML Ratio",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks the ratio of visible text to total HTML markup"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const htmlLength = document.documentElement?.outerHTML?.length || 0;
+    if (htmlLength === 0) return results;
+    const textContent = document.body?.textContent || "";
+    const textLength = textContent.replace(/\s+/g, " ").trim().length;
+    const ratio = Math.round(textLength / htmlLength * 100);
+    if (ratio < 10) {
+      results.push({
+        ruleId: "content-to-html-ratio",
+        ruleName: "Content-to-HTML Ratio",
+        message: `Low content-to-HTML ratio (${ratio}%) \u2014 search engines may view this as thin or boilerplate content`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Increase meaningful text content relative to HTML markup. Remove unnecessary divs, inline styles, and JavaScript.",
+        data: { ratio, textLength, htmlLength }
+      });
+    } else if (ratio < 20) {
+      results.push({
+        ruleId: "content-to-html-ratio",
+        ruleName: "Content-to-HTML Ratio",
+        message: `Content-to-HTML ratio is ${ratio}% \u2014 could be improved (aim for 25%+)`,
+        severity: "INFO",
+        category: "SEO",
+        tier: "pro",
+        fix: "Consider adding more text content or reducing unnecessary HTML markup to improve the ratio.",
+        data: { ratio, textLength, htmlLength }
+      });
+    }
+    return results;
+  }
+};
+var titleUniquenessRule = {
+  meta: {
+    id: "title-uniqueness",
+    name: "Title Uniqueness",
+    category: "SEO",
+    tier: "pro",
+    description: "Flags titles that appear generic or auto-generated (single-page heuristic)"
+  },
+  run(context) {
+    const { document, url } = context;
+    const results = [];
+    const title = document.querySelector("title")?.textContent?.trim();
+    if (!title) return results;
+    const genericPatterns = [
+      /^home$/i,
+      /^untitled/i,
+      /^page \d+$/i,
+      /^welcome$/i,
+      /^index$/i,
+      /^document$/i,
+      /^my site$/i,
+      /^my website$/i,
+      /^website$/i,
+      /^new page$/i
+    ];
+    for (const pattern of genericPatterns) {
+      if (pattern.test(title)) {
+        results.push({
+          ruleId: "title-uniqueness",
+          ruleName: "Title Uniqueness",
+          message: `Title "${title}" appears to be a generic/default title \u2014 use a unique, descriptive title`,
+          severity: "WARNING",
+          category: "SEO",
+          tier: "pro",
+          fix: "Write a unique, descriptive title for each page that includes your target keyword.",
+          data: { title }
+        });
+        break;
+      }
+    }
+    try {
+      const hostname = new URL(url).hostname.replace("www.", "");
+      const domainName = hostname.split(".")[0];
+      if (domainName && title.toLowerCase() === domainName.toLowerCase()) {
+        results.push({
+          ruleId: "title-uniqueness",
+          ruleName: "Title Uniqueness",
+          message: "Title is just the domain name \u2014 add a descriptive page-specific title",
+          severity: "WARNING",
+          category: "SEO",
+          tier: "pro",
+          fix: 'Include a page-specific description in your title, e.g., "Product Name \u2014 Your Brand".',
+          data: { title, hostname }
+        });
+      }
+    } catch {
+    }
+    return results;
+  }
+};
+var descriptionUniquenessRule = {
+  meta: {
+    id: "description-uniqueness",
+    name: "Description Uniqueness",
+    category: "SEO",
+    tier: "pro",
+    description: "Flags meta descriptions that appear generic or auto-generated (single-page heuristic)"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const metaDesc = document.querySelector('meta[name="description"]');
+    const description = metaDesc?.getAttribute("content")?.trim();
+    if (!description) return results;
+    const genericPatterns = [
+      /^welcome to/i,
+      /^this is a website/i,
+      /^a website about/i,
+      /^home page/i,
+      /^we are a company/i,
+      /^default description/i
+    ];
+    for (const pattern of genericPatterns) {
+      if (pattern.test(description)) {
+        results.push({
+          ruleId: "description-uniqueness",
+          ruleName: "Description Uniqueness",
+          message: `Meta description appears generic \u2014 write a unique, compelling description for this page`,
+          severity: "WARNING",
+          category: "SEO",
+          tier: "pro",
+          fix: "Write a unique meta description for each page that summarizes the specific content and includes a call to action.",
+          data: { description }
+        });
+        break;
+      }
+    }
+    const title = document.querySelector("title")?.textContent?.trim();
+    if (title && description.toLowerCase() === title.toLowerCase()) {
+      results.push({
+        ruleId: "description-uniqueness",
+        ruleName: "Description Uniqueness",
+        message: "Meta description is identical to the title \u2014 they should be different and complementary",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Write a meta description that expands on your title with more detail, a value proposition, or a call to action.",
+        data: { description, title }
+      });
+    }
+    return results;
+  }
+};
+var REQUIRED_FIELDS = {
+  Organization: ["name", "url"],
+  WebSite: ["name", "url"],
+  WebPage: ["name"],
+  Article: ["headline", "author", "datePublished"],
+  Product: ["name", "image"],
+  BreadcrumbList: ["itemListElement"],
+  FAQPage: ["mainEntity"],
+  LocalBusiness: ["name", "address"]
+};
+var structuredDataValidateRule = {
+  meta: {
+    id: "structured-data-validate",
+    name: "Structured Data Validation",
+    category: "SEO",
+    tier: "pro",
+    description: "Validates JSON-LD structured data for required fields based on schema type"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const jsonLdScripts = document.querySelectorAll(
+      'script[type="application/ld+json"]'
+    );
+    jsonLdScripts.forEach((script) => {
+      let data;
+      try {
+        data = JSON.parse(script.textContent || "");
+      } catch {
+        return;
+      }
+      const type = data["@type"];
+      if (!type) {
+        results.push({
+          ruleId: "structured-data-validate",
+          ruleName: "Structured Data Validation",
+          message: "JSON-LD block missing @type property",
+          severity: "WARNING",
+          category: "SEO",
+          tier: "pro",
+          fix: 'Add an @type property (e.g., "Organization", "WebPage", "Article") to your JSON-LD.'
+        });
+        return;
+      }
+      if (!data["@context"]) {
+        results.push({
+          ruleId: "structured-data-validate",
+          ruleName: "Structured Data Validation",
+          message: `JSON-LD "${type}" missing @context \u2014 should be "https://schema.org"`,
+          severity: "WARNING",
+          category: "SEO",
+          tier: "pro",
+          fix: 'Add "@context": "https://schema.org" to your JSON-LD block.',
+          data: { type }
+        });
+      }
+      const required = REQUIRED_FIELDS[type];
+      if (required) {
+        const missing = required.filter((field) => !data[field]);
+        if (missing.length > 0) {
+          results.push({
+            ruleId: "structured-data-validate",
+            ruleName: "Structured Data Validation",
+            message: `JSON-LD "${type}" missing required fields: ${missing.join(", ")}`,
+            severity: "WARNING",
+            category: "SEO",
+            tier: "pro",
+            fix: `Add the missing fields to your ${type} schema: ${missing.join(", ")}.`,
+            data: { type, missing }
+          });
+        }
+      }
+    });
+    return results;
+  }
+};
+var hreflangRule = {
+  meta: {
+    id: "hreflang",
+    name: "Hreflang Tags",
+    category: "SEO",
+    tier: "pro",
+    description: "Validates hreflang tags for multi-language pages"
+  },
+  run(context) {
+    const { document, url } = context;
+    const results = [];
+    const hreflangTags = document.querySelectorAll(
+      'link[rel="alternate"][hreflang]'
+    );
+    if (hreflangTags.length === 0) return results;
+    const hasXDefault = Array.from(hreflangTags).some(
+      (tag) => tag.getAttribute("hreflang") === "x-default"
+    );
+    if (!hasXDefault) {
+      results.push({
+        ruleId: "hreflang",
+        ruleName: "Hreflang Tags",
+        message: "Hreflang tags found but missing x-default \u2014 add a fallback for unmatched languages",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Add <link rel="alternate" hreflang="x-default" href="..." /> to specify the default/fallback page.'
+      });
+    }
+    const hasSelfRef = Array.from(hreflangTags).some((tag) => {
+      const href = tag.getAttribute("href");
+      return href === url || href === url.replace(/\/$/, "");
+    });
+    if (!hasSelfRef) {
+      results.push({
+        ruleId: "hreflang",
+        ruleName: "Hreflang Tags",
+        message: "Hreflang tags do not include a self-referencing tag for the current page",
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Add a hreflang tag that points to the current page URL with the appropriate language code."
+      });
+    }
+    const langCodePattern = /^[a-z]{2}(-[A-Z]{2})?$/;
+    hreflangTags.forEach((tag) => {
+      const lang = tag.getAttribute("hreflang");
+      if (lang && lang !== "x-default" && !langCodePattern.test(lang)) {
+        results.push({
+          ruleId: "hreflang",
+          ruleName: "Hreflang Tags",
+          message: `Invalid hreflang language code "${lang}" \u2014 use ISO 639-1 format (e.g., "en", "en-US")`,
+          severity: "WARNING",
+          category: "SEO",
+          tier: "pro",
+          fix: `Change "${lang}" to a valid ISO 639-1 language code (e.g., "en", "fr", "de-AT").`,
+          data: { invalidLang: lang }
+        });
+      }
+      const href = tag.getAttribute("href");
+      if (href && !href.startsWith("http")) {
+        results.push({
+          ruleId: "hreflang",
+          ruleName: "Hreflang Tags",
+          message: `Hreflang href should be an absolute URL (found: "${href}")`,
+          severity: "WARNING",
+          category: "SEO",
+          tier: "pro",
+          fix: "Use absolute URLs (starting with https://) for all hreflang href attributes."
+        });
+      }
+    });
+    return results;
+  }
+};
+var canonicalSelfReferencingRule = {
+  meta: {
+    id: "canonical-self-referencing",
+    name: "Canonical Self-Referencing",
+    category: "SEO",
+    tier: "pro",
+    description: "Checks that the canonical URL points to the current page (self-referencing canonical)"
+  },
+  run(context) {
+    const { document, url } = context;
+    const results = [];
+    const canonical = document.querySelector('link[rel="canonical"]');
+    if (!canonical) return results;
+    const href = canonical.getAttribute("href")?.trim();
+    if (!href) return results;
+    const normalize = (u) => u.replace(/\/$/, "").toLowerCase();
+    try {
+      const canonicalUrl = new URL(href, url).href;
+      const normalizedCanonical = normalize(canonicalUrl);
+      const normalizedUrl = normalize(url);
+      if (normalizedCanonical !== normalizedUrl) {
+        const sameHost = new URL(canonicalUrl).hostname === new URL(url).hostname;
+        if (sameHost) {
+          results.push({
+            ruleId: "canonical-self-referencing",
+            ruleName: "Canonical Self-Referencing",
+            message: `Canonical URL points to a different page on the same site \u2014 this tells search engines to index "${canonicalUrl}" instead of this page`,
+            severity: "INFO",
+            category: "SEO",
+            tier: "pro",
+            fix: "If this page should be indexed, change the canonical to point to itself. If this is intentional (e.g., pagination), you can ignore this.",
+            data: { canonical: canonicalUrl, pageUrl: url }
+          });
+        } else {
+          results.push({
+            ruleId: "canonical-self-referencing",
+            ruleName: "Canonical Self-Referencing",
+            message: `Canonical URL points to a different domain ("${new URL(canonicalUrl).hostname}") \u2014 this is unusual and may be a misconfiguration`,
+            severity: "WARNING",
+            category: "SEO",
+            tier: "pro",
+            fix: "Cross-domain canonical tags are rarely correct. Verify this is intentional, otherwise change the canonical to point to this page.",
+            data: { canonical: canonicalUrl, pageUrl: url }
+          });
+        }
+      }
+    } catch {
+      results.push({
+        ruleId: "canonical-self-referencing",
+        ruleName: "Canonical Self-Referencing",
+        message: `Cannot parse canonical URL "${href}" \u2014 ensure it's a valid absolute URL`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: "Use a valid absolute URL for your canonical tag (e.g., https://yoursite.com/page)."
+      });
+    }
+    return results;
+  }
+};
+var metaRenderBlockingRule = {
+  meta: {
+    id: "meta-render-blocking",
+    name: "Render-Blocking Resources",
+    category: "Performance",
+    tier: "pro",
+    description: "Checks for render-blocking stylesheets and synchronous scripts in the <head>"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const head = document.querySelector("head");
+    if (!head) return results;
+    const headScripts = head.querySelectorAll("script[src]");
+    let blockingScripts = 0;
+    headScripts.forEach((script) => {
+      const hasAsync = script.hasAttribute("async");
+      const hasDefer = script.hasAttribute("defer");
+      const type = script.getAttribute("type");
+      if (!hasAsync && !hasDefer && type !== "module") {
+        blockingScripts++;
+      }
+    });
+    if (blockingScripts > 0) {
+      results.push({
+        ruleId: "meta-render-blocking",
+        ruleName: "Render-Blocking Resources",
+        message: `${blockingScripts} synchronous script(s) in <head> may block page rendering`,
+        severity: "WARNING",
+        category: "Performance",
+        tier: "pro",
+        fix: "Add async or defer attributes to non-critical scripts in the <head>, or move them to the end of <body>.",
+        data: { blockingScripts }
+      });
+    }
+    const stylesheets = head.querySelectorAll(
+      'link[rel="stylesheet"]'
+    );
+    let blockingStylesheets = 0;
+    stylesheets.forEach((link) => {
+      const media = link.getAttribute("media");
+      if (!media || media === "all") blockingStylesheets++;
+    });
+    if (blockingStylesheets > 3) {
+      results.push({
+        ruleId: "meta-render-blocking",
+        ruleName: "Render-Blocking Resources",
+        message: `${blockingStylesheets} render-blocking stylesheets in <head> \u2014 consider inlining critical CSS`,
+        severity: "INFO",
+        category: "Performance",
+        tier: "pro",
+        fix: 'Inline critical CSS and load non-critical stylesheets asynchronously using media="print" with an onload handler.',
+        data: { blockingStylesheets }
+      });
+    }
+    return results;
+  }
+};
+var lazyLoadLcpRule = {
+  meta: {
+    id: "lazy-load-lcp",
+    name: "Lazy Load LCP",
+    category: "Performance",
+    tier: "pro",
+    description: "Checks that above-the-fold images (likely LCP candidates) are not lazy-loaded"
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const images = document.querySelectorAll("img");
+    const firstImages = Array.from(images).slice(0, 3);
+    for (const img of firstImages) {
+      const loading = img.getAttribute("loading");
+      const fetchpriority = img.getAttribute("fetchpriority");
+      if (loading === "lazy") {
+        const src = img.getAttribute("src") || "";
+        const alt = img.getAttribute("alt") || "";
+        const identifier = alt ? `"${alt.substring(0, 40)}"` : src ? `src="${src.substring(0, 50)}"` : "first image";
+        results.push({
+          ruleId: "lazy-load-lcp",
+          ruleName: "Lazy Load LCP",
+          message: `Above-the-fold image (${identifier}) has loading="lazy" \u2014 this delays the Largest Contentful Paint`,
+          severity: "WARNING",
+          category: "Performance",
+          tier: "pro",
+          fix: 'Remove loading="lazy" from above-the-fold images. Add fetchpriority="high" to the LCP image instead.'
+        });
+        break;
+      }
+      if (!fetchpriority && !loading) {
+        results.push({
+          ruleId: "lazy-load-lcp",
+          ruleName: "Lazy Load LCP",
+          message: 'Consider adding fetchpriority="high" to your hero/banner image to improve Largest Contentful Paint',
+          severity: "INFO",
+          category: "Performance",
+          tier: "pro",
+          fix: 'Add fetchpriority="high" to the most important above-the-fold image to prioritize its loading.'
+        });
+        break;
+      }
+    }
+    return results;
+  }
+};
+var httpsLinksRule = {
+  meta: {
+    id: "https-links",
+    name: "HTTPS Links",
+    category: "Pre-Launch",
+    tier: "pro",
+    description: "Checks that internal links use HTTPS instead of HTTP"
+  },
+  run(context) {
+    const { document, url } = context;
+    const results = [];
+    let hostname;
+    try {
+      hostname = new URL(url).hostname;
+    } catch {
+      return results;
+    }
+    const links = document.querySelectorAll('a[href^="http:"]');
+    let internalHttpLinks = 0;
+    let externalHttpLinks = 0;
+    links.forEach((link) => {
+      const href = link.getAttribute("href");
+      if (!href) return;
+      try {
+        const linkHostname = new URL(href).hostname;
+        if (linkHostname === hostname) {
+          internalHttpLinks++;
+        } else {
+          externalHttpLinks++;
+        }
+      } catch {
+      }
+    });
+    if (internalHttpLinks > 0) {
+      results.push({
+        ruleId: "https-links",
+        ruleName: "HTTPS Links",
+        message: `${internalHttpLinks} internal link(s) use HTTP instead of HTTPS`,
+        severity: "WARNING",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: "Change all internal links from http:// to https:// to avoid redirect chains and mixed content warnings.",
+        data: { internalHttpLinks }
+      });
+    }
+    if (externalHttpLinks > 0) {
+      results.push({
+        ruleId: "https-links",
+        ruleName: "HTTPS Links",
+        message: `${externalHttpLinks} external link(s) use HTTP \u2014 consider updating to HTTPS where available`,
+        severity: "INFO",
+        category: "Pre-Launch",
+        tier: "pro",
+        fix: "Update external links to use https:// where the destination supports it.",
+        data: { externalHttpLinks }
+      });
+    }
+    return results;
+  }
+};
+var metaRefreshRedirectRule = {
+  meta: {
+    id: "meta-refresh-redirect",
+    name: "Meta Refresh Redirect",
+    category: "SEO",
+    tier: "pro",
+    description: 'Checks for <meta http-equiv="refresh"> redirects which are bad for SEO'
+  },
+  run(context) {
+    const { document } = context;
+    const results = [];
+    const metaRefresh = document.querySelector(
+      'meta[http-equiv="refresh"]'
+    );
+    if (!metaRefresh) return results;
+    const content = metaRefresh.getAttribute("content") || "";
+    const hasUrl = content.toLowerCase().includes("url=");
+    const delay = Number.parseInt(content.split(";")[0] || "", 10);
+    if (hasUrl) {
+      results.push({
+        ruleId: "meta-refresh-redirect",
+        ruleName: "Meta Refresh Redirect",
+        message: `Page uses a meta refresh redirect${!Number.isNaN(delay) ? ` (${delay}s delay)` : ""} \u2014 use server-side 301 redirects instead`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Replace <meta http-equiv="refresh"> with a server-side 301 redirect. Meta refreshes are bad for SEO and user experience.',
+        data: { content, delay: Number.isNaN(delay) ? void 0 : delay }
+      });
+    } else if (!Number.isNaN(delay) && delay > 0) {
+      results.push({
+        ruleId: "meta-refresh-redirect",
+        ruleName: "Meta Refresh Redirect",
+        message: `Page auto-refreshes every ${delay} seconds \u2014 this may cause usability issues`,
+        severity: "INFO",
+        category: "SEO",
+        tier: "pro",
+        fix: "Consider removing the auto-refresh meta tag unless it serves a clear user need.",
+        data: { content, delay }
+      });
+    }
+    return results;
+  }
+};
+var nofollowAuditRule = {
+  meta: {
+    id: "nofollow-audit",
+    name: "Nofollow Audit",
+    category: "SEO",
+    tier: "pro",
+    description: 'Audits the use of rel="nofollow" on internal vs. external links'
+  },
+  run(context) {
+    const { document, url } = context;
+    const results = [];
+    let hostname;
+    try {
+      hostname = new URL(url).hostname;
+    } catch {
+      return results;
+    }
+    const nofollowLinks = document.querySelectorAll('a[rel~="nofollow"]');
+    let internalNofollow = 0;
+    nofollowLinks.forEach((link) => {
+      const href = link.getAttribute("href");
+      if (!href) return;
+      try {
+        const linkHostname = new URL(href, url).hostname;
+        if (linkHostname === hostname) internalNofollow++;
+      } catch {
+        if (href.startsWith("/") || href.startsWith(".")) {
+          internalNofollow++;
+        }
+      }
+    });
+    if (internalNofollow > 0) {
+      results.push({
+        ruleId: "nofollow-audit",
+        ruleName: "Nofollow Audit",
+        message: `${internalNofollow} internal link(s) have rel="nofollow" \u2014 this wastes PageRank and hurts internal linking`,
+        severity: "WARNING",
+        category: "SEO",
+        tier: "pro",
+        fix: 'Remove rel="nofollow" from internal links. Nofollow should only be used for external links you do not want to endorse (e.g., user-generated content, sponsored links).',
+        data: { internalNofollow, totalNofollow: nofollowLinks.length }
+      });
+    }
+    return results;
+  }
+};
+var proRules = [
+  // Ported — Pre-Launch
+  sslRule,
+  trackingRule,
+  xRobotsTagRule,
+  // Ported — Content / SEO
+  thinContentRule,
+  duplicateMetaRule,
+  structuredDataRule,
+  charsetRule,
+  // Ported — Accessibility
+  imageAltTextRule,
+  accessibilityRule,
+  semanticStructureRule,
+  // Ported — Performance
+  performanceRule,
+  imageDimensionsRule,
+  // Ported — Security
+  mixedContentRule,
+  securityHeadersRule,
+  // New — Social
+  ogImageSizeRule,
+  ogImageTypeRule,
+  twitterImageRule,
+  socialPreviewRenderRule,
+  // New — Content
+  titleKeywordStuffingRule,
+  contentToHtmlRatioRule,
+  titleUniquenessRule,
+  descriptionUniquenessRule,
+  // New — Technical
+  structuredDataValidateRule,
+  hreflangRule,
+  canonicalSelfReferencingRule,
+  // New — Performance
+  metaRenderBlockingRule,
+  lazyLoadLcpRule,
+  // New — Security / SEO
+  httpsLinksRule,
+  metaRefreshRedirectRule,
+  nofollowAuditRule
+];
+var proStandaloneRules = [
+  robotsTxtCheckRule,
+  sitemapPresenceRule,
+  ttfbRule
+];
+var PUBLIC_KEY_JWK = {
+  kty: "OKP",
+  crv: "Ed25519",
+  x: "Q628CrspKqI_ig04oril9DaBhFaCJ2fJtoeFJhzrWek"
+};
+var cachedPublicKey = null;
+async function getPublicKey() {
+  if (!cachedPublicKey) {
+    cachedPublicKey = await jose.importJWK(PUBLIC_KEY_JWK, "EdDSA");
+  }
+  return cachedPublicKey;
+}
+async function validateLicense(token) {
+  try {
+    const publicKey = await getPublicKey();
+    const { payload } = await jose.jwtVerify(token, publicKey, {
+      algorithms: ["EdDSA"],
+      issuer: "lintpage",
+      audience: "lintpage-pro"
+    });
+    const licensePayload = {
+      sub: payload.sub,
+      plan: payload.plan,
+      iat: payload.iat,
+      exp: payload.exp
+    };
+    return { valid: true, payload: licensePayload };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Invalid license key";
+    return { valid: false, error: message };
+  }
+}
+var proPlugin = {
+  name: "@lintpage/pro",
+  rules: proRules,
+  standaloneRules: proStandaloneRules
+};
+function loadProPlugin() {
+  return proPlugin;
+}
 
 // src/formatter.ts
 import chalk from "chalk";
@@ -129,8 +2735,8 @@ async function reportResults(result, options) {
 }
 
 // src/cli.ts
-import { writeFileSync, readFileSync, existsSync } from "fs";
-import { join } from "path";
+import { writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 var cli = cac("lintpage");
 var EXIT_PASS = 0;
 var EXIT_FAIL = 1;
@@ -224,8 +2830,8 @@ cli.command("<url>", "Run an audit on a URL").option("--format <format>", "Outpu
   }
 });
 cli.command("init", "Generate a .lintpagerc.json config file").action(() => {
-  const configPath = join(process.cwd(), ".lintpagerc.json");
-  if (existsSync(configPath)) {
+  const configPath = join2(process.cwd(), ".lintpagerc.json");
+  if (existsSync2(configPath)) {
     console.log(chalk2.yellow(".lintpagerc.json already exists"));
     process.exit(EXIT_PASS);
   }
@@ -235,8 +2841,8 @@ cli.command("init", "Generate a .lintpagerc.json config file").action(() => {
   process.exit(EXIT_PASS);
 });
 cli.help();
-var pkgPath = join(__dirname, "..", "package.json");
-var pkgJson = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf-8")) : { version: "0.0.0" };
+var pkgPath = join2(__dirname, "..", "package.json");
+var pkgJson = existsSync2(pkgPath) ? JSON.parse(readFileSync2(pkgPath, "utf-8")) : { version: "0.0.0" };
 cli.version(pkgJson.version);
 cli.parse();
 //# sourceMappingURL=cli.mjs.map