@lynxflow/seo-engine 2.4.0 → 2.6.0

package/dist/index.js

@@ -10782,6 +10782,590 @@ class TrustSignalsExtractor {
   }
 }
 
+// src/competitor-gap-blueprint.ts
+class CompetitorGapBlueprintEngine {
+  static buildBlueprint(targetTopic, userWordCount, competitors) {
+    const gaps = [];
+    const headingCounts = {};
+    const outdatedItems = [];
+    const diffAngles = [];
+    for (const comp of competitors) {
+      for (const h of comp.headings) {
+        const cleanH = h.toLowerCase().trim();
+        headingCounts[cleanH] = (headingCounts[cleanH] || 0) + 1;
+      }
+      if (comp.wordCount < 1500) {
+        gaps.push({
+          gapType: "thin_section",
+          description: `Competitor article is surface-level (${comp.wordCount} words) and lacks concrete implementation steps.`,
+          locationHeading: comp.headings[0] || "Overview",
+          competitorUrl: comp.url,
+          priority: "high",
+          counterOpportunity: `Publish an exhaustive, deep-dive section with interactive code examples, tables, and verifiable benchmarks.`
+        });
+      }
+      if (comp.contentSnippet) {
+        if (/202[0-4]/i.test(comp.contentSnippet)) {
+          outdatedItems.push(`Competitor ${comp.url} contains outdated 2020-2024 benchmarks and legacy screenshots.`);
+        }
+      }
+    }
+    const minThreshold = Math.max(1, Math.floor(competitors.length * 0.4));
+    const expectedCommonHeadings = Object.entries(headingCounts).filter(([_, count]) => count >= minThreshold).map(([h]) => h.charAt(0).toUpperCase() + h.slice(1));
+    diffAngles.push(`Real-Time Performance & In-Memory (O(1)) Speed Benchmarks (Zero competitors currently measure latency)`);
+    diffAngles.push(`AI Engine Optimization (SearchGPT, Perplexity & Gemini citations) with structured direct answer cards`);
+    diffAngles.push(`Interactive ROI / Cost Calculators embeddable directly in the content`);
+    const winningOutlineRecommendation = [
+      `1. Executive Summary & Direct Answer Card (For Google AI Overview & Perplexity)`,
+      ...expectedCommonHeadings.map((h, i) => `${i + 2}. ${h} (With Real Case Studies & Data)`),
+      `${expectedCommonHeadings.length + 2}. Proprietary Benchmark & Comparison Matrix (Our Unique Angle)`,
+      `${expectedCommonHeadings.length + 3}. Step-by-Step Implementation Guide for 2026`,
+      `${expectedCommonHeadings.length + 4}. Frequently Asked Questions (Structured JSON-LD FAQPage)`
+    ];
+    return {
+      mustFillGaps: gaps,
+      expectedCommonHeadings,
+      differentiationAngles: diffAngles,
+      outdatedToUpdate: outdatedItems,
+      winningOutlineRecommendation
+    };
+  }
+}
+
+// src/engagement-hook-analyzer.ts
+class EngagementHookAnalyzer {
+  static GENERIC_BAD_OPENERS = [
+    /^[A-Z][^.!?]*\bis\s+(?:a|an|the)\b/i,
+    /^[A-Z][^.!?]*\bare\s+(?:a|an|the)\b/i,
+    /^When it comes to/i,
+    /^In (?:today['’]s|the|this)\s+(?:digital|modern|world|age|fast-paced)/i,
+    /^If you['’]re (?:looking|searching|trying)/i,
+    /^(?:Many|Most|Some)\s+(?:people|companies|businesses|founders)/i,
+    /^There are (?:many|several|numerous)/i,
+    /^It['’]s (?:no secret|important|essential)/i,
+    /^De nos jours/i,
+    /^Dans le monde digital d'aujourd'hui/i
+  ];
+  static GOOD_HOOK_STARTERS = [
+    { type: "question", pattern: /\?$/ },
+    { type: "statistic", pattern: /^(?:\d+%|\d{1,3}(?:,\d{3})*|\$\d+)/ },
+    { type: "quote", pattern: /^["'«]/ },
+    { type: "thought_experiment", pattern: /^(?:What if|Imagine|Picture this|Here['’]s (?:the truth|what happened)|Et si|Imaginez)/i },
+    { type: "concrete_story", pattern: /^(?:Last (?:week|month|year)|In \d{4}|Hier|Le mois dernier|[A-Z][a-z]+ spent \d+)/i }
+  ];
+  static CTA_REGEX = /(?:Start|Try|Get|Claim|Download|Sign up|Essayer|Démarrer|Obtenir|Profiter|Découvrir|\[.*?→\]|\*\*\[.*?\]\*\*)/gi;
+  static analyze(content) {
+    const lines = content.split(`
+`).map((l) => l.trim()).filter(Boolean);
+    const textOnlyLines = lines.filter((l) => !l.startsWith("#") && !l.startsWith("---") && !l.startsWith("**Meta"));
+    const firstParagraph = textOnlyLines[0] || "";
+    const firstSentence = firstParagraph.split(/[.?!]/)[0]?.trim() || "";
+    const fixes = [];
+    let isStrongHook = false;
+    let hookType = "generic_bad_opener";
+    let hookFeedback = "Opening is generic. Replace with a punchy question, surprising stat, or narrative scenario.";
+    const isGeneric = this.GENERIC_BAD_OPENERS.some((r) => r.test(firstSentence));
+    if (!isGeneric) {
+      for (const h of this.GOOD_HOOK_STARTERS) {
+        if (h.pattern.test(firstSentence) || h.pattern.test(firstParagraph)) {
+          isStrongHook = true;
+          hookType = h.type;
+          hookFeedback = `Excellent hook using a ${h.type.replace("_", " ")}. Captures attention instantly.`;
+          break;
+        }
+      }
+      if (!isStrongHook) {
+        isStrongHook = true;
+        hookType = "concrete_story";
+        hookFeedback = "Opening avoids cliché LLM patterns.";
+      }
+    } else {
+      fixes.push(`Replace generic opener ("${firstSentence.slice(0, 45)}...") with a dramatic question or verified statistic.`);
+    }
+    const hook = {
+      openingSentence: firstSentence,
+      isStrongHook,
+      hookType,
+      feedback: hookFeedback,
+      suggestedHookUpgrade: `What if you could eliminate 80% of manual repetitive tasks in less than 48 hours?`
+    };
+    const rawSentences = content.replace(/([.?!])\s*(?=[A-Z0-9])/g, "$1|").split("|").map((s) => s.trim()).filter((s) => s.length > 5);
+    const sentenceLengths = rawSentences.map((s) => s.split(/\s+/).filter(Boolean).length);
+    const sCount = Math.max(1, sentenceLengths.length);
+    const avgWords = Math.round(sentenceLengths.reduce((a, b) => a + b, 0) / sCount * 10) / 10;
+    const variance = sentenceLengths.reduce((acc, len) => acc + Math.pow(len - avgWords, 2), 0) / sCount;
+    const stdDev = Math.round(Math.sqrt(variance) * 10) / 10;
+    const hasVariedRhythm = stdDev >= 5 && avgWords <= 18;
+    const rhythmScore = Math.min(100, Math.round(stdDev / 8 * 100));
+    if (!hasVariedRhythm) {
+      fixes.push("Vary sentence lengths: Alternate short punchy statements (4-7 words) with explanatory sentences (14-18 words).");
+    }
+    const rhythm = {
+      sentenceCount: sCount,
+      averageWords: avgWords,
+      standardDeviation: stdDev,
+      hasVariedRhythm,
+      score: rhythmScore
+    };
+    const thirdOfText = Math.floor(content.length / 3);
+    const topPart = content.slice(0, thirdOfText);
+    const midPart = content.slice(thirdOfText, thirdOfText * 2);
+    const botPart = content.slice(thirdOfText * 2);
+    const hasAboveTheFoldCta = this.CTA_REGEX.test(topPart);
+    const hasMidArticleCta = this.CTA_REGEX.test(midPart);
+    const hasBottomCta = this.CTA_REGEX.test(botPart);
+    const allCtas = content.match(this.CTA_REGEX) || [];
+    const isDistributed = (hasAboveTheFoldCta || hasMidArticleCta) && hasBottomCta;
+    if (!isDistributed) {
+      fixes.push("Add a mid-article contextual CTA box to capture readers who don't reach the bottom footer.");
+    }
+    const ctas = {
+      totalCtasDetected: allCtas.length,
+      isDistributedAcrossArticle: isDistributed,
+      hasAboveTheFoldCta,
+      hasMidArticleCta,
+      hasBottomCta
+    };
+    const paragraphs = content.split(/\n\s*\n/).filter((p) => p.trim().length > 20 && !p.startsWith("#"));
+    let longParas = 0;
+    for (const p of paragraphs) {
+      const pSentences = p.split(/[.?!]/).filter((s) => s.trim().length > 3).length;
+      if (pSentences > 4)
+        longParas++;
+    }
+    const isMobileBreathable = longParas <= Math.max(1, Math.floor(paragraphs.length * 0.15));
+    if (!isMobileBreathable) {
+      fixes.push(`Split ${longParas} bulky paragraphs into 2-3 sentence chunks to improve mobile scannability.`);
+    }
+    const paragraphEval = {
+      totalParagraphs: paragraphs.length,
+      longParagraphsCount: longParas,
+      isMobileBreathable
+    };
+    const passedArray = [isStrongHook, hasVariedRhythm, isDistributed, isMobileBreathable];
+    const passedCount = passedArray.filter(Boolean).length;
+    const engagementScore = Math.round(passedCount / 4 * 100);
+    return {
+      engagementScore,
+      allPassed: passedCount === 4,
+      passedCount,
+      hook,
+      rhythm,
+      ctas,
+      paragraphs: paragraphEval,
+      actionableFixes: fixes
+    };
+  }
+}
+
+// src/keyword-density-guard.ts
+class KeywordDensityGuard {
+  static audit(content, primaryKeyword, metaTitle) {
+    if (!content || !primaryKeyword) {
+      return {
+        keyword: primaryKeyword,
+        totalOccurrences: 0,
+        totalWords: 0,
+        densityPercent: 0,
+        status: "too_low",
+        placements: [],
+        consecutiveSentencesWithKeyword: 0,
+        stuffingAlert: false,
+        recommendations: ["Provide content and a target keyword to audit."]
+      };
+    }
+    const words = content.split(/\s+/).filter(Boolean);
+    const totalWords = words.length;
+    const escapedKw = primaryKeyword.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+    const kwRegex = new RegExp(`\\b${escapedKw}\\b`, "gi");
+    const testKw = (str) => new RegExp(`\\b${escapedKw}\\b`, "i").test(str);
+    const occurrences = (content.match(kwRegex) || []).length;
+    const densityPercent = totalWords > 0 ? Math.round(occurrences / totalWords * 1000) / 10 : 0;
+    const lines = content.split(`
+`);
+    const h1Line = lines.find((l) => l.trim().startsWith("# ")) || "";
+    const h2Lines = lines.filter((l) => l.trim().startsWith("## ")).join(" ");
+    const first100Words = words.slice(0, 100).join(" ");
+    const last100Words = words.slice(-100).join(" ");
+    const inTitle = metaTitle ? testKw(metaTitle) : false;
+    const inH1 = testKw(h1Line);
+    const inFirst100 = testKw(first100Words);
+    const inH2s = (h2Lines.match(new RegExp(`\\b${escapedKw}\\b`, "gi")) || []).length;
+    const inConclusion = testKw(last100Words);
+    const inFaq = /faq|frequently asked/i.test(content) && testKw(content);
+    const placements = [
+      { location: "title", present: inTitle, count: inTitle ? 1 : 0 },
+      { location: "h1", present: inH1, count: inH1 ? 1 : 0 },
+      { location: "first_100_words", present: inFirst100, count: inFirst100 ? 1 : 0 },
+      { location: "h2_headings", present: inH2s > 0, count: inH2s },
+      { location: "conclusion", present: inConclusion, count: inConclusion ? 1 : 0 },
+      { location: "faq", present: inFaq, count: inFaq ? 1 : 0 }
+    ];
+    const sentences = content.split(/[.?!]/).map((s) => s.trim()).filter((s) => s.length > 5);
+    let maxConsecutive = 0;
+    let currentConsecutive = 0;
+    for (const s of sentences) {
+      if (kwRegex.test(s)) {
+        currentConsecutive++;
+        if (currentConsecutive > maxConsecutive)
+          maxConsecutive = currentConsecutive;
+      } else {
+        currentConsecutive = 0;
+      }
+    }
+    const stuffingAlert = densityPercent > 2.2 || maxConsecutive >= 3;
+    let status = "optimal";
+    const recommendations = [];
+    if (densityPercent < 0.8) {
+      status = "too_low";
+      recommendations.push(`Primary keyword density is low (${densityPercent}%). Target: 1.0% - 1.8%.`);
+    } else if (densityPercent > 2.2) {
+      status = "stuffing_risk";
+      recommendations.push(`Keyword stuffing risk detected (${densityPercent}%). Reduce usage and replace with semantic LSI synonyms.`);
+    }
+    if (!inFirst100) {
+      recommendations.push("Include primary keyword naturally in the first 100 words.");
+    }
+    if (!inH1) {
+      recommendations.push("Include primary keyword in the main H1 heading.");
+    }
+    if (inH2s === 0) {
+      recommendations.push("Include primary keyword in at least one H2 subheading.");
+    }
+    if (maxConsecutive >= 3) {
+      recommendations.push(`Keyword appears in ${maxConsecutive} consecutive sentences. Space out mentions to improve natural reading flow.`);
+    }
+    return {
+      keyword: primaryKeyword,
+      totalOccurrences: occurrences,
+      totalWords,
+      densityPercent,
+      status,
+      placements,
+      consecutiveSentencesWithKeyword: maxConsecutive,
+      stuffingAlert,
+      recommendations
+    };
+  }
+}
+
+// src/content-quality-scorer.ts
+class ContentQualityScorer {
+  static VAGUE_WORDS = [
+    /\b(?:many|some|various|numerous|several|often|sometimes|usually|generally|typically|significantly|substantial|greatly|very|really|quite|relatively)\b/gi
+  ];
+  static SPECIFICITY_DATA_PATTERNS = [
+    /\b\d{1,3}%\b/g,
+    /(?:\$|€|£)\s*[\d,]+(?:\.\d{2})?\b/g,
+    /\b\d{4}\b/g,
+    /\b\d+(?:,\d{3})*\s*(?:users?|customers?|businesses?|downloads?|hours?|minutes?)\b/gi,
+    /\"[^\"]{10,120}\"/g
+  ];
+  static CONVERSATIONAL_DEVICES = [
+    /\([^)]{5,40}\)/g,
+    /\?(?:\s|$)/g,
+    /\b(?:don't|can't|won't|you're|you've|it's|that's|here's|let's|we've|we're|I've)\b/gi,
+    /(?:^|\.\s+)(?:Look|Here['’]s the thing|The truth is|Sound familiar|Trust me|Regardez|En clair)/gi
+  ];
+  static scoreContent(content, metadata) {
+    if (!content || content.trim().length === 0) {
+      return this.emptyReport();
+    }
+    const words = content.split(/\s+/).filter(Boolean);
+    const totalWords = words.length;
+    let conversationalHits = 0;
+    for (const pat of this.CONVERSATIONAL_DEVICES) {
+      conversationalHits += (content.match(pat) || []).length;
+    }
+    const humanityRaw = Math.min(100, Math.round(conversationalHits / Math.max(1, totalWords / 80) * 60) + 30);
+    const humanityScore = Math.max(20, Math.min(100, humanityRaw));
+    let dataPointsCount = 0;
+    for (const pat of this.SPECIFICITY_DATA_PATTERNS) {
+      dataPointsCount += (content.match(pat) || []).length;
+    }
+    let vagueWordsCount = 0;
+    for (const pat of this.VAGUE_WORDS) {
+      vagueWordsCount += (content.match(pat) || []).length;
+    }
+    const specificityRatio = dataPointsCount / Math.max(1, vagueWordsCount * 0.5 + 2);
+    const specificityScore = Math.max(25, Math.min(100, Math.round(specificityRatio * 35 + 40)));
+    const lines = content.split(`
+`).map((l) => l.trim()).filter(Boolean);
+    const listLines = lines.filter((l) => l.startsWith("-") || l.startsWith("*") || l.startsWith("1.") || l.startsWith("2.")).length;
+    const proseLines = lines.filter((l) => !l.startsWith("#") && !l.startsWith("-") && !l.startsWith("*") && !l.startsWith("1.")).length;
+    const totalContentLines = Math.max(1, listLines + proseLines);
+    const proseRatio = Math.round(proseLines / totalContentLines * 100) / 100;
+    let structureScore = 85;
+    const structureIssues = [];
+    if (proseRatio < 0.4) {
+      structureScore = 50;
+      structureIssues.push("Too list-heavy (> 60% bullet points). Add explanatory narrative prose paragraphs between lists.");
+    } else if (proseRatio > 0.85) {
+      structureScore = 65;
+      structureIssues.push("Too prose-heavy (> 85% text walls). Break up long sections with bullet lists, comparison tables, or callouts.");
+    }
+    let seoScore = 80;
+    const seoIssues = [];
+    const hasH1 = lines.some((l) => l.startsWith("# "));
+    const h2Count = lines.filter((l) => l.startsWith("## ")).length;
+    if (!hasH1) {
+      seoScore -= 25;
+      seoIssues.push("Missing H1 title heading.");
+    }
+    if (h2Count < 2) {
+      seoScore -= 20;
+      seoIssues.push("Fewer than 2 H2 subheadings found. Structure content with clear sub-topics.");
+    }
+    if (metadata?.primaryKeyword && !content.toLowerCase().includes(metadata.primaryKeyword.toLowerCase())) {
+      seoScore -= 20;
+      seoIssues.push(`Target keyword "${metadata.primaryKeyword}" is missing from body text.`);
+    }
+    const avgSentenceLength = Math.round(totalWords / Math.max(1, content.split(/[.?!]/).length) * 10) / 10;
+    let readabilityScore = 85;
+    const readIssues = [];
+    if (avgSentenceLength > 20) {
+      readabilityScore = 55;
+      readIssues.push(`Average sentence length is ${avgSentenceLength} words (Target: 13-17 words).`);
+    }
+    const composite = Math.round(humanityScore * 0.3 + specificityScore * 0.25 + structureScore * 0.2 + seoScore * 0.15 + readabilityScore * 0.1);
+    const passes = composite >= 70;
+    let grade = "F";
+    if (composite >= 90)
+      grade = "A+";
+    else if (composite >= 80)
+      grade = "A";
+    else if (composite >= 70)
+      grade = "B";
+    else if (composite >= 55)
+      grade = "C";
+    const topFixes = [
+      ...structureIssues,
+      ...seoIssues,
+      ...readIssues
+    ];
+    if (specificityScore < 70) {
+      topFixes.push("Inject verified data points (specific dollar amounts, percentage improvements, dates) instead of vague generalities.");
+    }
+    if (humanityScore < 70) {
+      topFixes.push("Adopt a conversational tone: add contractions (you're, it's), rhetorical questions, and casual transition words.");
+    }
+    return {
+      compositeScore: composite,
+      passesQualityThreshold: passes,
+      grade,
+      dimensions: {
+        humanity: {
+          score: humanityScore,
+          weight: 0.3,
+          weightedScore: Math.round(humanityScore * 0.3),
+          strengths: humanityScore >= 75 ? ["Conversational tone", "Natural pacing"] : [],
+          issues: humanityScore < 75 ? ["Sounds slightly robotic or formal"] : []
+        },
+        specificity: {
+          score: specificityScore,
+          weight: 0.25,
+          weightedScore: Math.round(specificityScore * 0.25),
+          strengths: specificityScore >= 75 ? ["High hard-data density", "Concrete benchmarks"] : [],
+          issues: specificityScore < 75 ? ["Excessive vague words (many, several, often)"] : []
+        },
+        structureBalance: {
+          score: structureScore,
+          weight: 0.2,
+          weightedScore: Math.round(structureScore * 0.2),
+          strengths: structureScore >= 75 ? ["Balanced mix of prose and scannable lists"] : [],
+          issues: structureIssues
+        },
+        seoCompliance: {
+          score: seoScore,
+          weight: 0.15,
+          weightedScore: Math.round(seoScore * 0.15),
+          strengths: seoScore >= 75 ? ["Proper H1/H2 hierarchy"] : [],
+          issues: seoIssues
+        },
+        readability: {
+          score: readabilityScore,
+          weight: 0.1,
+          weightedScore: Math.round(readabilityScore * 0.1),
+          strengths: readabilityScore >= 75 ? ["Punchy sentence lengths"] : [],
+          issues: readIssues
+        }
+      },
+      proseToListRatio: proseRatio,
+      topPriorityFixes: topFixes
+    };
+  }
+  static emptyReport() {
+    return {
+      compositeScore: 0,
+      passesQualityThreshold: false,
+      grade: "F",
+      dimensions: {
+        humanity: { score: 0, weight: 0.3, weightedScore: 0, strengths: [], issues: [] },
+        specificity: { score: 0, weight: 0.25, weightedScore: 0, strengths: [], issues: [] },
+        structureBalance: { score: 0, weight: 0.2, weightedScore: 0, strengths: [], issues: [] },
+        seoCompliance: { score: 0, weight: 0.15, weightedScore: 0, strengths: [], issues: [] },
+        readability: { score: 0, weight: 0.1, weightedScore: 0, strengths: [], issues: [] }
+      },
+      proseToListRatio: 0,
+      topPriorityFixes: ["Provide text content to score."]
+    };
+  }
+}
+
+// src/landing-cro-checker.ts
+class LandingCroChecker {
+  static auditLandingPage(content, config = {}) {
+    const checks = [];
+    const lines = content.split(`
+`).map((l) => l.trim()).filter(Boolean);
+    const h1 = lines.find((l) => l.startsWith("# "))?.replace("# ", "") || "";
+    const h1Words = h1.split(/\s+/).filter(Boolean).length;
+    const isH1Clear = h1Words >= 4 && h1Words <= 14;
+    checks.push({
+      id: "h1_length",
+      name: "Headline Length & Outcome Focus",
+      category: "headline",
+      passed: isH1Clear,
+      importance: "critical",
+      feedback: isH1Clear ? "H1 is clear, outcome-focused, and scannable in < 3s." : "H1 is missing or too long/vague."
+    });
+    const hasValueProp = /save|boost|cut|grow|automate|increase|réduire|augmenter|gagner/i.test(content);
+    checks.push({
+      id: "value_prop_benefit",
+      name: "Concrete Benefit & Outcome",
+      category: "value_prop",
+      passed: hasValueProp,
+      importance: "critical",
+      feedback: hasValueProp ? "Explicit outcome/benefit articulated in content." : "Lacks explicit outcome/benefit statements."
+    });
+    const hasReviews = /rated|reviews?|avis|clients?|customers?|businesses?|\d{1,3}(?:,\d{3})*\+/i.test(content);
+    checks.push({
+      id: "social_proof_ratings",
+      name: "Customer Reviews & Numbers",
+      category: "social_proof",
+      passed: hasReviews,
+      importance: "important",
+      feedback: hasReviews ? "Social proof count or star rating present." : "No social proof numbers found."
+    });
+    const hasActionCta = /(?:start|try|get|claim|démarrer|essayer|profiter|obtenir)\s+(?:free|trial|now|today|gratuit)/i.test(content);
+    checks.push({
+      id: "cta_action_verb",
+      name: "High-Contrast Outcome CTA",
+      category: "ctas",
+      passed: hasActionCta,
+      importance: "critical",
+      feedback: hasActionCta ? "High-converting action verb present in CTA." : "CTA is generic or missing action verb."
+    });
+    const hasFaq = /faq|frequently asked|questions|foire aux questions/i.test(content);
+    checks.push({
+      id: "faq_objection_handling",
+      name: "Objection Handling & FAQ Section",
+      category: "objection_handling",
+      passed: hasFaq,
+      importance: "important",
+      feedback: hasFaq ? "FAQ section handles user hesitations." : "Missing FAQ / objection handling section."
+    });
+    const hasRiskReversal = /no credit card|cancel anytime|money-back|sans carte|sans engagement|garantie/i.test(content);
+    checks.push({
+      id: "risk_reversal_guarantee",
+      name: "Zero-Risk Micro-Copy",
+      category: "risk_reversal",
+      passed: hasRiskReversal,
+      importance: "important",
+      feedback: hasRiskReversal ? "Risk reversal micro-copy found near CTA." : "No risk reversal guarantee found."
+    });
+    const hasUrgency = /today|now|instant|limited|aujourd'hui|maintenant|immédiat/i.test(content);
+    checks.push({
+      id: "urgency_trigger",
+      name: "Immediate Access & Momentum",
+      category: "urgency",
+      passed: hasUrgency,
+      importance: "enhancement",
+      feedback: hasUrgency ? "Presents immediate access momentum." : "Lacks urgency or immediacy trigger."
+    });
+    const hasSubheadings = lines.filter((l) => l.startsWith("## ")).length >= 3;
+    checks.push({
+      id: "structure_scannability",
+      name: "Visual Hierarchy & H2 Subheadings",
+      category: "structure",
+      passed: hasSubheadings,
+      importance: "important",
+      feedback: hasSubheadings ? "Clean visual hierarchy with 3+ H2 sections." : "Fewer than 3 H2 subheadings found."
+    });
+    const totalChecks = checks.length;
+    const passedChecks = checks.filter((c) => c.passed).length;
+    const criticalFailures = checks.filter((c) => !c.passed && c.importance === "critical");
+    const warnings = checks.filter((c) => !c.passed && c.importance === "important");
+    const overallCroScore = Math.round(passedChecks / totalChecks * 100);
+    const passes = overallCroScore >= 70 && criticalFailures.length === 0;
+    let grade = "F";
+    if (overallCroScore >= 90)
+      grade = "A+";
+    else if (overallCroScore >= 80)
+      grade = "A";
+    else if (overallCroScore >= 70)
+      grade = "B";
+    else if (overallCroScore >= 55)
+      grade = "C";
+    const categoryScores = {};
+    for (const check of checks) {
+      if (!categoryScores[check.category]) {
+        categoryScores[check.category] = { score: 0, passedCount: 0, totalCount: 0 };
+      }
+      categoryScores[check.category].totalCount++;
+      if (check.passed)
+        categoryScores[check.category].passedCount++;
+    }
+    for (const cat in categoryScores) {
+      categoryScores[cat].score = Math.round(categoryScores[cat].passedCount / categoryScores[cat].totalCount * 100);
+    }
+    const roadmap = checks.filter((c) => !c.passed).map((c) => `[${c.importance.toUpperCase()}] ${c.category}: ${c.feedback}`);
+    return {
+      overallCroScore,
+      passesCroAudit: passes,
+      grade,
+      criticalFailuresCount: criticalFailures.length,
+      warningsCount: warnings.length,
+      checks,
+      categoryScores,
+      conversionRoadmap: roadmap
+    };
+  }
+}
+
+// src/social-community-insights.ts
+class SocialCommunityInsightsAggregator {
+  static aggregate(topic, rawInsights) {
+    const painPoints = [];
+    const realLanguage = [];
+    const quotables = [];
+    for (const item of rawInsights) {
+      if (item.type === "pain_point" || item.type === "complaint") {
+        if (!painPoints.includes(item.quotableText)) {
+          painPoints.push(item.quotableText);
+        }
+      }
+      if (item.quotableText) {
+        quotables.push(`"${item.quotableText}" (${item.source})`);
+      }
+      for (const phrase of item.userVocabulary) {
+        if (!realLanguage.includes(phrase)) {
+          realLanguage.push(phrase);
+        }
+      }
+    }
+    const recommendedAngle = painPoints.length > 0 ? `Address the #1 community frustration: "${painPoints[0]}" by demonstrating immediate resolution in the hero hook.` : `Highlight community-tested best practices and back every recommendation with verified user metrics.`;
+    return {
+      topic,
+      totalInsights: rawInsights.length,
+      painPoints,
+      realLanguagePhrases: realLanguage,
+      quotableExcerpts: quotables,
+      recommendedAngleForCopy: recommendedAngle
+    };
+  }
+}
+
 // src/index.ts
 function createLynxSeoEngine(config) {
   return new LynxSeoEngine(config);
@@ -10804,6 +11388,12 @@ var LynxSeo = {
   searchIntent: SearchIntentClassifier,
   opportunityPrioritizer: SeoOpportunityPrioritizer,
   trustSignals: TrustSignalsExtractor,
+  competitorGap: CompetitorGapBlueprintEngine,
+  engagementHook: EngagementHookAnalyzer,
+  keywordDensity: KeywordDensityGuard,
+  contentQuality: ContentQualityScorer,
+  landingCroChecker: LandingCroChecker,
+  socialInsights: SocialCommunityInsightsAggregator,
   inspectMeta: SiteAuditor.inspectMeta,
   crawlDomain: DeepCrawlerAuditor.crawlAndAuditDomain,
   inspectHtmlSnapshot: DeepCrawlerAuditor.inspectHtmlSnapshot,
@@ -10870,6 +11460,7 @@ export {
   SocialVideoSeoAnalyticsEngine,
   SocialTrendSeoGenerator,
   SocialGrowthSuite,
+  SocialCommunityInsightsAggregator,
   SocialAdsSocialSeoEngine,
   SiteAuditor,
   SerpRankHistoryEngine,
@@ -10907,10 +11498,12 @@ export {
   LynxAnalyticsClient,
   LlmContentCleaner,
   LegalDisclaimerEngine,
+  LandingCroChecker,
   LagoTokenMeter,
   KnowledgeGraphLinker,
   KnowledgeBankBuilder,
   KeywordPermutatorEngine,
+  KeywordDensityGuard,
   IsrCacheManager,
   InternalPageRankEngine,
   InstantMatrixSearchEngine,
@@ -10926,12 +11519,15 @@ export {
   FeaturesKnowledgeHarvester,
   ExtendedSchemaGraphBuilder,
   ExistingMediaHarvester,
+  EngagementHookAnalyzer,
   EmbeddableSeoWidgetGenerator,
   DeepCrawlerAuditor,
   CrosslinkScorerEngine,
   CroCopywritingEngine,
   CopywritingFrameworksMaster,
   ContextTemplatesGenerator,
+  ContentQualityScorer,
+  CompetitorGapBlueprintEngine,
   CONTENT_AI_40_TOOLS,
   BrandDnaCalendarEngine,
   BacklinksClient,