@lynxflow/seo-engine 2.5.0 → 2.7.0

package/dist/index.mjs

@@ -11049,6 +11049,543 @@ class KeywordDensityGuard {
   }
 }
 
+// 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/landing-channel-scorer.ts
+class LandingChannelScorer {
+  static CONFIGS = {
+    seo: { minWords: 1200, optimalWords: 2000, maxWords: 3000, minCtas: 3, optimalCtas: 5, maxDistractions: 6 },
+    ppc: { minWords: 350, optimalWords: 600, maxWords: 900, minCtas: 2, optimalCtas: 3, maxDistractions: 1 }
+  };
+  static scorePage(content, options) {
+    const config = this.CONFIGS[options.channel] || this.CONFIGS.seo;
+    const words = content.split(/\s+/).filter(Boolean);
+    const totalWords = words.length;
+    const ctaMatches = content.match(/(?:start|try|get|claim|demo|free trial|sign up|démarrer|essayer|profiter|obtenir)\s+(?:free|trial|now|today|gratuit|demo)?/gi) || [];
+    const ctaCount = ctaMatches.length;
+    const linkMatches = content.match(/\[.*?\]\(.*?\)/g) || [];
+    const distractionLinksCount = linkMatches.filter((l) => !l.toLowerCase().includes("pricing") && !l.toLowerCase().includes("signup")).length;
+    const hasH1 = /^#\s+.+/m.test(content);
+    const aboveFoldScore = hasH1 && ctaCount >= 1 ? 25 : 12;
+    let ctaScore = 15;
+    if (ctaCount >= config.minCtas && ctaCount <= config.optimalCtas + 2) {
+      ctaScore = 25;
+    } else if (ctaCount === 0) {
+      ctaScore = 0;
+    }
+    const hasProof = /rated|reviews?|avis|clients?|customers?|\d{1,3}(?:,\d{3})*\+/i.test(content);
+    const trustScore = hasProof ? 20 : 5;
+    const hasH2s = (content.match(/^##\s+.+/gm) || []).length >= 2;
+    const structureScore = hasH2s ? 15 : 8;
+    let channelFitScore = 15;
+    const recommendations = [];
+    if (options.channel === "seo") {
+      if (totalWords < config.minWords) {
+        channelFitScore -= 8;
+        recommendations.push(`SEO landing pages need depth (${totalWords}/${config.minWords} words). Expand with FAQ, feature breakdown, and case studies.`);
+      }
+    } else {
+      if (totalWords > config.maxWords) {
+        channelFitScore -= 8;
+        recommendations.push(`PPC landing page is too long (${totalWords} words). Cut text walls down to ~${config.optimalWords} words to maximize instant conversions.`);
+      }
+      if (distractionLinksCount > config.maxDistractions) {
+        channelFitScore -= 7;
+        recommendations.push(`Remove ${distractionLinksCount} navigation/leak links. PPC pages should only offer ONE path to conversion.`);
+      }
+    }
+    if (ctaCount < config.minCtas) {
+      recommendations.push(`Add ${config.minCtas - ctaCount} additional CTA button(s) distributed across the page.`);
+    }
+    if (!hasProof) {
+      recommendations.push("Add social proof indicators (reviews, user counts, client logos).");
+    }
+    const totalScore = Math.max(10, Math.min(100, aboveFoldScore + ctaScore + trustScore + structureScore + channelFitScore));
+    const passed = totalScore >= 70;
+    return {
+      channel: options.channel,
+      score: totalScore,
+      passed,
+      wordCount: totalWords,
+      wordCountTarget: { min: config.minWords, optimal: config.optimalWords, max: config.maxWords },
+      ctaCount,
+      ctaTarget: { min: config.minCtas, optimal: config.optimalWords ? config.optimalCtas : 3 },
+      distractionLinksCount,
+      categoryBreakdown: {
+        aboveTheFold: aboveFoldScore,
+        ctaAlignment: ctaScore,
+        trustSignals: trustScore,
+        structure: structureScore,
+        channelFit: channelFitScore
+      },
+      recommendations
+    };
+  }
+}
+
+// src/article-strategic-planner.ts
+class ArticleStrategicPlanner {
+  static planArticle(topic, primaryKeyword, depth = "standard") {
+    const totalWords = depth === "exhaustive_pillar" ? 3200 : 2200;
+    const readingTime = Math.round(totalWords / 200);
+    const sections = [
+      {
+        sectionNumber: 1,
+        type: "intro",
+        heading: `Introduction & Executive Direct Answer`,
+        targetWordCount: 250,
+        strategicObjective: "Hook the reader with a thought-provoking metric and provide a 40-word Direct Answer for SearchGPT & Gemini AI Overviews.",
+        hasFeaturedSnippetTarget: true,
+        internalLinkAnchors: ["Product Overview", "Platform Features"]
+      },
+      {
+        sectionNumber: 2,
+        type: "explanation",
+        heading: `Why ${primaryKeyword} Matters in 2026`,
+        targetWordCount: depth === "exhaustive_pillar" ? 600 : 450,
+        strategicObjective: "Establish market context, operational bottlenecks of manual workflows, and revenue impact.",
+        hasFeaturedSnippetTarget: false,
+        ctaIntensity: "soft",
+        internalLinkAnchors: ["Pricing & Plans"]
+      },
+      {
+        sectionNumber: 3,
+        type: "comparison",
+        heading: `Top Approaches & Benchmarks Matrix`,
+        targetWordCount: depth === "exhaustive_pillar" ? 750 : 500,
+        strategicObjective: "Present an objective comparison table with speed, latency, feature availability, and pricing.",
+        hasFeaturedSnippetTarget: true,
+        ctaIntensity: "medium",
+        internalLinkAnchors: ["Interactive Calculator", "Case Studies"]
+      },
+      {
+        sectionNumber: 4,
+        type: "how_to",
+        heading: `Step-by-Step Implementation Blueprint`,
+        targetWordCount: depth === "exhaustive_pillar" ? 800 : 550,
+        strategicObjective: "Provide actionable step-by-step tutorial with code snippets, configuration files, and verification criteria.",
+        hasFeaturedSnippetTarget: false,
+        ctaIntensity: "strong",
+        internalLinkAnchors: ["Documentation Hub", "API Reference"]
+      },
+      {
+        sectionNumber: 5,
+        type: "faq",
+        heading: `Frequently Asked Questions about ${primaryKeyword}`,
+        targetWordCount: 350,
+        strategicObjective: "Address top 4 'People Also Ask' search queries to qualify for Google FAQ rich snippet.",
+        hasFeaturedSnippetTarget: true,
+        internalLinkAnchors: []
+      },
+      {
+        sectionNumber: 6,
+        type: "conclusion",
+        heading: `Final Takeaways & Next Steps`,
+        targetWordCount: 150,
+        strategicObjective: "Summarize key findings and present final primary action button.",
+        hasFeaturedSnippetTarget: false,
+        ctaIntensity: "strong",
+        internalLinkAnchors: ["Start Free Trial"]
+      }
+    ];
+    return {
+      topic,
+      targetTotalWords: totalWords,
+      estimatedReadingTimeMinutes: readingTime,
+      meta: {
+        titleOptions: [
+          `${topic}: Complete Guide for 2026`,
+          `How to Master ${topic} (Step-by-Step)`,
+          `The Ultimate ${topic} Blueprint: Speed & Accuracy`
+        ],
+        metaDescription: `Discover how to master ${topic} in 2026. Explore step-by-step implementation, benchmarks, comparison matrices, and FAQ.`,
+        targetKeywords: [primaryKeyword, `${primaryKeyword} guide`, `best ${primaryKeyword} tools`]
+      },
+      sections,
+      ctaMap: {
+        soft: 2,
+        medium: 3,
+        strong: 4
+      }
+    };
+  }
+}
+
+// src/topic-cluster-architect.ts
+class TopicClusterArchitect {
+  static buildCluster(pillarTopic, subTopics) {
+    const pillarSlug = `/${pillarTopic.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}`;
+    let totalVolume = 0;
+    const spokes = subTopics.map((st) => {
+      const slug = `${pillarSlug}/${st.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}`;
+      const vol = st.volume || 1200;
+      totalVolume += vol;
+      return {
+        subTopic: st.name,
+        slug,
+        searchIntent: st.intent || "informational",
+        monthlySearchVolume: vol,
+        keywordDifficulty: st.difficulty || 35,
+        targetWordCount: 1800,
+        inboundLinks: [pillarSlug],
+        outboundLinks: [pillarSlug]
+      };
+    });
+    const crossLinks = [];
+    for (const spoke of spokes) {
+      crossLinks.push({
+        fromSlug: spoke.slug,
+        toSlug: pillarSlug,
+        anchorText: `${pillarTopic} Complete Overview`
+      });
+      crossLinks.push({
+        fromSlug: pillarSlug,
+        toSlug: spoke.slug,
+        anchorText: `Deep dive on ${spoke.subTopic}`
+      });
+    }
+    for (let i = 0;i < spokes.length; i++) {
+      const nextSpoke = spokes[(i + 1) % spokes.length];
+      crossLinks.push({
+        fromSlug: spokes[i].slug,
+        toSlug: nextSpoke.slug,
+        anchorText: `Related: ${nextSpoke.subTopic}`
+      });
+      spokes[i].outboundLinks.push(nextSpoke.slug);
+      nextSpoke.inboundLinks.push(spokes[i].slug);
+    }
+    let authority = "emerging";
+    if (spokes.length >= 6 && totalVolume > 5000)
+      authority = "dominant";
+    else if (spokes.length >= 3)
+      authority = "strong";
+    return {
+      pillarTopic,
+      pillarSlug,
+      totalSubSpokes: spokes.length,
+      totalEstimatedSearchVolume: totalVolume,
+      spokes,
+      crossLinkMatrix: crossLinks,
+      clusterAuthorityPotential: authority
+    };
+  }
+}
+
 // src/index.ts
 function createLynxSeoEngine(config) {
   return new LynxSeoEngine(config);
@@ -11074,6 +11611,12 @@ var LynxSeo = {
   competitorGap: CompetitorGapBlueprintEngine,
   engagementHook: EngagementHookAnalyzer,
   keywordDensity: KeywordDensityGuard,
+  contentQuality: ContentQualityScorer,
+  landingCroChecker: LandingCroChecker,
+  socialInsights: SocialCommunityInsightsAggregator,
+  channelScorer: LandingChannelScorer,
+  articlePlanner: ArticleStrategicPlanner,
+  topicClusters: TopicClusterArchitect,
   inspectMeta: SiteAuditor.inspectMeta,
   crawlDomain: DeepCrawlerAuditor.crawlAndAuditDomain,
   inspectHtmlSnapshot: DeepCrawlerAuditor.inspectHtmlSnapshot,
@@ -11134,12 +11677,14 @@ export {
   UrlyticsEngine,
   UI_ICONS,
   TrustSignalsExtractor,
+  TopicClusterArchitect,
   TokenQuotaManager,
   TechnicalRulesAuditor,
   TeamRbacEngine,
   SocialVideoSeoAnalyticsEngine,
   SocialTrendSeoGenerator,
   SocialGrowthSuite,
+  SocialCommunityInsightsAggregator,
   SocialAdsSocialSeoEngine,
   SiteAuditor,
   SerpRankHistoryEngine,
@@ -11177,6 +11722,8 @@ export {
   LynxAnalyticsClient,
   LlmContentCleaner,
   LegalDisclaimerEngine,
+  LandingCroChecker,
+  LandingChannelScorer,
   LagoTokenMeter,
   KnowledgeGraphLinker,
   KnowledgeBankBuilder,
@@ -11204,12 +11751,14 @@ export {
   CroCopywritingEngine,
   CopywritingFrameworksMaster,
   ContextTemplatesGenerator,
+  ContentQualityScorer,
   CompetitorGapBlueprintEngine,
   CONTENT_AI_40_TOOLS,
   BrandDnaCalendarEngine,
   BacklinksClient,
   BUILT_IN_LOCATIONS_DATABASE,
   BRAND_ICONS,
+  ArticleStrategicPlanner,
   ApiKeyGuardian,
   AiCopilotClient,
   AiBotsLogAnalyzer,

package/dist/landing-channel-scorer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 🎯 Dual-Channel Landing Page Scorer (SEO vs. PPC)
+ * Ported & optimized from Python landing_page_scorer.py (28 KB).
+ * Evaluates landing pages with tailored benchmarks for SEO (1,500-2,500 words) vs PPC (400-800 words, zero leak links).
+ */
+export interface ChannelScoringConfig {
+    channel: "seo" | "ppc";
+    conversionGoal?: "trial" | "demo" | "lead";
+}
+export interface ChannelScoringReport {
+    channel: "seo" | "ppc";
+    score: number;
+    passed: boolean;
+    wordCount: number;
+    wordCountTarget: {
+        min: number;
+        optimal: number;
+        max: number;
+    };
+    ctaCount: number;
+    ctaTarget: {
+        min: number;
+        optimal: number;
+    };
+    distractionLinksCount: number;
+    categoryBreakdown: {
+        aboveTheFold: number;
+        ctaAlignment: number;
+        trustSignals: number;
+        structure: number;
+        channelFit: number;
+    };
+    recommendations: string[];
+}
+export declare class LandingChannelScorer {
+    private static readonly CONFIGS;
+    /**
+     * Scores landing page according to the specific acquisition channel.
+     */
+    static scorePage(content: string, options: ChannelScoringConfig): ChannelScoringReport;
+}

package/dist/landing-cro-checker.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 📊 Comprehensive Landing Page CRO Checker
+ * Ported & optimized from Python cro_checker.py (23 KB).
+ * Evaluates 8 landing page conversion categories with pass/fail criteria and grade rating.
+ */
+export interface CroCheckItem {
+    id: string;
+    name: string;
+    category: "headline" | "value_prop" | "social_proof" | "ctas" | "objection_handling" | "risk_reversal" | "urgency" | "structure";
+    passed: boolean;
+    importance: "critical" | "important" | "enhancement";
+    feedback: string;
+}
+export interface LandingCroAuditResult {
+    overallCroScore: number;
+    passesCroAudit: boolean;
+    grade: "A+" | "A" | "B" | "C" | "F";
+    criticalFailuresCount: number;
+    warningsCount: number;
+    checks: CroCheckItem[];
+    categoryScores: Record<string, {
+        score: number;
+        passedCount: number;
+        totalCount: number;
+    }>;
+    conversionRoadmap: string[];
+}
+export declare class LandingCroChecker {
+    /**
+     * Runs the 8-category CRO checklist against landing page content or markup.
+     */
+    static auditLandingPage(content: string, config?: {
+        pageType?: "seo" | "ppc";
+        conversionGoal?: "trial" | "demo" | "lead";
+    }): LandingCroAuditResult;
+}