@consilioweb/payload-seo-analyzer 1.7.1 → 1.8.1

package/dist/index.cjs

@@ -15,7 +15,7 @@ var MIN_WORDS_GENERIC = 300;
 var MIN_WORDS_THIN = 100;
 var MIN_WORDS_QUALITY_FAIL = 50;
 var MIN_WORDS_QUALITY_WARN = 200;
-var CORNERSTONE_MIN_WORDS = 1500;
+var CORNERSTONE_MIN_WORDS = 600;
 var THIN_AGING_MIN_WORDS = 500;
 var KEYWORD_DENSITY_MAX = 3;
 var KEYWORD_DENSITY_WARN = 2.5;
@@ -1228,6 +1228,44 @@ function buildSeoInputFromDoc(doc, collection, options) {
   const meta = doc.meta || {};
   const hero = doc.hero || {};
   const isPost = collection === "posts";
+  const canonicalUrl = typeof meta.canonicalUrl === "string" && meta.canonicalUrl || typeof doc.canonicalUrl === "string" && doc.canonicalUrl || void 0;
+  let robotsMeta;
+  const rawRobots = typeof meta.robots === "string" && meta.robots || typeof doc.robots === "string" && doc.robots || "";
+  if (rawRobots) {
+    robotsMeta = rawRobots;
+  } else {
+    const directives = [];
+    if (doc.noindex === true || meta.noindex === true) directives.push("noindex");
+    if (doc.nofollow === true || meta.nofollow === true) directives.push("nofollow");
+    if (directives.length > 0) robotsMeta = directives.join(", ");
+  }
+  let author;
+  let authorUrl;
+  const populatedAuthors = doc.populatedAuthors;
+  if (Array.isArray(populatedAuthors) && populatedAuthors.length > 0) {
+    const a = populatedAuthors[0] || {};
+    author = typeof a.name === "string" && a.name || typeof a.firstName === "string" && a.firstName || void 0;
+    if (typeof a.url === "string") authorUrl = a.url;
+  } else if (Array.isArray(doc.authors) && doc.authors.length > 0) {
+    const a = doc.authors[0];
+    if (a && typeof a === "object" && typeof a.name === "string") author = a.name;
+  } else if (typeof doc.author === "string" && doc.author) {
+    author = doc.author;
+  } else if (doc.author && typeof doc.author === "object" && typeof doc.author.name === "string") {
+    author = doc.author.name;
+  }
+  if (!authorUrl && typeof doc.authorUrl === "string") authorUrl = doc.authorUrl;
+  const publishedAt = typeof doc.publishedAt === "string" && doc.publishedAt || typeof doc.createdAt === "string" && doc.createdAt || void 0;
+  const displayedDate = typeof doc.publishedAt === "string" && doc.publishedAt || typeof doc.date === "string" && doc.date || void 0;
+  let localeAlternates;
+  const rawAlts = doc.localeAlternates || doc.alternates || doc.hreflang;
+  if (Array.isArray(rawAlts)) {
+    const mapped = rawAlts.filter((a) => !!a && typeof a === "object").map((a) => ({
+      hreflang: String(a.hreflang || a.locale || a.lang || ""),
+      href: String(a.href || a.url || "")
+    })).filter((a) => a.hreflang && a.href);
+    if (mapped.length > 0) localeAlternates = mapped;
+  }
   return {
     metaTitle: meta.title || "",
     metaDescription: meta.description || "",
@@ -1247,7 +1285,14 @@ function buildSeoInputFromDoc(doc, collection, options) {
     isPost,
     isCornerstone: !!doc.isCornerstone,
     updatedAt: doc.updatedAt || void 0,
+    publishedAt,
     contentLastReviewed: doc.contentLastReviewed || void 0,
+    displayedDate,
+    author,
+    authorUrl,
+    localeAlternates,
+    canonicalUrl,
+    robotsMeta,
     isGlobal: options?.isGlobal ?? false
   };
 }
@@ -1587,7 +1632,10 @@ function analyzeDoc(doc, collection, seoConfig) {
   if (seoInput.isGlobal) {
     seoInput.slug = "";
   }
-  const analysis = analyzeSeo(seoInput, seoConfig);
+  const analysis = analyzeSeo(seoInput, {
+    ...seoConfig,
+    disabledRules: [...seoConfig?.disabledRules ?? [], "geo", "eeat", "hreflang"]
+  });
   const extracted = extractDocContent(doc);
   const fullText = extracted.text;
   const allLinks = extracted.links;
@@ -1625,6 +1673,7 @@ function analyzeDoc(doc, collection, seoConfig) {
     hasH1: h1Count > 0,
     h1Count,
     score: analysis.score,
+    aiReadiness: analysis.aiReadiness ? analysis.aiReadiness.score : null,
     level: analysis.level,
     status: doc._status || "published",
     updatedAt: doc.updatedAt || "",
@@ -1647,28 +1696,48 @@ function createAuditHandler(collections, seoConfig, globals = []) {
       let cached = noCache ? null : seoCache.get(CACHE_KEY);
       if (!cached) {
         const { config: mergedConfig, ignoredSlugs } = await loadMergedConfig(req.payload, seoConfig);
+        const BATCH_SIZE = Math.min(100, Math.max(1, parseInt(process.env.SEO_AUDIT_BATCH_SIZE || "25", 10) || 25));
+        const MAX_DOCS2 = Math.max(1, parseInt(process.env.SEO_AUDIT_MAX_DOCS || "1500", 10) || 1500);
         const allResults = [];
-        for (const collectionSlug of collections) {
-          try {
-            let page2 = 1;
-            let hasMore = true;
-            while (hasMore) {
-              const result = await req.payload.find({
-                collection: collectionSlug,
-                limit: 100,
-                page: page2,
-                depth: 1,
-                overrideAccess: true
-              });
-              for (const doc of result.docs) {
-                if (ignoredSlugs.includes(doc.slug)) continue;
-                allResults.push(analyzeDoc(doc, collectionSlug, mergedConfig));
+        let capped2 = false;
+        collectionsLoop:
+          for (const collectionSlug of collections) {
+            try {
+              let page2 = 1;
+              let hasMore = true;
+              while (hasMore) {
+                const result = await req.payload.find({
+                  collection: collectionSlug,
+                  limit: BATCH_SIZE,
+                  page: page2,
+                  depth: 1,
+                  overrideAccess: true
+                });
+                for (const doc of result.docs) {
+                  if (ignoredSlugs.includes(doc.slug)) continue;
+                  if (allResults.length >= MAX_DOCS2) {
+                    capped2 = true;
+                    break collectionsLoop;
+                  }
+                  try {
+                    allResults.push(analyzeDoc(doc, collectionSlug, mergedConfig));
+                  } catch (e) {
+                    req.payload.logger.warn(
+                      `[seo] audit: skipped ${collectionSlug}/${doc.id}: ${e instanceof Error ? e.message : "error"}`
+                    );
+                  }
+                }
+                hasMore = result.hasNextPage;
+                page2++;
+                await new Promise((resolve) => setImmediate(resolve));
               }
-              hasMore = result.hasNextPage;
-              page2++;
+            } catch {
             }
-          } catch {
           }
+        if (capped2) {
+          req.payload.logger.warn(
+            `[seo] audit: capped at ${MAX_DOCS2} docs (SEO_AUDIT_MAX_DOCS). Lower SEO_AUDIT_BATCH_SIZE on low-memory hosts, or raise the cap.`
+          );
         }
         for (const globalSlug of globals) {
           try {
@@ -1731,10 +1800,10 @@ function createAuditHandler(collections, seoConfig, globals = []) {
           avgWordCount: totalDocs2 > 0 ? Math.round(enrichedResults2.reduce((s, r) => s + r.wordCount, 0) / totalDocs2) : 0,
           avgReadability: totalDocs2 > 0 ? Math.round(enrichedResults2.reduce((s, r) => s + r.readabilityScore, 0) / totalDocs2) : 0
         };
-        cached = { enrichedResults: enrichedResults2, stats: stats2 };
+        cached = { enrichedResults: enrichedResults2, stats: stats2, capped: capped2 };
         seoCache.set(CACHE_KEY, cached);
       }
-      const { enrichedResults, stats } = cached;
+      const { enrichedResults, stats, capped } = cached;
       const totalDocs = enrichedResults.length;
       const totalPages = Math.ceil(totalDocs / limit);
       const startIdx = (page - 1) * limit;
@@ -1750,7 +1819,8 @@ function createAuditHandler(collections, seoConfig, globals = []) {
           hasNextPage: page < totalPages,
           hasPrevPage: page > 1
         },
-        cached: !noCache && seoCache.get(CACHE_KEY) !== null
+        cached: !noCache && seoCache.get(CACHE_KEY) !== null,
+        capped
       }, { headers: { "Cache-Control": "no-store" } });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Internal server error";
@@ -1760,6 +1830,97 @@ function createAuditHandler(collections, seoConfig, globals = []) {
   };
 }
 
+// src/endpoints/indexationAudit.ts
+var INDEXATION_CHECK_IDS = /* @__PURE__ */ new Set([
+  "robots-noindex",
+  "robots-nofollow",
+  "canonical-cross",
+  "canonical-external",
+  "canonical-invalid",
+  "canonical-missing"
+]);
+function createIndexationAuditHandler(collections, seoConfig, globals = []) {
+  return async (req) => {
+    try {
+      if (!req.user) {
+        return Response.json({ error: "Unauthorized" }, { status: 401 });
+      }
+      const { config: mergedConfig, ignoredSlugs } = await loadMergedConfig(req.payload, seoConfig);
+      const entries = [];
+      const inspect = (doc, collection, isGlobal = false) => {
+        const input = buildSeoInputFromDoc(doc, collection, { isGlobal });
+        const analysis = analyzeSeo(input, mergedConfig);
+        const issues = analysis.checks.filter(
+          (c) => c.group === "technical" && INDEXATION_CHECK_IDS.has(c.id) && c.status !== "pass"
+        ).map((c) => ({ id: c.id, status: c.status, message: c.message }));
+        const noindex = (input.robotsMeta || "").toLowerCase().includes("noindex");
+        if (issues.length > 0 || noindex) {
+          entries.push({
+            collection,
+            id: doc.id ?? (isGlobal ? collection : ""),
+            slug: doc.slug || "",
+            title: doc.title || doc.slug || String(doc.id ?? collection),
+            noindex,
+            issues
+          });
+        }
+      };
+      for (const collectionSlug of collections) {
+        try {
+          let page = 1;
+          let hasMore = true;
+          while (hasMore) {
+            const result = await req.payload.find({
+              collection: collectionSlug,
+              limit: 100,
+              page,
+              depth: 1,
+              overrideAccess: true
+            });
+            for (const doc of result.docs) {
+              if (ignoredSlugs.includes(doc.slug)) continue;
+              inspect(doc, collectionSlug);
+            }
+            hasMore = result.hasNextPage;
+            page++;
+          }
+        } catch {
+        }
+      }
+      for (const globalSlug of globals) {
+        try {
+          const doc = await req.payload.findGlobal({
+            slug: globalSlug,
+            depth: 1,
+            overrideAccess: true
+          });
+          if (doc) inspect(doc, `global:${globalSlug}`, true);
+        } catch {
+        }
+      }
+      const noindexCount = entries.filter((e) => e.noindex).length;
+      const canonicalIssueCount = entries.filter(
+        (e) => e.issues.some((i) => i.id.startsWith("canonical"))
+      ).length;
+      return Response.json(
+        {
+          entries,
+          summary: {
+            totalFlagged: entries.length,
+            noindexCount,
+            canonicalIssueCount
+          }
+        },
+        { headers: { "Cache-Control": "no-store" } }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      req.payload.logger.error(`[seo] indexation-audit error: ${message}`);
+      return Response.json({ error: message }, { status: 500 });
+    }
+  };
+}
+
 // src/endpoints/history.ts
 var TREND_THRESHOLD = 3;
 function createHistoryHandler() {
@@ -2746,6 +2907,9 @@ function createAiGenerateHandler() {
 }
 
 // src/endpoints/cannibalization.ts
+function canonicalIntent(keyword) {
+  return keyword.toLowerCase().normalize("NFD").replace(/\p{Diacritic}/gu, "").replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter(Boolean).sort().join(" ");
+}
 function createCannibalizationHandler(collections, globals = []) {
   return async (req) => {
     try {
@@ -2775,26 +2939,28 @@ function createCannibalizationHandler(collections, globals = []) {
           collection: collectionLabel,
           score: 0
         };
-        const keywords = [];
-        if (d.focusKeyword && typeof d.focusKeyword === "string" && d.focusKeyword.trim()) {
-          keywords.push(d.focusKeyword.trim().toLowerCase());
-        }
+        const seenCanon = /* @__PURE__ */ new Set();
+        const docKeywords = [];
+        const addKeyword = (raw) => {
+          if (typeof raw !== "string") return;
+          const display = raw.trim();
+          if (!display) return;
+          const key = canonicalIntent(display);
+          if (!key || seenCanon.has(key)) return;
+          seenCanon.add(key);
+          docKeywords.push({ display, key });
+        };
+        addKeyword(d.focusKeyword);
         if (Array.isArray(d.focusKeywords)) {
           for (const kw of d.focusKeywords) {
-            const keyword = typeof kw === "string" ? kw : kw?.keyword;
-            if (keyword && typeof keyword === "string" && keyword.trim()) {
-              const normalized = keyword.trim().toLowerCase();
-              if (!keywords.includes(normalized)) {
-                keywords.push(normalized);
-              }
-            }
+            addKeyword(typeof kw === "string" ? kw : kw?.keyword);
           }
         }
-        for (const kw of keywords) {
-          if (!keywordMap.has(kw)) {
-            keywordMap.set(kw, []);
+        for (const { display, key } of docKeywords) {
+          if (!keywordMap.has(key)) {
+            keywordMap.set(key, { display, pages: [] });
           }
-          keywordMap.get(kw).push(pageEntry);
+          keywordMap.get(key).pages.push(pageEntry);
         }
       }
       const scoreMap = /* @__PURE__ */ new Map();
@@ -2820,13 +2986,13 @@ function createCannibalizationHandler(collections, globals = []) {
       const conflicts = [];
       let totalAffectedPages = 0;
       const affectedPageIds = /* @__PURE__ */ new Set();
-      for (const [keyword, pages] of keywordMap.entries()) {
+      for (const { display, pages } of keywordMap.values()) {
         if (pages.length < 2) continue;
         const enrichedPages = pages.map((p) => ({
           ...p,
           score: scoreMap.get(`${p.collection}::${p.id}`) || 0
         }));
-        conflicts.push({ keyword, pages: enrichedPages });
+        conflicts.push({ keyword: display, pages: enrichedPages });
         for (const p of enrichedPages) {
           const pageKey = `${p.collection}::${p.id}`;
           if (!affectedPageIds.has(pageKey)) {
@@ -3600,6 +3766,420 @@ function createPerformanceHandler() {
   };
 }
 
+// src/endpoints/coreWebVitals.ts
+var CWV_THRESHOLDS = {
+  lcp: { good: 2500, poor: 4e3 },
+  // ms
+  inp: { good: 200, poor: 500 },
+  // ms
+  cls: { good: 0.1, poor: 0.25 }
+  // unitless
+};
+function rate(value, t) {
+  if (value === null || Number.isNaN(value)) return "unknown";
+  if (value <= t.good) return "good";
+  if (value <= t.poor) return "needs-improvement";
+  return "poor";
+}
+function resolveSiteUrl(seoConfig) {
+  return (seoConfig?.siteUrl || process.env.NEXT_PUBLIC_SERVER_URL || process.env.PAYLOAD_PUBLIC_SERVER_URL || void 0)?.replace(/\/$/, "");
+}
+function createCoreWebVitalsHandler(seoConfig) {
+  return async (req) => {
+    try {
+      if (!req.user) {
+        return Response.json({ error: "Unauthorized" }, { status: 401 });
+      }
+      const reqUrl = new URL(req.url);
+      const target = reqUrl.searchParams.get("url");
+      const strategy = reqUrl.searchParams.get("strategy") === "desktop" ? "desktop" : "mobile";
+      if (!target) {
+        return Response.json({ error: "Missing required query param: url" }, { status: 400 });
+      }
+      const siteUrl = resolveSiteUrl(seoConfig);
+      if (!siteUrl) {
+        return Response.json(
+          { error: "siteUrl is not configured \u2014 set it in the plugin config or NEXT_PUBLIC_SERVER_URL." },
+          { status: 400 }
+        );
+      }
+      let targetOrigin;
+      let siteOrigin;
+      try {
+        targetOrigin = new URL(target).origin;
+        siteOrigin = new URL(siteUrl).origin;
+      } catch {
+        return Response.json({ error: "Invalid url." }, { status: 400 });
+      }
+      if (targetOrigin !== siteOrigin) {
+        return Response.json(
+          { error: "Only the configured site origin can be tested." },
+          { status: 403 }
+        );
+      }
+      const apiKey = process.env.PAGESPEED_API_KEY || process.env.GOOGLE_PAGESPEED_API_KEY || "";
+      const psi = new URL("https://www.googleapis.com/pagespeedonline/v5/runPagespeed");
+      psi.searchParams.set("url", target);
+      psi.searchParams.set("category", "performance");
+      psi.searchParams.set("strategy", strategy);
+      if (apiKey) psi.searchParams.set("key", apiKey);
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3e4);
+      let psiData;
+      try {
+        const resp = await fetch(psi.toString(), { signal: controller.signal });
+        if (!resp.ok) {
+          const detail = resp.status === 429 ? " (PSI quota exceeded \u2014 add a PAGESPEED_API_KEY)" : "";
+          return Response.json(
+            { error: `PageSpeed Insights request failed: ${resp.status}${detail}` },
+            { status: 502 }
+          );
+        }
+        psiData = await resp.json();
+      } finally {
+        clearTimeout(timeout);
+      }
+      const loadingExperience = psiData.loadingExperience || {};
+      const metrics = loadingExperience.metrics || {};
+      const fieldMetric = (key) => {
+        const m = metrics[key];
+        const p = m?.percentile;
+        return typeof p === "number" ? p : null;
+      };
+      const fieldLcp = fieldMetric("LARGEST_CONTENTFUL_PAINT_MS");
+      const fieldInp = fieldMetric("INTERACTION_TO_NEXT_PAINT");
+      const fieldClsRaw = fieldMetric("CUMULATIVE_LAYOUT_SHIFT_SCORE");
+      const fieldCls = fieldClsRaw !== null ? fieldClsRaw / 100 : null;
+      const hasFieldData = fieldLcp !== null || fieldInp !== null || fieldCls !== null;
+      const lighthouse = psiData.lighthouseResult || {};
+      const audits = lighthouse.audits || {};
+      const labNumeric = (id) => {
+        const v = audits[id]?.numericValue;
+        return typeof v === "number" ? v : null;
+      };
+      const labLcp = labNumeric("largest-contentful-paint");
+      const labCls = labNumeric("cumulative-layout-shift");
+      const labTbt = labNumeric("total-blocking-time");
+      const lcp = fieldLcp ?? labLcp;
+      const inp = fieldInp;
+      const cls = fieldCls ?? labCls;
+      return Response.json(
+        {
+          url: target,
+          strategy,
+          source: hasFieldData ? "field" : "lab",
+          hasFieldData,
+          metrics: {
+            lcp: { value: lcp, unit: "ms", rating: rate(lcp, CWV_THRESHOLDS.lcp) },
+            inp: {
+              value: inp,
+              unit: "ms",
+              rating: rate(inp, CWV_THRESHOLDS.inp),
+              note: inp === null ? "INP needs real-user (field) data; not available in lab." : void 0
+            },
+            cls: { value: cls, unit: "score", rating: rate(cls, CWV_THRESHOLDS.cls) },
+            tbt: { value: labTbt, unit: "ms", source: "lab" }
+          },
+          thresholds: CWV_THRESHOLDS,
+          keyConfigured: !!apiKey,
+          note: "Informational only \u2014 Core Web Vitals are a ranking tie-breaker, not part of the on-page SEO score."
+        },
+        { headers: { "Cache-Control": "no-store" } }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      req.payload.logger.error(`[seo] core-web-vitals error: ${message}`);
+      return Response.json({ error: message }, { status: 500 });
+    }
+  };
+}
+var ALGO = "aes-256-gcm";
+var KEY_NAMESPACE = "seo-analyzer:gsc:v1";
+var FORMAT_VERSION = "v1";
+function deriveKey(secret) {
+  const explicit = process.env.SEO_GSC_ENCRYPTION_KEY;
+  if (explicit) {
+    const buf = explicit.length === 64 ? Buffer.from(explicit, "hex") : Buffer.from(explicit, "base64");
+    if (buf.length === 32) return buf;
+    throw new Error("SEO_GSC_ENCRYPTION_KEY must decode to exactly 32 bytes (hex64 or base64).");
+  }
+  if (!secret) {
+    throw new Error("No encryption secret available (set SEO_GSC_ENCRYPTION_KEY or Payload secret).");
+  }
+  return crypto.scryptSync(secret, KEY_NAMESPACE, 32);
+}
+function encryptToken(plaintext, secret) {
+  const key = deriveKey(secret);
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv(ALGO, key, iv);
+  const enc = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return [FORMAT_VERSION, iv.toString("base64"), tag.toString("base64"), enc.toString("base64")].join(":");
+}
+function decryptToken(payload, secret) {
+  const parts = payload.split(":");
+  if (parts.length !== 4 || parts[0] !== FORMAT_VERSION) {
+    throw new Error("Invalid encrypted token format.");
+  }
+  const key = deriveKey(secret);
+  const iv = Buffer.from(parts[1], "base64");
+  const tag = Buffer.from(parts[2], "base64");
+  const enc = Buffer.from(parts[3], "base64");
+  const decipher = crypto.createDecipheriv(ALGO, key, iv);
+  decipher.setAuthTag(tag);
+  const dec = Buffer.concat([decipher.update(enc), decipher.final()]);
+  return dec.toString("utf8");
+}
+function safeEqual(a, b) {
+  const ba = Buffer.from(a);
+  const bb = Buffer.from(b);
+  if (ba.length !== bb.length) return false;
+  return crypto.timingSafeEqual(ba, bb);
+}
+
+// src/endpoints/gscOAuth.ts
+var AUTH_COLLECTION = "seo-gsc-auth";
+var SCOPES = "https://www.googleapis.com/auth/webmasters.readonly openid email";
+function isAdmin5(user) {
+  if (!user) return false;
+  if (user.role === "admin") return true;
+  if (Array.isArray(user.roles) && user.roles.includes("admin")) return true;
+  return false;
+}
+function resolveSiteUrl2(seoConfig) {
+  return (seoConfig?.siteUrl || process.env.NEXT_PUBLIC_SERVER_URL || process.env.PAYLOAD_PUBLIC_SERVER_URL || void 0)?.replace(/\/$/, "");
+}
+function getOAuthConfig(basePath, seoConfig) {
+  const clientId = process.env.GSC_OAUTH_CLIENT_ID || "";
+  const clientSecret = process.env.GSC_OAUTH_CLIENT_SECRET || "";
+  const siteUrl = resolveSiteUrl2(seoConfig);
+  if (!clientId || !clientSecret || !siteUrl) return null;
+  return { clientId, clientSecret, siteUrl, redirectUri: `${siteUrl}/api${basePath}/gsc/callback` };
+}
+async function getOrCreateAuthDoc(payload) {
+  const found = await payload.find({ collection: AUTH_COLLECTION, limit: 1, overrideAccess: true });
+  if (found.docs.length > 0) return found.docs[0];
+  return payload.create({ collection: AUTH_COLLECTION, data: {}, overrideAccess: true });
+}
+async function tokenRequest(cfg, body) {
+  const resp = await fetch("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: cfg.clientId,
+      client_secret: cfg.clientSecret,
+      ...body
+    }).toString()
+  });
+  const json = await resp.json();
+  if (!resp.ok) {
+    throw new Error(`Token endpoint error: ${resp.status} ${json.error || ""}`);
+  }
+  return json;
+}
+function createGscStatusHandler(basePath, seoConfig) {
+  return async (req) => {
+    try {
+      if (!req.user) return Response.json({ error: "Unauthorized" }, { status: 401 });
+      const cfg = getOAuthConfig(basePath, seoConfig);
+      const doc = await getOrCreateAuthDoc(req.payload);
+      return Response.json(
+        {
+          configured: !!cfg,
+          connected: !!doc.refreshTokenEnc,
+          connectedEmail: doc.connectedEmail || null,
+          connectedAt: doc.connectedAt || null,
+          propertyUrl: doc.propertyUrl || cfg?.siteUrl || null,
+          redirectUri: cfg?.redirectUri || null
+        },
+        { headers: { "Cache-Control": "no-store" } }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      req.payload.logger.error(`[seo] gsc-status error: ${message}`);
+      return Response.json({ error: message }, { status: 500 });
+    }
+  };
+}
+function createGscAuthStartHandler(basePath, seoConfig) {
+  return async (req) => {
+    try {
+      if (!isAdmin5(req.user)) return Response.json({ error: "Forbidden" }, { status: 403 });
+      const cfg = getOAuthConfig(basePath, seoConfig);
+      if (!cfg) {
+        return Response.json(
+          { error: "GSC OAuth not configured. Set GSC_OAUTH_CLIENT_ID, GSC_OAUTH_CLIENT_SECRET and siteUrl." },
+          { status: 400 }
+        );
+      }
+      const state = crypto.randomBytes(24).toString("hex");
+      const doc = await getOrCreateAuthDoc(req.payload);
+      await req.payload.update({
+        collection: AUTH_COLLECTION,
+        id: doc.id,
+        data: { pendingState: state },
+        overrideAccess: true
+      });
+      const authUrl = new URL("https://accounts.google.com/o/oauth2/v2/auth");
+      authUrl.searchParams.set("client_id", cfg.clientId);
+      authUrl.searchParams.set("redirect_uri", cfg.redirectUri);
+      authUrl.searchParams.set("response_type", "code");
+      authUrl.searchParams.set("scope", SCOPES);
+      authUrl.searchParams.set("access_type", "offline");
+      authUrl.searchParams.set("prompt", "consent");
+      authUrl.searchParams.set("state", state);
+      return Response.json({ authUrl: authUrl.toString() }, { headers: { "Cache-Control": "no-store" } });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      req.payload.logger.error(`[seo] gsc-auth error: ${message}`);
+      return Response.json({ error: message }, { status: 500 });
+    }
+  };
+}
+function createGscCallbackHandler(basePath, seoConfig) {
+  return async (req) => {
+    const htmlPage = (title, body) => new Response(
+      `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title></head><body style="font-family:system-ui;padding:2rem;max-width:40rem;margin:auto"><h1>${title}</h1><p>${body}</p><p><a href="/admin/performance">\u2190 Back to the SEO dashboard</a></p></body></html>`,
+      { status: 200, headers: { "content-type": "text/html; charset=utf-8" } }
+    );
+    try {
+      if (!isAdmin5(req.user)) {
+        return htmlPage("Connection failed", "You must be signed in as an admin to connect Google Search Console.");
+      }
+      const cfg = getOAuthConfig(basePath, seoConfig);
+      if (!cfg) return htmlPage("Connection failed", "GSC OAuth is not configured on the server.");
+      const url = new URL(req.url);
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const oauthError = url.searchParams.get("error");
+      if (oauthError) return htmlPage("Connection cancelled", `Google returned: ${oauthError}`);
+      if (!code || !state) return htmlPage("Connection failed", "Missing code or state.");
+      const doc = await getOrCreateAuthDoc(req.payload);
+      if (!doc.pendingState || !safeEqual(state, doc.pendingState)) {
+        return htmlPage("Connection failed", "Invalid state (possible CSRF). Please restart the connection.");
+      }
+      const tokens = await tokenRequest(cfg, {
+        code,
+        redirect_uri: cfg.redirectUri,
+        grant_type: "authorization_code"
+      });
+      const refreshToken = tokens.refresh_token;
+      const accessToken = tokens.access_token;
+      if (!refreshToken) {
+        return htmlPage(
+          "Connection failed",
+          "Google did not return a refresh token. Revoke the app access in your Google account and try again (the consent screen must show)."
+        );
+      }
+      let email = null;
+      if (accessToken) {
+        try {
+          const ui = await fetch("https://www.googleapis.com/oauth2/v2/userinfo", {
+            headers: { authorization: `Bearer ${accessToken}` }
+          });
+          if (ui.ok) email = (await ui.json()).email;
+        } catch {
+        }
+      }
+      const secret = req.payload.secret || "";
+      const refreshTokenEnc = encryptToken(refreshToken, secret);
+      await req.payload.update({
+        collection: AUTH_COLLECTION,
+        id: doc.id,
+        data: {
+          refreshTokenEnc,
+          pendingState: null,
+          connectedEmail: email,
+          connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          scope: tokens.scope || SCOPES,
+          propertyUrl: doc.propertyUrl || cfg.siteUrl
+        },
+        overrideAccess: true
+      });
+      return htmlPage("Google Search Console connected \u2705", "You can close this tab and return to the SEO dashboard.");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      req.payload.logger.error(`[seo] gsc-callback error: ${message}`);
+      return htmlPage("Connection failed", "An unexpected error occurred. Check the server logs.");
+    }
+  };
+}
+function createGscDataHandler(basePath, seoConfig) {
+  return async (req) => {
+    try {
+      if (!isAdmin5(req.user)) return Response.json({ error: "Forbidden" }, { status: 403 });
+      const cfg = getOAuthConfig(basePath, seoConfig);
+      if (!cfg) return Response.json({ error: "GSC OAuth not configured." }, { status: 400 });
+      const doc = await getOrCreateAuthDoc(req.payload);
+      if (!doc.refreshTokenEnc) {
+        return Response.json({ error: "Not connected to Google Search Console." }, { status: 409 });
+      }
+      const secret = req.payload.secret || "";
+      let refreshToken;
+      try {
+        refreshToken = decryptToken(doc.refreshTokenEnc, secret);
+      } catch {
+        return Response.json(
+          { error: "Stored token could not be decrypted (encryption key changed?). Reconnect GSC." },
+          { status: 409 }
+        );
+      }
+      const tokens = await tokenRequest(cfg, { refresh_token: refreshToken, grant_type: "refresh_token" });
+      const accessToken = tokens.access_token;
+      if (!accessToken) return Response.json({ error: "Could not refresh access token." }, { status: 502 });
+      const url = new URL(req.url);
+      const today = /* @__PURE__ */ new Date();
+      const defaultEnd = today.toISOString().slice(0, 10);
+      const defaultStart = new Date(today.getTime() - 28 * 864e5).toISOString().slice(0, 10);
+      const startDate = url.searchParams.get("startDate") || defaultStart;
+      const endDate = url.searchParams.get("endDate") || defaultEnd;
+      const dimension = url.searchParams.get("dimension") === "page" ? "page" : "query";
+      const rowLimit = Math.min(1e3, Math.max(1, parseInt(url.searchParams.get("rowLimit") || "100", 10)));
+      const property = doc.propertyUrl || cfg.siteUrl;
+      const gscResp = await fetch(
+        `https://www.googleapis.com/webmasters/v3/sites/${encodeURIComponent(property)}/searchAnalytics/query`,
+        {
+          method: "POST",
+          headers: { authorization: `Bearer ${accessToken}`, "content-type": "application/json" },
+          body: JSON.stringify({ startDate, endDate, dimensions: [dimension], rowLimit })
+        }
+      );
+      const gscJson = await gscResp.json();
+      if (!gscResp.ok) {
+        const err = gscJson.error?.message || gscResp.status;
+        return Response.json({ error: `GSC query failed: ${err}` }, { status: 502 });
+      }
+      return Response.json(
+        { property, startDate, endDate, dimension, rows: gscJson.rows || [] },
+        { headers: { "Cache-Control": "no-store" } }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      req.payload.logger.error(`[seo] gsc-data error: ${message}`);
+      return Response.json({ error: message }, { status: 500 });
+    }
+  };
+}
+function createGscDisconnectHandler() {
+  return async (req) => {
+    try {
+      if (!isAdmin5(req.user)) return Response.json({ error: "Forbidden" }, { status: 403 });
+      const doc = await getOrCreateAuthDoc(req.payload);
+      await req.payload.update({
+        collection: AUTH_COLLECTION,
+        id: doc.id,
+        data: { refreshTokenEnc: null, pendingState: null, connectedEmail: null, connectedAt: null, scope: null },
+        overrideAccess: true
+      });
+      return Response.json({ disconnected: true }, { headers: { "Cache-Control": "no-store" } });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      req.payload.logger.error(`[seo] gsc-disconnect error: ${message}`);
+      return Response.json({ error: message }, { status: 500 });
+    }
+  };
+}
+
 // src/endpoints/keywordResearch.ts
 var STOP_WORDS_SET = /* @__PURE__ */ new Set();
 function getStopWords2() {
@@ -4136,12 +4716,12 @@ function detectSchemaType(collection, doc) {
   if (collection === "posts") return "Article";
   const layout = doc.layout;
   if (layout && Array.isArray(layout)) {
-    const hasFaqBlock = layout.some((block) => {
+    const hasFaqBlock2 = layout.some((block) => {
       if (!block || typeof block !== "object") return false;
       const b = block;
       return b.blockType === "faq" || b.blockType === "FAQ" || b.blockType === "faqBlock";
     });
-    if (hasFaqBlock) return "FAQPage";
+    if (hasFaqBlock2) return "FAQPage";
   }
   if (doc.price !== void 0 || doc.sku !== void 0 || collection === "products") {
     return "Product";
@@ -4292,6 +4872,75 @@ function buildOrganizationSchema(doc, siteUrl) {
   if (doc.logo) {
     schema.logo = typeof doc.logo === "string" ? doc.logo : doc.logo?.url;
   }
+  if (Array.isArray(doc.sameAs)) {
+    const sameAs = doc.sameAs.filter((s) => typeof s === "string");
+    if (sameAs.length > 0) schema.sameAs = sameAs;
+  }
+  return schema;
+}
+function buildPersonSchema(doc, siteUrl) {
+  const meta = doc.meta || {};
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Person",
+    name: doc.name || doc.title || meta.title || ""
+  };
+  if (doc.jobTitle) schema.jobTitle = doc.jobTitle;
+  if (doc.description || meta.description) schema.description = doc.description || meta.description;
+  schema.url = typeof doc.url === "string" && doc.url || `${siteUrl}/${doc.slug || ""}`;
+  if (Array.isArray(doc.sameAs)) {
+    const sameAs = doc.sameAs.filter((s) => typeof s === "string");
+    if (sameAs.length > 0) schema.sameAs = sameAs;
+  }
+  return schema;
+}
+function buildEventSchema(doc, siteUrl) {
+  const meta = doc.meta || {};
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Event",
+    name: doc.title || meta.title || "",
+    description: meta.description || "",
+    startDate: doc.startDate || doc.eventStart || void 0,
+    endDate: doc.endDate || doc.eventEnd || void 0,
+    url: `${siteUrl}/${doc.slug || ""}`
+  };
+  if (doc.location) {
+    schema.location = typeof doc.location === "string" ? { "@type": "Place", name: doc.location } : { "@type": "Place", ...doc.location };
+  }
+  return schema;
+}
+function buildRecipeSchema(doc, siteUrl) {
+  const meta = doc.meta || {};
+  const heroMedia = doc.hero?.media;
+  const imageUrl = getImageUrl(meta.image, heroMedia, siteUrl);
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Recipe",
+    name: doc.title || meta.title || "",
+    description: meta.description || ""
+  };
+  if (imageUrl) schema.image = imageUrl;
+  if (Array.isArray(doc.recipeIngredient)) schema.recipeIngredient = doc.recipeIngredient;
+  else if (Array.isArray(doc.ingredients)) schema.recipeIngredient = doc.ingredients;
+  if (doc.recipeInstructions) schema.recipeInstructions = doc.recipeInstructions;
+  else if (doc.instructions) schema.recipeInstructions = doc.instructions;
+  return schema;
+}
+function buildVideoSchema(doc, siteUrl) {
+  const meta = doc.meta || {};
+  const heroMedia = doc.hero?.media;
+  const imageUrl = getImageUrl(meta.image, heroMedia, siteUrl);
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "VideoObject",
+    name: doc.title || meta.title || "",
+    description: meta.description || "",
+    uploadDate: doc.uploadDate || doc.createdAt || void 0
+  };
+  if (imageUrl) schema.thumbnailUrl = imageUrl;
+  if (doc.videoUrl || doc.contentUrl) schema.contentUrl = doc.videoUrl || doc.contentUrl;
+  if (doc.duration) schema.duration = doc.duration;
   return schema;
 }
 function getImageUrl(metaImage, heroMedia, siteUrl) {
@@ -4330,7 +4979,7 @@ function createSchemaGeneratorHandler(targetCollections) {
           { status: 400 }
         );
       }
-      const validTypes = ["Article", "LocalBusiness", "BreadcrumbList", "FAQPage", "Product", "Organization"];
+      const validTypes = ["Article", "LocalBusiness", "BreadcrumbList", "FAQPage", "Product", "Organization", "Person", "Event", "Recipe", "Video"];
       if (typeOverrideRaw !== null && !validTypes.includes(typeOverrideRaw)) {
         return Response.json(
           { error: `Invalid schema type. Valid types: ${validTypes.join(", ")}` },
@@ -4375,6 +5024,18 @@ function createSchemaGeneratorHandler(targetCollections) {
         case "Organization":
           jsonLd = buildOrganizationSchema(doc, siteUrl);
           break;
+        case "Person":
+          jsonLd = buildPersonSchema(doc, siteUrl);
+          break;
+        case "Event":
+          jsonLd = buildEventSchema(doc, siteUrl);
+          break;
+        case "Recipe":
+          jsonLd = buildRecipeSchema(doc, siteUrl);
+          break;
+        case "Video":
+          jsonLd = buildVideoSchema(doc, siteUrl);
+          break;
       }
       const cleaned = JSON.parse(JSON.stringify(jsonLd));
       return Response.json({
@@ -4696,7 +5357,7 @@ function createAiRewriteHandler(targetCollections) {
 }
 
 // src/endpoints/robots.ts
-function isAdmin5(user) {
+function isAdmin6(user) {
   if (!user) return false;
   if (user.role === "admin") return true;
   if (Array.isArray(user.roles) && user.roles.includes("admin")) return true;
@@ -4745,7 +5406,7 @@ function createRobotsUpdateHandler() {
       if (!req.user) {
         return Response.json({ error: "Unauthorized" }, { status: 401 });
       }
-      if (!isAdmin5(req.user)) {
+      if (!isAdmin6(req.user)) {
         return Response.json({ error: "Admin access required" }, { status: 403 });
       }
       const body = await parseJsonBody(req);
@@ -5481,6 +6142,55 @@ function createSeoLogsCollection() {
   };
 }
 
+// src/collections/SeoGscAuth.ts
+function createSeoGscAuthCollection() {
+  return {
+    slug: "seo-gsc-auth",
+    admin: {
+      hidden: true,
+      custom: { navHidden: true }
+    },
+    access: {
+      read: ({ req }) => !!req.user,
+      update: ({ req }) => !!req.user,
+      create: ({ req }) => !!req.user,
+      delete: ({ req }) => !!req.user
+    },
+    fields: [
+      {
+        name: "refreshTokenEnc",
+        type: "text",
+        // The encrypted refresh-token blob must never leave the server.
+        access: {
+          read: () => false,
+          create: () => false,
+          update: () => false
+        },
+        admin: { hidden: true }
+      },
+      {
+        name: "pendingState",
+        type: "text",
+        // CSRF state for the in-flight OAuth handshake — also server-only.
+        access: {
+          read: () => false,
+          create: () => false,
+          update: () => false
+        },
+        admin: { hidden: true }
+      },
+      { name: "connectedEmail", type: "text", admin: { readOnly: true } },
+      { name: "connectedAt", type: "date", admin: { readOnly: true } },
+      {
+        name: "propertyUrl",
+        type: "text",
+        admin: { description: "GSC property (e.g. sc-domain:example.com or https://example.com/)" }
+      },
+      { name: "scope", type: "text", admin: { readOnly: true } }
+    ]
+  };
+}
+
 // src/rateLimiter.ts
 function createRateLimiter(maxRequests, windowMs) {
   const store = /* @__PURE__ */ new Map();
@@ -5528,7 +6238,7 @@ function getClientIp(req) {
 
 // src/endpoints/seoLogs.ts
 var VALID_LOG_TYPES = ["404", "redirect", "error"];
-function isAdmin6(user) {
+function isAdmin7(user) {
   if (!user) return false;
   if (user.role === "admin") return true;
   if (Array.isArray(user.roles) && user.roles.includes("admin")) return true;
@@ -5625,7 +6335,7 @@ function createSeoLogsHandler(seoLogsSecret) {
       return Response.json({ error: "Unauthorized" }, { status: 401 });
     }
     if (method === "DELETE") {
-      if (!isAdmin6(req.user)) {
+      if (!isAdmin7(req.user)) {
         return Response.json({ error: "Admin access required" }, { status: 403 });
       }
       try {
@@ -7209,6 +7919,9 @@ var fr = {
     groupTechnical: "Technique",
     groupAccessibility: "Accessibilit\xE9",
     groupEcommerce: "E-commerce",
+    groupEeat: "E-E-A-T",
+    groupGeo: "GEO (IA)",
+    groupHreflang: "Hreflang",
     levelExcellent: "Excellent",
     levelGood: "Bon",
     levelFair: "Acceptable",
@@ -7217,6 +7930,8 @@ var fr = {
     categoryImportant: "Important",
     categoryBonus: "Bonus",
     seoScore: "Score SEO",
+    aiReadiness: "IA",
+    aiReadinessTooltip: "Pr\xEAt pour l'IA \u2014 qualit\xE9 de structuration pour \xEAtre cit\xE9 par les moteurs g\xE9n\xE9ratifs (AI Overviews, ChatGPT, Perplexity). Distinct du score SEO.",
     outOf100: "/ 100",
     cornerstoneLabel: "PILIER",
     checksPassed: "crit\xE8res valid\xE9s",
@@ -7782,6 +8497,9 @@ var en = {
     groupTechnical: "Technical",
     groupAccessibility: "Accessibility",
     groupEcommerce: "E-commerce",
+    groupEeat: "E-E-A-T",
+    groupGeo: "GEO (AI)",
+    groupHreflang: "Hreflang",
     levelExcellent: "Excellent",
     levelGood: "Good",
     levelFair: "Fair",
@@ -7790,6 +8508,8 @@ var en = {
     categoryImportant: "Important",
     categoryBonus: "Bonus",
     seoScore: "SEO Score",
+    aiReadiness: "AI",
+    aiReadinessTooltip: "AI-readiness \u2014 how well the page is structured to be cited by generative engines (AI Overviews, ChatGPT, Perplexity). Separate from the SEO score.",
     outOf100: "/ 100",
     cornerstoneLabel: "CORNERSTONE",
     checksPassed: "checks passed",
@@ -7959,6 +8679,10 @@ var seoAnalyzerPlugin = (pluginConfig = {}) => (incomingConfig) => {
     aiFeatures: true,
     duplicateContent: true,
     settings: true,
+    gscApi: false,
+    // opt-in — requires Google Cloud OAuth setup + secrets
+    warmCache: true,
+    // disable on low-memory hosts to skip startup pre-loading
     ...pluginConfig.features
   };
   function hasExistingSeoMeta(fields) {
@@ -8099,6 +8823,7 @@ var seoAnalyzerPlugin = (pluginConfig = {}) => (incomingConfig) => {
   if (features.redirects && !hasExistingRedirects) pluginCollections.push(createSeoRedirectsCollection(redirectsSlug));
   if (features.performance) pluginCollections.push(createSeoPerformanceCollection());
   if (features.seoLogs) pluginCollections.push(createSeoLogsCollection());
+  if (features.gscApi) pluginCollections.push(createSeoGscAuthCollection());
   config.collections = [
     ...config.collections || [],
     ...pluginCollections
@@ -8151,6 +8876,11 @@ var seoAnalyzerPlugin = (pluginConfig = {}) => (incomingConfig) => {
       method: "get",
       handler: withRateLimit(createAuditHandler(targetCollections, seoConfig, targetGlobals))
     });
+    pluginEndpoints.push({
+      path: `${basePath}/indexation-audit`,
+      method: "get",
+      handler: withRateLimit(createIndexationAuditHandler(targetCollections, seoConfig, targetGlobals))
+    });
   }
   if (features.scoreHistory) {
     pluginEndpoints.push({
@@ -8225,7 +8955,18 @@ var seoAnalyzerPlugin = (pluginConfig = {}) => (incomingConfig) => {
   if (features.performance) {
     pluginEndpoints.push(
       { path: `${basePath}/performance`, method: "get", handler: createPerformanceHandler() },
-      { path: `${basePath}/performance`, method: "post", handler: createPerformanceHandler() }
+      { path: `${basePath}/performance`, method: "post", handler: createPerformanceHandler() },
+      // Core Web Vitals via PageSpeed Insights — informational, on-demand, SSRF-safe
+      { path: `${basePath}/core-web-vitals`, method: "get", handler: withRateLimit(createCoreWebVitalsHandler(seoConfig)) }
+    );
+  }
+  if (features.gscApi) {
+    pluginEndpoints.push(
+      { path: `${basePath}/gsc/status`, method: "get", handler: createGscStatusHandler(basePath, seoConfig) },
+      { path: `${basePath}/gsc/auth`, method: "get", handler: createGscAuthStartHandler(basePath, seoConfig) },
+      { path: `${basePath}/gsc/callback`, method: "get", handler: createGscCallbackHandler(basePath, seoConfig) },
+      { path: `${basePath}/gsc/data`, method: "get", handler: withRateLimit(createGscDataHandler(basePath, seoConfig)) },
+      { path: `${basePath}/gsc/disconnect`, method: "post", handler: createGscDisconnectHandler() }
     );
   }
   if (features.keywords) {
@@ -8368,7 +9109,9 @@ var seoAnalyzerPlugin = (pluginConfig = {}) => (incomingConfig) => {
   const existingOnInit = config.onInit;
   config.onInit = async (payload) => {
     if (existingOnInit) await existingOnInit(payload);
-    startCacheWarmUp(payload, basePath, targetGlobals, targetCollections);
+    if (features.warmCache) {
+      startCacheWarmUp(payload, basePath, targetGlobals, targetCollections);
+    }
   };
   return config;
 };
@@ -8399,8 +9142,11 @@ var rulesFr = {
     powerWordsPass: (count, words) => `Le title contient ${count} mot(s) puissant(s) : ${words}`,
     powerWordsFail: 'Le title ne contient aucun mot puissant \u2014 Ajoutez un mot comme "gratuit", "guide", "complet" pour booster le CTR.',
     powerWordsTip: "Les mots puissants (gratuit, exclusif, guide, complet, essentiel...) attirent l'attention dans les resultats de recherche.",
+    pixelWidthLabel: "Largeur du title (pixels)",
+    pixelWidthPass: (px) => `Largeur estimee ${px}px \u2014 sous le seuil de troncature SERP (~600px).`,
+    pixelWidthWarn: (px) => `Largeur estimee ${px}px \u2014 risque de troncature dans Google (~600px). Informatif.`,
     hasNumberLabel: "Nombre dans le title",
-    hasNumberPass: "Le title contient un nombre \u2014 Les titres avec chiffres generent +36% de CTR.",
+    hasNumberPass: "Le title contient un nombre \u2014 format type liste, souvent plus engageant.",
     hasNumberFail: 'Aucun nombre dans le title \u2014 Les titres avec chiffres (ex: "5 astuces", "Top 10") attirent plus de clics.',
     hasNumberTip: 'Ajoutez un nombre pour creer un titre de type liste (ex: "7 conseils pour...", "Les 3 erreurs a eviter").',
     isQuestionLabel: "Title interrogatif",
@@ -8484,12 +9230,12 @@ var rulesFr = {
     keywordIntroFail: (kw) => `Ajoutez le mot-cle "${kw}" dans les premieres phrases du contenu.`,
     densityLabel: "Densite du mot-cle",
     densityOverstuffed: (density) => `Densite du mot-cle : ${density}% \u2014 Trop eleve (>3%), risque de suroptimisation (keyword stuffing).`,
-    densityHigh: (density) => `Densite du mot-cle : ${density}% \u2014 Legerement elevee. Restez entre 0,5% et 2,5%.`,
-    densityPass: (density) => `Densite du mot-cle : ${density}% \u2014 Equilibre ideal.`,
+    densityHigh: (density) => `Densite du mot-cle : ${density}% \u2014 Legerement elevee, restez naturel pour eviter la sur-optimisation.`,
+    densityPass: (density) => `Densite du mot-cle : ${density}% \u2014 Usage naturel, aucun bourrage detecte.`,
     densityPassWordLevel: (density) => `Les composants du mot-cle sont presents dans le contenu (densite estimee : ${density}%).`,
     densityLowWordLevel: (density) => `Les composants du mot-cle sont presents mais peu frequents (densite estimee : ${density}%). Renforcez leur presence.`,
     densityLow: (density) => `Densite du mot-cle : ${density}% \u2014 Trop faible. Visez 0,5% a 2,5%.`,
-    densityMissing: (kw) => `Le mot-cle "${kw}" n'apparait jamais dans le contenu.`,
+    densityMissing: (kw) => `Le mot-cle "${kw}" n'apparait pas dans le corps \u2014 privilegiez une couverture naturelle du sujet plutot que la repetition.`,
     placeholderLabel: "Contenu placeholder",
     placeholderFail: "Du contenu placeholder a ete detecte (lorem ipsum, TODO, etc.) \u2014 Remplacez par du vrai contenu.",
     placeholderPass: "Aucun contenu placeholder detecte.",
@@ -8575,7 +9321,7 @@ var rulesFr = {
   cornerstone: {
     wordcountLabel: "Longueur du contenu pilier",
     wordcountPass: (count) => `${count} mots \u2014 Le contenu pilier est suffisamment complet.`,
-    wordcountFail: (count) => `${count} mots \u2014 Un contenu pilier devrait contenir au moins 1500 mots pour etre vraiment complet.`,
+    wordcountFail: (count) => `${count} mots \u2014 Contenu pilier trop leger ; developpez la couverture du sujet (sans viser un nombre de mots arbitraire).`,
     internalLinksLabel: "Maillage interne du contenu pilier",
     internalLinksPass: (count) => `${count} liens internes \u2014 Bon maillage pour un contenu pilier.`,
     internalLinksFail: (count) => `${count} lien(s) interne(s) \u2014 Un contenu pilier devrait avoir au moins 5 liens internes vers du contenu associe.`,
@@ -8629,12 +9375,23 @@ var rulesFr = {
     yearRefWarn: (oldest, current, last) => `Le contenu mentionne l'annee ${oldest} sans reference a ${current} ou ${last} \u2014 Contenu potentiellement obsolete.`,
     yearRefPass: (year) => `Le contenu fait reference a l'annee en cours (${year}).`,
     thinAgingLabel: "Contenu leger et ancien",
-    thinAgingFail: (words, days) => `Seulement ${words} mots et non mis a jour depuis ${days} jours \u2014 Un contenu leger ancien perd rapidement en pertinence.`
+    thinAgingFail: (words, days) => `Seulement ${words} mots et non mis a jour depuis ${days} jours \u2014 Un contenu leger ancien perd rapidement en pertinence.`,
+    fakeRefreshLabel: "Faux rafraichissement",
+    fakeRefreshWarn: (displayedDays, updatedDays) => `La date affichee (il y a ${displayedDays} j) est plus recente que la derniere modification reelle (il y a ${updatedDays} j) \u2014 evitez de rajeunir la date sans vraie mise a jour du contenu.`,
+    fakeRefreshTip: "Google detecte la vraie date de modification. Mettez a jour le fond du contenu, pas seulement la date affichee."
   },
   schema: {
     readinessLabel: "Donnees structurees",
     readinessPass: "La page a suffisamment de metadonnees pour generer du JSON-LD (title, description, image).",
-    readinessFail: "Completez le title, la description et ajoutez une image pour exploiter pleinement les donnees structurees."
+    readinessFail: "Completez le title, la description et ajoutez une image pour exploiter pleinement les donnees structurees.",
+    coverageLabel: "Couverture des donnees structurees",
+    coverageOptional: "Les donnees structurees sont optionnelles pour ce type de page.",
+    coveragePass: (type) => `Donnees CMS suffisantes pour generer un schema ${type} valide.`,
+    coverageMissing: (type, fields) => `Schema ${type} attendu pour cette page \u2014 champ(s) requis manquant(s) dans le CMS : ${fields}.`,
+    coverageMissingTip: "Completez ces champs, ou assurez-vous que le JSON-LD correspondant est injecte au rendu (frontend).",
+    coverageRemind: (type, fields) => `Schema ${type} : champs CMS requis presents. Verifiez aussi ces champs requis non detectables automatiquement : ${fields}.`,
+    faqNoRichResultLabel: "FAQ / donnees structurees",
+    faqNoRichResult: "FAQPage detecte \u2014 markup valide et toujours lu par les moteurs et l'IA, mais Google ne genere plus de rich result FAQ (2026). Conservez le markup, n'attendez pas d'extrait enrichi en SERP."
   },
   technical: {
     canonicalMissingLabel: "URL canonique",
@@ -8643,6 +9400,8 @@ var rulesFr = {
     canonicalInvalidMessage: (url) => `URL canonique "${url}" invalide \u2014 Utilisez une URL absolue (https://...).`,
     canonicalExternalLabel: "URL canonique",
     canonicalExternalMessage: "URL canonique pointe vers un domaine externe \u2014 Verifiez que c'est intentionnel.",
+    canonicalCrossLabel: "URL canonique",
+    canonicalCrossMessage: (target) => `URL canonique pointe vers une AUTRE page (${target}) \u2014 cette page se desindexe au profit de cette URL. Verifiez que c'est intentionnel.`,
     canonicalOkLabel: "URL canonique",
     canonicalOkMessage: "URL canonique correctement definie.",
     robotsNoindexLabel: "Robots noindex",
@@ -8767,8 +9526,11 @@ var rulesEn = {
     powerWordsPass: (count, words) => `The title contains ${count} power word(s): ${words}`,
     powerWordsFail: 'The title contains no power words \u2014 Add a word like "free", "guide", "ultimate" to boost CTR.',
     powerWordsTip: "Power words (free, exclusive, guide, ultimate, essential...) attract attention in search results.",
+    pixelWidthLabel: "Title pixel width",
+    pixelWidthPass: (px) => `Estimated width ${px}px \u2014 under the SERP truncation threshold (~600px).`,
+    pixelWidthWarn: (px) => `Estimated width ${px}px \u2014 may be truncated in Google (~600px). Informational.`,
     hasNumberLabel: "Number in title",
-    hasNumberPass: "The title contains a number \u2014 Titles with numbers generate +36% CTR.",
+    hasNumberPass: "The title contains a number \u2014 list-style format, often more engaging.",
     hasNumberFail: 'No number in the title \u2014 Titles with numbers (e.g. "5 tips", "Top 10") attract more clicks.',
     hasNumberTip: 'Add a number to create a list-type title (e.g. "7 tips for...", "The 3 mistakes to avoid").',
     isQuestionLabel: "Question title",
@@ -8852,12 +9614,12 @@ var rulesEn = {
     keywordIntroFail: (kw) => `Add the keyword "${kw}" in the first sentences of the content.`,
     densityLabel: "Keyword density",
     densityOverstuffed: (density) => `Keyword density: ${density}% \u2014 Too high (>3%), risk of keyword stuffing.`,
-    densityHigh: (density) => `Keyword density: ${density}% \u2014 Slightly high. Stay between 0.5% and 2.5%.`,
-    densityPass: (density) => `Keyword density: ${density}% \u2014 Ideal balance.`,
+    densityHigh: (density) => `Keyword density: ${density}% \u2014 Slightly high; keep it natural to avoid over-optimisation.`,
+    densityPass: (density) => `Keyword density: ${density}% \u2014 Natural usage, no stuffing detected.`,
     densityPassWordLevel: (density) => `Keyword components are present in the content (estimated density: ${density}%).`,
     densityLowWordLevel: (density) => `Keyword components are present but infrequent (estimated density: ${density}%). Strengthen their presence.`,
     densityLow: (density) => `Keyword density: ${density}% \u2014 Too low. Aim for 0.5% to 2.5%.`,
-    densityMissing: (kw) => `The keyword "${kw}" never appears in the content.`,
+    densityMissing: (kw) => `The keyword "${kw}" does not appear in the body \u2014 focus on covering the topic naturally rather than repeating it.`,
     placeholderLabel: "Placeholder content",
     placeholderFail: "Placeholder content detected (lorem ipsum, TODO, etc.) \u2014 Replace with real content.",
     placeholderPass: "No placeholder content detected.",
@@ -8943,7 +9705,7 @@ var rulesEn = {
   cornerstone: {
     wordcountLabel: "Pillar content length",
     wordcountPass: (count) => `${count} words \u2014 The pillar content is comprehensive enough.`,
-    wordcountFail: (count) => `${count} words \u2014 Pillar content should contain at least 1500 words to be truly comprehensive.`,
+    wordcountFail: (count) => `${count} words \u2014 Pillar content seems thin; expand topical coverage (without targeting an arbitrary word count).`,
     internalLinksLabel: "Pillar content internal linking",
     internalLinksPass: (count) => `${count} internal links \u2014 Good linking for pillar content.`,
     internalLinksFail: (count) => `${count} internal link(s) \u2014 Pillar content should have at least 5 internal links to related content.`,
@@ -8997,12 +9759,23 @@ var rulesEn = {
     yearRefWarn: (oldest, current, last) => `The content mentions year ${oldest} without reference to ${current} or ${last} \u2014 Potentially outdated.`,
     yearRefPass: (year) => `The content references the current year (${year}).`,
     thinAgingLabel: "Thin and old content",
-    thinAgingFail: (words, days) => `Only ${words} words and not updated for ${days} days \u2014 Thin old content loses relevance quickly.`
+    thinAgingFail: (words, days) => `Only ${words} words and not updated for ${days} days \u2014 Thin old content loses relevance quickly.`,
+    fakeRefreshLabel: "Fake refresh",
+    fakeRefreshWarn: (displayedDays, updatedDays) => `The displayed date (${displayedDays} days ago) is newer than the last real modification (${updatedDays} days ago) \u2014 avoid bumping the date without a real content update.`,
+    fakeRefreshTip: "Google detects the real modification date. Update the actual content, not just the displayed date."
   },
   schema: {
     readinessLabel: "Structured data",
     readinessPass: "The page has sufficient metadata to generate JSON-LD (title, description, image).",
-    readinessFail: "Complete the title, description and add an image to fully leverage structured data."
+    readinessFail: "Complete the title, description and add an image to fully leverage structured data.",
+    coverageLabel: "Structured data coverage",
+    coverageOptional: "Structured data is optional for this page type.",
+    coveragePass: (type) => `Enough CMS data to generate a valid ${type} schema.`,
+    coverageMissing: (type, fields) => `${type} schema expected for this page \u2014 required field(s) missing in the CMS: ${fields}.`,
+    coverageMissingTip: "Complete these fields, or make sure the matching JSON-LD is injected at render time (frontend).",
+    coverageRemind: (type, fields) => `${type} schema: required CMS fields are present. Also confirm these required fields the analyzer cannot detect: ${fields}.`,
+    faqNoRichResultLabel: "FAQ / structured data",
+    faqNoRichResult: "FAQPage detected \u2014 markup is valid and still read by search/AI engines, but Google no longer renders FAQ rich results (2026). Keep the markup; do not expect an enhanced SERP snippet."
   },
   technical: {
     canonicalMissingLabel: "Canonical URL",
@@ -9011,6 +9784,8 @@ var rulesEn = {
     canonicalInvalidMessage: (url) => `Canonical URL "${url}" is invalid \u2014 Use an absolute URL (https://...).`,
     canonicalExternalLabel: "Canonical URL",
     canonicalExternalMessage: "Canonical URL points to an external domain \u2014 Verify this is intentional.",
+    canonicalCrossLabel: "Canonical URL",
+    canonicalCrossMessage: (target) => `Canonical URL points to a DIFFERENT page (${target}) \u2014 this page de-indexes itself in favor of that URL. Verify this is intentional.`,
     canonicalOkLabel: "Canonical URL",
     canonicalOkMessage: "Canonical URL is correctly defined.",
     robotsNoindexLabel: "Robots noindex",
@@ -9363,6 +10138,21 @@ function getTranslations(locale) {
 }
 
 // src/rules/title.ts
+var TITLE_PIXEL_MAX = 600;
+var NARROW_CHARS = new Set("iIl.,:;|!'`jft()[]{}/\\".split(""));
+var WIDE_CHARS = new Set("mwMW@%".split(""));
+function estimateTitlePixelWidth(title) {
+  let px = 0;
+  for (const ch of title) {
+    if (ch === " ") px += 5;
+    else if (NARROW_CHARS.has(ch)) px += 5;
+    else if (WIDE_CHARS.has(ch)) px += 15;
+    else if (ch >= "A" && ch <= "Z") px += 12;
+    else if (ch >= "0" && ch <= "9") px += 10;
+    else px += 9;
+  }
+  return Math.round(px);
+}
 function checkTitle(input, ctx) {
   const checks = [];
   const r = getTranslations(ctx.locale).rules.title;
@@ -9388,8 +10178,10 @@ function checkTitle(input, ctx) {
       label: r.lengthLabel,
       status: "warning",
       message: r.lengthShort(titleLen),
-      category: "critical",
-      weight: 3,
+      // SEO desintox: title length is a SERP-display hint, NOT a ranking factor
+      // (Google rewrites 60%+ of titles). Informational weight, never critical.
+      category: "bonus",
+      weight: 1,
       group: "title",
       tip: r.lengthShortTip
     });
@@ -9399,8 +10191,8 @@ function checkTitle(input, ctx) {
       label: r.lengthLabel,
       status: "warning",
       message: r.lengthLong(titleLen),
-      category: "critical",
-      weight: 3,
+      category: "bonus",
+      weight: 1,
       group: "title",
       tip: r.lengthLongTip
     });
@@ -9410,11 +10202,21 @@ function checkTitle(input, ctx) {
       label: r.lengthLabel,
       status: "pass",
       message: r.lengthPass(titleLen),
-      category: "critical",
-      weight: 3,
+      category: "bonus",
+      weight: 1,
       group: "title"
     });
   }
+  const titlePx = estimateTitlePixelWidth(title);
+  checks.push({
+    id: "title-pixel-width",
+    label: r.pixelWidthLabel,
+    status: titlePx > TITLE_PIXEL_MAX ? "warning" : "pass",
+    message: titlePx > TITLE_PIXEL_MAX ? r.pixelWidthWarn(titlePx) : r.pixelWidthPass(titlePx),
+    category: "bonus",
+    weight: 0,
+    group: "title"
+  });
   if (kw) {
     const titleNorm = normalizeForComparison(title);
     const kwPresent = keywordMatchesText(kw, titleNorm);
@@ -9950,44 +10752,15 @@ function checkContent(input, ctx) {
         weight: 2,
         group: "content"
       });
-    } else if (density >= KEYWORD_DENSITY_MIN) {
-      checks.push({
-        id: "content-keyword-density",
-        label: r.densityLabel,
-        status: "pass",
-        message: exactCount > 0 ? r.densityPass(density.toFixed(1)) : r.densityPassWordLevel(density.toFixed(1)),
-        category: "important",
-        weight: 2,
-        group: "content"
-      });
-    } else if (wordLevelMatch) {
-      checks.push({
-        id: "content-keyword-density",
-        label: r.densityLabel,
-        status: "warning",
-        message: r.densityLowWordLevel(density.toFixed(1)),
-        category: "important",
-        weight: 2,
-        group: "content"
-      });
-    } else if (exactCount > 0) {
-      checks.push({
-        id: "content-keyword-density",
-        label: r.densityLabel,
-        status: "warning",
-        message: r.densityLow(density.toFixed(1)),
-        category: "important",
-        weight: 2,
-        group: "content"
-      });
     } else {
+      const present = exactCount > 0 || wordLevelMatch;
       checks.push({
         id: "content-keyword-density",
         label: r.densityLabel,
-        status: "fail",
-        message: r.densityMissing(input.focusKeyword || normalizedKeyword),
-        category: "important",
-        weight: 2,
+        status: "pass",
+        message: present ? r.densityPass(density.toFixed(1)) : r.densityMissing(input.focusKeyword || normalizedKeyword),
+        category: "bonus",
+        weight: 0,
         group: "content"
       });
     }
@@ -10034,39 +10807,17 @@ function checkContent(input, ctx) {
     const tiersWithKw = [tier1, tier2, tier3].filter(
       (t) => keywordMatchesText(normalizedKeyword, t)
     ).length;
-    if (tiersWithKw >= 2) {
-      checks.push({
-        id: "content-keyword-distribution",
-        label: r.distributionLabel,
-        status: "pass",
-        message: r.distributionPass(tiersWithKw),
-        category: "important",
-        weight: 2,
-        group: "content"
-      });
-    } else if (tiersWithKw === 1) {
-      checks.push({
-        id: "content-keyword-distribution",
-        label: r.distributionLabel,
-        status: "warning",
-        message: r.distributionWarn,
-        category: "important",
-        weight: 2,
-        group: "content",
-        tip: r.distributionWarnTip
-      });
-    } else {
-      checks.push({
-        id: "content-keyword-distribution",
-        label: r.distributionLabel,
-        status: "fail",
-        message: r.distributionFail,
-        category: "important",
-        weight: 2,
-        group: "content",
-        tip: r.distributionFailTip
-      });
-    }
+    const wellDistributed = tiersWithKw >= 2;
+    checks.push({
+      id: "content-keyword-distribution",
+      label: r.distributionLabel,
+      status: wellDistributed ? "pass" : "warning",
+      message: wellDistributed ? r.distributionPass(tiersWithKw) : r.distributionWarn,
+      category: "bonus",
+      weight: 0,
+      group: "content",
+      ...wellDistributed ? {} : { tip: r.distributionWarnTip }
+    });
   }
   if (wordCount > 500) {
     const allLists = [];
@@ -10558,23 +11309,161 @@ function checkSocial(input, ctx) {
   return checks;
 }
 
+// src/rules/schema-requirements.ts
+var SCHEMA_REQUIREMENTS = {
+  Article: {
+    required: ["headline", "image"],
+    recommended: ["author", "datePublished", "dateModified", "publisher"],
+    richResult: true
+  },
+  Product: {
+    // Google needs name + at least one of offers / review / aggregateRating
+    required: ["name", "offers"],
+    recommended: ["image", "brand", "aggregateRating", "review", "sku"],
+    richResult: true
+  },
+  LocalBusiness: {
+    required: ["name", "address"],
+    recommended: ["telephone", "openingHours", "geo", "priceRange"],
+    richResult: true
+  },
+  BreadcrumbList: {
+    required: ["itemListElement"],
+    recommended: [],
+    richResult: true
+  },
+  Organization: {
+    required: ["name", "url"],
+    recommended: ["logo", "sameAs"],
+    richResult: false
+  },
+  Person: {
+    required: ["name"],
+    recommended: ["sameAs", "jobTitle", "image", "url"],
+    richResult: false
+  },
+  FAQPage: {
+    required: ["mainEntity"],
+    recommended: [],
+    // FAQ rich results removed by Google (May 2026). Markup still useful for AI/search understanding.
+    richResult: false
+  },
+  Event: {
+    required: ["name", "startDate", "location"],
+    recommended: ["endDate", "offers", "image", "performer"],
+    richResult: true
+  },
+  Recipe: {
+    required: ["name", "image", "recipeIngredient", "recipeInstructions"],
+    recommended: ["nutrition", "aggregateRating", "totalTime", "recipeYield"],
+    richResult: true
+  },
+  Video: {
+    required: ["name", "thumbnailUrl", "uploadDate"],
+    recommended: ["duration", "contentUrl", "description"],
+    richResult: true
+  }
+};
+var CMS_VERIFIABLE_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
+  "headline",
+  "name",
+  "image",
+  "url",
+  "itemListElement",
+  "mainEntity"
+]);
+
 // src/rules/schema.ts
+var FAQ_BLOCK_TYPES = /* @__PURE__ */ new Set(["faq", "FAQ", "faqBlock", "faqs"]);
+function hasFaqBlock(blocks) {
+  if (!Array.isArray(blocks)) return false;
+  return blocks.some((block) => {
+    if (!block || typeof block !== "object") return false;
+    const t = block.blockType;
+    return typeof t === "string" && FAQ_BLOCK_TYPES.has(t);
+  });
+}
+function detectExpectedSchemaType(input, ctx) {
+  if (input.isProduct) return "Product";
+  if (input.isPost || ctx.pageType === "blog") return "Article";
+  if (ctx.pageType === "local-seo") return "LocalBusiness";
+  if (ctx.pageType === "agency") return "Organization";
+  if (ctx.pageType === "legal" || ctx.pageType === "contact" || ctx.pageType === "form") return null;
+  return "Article";
+}
 function checkSchema(input, ctx) {
   const checks = [];
   const r = getTranslations(ctx.locale).rules.schema;
-  const hasMetaTitle = !!input.metaTitle;
-  const hasMetaDesc = !!input.metaDescription;
-  const hasImage = ctx.imageStats.total > 0;
-  const readyForSchema = hasMetaTitle && hasMetaDesc && hasImage;
-  checks.push({
-    id: "schema-readiness",
-    label: r.readinessLabel,
-    status: readyForSchema ? "pass" : "warning",
-    message: readyForSchema ? r.readinessPass : r.readinessFail,
-    category: "bonus",
-    weight: 1,
-    group: "schema"
-  });
+  const faqPresent = hasFaqBlock(input.blocks);
+  const present = {
+    headline: !!(input.metaTitle || input.heroTitle) || ctx.allHeadings.some((h) => h.tag === "h1"),
+    name: !!(input.metaTitle || input.heroTitle),
+    image: ctx.imageStats.total > 0 || !!input.metaImage,
+    url: true,
+    itemListElement: !!input.slug,
+    mainEntity: faqPresent
+  };
+  const expected = detectExpectedSchemaType(input, ctx);
+  if (expected === null) {
+    checks.push({
+      id: "schema-coverage",
+      label: r.coverageLabel,
+      status: "pass",
+      message: r.coverageOptional,
+      category: "bonus",
+      weight: 0,
+      group: "schema"
+    });
+  } else {
+    const reqDef = SCHEMA_REQUIREMENTS[expected];
+    const knownMissing = reqDef.required.filter(
+      (f) => CMS_VERIFIABLE_SCHEMA_FIELDS.has(f) && !present[f]
+    );
+    const unverifiable = reqDef.required.filter((f) => !CMS_VERIFIABLE_SCHEMA_FIELDS.has(f));
+    if (knownMissing.length > 0) {
+      checks.push({
+        id: "schema-coverage",
+        label: r.coverageLabel,
+        status: "warning",
+        message: r.coverageMissing(expected, knownMissing.join(", ")),
+        category: "bonus",
+        weight: 1,
+        group: "schema",
+        tip: r.coverageMissingTip
+      });
+    } else if (unverifiable.length > 0) {
+      checks.push({
+        id: "schema-coverage",
+        label: r.coverageLabel,
+        status: "pass",
+        message: r.coverageRemind(expected, unverifiable.join(", ")),
+        category: "bonus",
+        weight: 0,
+        group: "schema"
+      });
+    } else {
+      checks.push({
+        id: "schema-coverage",
+        label: r.coverageLabel,
+        status: "pass",
+        message: r.coveragePass(expected),
+        category: "bonus",
+        weight: 1,
+        group: "schema"
+      });
+    }
+  }
+  if (faqPresent && true) {
+    checks.push({
+      id: "schema-faq-no-rich-result",
+      label: r.faqNoRichResultLabel,
+      status: "pass",
+      message: r.faqNoRichResult,
+      category: "bonus",
+      weight: 0,
+      group: "schema"
+    });
+  }
   return checks;
 }
 
@@ -10696,8 +11585,8 @@ function checkReadability(input, ctx) {
         label: r.passiveLabelFail,
         status: "warning",
         message: r.passiveFail(passiveSentences.length, sentences.length, Math.round(passiveRatio * 100)),
-        category: "important",
-        weight: 2,
+        category: "bonus",
+        weight: 0,
         group: "readability"
       });
     } else {
@@ -10706,8 +11595,8 @@ function checkReadability(input, ctx) {
         label: r.passiveLabelPass,
         status: "pass",
         message: r.passivePass(Math.round(passiveRatio * 100)),
-        category: "important",
-        weight: 2,
+        category: "bonus",
+        weight: 0,
         group: "readability"
       });
     }
@@ -10722,7 +11611,7 @@ function checkReadability(input, ctx) {
         status: "warning",
         message: r.transitionsFail(Math.round(transitionRatio * 100)),
         category: "bonus",
-        weight: 1,
+        weight: 0,
         group: "readability"
       });
     } else {
@@ -10732,7 +11621,7 @@ function checkReadability(input, ctx) {
         status: "pass",
         message: r.transitionsPass(Math.round(transitionRatio * 100)),
         category: "bonus",
-        weight: 1,
+        weight: 0,
         group: "readability"
       });
     }
@@ -11180,10 +12069,34 @@ function checkFreshness(input, ctx) {
       group: "freshness"
     });
   }
+  if (input.displayedDate && input.updatedAt) {
+    const displayedDays = daysSince(input.displayedDate);
+    const updatedDays = daysSince(input.updatedAt);
+    if (displayedDays !== Infinity && updatedDays !== Infinity && updatedDays - displayedDays > 60) {
+      checks.push({
+        id: "freshness-fake-refresh",
+        label: r.fakeRefreshLabel,
+        status: "warning",
+        message: r.fakeRefreshWarn(displayedDays, updatedDays),
+        category: "bonus",
+        weight: 0,
+        group: "freshness",
+        tip: r.fakeRefreshTip
+      });
+    }
+  }
   return checks;
 }
 
 // src/rules/technical.ts
+function isCrossCanonical(canonical, siteUrl, slug) {
+  const norm = (p) => p.replace(/[?#].*$/, "").replace(/^\/+/, "").replace(/\/+$/, "").toLowerCase();
+  const canonicalPath = norm(canonical.slice(siteUrl.length));
+  const selfPath = norm(slug);
+  const selfIsHome = selfPath === "" || selfPath === "home";
+  if (selfIsHome) return canonicalPath !== "" && canonicalPath !== "home";
+  return canonicalPath !== selfPath;
+}
 function checkTechnical(input, ctx) {
   const checks = [];
   const r = getTranslations(ctx.locale).rules.technical;
@@ -11221,6 +12134,16 @@ function checkTechnical(input, ctx) {
           weight: 2,
           group: "technical"
         });
+      } else if (siteUrl && input.slug && !input.isGlobal && isCrossCanonical(canonical, siteUrl, input.slug)) {
+        checks.push({
+          id: "canonical-cross",
+          label: r.canonicalCrossLabel,
+          status: "warning",
+          message: r.canonicalCrossMessage(canonical),
+          category: "important",
+          weight: 2,
+          group: "technical"
+        });
       } else {
         checks.push({
           id: "canonical-ok",
@@ -11513,6 +12436,336 @@ function checkEcommerce(input, ctx) {
   return checks;
 }
 
+// src/rules/eeat.ts
+var STRINGS = {
+  fr: {
+    authorLabel: "Auteur attribu\xE9 (E-E-A-T)",
+    authorPass: "Un auteur est attribu\xE9 \u2014 bon signal de transparence E-E-A-T.",
+    authorFail: "Aucun auteur identifi\xE9 \u2014 attribuez un auteur r\xE9el pour renforcer la confiance (E-E-A-T).",
+    authorTip: "Ajoutez un auteur avec une courte bio et un lien vers son profil (Person schema + sameAs).",
+    authorEntityLabel: "Entit\xE9 auteur (profil / sameAs)",
+    authorEntityPass: "L'auteur a un lien de profil \u2014 renforce l'entit\xE9 (sameAs) pour les moteurs et l'IA.",
+    authorEntityFail: "L'auteur n'a pas de lien de profil \u2014 ajoutez une URL (LinkedIn, page auteur) comme sameAs.",
+    datesLabel: "Dates de publication / mise \xE0 jour",
+    datesPass: "Dates de publication et de mise \xE0 jour disponibles \u2014 bon pour la fra\xEEcheur et la confiance.",
+    datesFail: "Date de publication ou de mise \xE0 jour manquante \u2014 exposez datePublished et dateModified.",
+    sourcesLabel: "Sources externes cit\xE9es",
+    sourcesPass: (n) => `${n} lien(s) vers des sources externes \u2014 renforce la cr\xE9dibilit\xE9 et l'E-E-A-T.`,
+    sourcesFail: "Aucune source externe cit\xE9e \u2014 liez des sources fiables pour appuyer vos affirmations.",
+    sourcesTip: "Citez des \xE9tudes, donn\xE9es officielles ou r\xE9f\xE9rences sectorielles avec des liens sortants.",
+    dataLabel: "Donn\xE9es originales / chiffr\xE9es",
+    dataPass: "Le contenu pr\xE9sente des donn\xE9es chiffr\xE9es \u2014 signal d'expertise et de contenu original.",
+    dataFail: "Peu de donn\xE9es chiffr\xE9es d\xE9tect\xE9es \u2014 ajoutez des chiffres, statistiques ou r\xE9sultats concrets.",
+    dataTip: "Le contenu d\xE9montrant une exp\xE9rience de premi\xE8re main (donn\xE9es, chiffres, exemples v\xE9cus) est le levier de mont\xE9e n\xB01 en 2026."
+  },
+  en: {
+    authorLabel: "Attributed author (E-E-A-T)",
+    authorPass: "An author is attributed \u2014 good E-E-A-T transparency signal.",
+    authorFail: "No identified author \u2014 attribute a real author to strengthen trust (E-E-A-T).",
+    authorTip: "Add an author with a short bio and a link to their profile (Person schema + sameAs).",
+    authorEntityLabel: "Author entity (profile / sameAs)",
+    authorEntityPass: "The author has a profile link \u2014 strengthens the entity (sameAs) for search and AI.",
+    authorEntityFail: "The author has no profile link \u2014 add a URL (LinkedIn, author page) as sameAs.",
+    datesLabel: "Published / updated dates",
+    datesPass: "Published and modified dates available \u2014 good for freshness and trust.",
+    datesFail: "Published or modified date missing \u2014 expose datePublished and dateModified.",
+    sourcesLabel: "External sources cited",
+    sourcesPass: (n) => `${n} link(s) to external sources \u2014 strengthens credibility and E-E-A-T.`,
+    sourcesFail: "No external source cited \u2014 link reliable sources to back your claims.",
+    sourcesTip: "Cite studies, official data or industry references with outbound links.",
+    dataLabel: "Original / quantitative data",
+    dataPass: "The content includes quantitative data \u2014 a signal of expertise and original content.",
+    dataFail: "Little quantitative data detected \u2014 add figures, statistics or concrete results.",
+    dataTip: "First-hand-experience content (data, figures, lived examples) is the #1 visibility lever in 2026."
+  }
+};
+var EEAT_SKIP_PAGE_TYPES = /* @__PURE__ */ new Set(["legal", "contact", "form", "home"]);
+function checkEeat(input, ctx) {
+  const checks = [];
+  if (EEAT_SKIP_PAGE_TYPES.has(ctx.pageType) || ctx.wordCount < 100) return checks;
+  const s = STRINGS[ctx.locale] ?? STRINGS.fr;
+  const hasAuthor = !!(input.author && input.author.trim());
+  checks.push({
+    id: "eeat-author",
+    label: s.authorLabel,
+    status: hasAuthor ? "pass" : "warning",
+    message: hasAuthor ? s.authorPass : s.authorFail,
+    category: "important",
+    weight: 0,
+    group: "eeat",
+    ...hasAuthor ? {} : { tip: s.authorTip }
+  });
+  if (hasAuthor) {
+    const hasLink = !!(input.authorUrl && input.authorUrl.trim());
+    checks.push({
+      id: "eeat-author-entity",
+      label: s.authorEntityLabel,
+      status: hasLink ? "pass" : "warning",
+      message: hasLink ? s.authorEntityPass : s.authorEntityFail,
+      category: "bonus",
+      weight: 0,
+      group: "eeat"
+    });
+  }
+  const datesOk = !!input.publishedAt && !!input.updatedAt;
+  checks.push({
+    id: "eeat-dates",
+    label: s.datesLabel,
+    status: datesOk ? "pass" : "warning",
+    message: datesOk ? s.datesPass : s.datesFail,
+    category: "bonus",
+    weight: 0,
+    group: "eeat"
+  });
+  const externalLinks = ctx.allLinks.filter((l) => /^https?:\/\//i.test(l.url));
+  const hasSources = externalLinks.length > 0;
+  checks.push({
+    id: "eeat-sources",
+    label: s.sourcesLabel,
+    status: hasSources ? "pass" : "warning",
+    message: hasSources ? s.sourcesPass(externalLinks.length) : s.sourcesFail,
+    category: "bonus",
+    weight: 0,
+    group: "eeat",
+    ...hasSources ? {} : { tip: s.sourcesTip }
+  });
+  const hasPercent = /\d+([.,]\d+)?\s?%/.test(ctx.fullText);
+  const numberCount = (ctx.fullText.match(/\b\d{2,}\b/g) || []).length;
+  const hasData = hasPercent || numberCount >= 3;
+  checks.push({
+    id: "eeat-original-data",
+    label: s.dataLabel,
+    status: hasData ? "pass" : "warning",
+    message: hasData ? s.dataPass : s.dataFail,
+    category: "bonus",
+    weight: 0,
+    group: "eeat",
+    ...hasData ? {} : { tip: s.dataTip }
+  });
+  return checks;
+}
+
+// src/rules/geo.ts
+var QUESTION_WORDS = {
+  fr: ["comment", "pourquoi", "quand", "quel", "quelle", "quels", "quelles", "combien", "ou", "o\xF9", "qui", "que", "quoi", "est-ce"],
+  en: ["how", "why", "when", "what", "which", "where", "who", "can", "do", "does", "is", "are", "should"]
+};
+var STRINGS2 = {
+  fr: {
+    answerLabel: "R\xE9ponse en t\xEAte (answer-first)",
+    answerPass: "Le contenu d\xE9marre par une accroche concise \u2014 favorise l'extraction par l'IA.",
+    answerFail: "Le contenu ne d\xE9marre pas par une r\xE9ponse concise \u2014 placez une r\xE9ponse directe en t\xEAte de page/section.",
+    answerTip: "Format BLUF (Bottom Line Up Front) : r\xE9pondez \xE0 l'intention en 1-2 phrases avant de d\xE9velopper.",
+    questionsLabel: "Titres en question",
+    questionsPass: (n) => `${n} sous-titre(s) formul\xE9(s) en question \u2014 structure Q\u2192R id\xE9ale pour l'IA.`,
+    questionsFail: "Aucun titre en question \u2014 formulez certains H2/H3 en questions (les moteurs IA citent les paires question/r\xE9ponse).",
+    structureLabel: "Contenu extractible (listes / tableaux)",
+    structurePass: "Listes ou tableaux d\xE9tect\xE9s \u2014 unit\xE9s facilement extraites et cit\xE9es par l'IA.",
+    structureFail: "Aucune liste ni tableau \u2014 structurez les \xE9num\xE9rations et comparaisons en listes/tableaux.",
+    chunkLabel: "Contenu d\xE9coup\xE9 (scannable)",
+    chunkPass: "Contenu bien d\xE9coup\xE9 en sections \u2014 facilite l'extraction de passages.",
+    chunkFail: "Contenu peu d\xE9coup\xE9 \u2014 ajoutez des sous-titres pour cr\xE9er des passages auto-suffisants."
+  },
+  en: {
+    answerLabel: "Answer-first lead",
+    answerPass: "Content opens with a concise lead \u2014 helps AI extraction.",
+    answerFail: "Content does not open with a concise answer \u2014 put a direct answer at the top of the page/section.",
+    answerTip: "BLUF (Bottom Line Up Front): answer the intent in 1-2 sentences before expanding.",
+    questionsLabel: "Question-style headings",
+    questionsPass: (n) => `${n} heading(s) phrased as questions \u2014 ideal Q\u2192A structure for AI.`,
+    questionsFail: "No question headings \u2014 phrase some H2/H3 as questions (AI engines cite question/answer pairs).",
+    structureLabel: "Extractable content (lists / tables)",
+    structurePass: "Lists or tables detected \u2014 units easily extracted and cited by AI.",
+    structureFail: "No list or table \u2014 structure enumerations and comparisons as lists/tables.",
+    chunkLabel: "Chunked content (scannable)",
+    chunkPass: "Content is well chunked into sections \u2014 helps passage extraction.",
+    chunkFail: "Content is barely chunked \u2014 add subheadings to create self-contained passages."
+  }
+};
+var GEO_SKIP_PAGE_TYPES = /* @__PURE__ */ new Set(["legal", "contact", "form", "home"]);
+function isQuestionHeading(text, locale) {
+  const t = text.trim().toLowerCase();
+  if (t.endsWith("?")) return true;
+  const words = QUESTION_WORDS[locale] ?? QUESTION_WORDS.fr;
+  return words.some((w) => t.startsWith(w + " ") || t.startsWith(w + "-"));
+}
+function collectLexicalSources(input) {
+  const sources = [];
+  if (input.heroRichText) sources.push(input.heroRichText);
+  if (input.content) sources.push(input.content);
+  if (Array.isArray(input.blocks)) {
+    for (const b of input.blocks) {
+      if (!b || typeof b !== "object") continue;
+      const blk = b;
+      if (blk.richText) sources.push(blk.richText);
+      if (Array.isArray(blk.columns)) {
+        for (const c of blk.columns) {
+          if (c && typeof c === "object" && c.richText) {
+            sources.push(c.richText);
+          }
+        }
+      }
+    }
+  }
+  return sources;
+}
+function containsLexicalType(node, type, depth = 0) {
+  if (depth > 50 || !node || typeof node !== "object") return false;
+  const n = node;
+  if (n.type === type) return true;
+  const root = n.root || n;
+  const children = root.children || n.children;
+  if (Array.isArray(children)) {
+    for (const c of children) {
+      if (containsLexicalType(c, type, depth + 1)) return true;
+    }
+  }
+  return false;
+}
+function checkGeo(input, ctx) {
+  const checks = [];
+  if (GEO_SKIP_PAGE_TYPES.has(ctx.pageType) || ctx.wordCount < 150) return checks;
+  const s = STRINGS2[ctx.locale] ?? STRINGS2.fr;
+  const locale = ctx.locale;
+  const firstSentence = (ctx.sentences[0] || "").trim();
+  const firstSentenceWords = firstSentence ? firstSentence.split(/\s+/).length : 0;
+  const answerFirst = firstSentenceWords > 0 && firstSentenceWords <= 30;
+  checks.push({
+    id: "geo-answer-first",
+    label: s.answerLabel,
+    status: answerFirst ? "pass" : "warning",
+    message: answerFirst ? s.answerPass : s.answerFail,
+    category: "bonus",
+    weight: 0,
+    group: "geo",
+    ...answerFirst ? {} : { tip: s.answerTip }
+  });
+  const questionHeadings = ctx.allHeadings.filter(
+    (h) => h.tag !== "h1" && isQuestionHeading(h.text, locale)
+  ).length;
+  checks.push({
+    id: "geo-question-headings",
+    label: s.questionsLabel,
+    status: questionHeadings > 0 ? "pass" : "warning",
+    message: questionHeadings > 0 ? s.questionsPass(questionHeadings) : s.questionsFail,
+    category: "bonus",
+    weight: 0,
+    group: "geo"
+  });
+  const sources = collectLexicalSources(input);
+  const hasList = sources.some((src) => extractListsFromLexical(src).length > 0);
+  const hasTable = sources.some((src) => containsLexicalType(src, "table"));
+  const structured = hasList || hasTable;
+  checks.push({
+    id: "geo-extractable-structure",
+    label: s.structureLabel,
+    status: structured ? "pass" : "warning",
+    message: structured ? s.structurePass : s.structureFail,
+    category: "bonus",
+    weight: 0,
+    group: "geo"
+  });
+  const subheadings = ctx.allHeadings.filter((h) => h.tag !== "h1").length;
+  const expected = Math.max(1, Math.floor(ctx.wordCount / 300));
+  const chunked = subheadings >= expected;
+  checks.push({
+    id: "geo-chunked",
+    label: s.chunkLabel,
+    status: chunked ? "pass" : "warning",
+    message: chunked ? s.chunkPass : s.chunkFail,
+    category: "bonus",
+    weight: 0,
+    group: "geo"
+  });
+  return checks;
+}
+
+// src/rules/hreflang.ts
+var HREFLANG_RE = /^[a-z]{2,3}(-[a-z]{2,4})?$/i;
+var STRINGS3 = {
+  fr: {
+    codesLabel: "Codes hreflang valides",
+    codesPass: "Tous les codes hreflang sont au format valide (langue ISO 639-1, r\xE9gion ISO 3166-1 optionnelle).",
+    codesFail: (bad) => `Code(s) hreflang invalide(s) : ${bad} \u2014 un seul code erron\xE9 fait ignorer tout le cluster par Google.`,
+    dupLabel: "Doublons hreflang",
+    dupPass: "Aucun doublon de code hreflang.",
+    dupFail: (dup) => `Code(s) hreflang en double : ${dup} \u2014 chaque locale doit \xEAtre d\xE9clar\xE9e une seule fois.`,
+    absLabel: "URLs hreflang absolues",
+    absPass: "Toutes les URLs hreflang sont absolues.",
+    absFail: "Certaines URLs hreflang ne sont pas absolues \u2014 utilisez des URLs compl\xE8tes (https://...).",
+    xdefLabel: "hreflang x-default",
+    xdefPass: "Un x-default est d\xE9fini \u2014 bonne pratique pour les visiteurs hors locales cibl\xE9es.",
+    xdefFail: 'Aucun x-default \u2014 ajoutez un hreflang="x-default" pour les locales non couvertes.'
+  },
+  en: {
+    codesLabel: "Valid hreflang codes",
+    codesPass: "All hreflang codes are well-formed (ISO 639-1 language, optional ISO 3166-1 region).",
+    codesFail: (bad) => `Invalid hreflang code(s): ${bad} \u2014 a single bad code makes Google ignore the whole cluster.`,
+    dupLabel: "Duplicate hreflang",
+    dupPass: "No duplicate hreflang code.",
+    dupFail: (dup) => `Duplicate hreflang code(s): ${dup} \u2014 each locale must be declared once.`,
+    absLabel: "Absolute hreflang URLs",
+    absPass: "All hreflang URLs are absolute.",
+    absFail: "Some hreflang URLs are not absolute \u2014 use full URLs (https://...).",
+    xdefLabel: "hreflang x-default",
+    xdefPass: "An x-default is defined \u2014 good practice for visitors outside targeted locales.",
+    xdefFail: 'No x-default \u2014 add hreflang="x-default" for locales you do not cover.'
+  }
+};
+function checkHreflang(input, ctx) {
+  const alts = input.localeAlternates;
+  if (!Array.isArray(alts) || alts.length === 0) return [];
+  const s = STRINGS3[ctx.locale] ?? STRINGS3.fr;
+  const checks = [];
+  const codes = alts.map((a) => (a.hreflang || "").trim()).filter(Boolean);
+  const invalid = codes.filter((c) => c.toLowerCase() !== "x-default" && !HREFLANG_RE.test(c));
+  checks.push({
+    id: "hreflang-codes",
+    label: s.codesLabel,
+    status: invalid.length === 0 ? "pass" : "fail",
+    message: invalid.length === 0 ? s.codesPass : s.codesFail(invalid.join(", ")),
+    category: "important",
+    weight: 2,
+    group: "hreflang"
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const dups = /* @__PURE__ */ new Set();
+  for (const c of codes.map((c2) => c2.toLowerCase())) {
+    if (seen.has(c)) dups.add(c);
+    seen.add(c);
+  }
+  checks.push({
+    id: "hreflang-duplicates",
+    label: s.dupLabel,
+    status: dups.size === 0 ? "pass" : "warning",
+    message: dups.size === 0 ? s.dupPass : s.dupFail([...dups].join(", ")),
+    category: "important",
+    weight: 1,
+    group: "hreflang"
+  });
+  const allAbsolute = alts.every((a) => /^https?:\/\//i.test((a.href || "").trim()));
+  checks.push({
+    id: "hreflang-absolute",
+    label: s.absLabel,
+    status: allAbsolute ? "pass" : "warning",
+    message: allAbsolute ? s.absPass : s.absFail,
+    category: "important",
+    weight: 1,
+    group: "hreflang"
+  });
+  const hasXDefault = codes.some((c) => c.toLowerCase() === "x-default");
+  checks.push({
+    id: "hreflang-x-default",
+    label: s.xdefLabel,
+    status: hasXDefault ? "pass" : "warning",
+    message: hasXDefault ? s.xdefPass : s.xdefFail,
+    category: "bonus",
+    weight: 1,
+    group: "hreflang"
+  });
+  return checks;
+}
+
 // src/index.ts
 function buildContext(data, config) {
   const {
@@ -11717,6 +12970,9 @@ function analyzeSeo(data, config) {
     { group: "freshness", fn: checkFreshness },
     { group: "technical", fn: checkTechnical },
     { group: "accessibility", fn: checkAccessibility },
+    { group: "eeat", fn: checkEeat },
+    { group: "geo", fn: checkGeo },
+    { group: "hreflang", fn: checkHreflang },
     // E-commerce rules only run for product pages
     ...data.isProduct ? [{ group: "ecommerce", fn: checkEcommerce }] : []
   ];
@@ -11748,7 +13004,24 @@ function analyzeSeo(data, config) {
   if (score >= SCORE_EXCELLENT) level = "excellent";
   else if (score >= SCORE_GOOD) level = "good";
   else if (score >= SCORE_OK) level = "ok";
-  return { score, level, checks };
+  const aiChecks = checks.filter(
+    (c) => c.group === "geo" || c.group === "eeat" || c.id === "schema-coverage"
+  );
+  let aiReadiness;
+  if (aiChecks.length > 0) {
+    let aiEarned = 0;
+    for (const c of aiChecks) {
+      if (c.status === "pass") aiEarned += 1;
+      else if (c.status === "warning") aiEarned += WARNING_MULTIPLIER;
+    }
+    const aiScore = Math.round(aiEarned / aiChecks.length * 100);
+    let aiLevel = "poor";
+    if (aiScore >= SCORE_EXCELLENT) aiLevel = "excellent";
+    else if (aiScore >= SCORE_GOOD) aiLevel = "good";
+    else if (aiScore >= SCORE_OK) aiLevel = "ok";
+    aiReadiness = { score: aiScore, level: aiLevel, checkCount: aiChecks.length };
+  }
+  return { score, level, checks, ...aiReadiness ? { aiReadiness } : {} };
 }
 
 exports.ACTION_VERBS = ACTION_VERBS;