@lynxflow/seo-engine 2.2.0 → 2.3.0

package/README.md

@@ -4,7 +4,7 @@ High-Performance Universal Programmatic SEO & Structured Data Engine for Modern
 
 [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
 [![License](https://img.shields.io/badge/License-Proprietary-green.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/Version-2.2.0-orange.svg)](https://www.npmjs.com/package/@lynxflow/seo-engine)
+[![Version](https://img.shields.io/badge/Version-2.3.0-orange.svg)](https://www.npmjs.com/package/@lynxflow/seo-engine)
 
 ---
 

package/dist/above-fold-cro-auditor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 🎯 Above-The-Fold & Landing Page CRO Auditor
+ * Evaluates hero sections and landing page conversion architecture (0-100 Score).
+ * Analyzes Value Proposition clarity, CTA strength, Trust signals, and Friction points.
+ */
+export interface AboveFoldAuditInput {
+    h1: string;
+    subheadline?: string;
+    primaryCtaText: string;
+    primaryCtaUrl?: string;
+    hasTestimonialsOrStars?: boolean;
+    hasRiskReversalOrGuarantee?: boolean;
+    hasCustomerLogos?: boolean;
+    pageContentSnippet?: string;
+}
+export interface CroCriterionResult {
+    name: string;
+    passed: boolean;
+    score: number;
+    feedback: string;
+}
+export interface AboveFoldCroReport {
+    croScore: number;
+    rating: "high_converting" | "solid" | "high_friction";
+    criteria: CroCriterionResult[];
+    recommendedFixes: string[];
+    suggestedHeroVariant: {
+        h1: string;
+        subheadline: string;
+        ctaText: string;
+        reassuranceBadge: string;
+    };
+}
+export declare class AboveFoldCroAuditor {
+    private static readonly STRONG_ACTION_VERBS;
+    private static readonly WEAK_ACTION_VERBS;
+    /**
+     * Audits hero section and returns a comprehensive CRO report.
+     */
+    static auditHero(input: AboveFoldAuditInput): AboveFoldCroReport;
+}

package/dist/context-templates-generator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 📁 Context Templates Generator for AI Coding Agents
+ * Automatically generates production-ready markdown configuration templates
+ * (.claude/ and context/ directories) for Claude Code, Cursor, and Antigravity.
+ */
+export interface BrandContextInput {
+    brandName: string;
+    domain: string;
+    industry: string;
+    coreFeatures: string[];
+    targetAudience: string;
+    primaryKeywords: string[];
+}
+export declare class ContextTemplatesGenerator {
+    /**
+     * Generates a complete bundle of 8 context markdown files tailored to a brand.
+     */
+    static generateAllContextFiles(input: BrandContextInput): Record<string, string>;
+    static generateBrandVoice(input: BrandContextInput): string;
+    static generateFeatures(input: BrandContextInput): string;
+    static generateInternalLinksMap(input: BrandContextInput): string;
+    static generateStyleGuide(input: BrandContextInput): string;
+    static generateTargetKeywords(input: BrandContextInput): string;
+    static generateCompetitorAnalysis(input: BrandContextInput): string;
+    static generateSeoGuidelines(input: BrandContextInput): string;
+    static generateCroBestPractices(input: BrandContextInput): string;
+}

package/dist/humanity-ai-scrubber.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 🧹 Humanity AI Scrubber & Anti-AI Watermark Engine
+ * Detects and removes robotic LLM patterns, clichés, em-dash abuses, and filler phrases.
+ * Computes a rigorous Humanity Score (0-100) and produces humanized copy.
+ */
+export interface AiClichéMatch {
+    pattern: string;
+    count: number;
+    category: "filler_word" | "robotic_intro" | "excessive_punctuation" | "overused_transition";
+    suggestion: string;
+}
+export interface HumanityScrubReport {
+    humanityScore: number;
+    aiProbabilityScore: number;
+    totalWords: number;
+    clichésDetectedCount: number;
+    clichés: AiClichéMatch[];
+    isHumanSounding: boolean;
+    scrubbedText: string;
+    improvementRecommendations: string[];
+}
+export declare class HumanityAiScrubber {
+    private static readonly BANNED_AI_WORDS;
+    private static readonly ROBOTIC_INTROS;
+    /**
+     * Analyzes text and returns a comprehensive Humanity Score and scrubbed output.
+     */
+    static analyzeAndScrub(text: string, language?: string): HumanityScrubReport;
+}

package/dist/index.d.ts

@@ -114,6 +114,11 @@ import { PageRegenerationTracker } from "./generation-tracker";
 import { GoogleIndexingClient } from "./google-indexing-client";
 import { AeoSnippetSynthesizer } from "./aeo-snippet-synthesizer";
 import { SemanticCannibalizationDetector } from "./semantic-cannibalization";
+import { HumanityAiScrubber } from "./humanity-ai-scrubber";
+import { SerpLengthComparator } from "./serp-length-comparator";
+import { PassiveVoiceComplexityAnalyzer } from "./passive-voice-complexity";
+import { AboveFoldCroAuditor } from "./above-fold-cro-auditor";
+import { ContextTemplatesGenerator } from "./context-templates-generator";
 export declare function createLynxSeoEngine(config: EngineConfig): LynxSeoEngine;
 export declare const LynxSeo: {
     createEngine: typeof createLynxSeoEngine;
@@ -125,6 +130,11 @@ export declare const LynxSeo: {
     googleIndexing: typeof GoogleIndexingClient;
     aeoSnippet: typeof AeoSnippetSynthesizer;
     cannibalization: typeof SemanticCannibalizationDetector;
+    humanityScrubber: typeof HumanityAiScrubber;
+    serpLength: typeof SerpLengthComparator;
+    readabilityComplexity: typeof PassiveVoiceComplexityAnalyzer;
+    aboveFoldCro: typeof AboveFoldCroAuditor;
+    contextTemplates: typeof ContextTemplatesGenerator;
     inspectMeta: typeof SiteAuditor.inspectMeta;
     crawlDomain: typeof DeepCrawlerAuditor.crawlAndAuditDomain;
     inspectHtmlSnapshot: typeof DeepCrawlerAuditor.inspectHtmlSnapshot;
@@ -166,6 +176,11 @@ export declare const LynxSeo: {
     marketingSkills: typeof MarketingSkillsEngine;
     regenerationTracker: typeof PageRegenerationTracker;
 };
+export * from "./humanity-ai-scrubber";
+export * from "./serp-length-comparator";
+export * from "./passive-voice-complexity";
+export * from "./above-fold-cro-auditor";
+export * from "./context-templates-generator";
 export * from "./google-indexing-client";
 export * from "./aeo-snippet-synthesizer";
 export * from "./semantic-cannibalization";

package/dist/index.js

@@ -9902,6 +9902,497 @@ class SemanticCannibalizationDetector {
   }
 }
 
+// src/humanity-ai-scrubber.ts
+class HumanityAiScrubber {
+  static BANNED_AI_WORDS = {
+    delve: "explore / look into",
+    delving: "exploring",
+    tapestry: "structure / landscape",
+    testament: "proof / demonstration",
+    pivotal: "key / important",
+    crucial: "essential / vital",
+    foster: "encourage / build",
+    paramount: "primary / top priority",
+    beacon: "leader / reference",
+    unwavering: "solid / steady",
+    leverage: "use / apply",
+    streamline: "simplify / speed up",
+    revolutionize: "transform",
+    groundbreaking: "innovative",
+    moreover: "also / additionally",
+    furthermore: "also",
+    "in summary": "to wrap up",
+    "in conclusion": "finally / in short"
+  };
+  static ROBOTIC_INTROS = [
+    /in today['’]s fast-paced (digital )?(world|landscape|era)/i,
+    /in an era where (technology|digital|ai)/i,
+    /it is important to remember that/i,
+    /when it comes to (managing|growing|scaling)/i,
+    /it is crucial to understand that/i,
+    /look no further than/i
+  ];
+  static analyzeAndScrub(text, language = "en") {
+    if (!text || text.trim().length === 0) {
+      return {
+        humanityScore: 100,
+        aiProbabilityScore: 0,
+        totalWords: 0,
+        clichésDetectedCount: 0,
+        clichés: [],
+        isHumanSounding: true,
+        scrubbedText: "",
+        improvementRecommendations: []
+      };
+    }
+    let scrubbed = text;
+    const words = text.split(/\s+/).filter(Boolean);
+    const totalWords = words.length;
+    const clich_s = [];
+    const recommendations = [];
+    for (const [word, replacement] of Object.entries(this.BANNED_AI_WORDS)) {
+      const regex = new RegExp(`\\b${word}\\b`, "gi");
+      const matches = text.match(regex);
+      if (matches && matches.length > 0) {
+        clich_s.push({
+          pattern: word,
+          count: matches.length,
+          category: "filler_word",
+          suggestion: `Replace with "${replacement}"`
+        });
+        scrubbed = scrubbed.replace(regex, replacement.split(" / ")[0]);
+      }
+    }
+    for (const introRegex of this.ROBOTIC_INTROS) {
+      if (introRegex.test(text)) {
+        clich_s.push({
+          pattern: introRegex.source,
+          count: 1,
+          category: "robotic_intro",
+          suggestion: "Delete cliché opening sentence. Start immediately with the core problem or direct value."
+        });
+        scrubbed = scrubbed.replace(introRegex, "");
+      }
+    }
+    const emDashCount = (text.match(/—|--/g) || []).length;
+    if (emDashCount > Math.max(2, Math.floor(totalWords / 250))) {
+      clich_s.push({
+        pattern: "Em-dash (—)",
+        count: emDashCount,
+        category: "excessive_punctuation",
+        suggestion: "Reduce em-dashes (—). Replace with simple commas, colons, or clean periods."
+      });
+      scrubbed = scrubbed.replace(/\s*—\s*/g, ", ").replace(/\s*--\s*/g, ", ");
+    }
+    const totalViolations = clich_s.reduce((acc, c) => acc + c.count, 0);
+    const penalty = Math.min(80, totalViolations * 8);
+    const humanityScore = Math.max(15, 100 - penalty);
+    const aiProbabilityScore = 100 - humanityScore;
+    const isHumanSounding = humanityScore >= 80;
+    if (humanityScore < 80) {
+      recommendations.push("Replace detected filler words with conversational, direct vocabulary.");
+    }
+    if (emDashCount > 2) {
+      recommendations.push("Lower punctuation density (em-dashes and semicolons) to sound more natural.");
+    }
+    if (clich_s.some((c) => c.category === "robotic_intro")) {
+      recommendations.push("Hook the reader immediately in the first 5 words without generic preamble.");
+    }
+    return {
+      humanityScore,
+      aiProbabilityScore,
+      totalWords,
+      clichésDetectedCount: totalViolations,
+      clichés: clich_s,
+      isHumanSounding,
+      scrubbedText: scrubbed.trim(),
+      improvementRecommendations: recommendations
+    };
+  }
+}
+
+// src/serp-length-comparator.ts
+class SerpLengthComparator {
+  static compareLength(userWordCount, targetQuery, competitors) {
+    const comps = competitors && competitors.length > 0 ? competitors : [
+      { url: "https://competitor1.com/guide", rank: 1, wordCount: 2850 },
+      { url: "https://competitor2.com/article", rank: 2, wordCount: 2420 },
+      { url: "https://competitor3.com/blog", rank: 3, wordCount: 3100 },
+      { url: "https://competitor4.com/overview", rank: 4, wordCount: 1950 },
+      { url: "https://competitor5.com/tutorial", rank: 5, wordCount: 2200 },
+      { url: "https://competitor6.com/review", rank: 6, wordCount: 1800 },
+      { url: "https://competitor7.com/best-tools", rank: 7, wordCount: 2600 },
+      { url: "https://competitor8.com/strategies", rank: 8, wordCount: 1750 },
+      { url: "https://competitor9.com/case-study", rank: 9, wordCount: 1600 },
+      { url: "https://competitor10.com/list", rank: 10, wordCount: 2100 }
+    ];
+    const sortedCounts = comps.map((c) => c.wordCount).sort((a, b) => a - b);
+    const count = sortedCounts.length;
+    const min = sortedCounts[0];
+    const max = sortedCounts[count - 1];
+    const median = sortedCounts[Math.floor(count / 2)];
+    const p75 = sortedCounts[Math.floor(count * 0.75)];
+    const top3 = comps.filter((c) => c.rank <= 3);
+    const top3Average = Math.round(top3.reduce((acc, c) => acc + c.wordCount, 0) / Math.max(1, top3.length));
+    const recommendedTargetWords = Math.round(Math.max(median, top3Average) * 1.1);
+    const gapToTarget = recommendedTargetWords - userWordCount;
+    let status = "optimal";
+    let actionPlan = `Content length is aligned with top-ranking competitors (Recommended: ~${recommendedTargetWords} words).`;
+    if (gapToTarget > 300) {
+      status = "insufficient";
+      actionPlan = `Content has a deficit of ${gapToTarget} words compared to top 3 SERP average (~${top3Average} words). Expand with 2-3 detailed sub-sections, case studies, or step-by-step FAQs.`;
+    } else if (gapToTarget < -1500) {
+      status = "excessive";
+      actionPlan = `Content exceeds the 75th percentile by ${Math.abs(gapToTarget)} words. Ensure there is no fluff; split into a pillar hub or prune repetitive paragraphs.`;
+    }
+    return {
+      userWordCount,
+      targetQuery,
+      competitorCount: comps.length,
+      competitors: comps,
+      stats: {
+        min,
+        max,
+        median,
+        p75,
+        top3Average,
+        recommendedTargetWords
+      },
+      gapToTarget,
+      status,
+      actionPlan
+    };
+  }
+}
+
+// src/passive-voice-complexity.ts
+class PassiveVoiceComplexityAnalyzer {
+  static PASSIVE_PATTERNS = {
+    en: [
+      /\b(is|are|was|were|been|being|be)\s+([a-z]+ed|built|written|made|done|seen|found|given|taken|chosen)\b/i,
+      /\bby\s+(the|a|an|our|their|users|google)\b/i
+    ],
+    fr: [
+      /\b(est|sont|a été|ont été|étant|fut|seront)\s+([a-z]+é|[a-z]+ée|[a-z]+és|[a-z]+ées|fait|pris|écrit|construit)\b/i,
+      /\bpar\s+(le|la|les|un|une|des|notre)\b/i
+    ],
+    es: [
+      /\b(es|son|fue|fueron|sido|siendo)\s+([a-z]+ado|[a-z]+ados|[a-z]+ada|[a-z]+adas|hecho|escrito|visto)\b/i,
+      /\bpor\s+(el|la|los|las|un|una)\b/i
+    ],
+    de: [
+      /\b(wird|wurden|wurde|worden|geworden)\s+([a-z]+t|[a-z]+en)\b/i,
+      /\bvon\s+(dem|der|den|einem|einer)\b/i
+    ]
+  };
+  static analyze(text, language = "en") {
+    if (!text || text.trim().length === 0) {
+      return {
+        totalSentences: 0,
+        totalWords: 0,
+        averageWordsPerSentence: 0,
+        passiveVoiceRatio: 0,
+        passiveSentencesCount: 0,
+        complexSentencesCount: 0,
+        gradeLevelEstimate: 0,
+        readabilityEaseScore: 100,
+        status: "clear_and_punchy",
+        keyWarnings: [],
+        sentences: []
+      };
+    }
+    const rawSentences = text.replace(/([.?!])\s*(?=[A-Z0-9À-ÖØ-ß])/g, "$1|").split("|").map((s) => s.trim()).filter((s) => s.length > 3);
+    const patterns = this.PASSIVE_PATTERNS[language] || this.PASSIVE_PATTERNS.en;
+    const sentenceDetails = [];
+    let totalWords = 0;
+    let passiveCount = 0;
+    let complexCount = 0;
+    for (const sentence of rawSentences) {
+      const words = sentence.split(/\s+/).filter(Boolean);
+      const wCount = words.length;
+      totalWords += wCount;
+      const isPassive = patterns.some((regex) => regex.test(sentence));
+      const isTooLong = wCount > 22;
+      if (isPassive)
+        passiveCount++;
+      if (isTooLong)
+        complexCount++;
+      sentenceDetails.push({
+        text: sentence,
+        wordCount: wCount,
+        isPassive,
+        isTooLong
+      });
+    }
+    const totalSentences = Math.max(1, rawSentences.length);
+    const avgWordsPerSentence = Math.round(totalWords / totalSentences * 10) / 10;
+    const passiveVoiceRatio = Math.round(passiveCount / totalSentences * 100) / 100;
+    const syllableEstimate = totalWords * 1.4;
+    const ease = Math.max(10, Math.min(100, Math.round(206.835 - 1.015 * avgWordsPerSentence - 84.6 * (syllableEstimate / totalWords))));
+    const gradeLevel = Math.max(4, Math.round(0.39 * avgWordsPerSentence + 11.8 * (syllableEstimate / totalWords) - 15.59));
+    const warnings = [];
+    if (passiveVoiceRatio > 0.15) {
+      warnings.push(`Passive voice is ${Math.round(passiveVoiceRatio * 100)}% (Target: < 10%). Convert passive constructions to active voice.`);
+    }
+    if (complexCount > totalSentences * 0.25) {
+      warnings.push(`${complexCount} sentences exceed 22 words. Break long compound sentences into shorter, punchier statements.`);
+    }
+    if (avgWordsPerSentence > 18) {
+      warnings.push(`Average sentence length is ${avgWordsPerSentence} words (Target: 12-16 words).`);
+    }
+    let status = "clear_and_punchy";
+    if (ease < 50 || passiveVoiceRatio > 0.2) {
+      status = "hard_to_read";
+    } else if (ease < 65 || passiveVoiceRatio > 0.12) {
+      status = "acceptable";
+    }
+    return {
+      totalSentences,
+      totalWords,
+      averageWordsPerSentence: avgWordsPerSentence,
+      passiveVoiceRatio,
+      passiveSentencesCount: passiveCount,
+      complexSentencesCount: complexCount,
+      gradeLevelEstimate: gradeLevel,
+      readabilityEaseScore: ease,
+      status,
+      keyWarnings: warnings,
+      sentences: sentenceDetails
+    };
+  }
+}
+
+// src/above-fold-cro-auditor.ts
+class AboveFoldCroAuditor {
+  static STRONG_ACTION_VERBS = [
+    /start/i,
+    /get/i,
+    /try/i,
+    /claim/i,
+    /launch/i,
+    /boost/i,
+    /automate/i,
+    /démarrer/i,
+    /essayer/i,
+    /obtenir/i,
+    /profiter/i,
+    /iniciar/i,
+    /probar/i,
+    /jetzt/i,
+    /kostenlos/i
+  ];
+  static WEAK_ACTION_VERBS = [
+    /^submit$/i,
+    /^click here$/i,
+    /^learn more$/i,
+    /^envoyer$/i,
+    /^cliquez ici$/i,
+    /^en savoir plus$/i,
+    /^weiter$/i,
+    /^leer más$/i
+  ];
+  static auditHero(input) {
+    const criteria = [];
+    const fixes = [];
+    const h1Words = input.h1.trim().split(/\s+/).length;
+    const isH1Clear = h1Words >= 4 && h1Words <= 14;
+    let h1Score = isH1Clear ? 25 : 12;
+    if (!isH1Clear) {
+      fixes.push("Optimize H1 length between 4 and 12 words. Make the specific outcome and audience explicit.");
+    }
+    criteria.push({
+      name: "Headline Clarity & Value Proposition",
+      passed: isH1Clear,
+      score: h1Score,
+      feedback: isH1Clear ? "Headline is concise, outcome-oriented, and immediately readable in < 3 seconds." : "Headline is either too vague (< 4 words) or too dense (> 14 words)."
+    });
+    const hasStrongVerb = this.STRONG_ACTION_VERBS.some((r) => r.test(input.primaryCtaText));
+    const hasWeakVerb = this.WEAK_ACTION_VERBS.some((r) => r.test(input.primaryCtaText.trim()));
+    const isCtaEffective = hasStrongVerb && !hasWeakVerb;
+    let ctaScore = isCtaEffective ? 25 : hasWeakVerb ? 5 : 15;
+    if (!isCtaEffective) {
+      fixes.push(`Replace generic CTA "${input.primaryCtaText}" with an outcome-focused action verb (e.g. "Start Free Trial", "Get Instant Access", "Démarrer Gratuitement").`);
+    }
+    criteria.push({
+      name: "Primary CTA Contrast & Action Verb",
+      passed: isCtaEffective,
+      score: ctaScore,
+      feedback: isCtaEffective ? `CTA "${input.primaryCtaText}" uses a strong, high-conversion action trigger.` : `CTA "${input.primaryCtaText}" lacks urgency or is too generic.`
+    });
+    const hasProof = Boolean(input.hasTestimonialsOrStars || input.hasCustomerLogos);
+    let proofScore = hasProof ? 20 : 0;
+    if (!hasProof) {
+      fixes.push("Add social proof above the fold (e.g. 'Rated 4.9/5 by 1,200+ teams' or client logos).");
+    }
+    criteria.push({
+      name: "Above-the-Fold Social Proof & Ratings",
+      passed: hasProof,
+      score: proofScore,
+      feedback: hasProof ? "Trust signals and social proof are visible immediately above the fold." : "Missing social proof above the fold. Increases visitor bounce risk."
+    });
+    const hasReversal = Boolean(input.hasRiskReversalOrGuarantee);
+    let reversalScore = hasReversal ? 20 : 5;
+    if (!hasReversal) {
+      fixes.push("Add a friction-killer under the CTA (e.g. 'No credit card required • Cancel anytime • 14-day free trial').");
+    }
+    criteria.push({
+      name: "Risk Reversal & Friction Elimination",
+      passed: hasReversal,
+      score: reversalScore,
+      feedback: hasReversal ? "Zero-risk micro-copy present under the main action trigger." : "No risk reversal micro-copy found under CTA."
+    });
+    const subWords = (input.subheadline || "").trim().split(/\s+/).length;
+    const isSubheadlineSolid = subWords >= 8 && subWords <= 30;
+    let subScore = isSubheadlineSolid ? 10 : 5;
+    if (!isSubheadlineSolid) {
+      fixes.push("Add a supporting subheadline (12-25 words) explaining HOW the product solves the pain point.");
+    }
+    criteria.push({
+      name: "Subheadline Supporting Context",
+      passed: isSubheadlineSolid,
+      score: subScore,
+      feedback: isSubheadlineSolid ? "Subheadline reinforces the value proposition with concrete details." : "Subheadline is missing or insufficient."
+    });
+    const croScore = h1Score + ctaScore + proofScore + reversalScore + subScore;
+    const rating = croScore >= 80 ? "high_converting" : croScore >= 55 ? "solid" : "high_friction";
+    return {
+      croScore,
+      rating,
+      criteria,
+      recommendedFixes: fixes,
+      suggestedHeroVariant: {
+        h1: input.h1.includes("—") ? input.h1 : `${input.h1} — Built for Fast Growing Teams`,
+        subheadline: input.subheadline || "Automate operational workflows, boost organic search traffic, and cut manual workload in half with instant setup.",
+        ctaText: "Start Free Trial — Instant Setup",
+        reassuranceBadge: "No credit card required • 14-day trial • 100% Free migration"
+      }
+    };
+  }
+}
+
+// src/context-templates-generator.ts
+class ContextTemplatesGenerator {
+  static generateAllContextFiles(input) {
+    return {
+      "context/brand-voice.md": this.generateBrandVoice(input),
+      "context/features.md": this.generateFeatures(input),
+      "context/internal-links-map.md": this.generateInternalLinksMap(input),
+      "context/style-guide.md": this.generateStyleGuide(input),
+      "context/target-keywords.md": this.generateTargetKeywords(input),
+      "context/competitor-analysis.md": this.generateCompetitorAnalysis(input),
+      "context/seo-guidelines.md": this.generateSeoGuidelines(input),
+      "context/cro-best-practices.md": this.generateCroBestPractices(input)
+    };
+  }
+  static generateBrandVoice(input) {
+    return `# Brand Voice & Messaging Framework — ${input.brandName}
+
+## 1. Core Voice Pillars
+- **Authoritative yet Approachable:** Speak with deep domain expertise in ${input.industry}, without academic jargon.
+- **Direct & Action-Oriented:** Get straight to the solution in the first 5 words. No fluff or generic preambles.
+- **Outcome-Focused:** Emphasize time saved, revenue recovered, and operational ease for ${input.targetAudience}.
+
+## 2. Terminology & Word Preferences
+- **Preferred Words:** Streamlined, automated, verified, instant, high-performance, precision.
+- **Banned Words:** Delve, tapestry, testament, crucial, groundbreaking, revolutionize, in today's fast-paced world.
+
+## 3. Core Audience
+- **Primary Persona:** ${input.targetAudience}
+- **Primary Domain:** ${input.domain}
+`.trim();
+  }
+  static generateFeatures(input) {
+    const list = input.coreFeatures.map((f) => `- **${f}:** Enterprise-grade workflow automation and real-time synchronization.`).join(`
+`);
+    return `# Product Features & Capabilities — ${input.brandName}
+
+## 1. Feature Catalog
+${list}
+
+## 2. Competitive Value Proposition
+- Instant setup (< 3 minutes).
+- Zero complex infrastructure requirements.
+- 100% scalable in-memory architecture.
+`.trim();
+  }
+  static generateInternalLinksMap(input) {
+    return `# Internal Links Architecture Map — ${input.domain}
+
+## 1. Core Pillar Hubs
+- **Homepage:** \`${input.domain}/\` (Anchor: "${input.brandName}", "${input.industry} Software")
+- **Solutions & PSEO Hub:** \`${input.domain}/solutions\` (Anchor: "Explore all solutions", "Platform features")
+- **Pricing & Plans:** \`${input.domain}/pricing\` (Anchor: "View pricing plans", "Compare tiers")
+- **Free Tools:** \`${input.domain}/tools\` (Anchor: "Free interactive calculators", "SEO tools")
+
+## 2. Linking Best Practices
+- Add 3-5 relevant internal links per 2,000 words.
+- Use descriptive, keyword-rich anchor text rather than "click here".
+`.trim();
+  }
+  static generateStyleGuide(input) {
+    return `# Editorial & Style Guide — ${input.brandName}
+
+## 1. Formatting Rules
+- **Sentence Length:** 12 to 18 words on average. Never exceed 24 words in a single sentence.
+- **Paragraphs:** 2 to 4 sentences maximum for high mobile readability.
+- **Subheadings:** Introduce an H2 or H3 every 250-350 words.
+- **Punctuation:** Limit em-dashes (—) to 1 per 500 words. Use clear periods and commas.
+
+## 2. Readability Target
+- **Flesch Reading Ease:** 65 to 80.
+- **Reading Level:** 7th to 9th grade.
+`.trim();
+  }
+  static generateTargetKeywords(input) {
+    const kwList = input.primaryKeywords.map((k) => `- \`${k}\` (Intent: Commercial/Transactional)`).join(`
+`);
+    return `# Target Keywords & Topic Clusters — ${input.brandName}
+
+## 1. Primary Keywords
+${kwList}
+
+## 2. Secondary Modifiers & Long-Tail
+- Best ${input.industry} software for ${input.targetAudience}
+- How to automate ${input.industry} workflows in 2026
+- ${input.brandName} pricing and alternatives
+`.trim();
+  }
+  static generateCompetitorAnalysis(input) {
+    return `# Competitor Analysis & Differentiation — ${input.brandName}
+
+## 1. Market Overview
+- **Our Positioning:** The fastest, lightest, in-memory automation platform for ${input.industry}.
+- **Key Differentiator:** 100% cloud-native, sub-millisecond response time, no heavy legacy bloat.
+
+## 2. Comparison Angles
+- Transparent pricing with zero hidden add-on fees.
+- Modern API & MCP integrations (Claude Code, Cursor, Antigravity).
+`.trim();
+  }
+  static generateSeoGuidelines(input) {
+    return `# SEO Technical & On-Page Requirements — ${input.brandName}
+
+## 1. Title & Meta Descriptions
+- **Title Tag:** 50-60 characters, primary keyword in front.
+- **Meta Description:** 140-155 characters, includes value prop and soft CTA.
+
+## 2. Schema.org Graphs
+- Inject valid JSON-LD graph on all programmatic pages (SoftwareApplication, LocalBusiness, FAQPage, Breadcrumbs).
+- Zero syntax errors or missing required fields.
+`.trim();
+  }
+  static generateCroBestPractices(input) {
+    return `# Conversion Rate Optimization (CRO) Standards — ${input.brandName}
+
+## 1. Above-The-Fold Checklist
+- [ ] Clear H1 communicating the specific outcome in < 3 seconds.
+- [ ] High-contrast primary CTA with strong action verb.
+- [ ] Social proof visible without scrolling (star ratings, reviews, client logos).
+- [ ] Risk reversal micro-copy directly beneath the main button ("No credit card required").
+`.trim();
+  }
+}
+
 // src/index.ts
 function createLynxSeoEngine(config) {
   return new LynxSeoEngine(config);
@@ -9916,6 +10407,11 @@ var LynxSeo = {
   googleIndexing: GoogleIndexingClient,
   aeoSnippet: AeoSnippetSynthesizer,
   cannibalization: SemanticCannibalizationDetector,
+  humanityScrubber: HumanityAiScrubber,
+  serpLength: SerpLengthComparator,
+  readabilityComplexity: PassiveVoiceComplexityAnalyzer,
+  aboveFoldCro: AboveFoldCroAuditor,
+  contextTemplates: ContextTemplatesGenerator,
   inspectMeta: SiteAuditor.inspectMeta,
   crawlDomain: DeepCrawlerAuditor.crawlAndAuditDomain,
   inspectHtmlSnapshot: DeepCrawlerAuditor.inspectHtmlSnapshot,
@@ -9984,6 +10480,7 @@ export {
   SocialAdsSocialSeoEngine,
   SiteAuditor,
   SerpRankHistoryEngine,
+  SerpLengthComparator,
   SerpClient,
   SeoOpportunitiesDecayDetector,
   SemanticCannibalizationDetector,
@@ -9996,6 +10493,7 @@ export {
   PublicRoutesManifestEngine,
   PseoMatrixEngine,
   PowerWordsPsychologyEngine,
+  PassiveVoiceComplexityAnalyzer,
   PageRegenerationTracker,
   PSEO_AGENT_SYSTEM_PROMPT,
   OgImageGenerator,
@@ -10024,6 +10522,7 @@ export {
   IndexNowClient,
   I18nDetector,
   HyperswitchGateway,
+  HumanityAiScrubber,
   GoogleIndexingClient,
   GoogleBusinessProfileEngine,
   GeoMeshLinkingEngine,
@@ -10037,6 +10536,7 @@ export {
   CrosslinkScorerEngine,
   CroCopywritingEngine,
   CopywritingFrameworksMaster,
+  ContextTemplatesGenerator,
   CONTENT_AI_40_TOOLS,
   BrandDnaCalendarEngine,
   BacklinksClient,
@@ -10046,5 +10546,6 @@ export {
   AiCopilotClient,
   AiBotsLogAnalyzer,
   AeoSnippetSynthesizer,
-  AdIntelligenceCroEngine
+  AdIntelligenceCroEngine,
+  AboveFoldCroAuditor
 };

package/dist/index.mjs

@@ -9902,6 +9902,497 @@ class SemanticCannibalizationDetector {
   }
 }
 
+// src/humanity-ai-scrubber.ts
+class HumanityAiScrubber {
+  static BANNED_AI_WORDS = {
+    delve: "explore / look into",
+    delving: "exploring",
+    tapestry: "structure / landscape",
+    testament: "proof / demonstration",
+    pivotal: "key / important",
+    crucial: "essential / vital",
+    foster: "encourage / build",
+    paramount: "primary / top priority",
+    beacon: "leader / reference",
+    unwavering: "solid / steady",
+    leverage: "use / apply",
+    streamline: "simplify / speed up",
+    revolutionize: "transform",
+    groundbreaking: "innovative",
+    moreover: "also / additionally",
+    furthermore: "also",
+    "in summary": "to wrap up",
+    "in conclusion": "finally / in short"
+  };
+  static ROBOTIC_INTROS = [
+    /in today['’]s fast-paced (digital )?(world|landscape|era)/i,
+    /in an era where (technology|digital|ai)/i,
+    /it is important to remember that/i,
+    /when it comes to (managing|growing|scaling)/i,
+    /it is crucial to understand that/i,
+    /look no further than/i
+  ];
+  static analyzeAndScrub(text, language = "en") {
+    if (!text || text.trim().length === 0) {
+      return {
+        humanityScore: 100,
+        aiProbabilityScore: 0,
+        totalWords: 0,
+        clichésDetectedCount: 0,
+        clichés: [],
+        isHumanSounding: true,
+        scrubbedText: "",
+        improvementRecommendations: []
+      };
+    }
+    let scrubbed = text;
+    const words = text.split(/\s+/).filter(Boolean);
+    const totalWords = words.length;
+    const clich_s = [];
+    const recommendations = [];
+    for (const [word, replacement] of Object.entries(this.BANNED_AI_WORDS)) {
+      const regex = new RegExp(`\\b${word}\\b`, "gi");
+      const matches = text.match(regex);
+      if (matches && matches.length > 0) {
+        clich_s.push({
+          pattern: word,
+          count: matches.length,
+          category: "filler_word",
+          suggestion: `Replace with "${replacement}"`
+        });
+        scrubbed = scrubbed.replace(regex, replacement.split(" / ")[0]);
+      }
+    }
+    for (const introRegex of this.ROBOTIC_INTROS) {
+      if (introRegex.test(text)) {
+        clich_s.push({
+          pattern: introRegex.source,
+          count: 1,
+          category: "robotic_intro",
+          suggestion: "Delete cliché opening sentence. Start immediately with the core problem or direct value."
+        });
+        scrubbed = scrubbed.replace(introRegex, "");
+      }
+    }
+    const emDashCount = (text.match(/—|--/g) || []).length;
+    if (emDashCount > Math.max(2, Math.floor(totalWords / 250))) {
+      clich_s.push({
+        pattern: "Em-dash (—)",
+        count: emDashCount,
+        category: "excessive_punctuation",
+        suggestion: "Reduce em-dashes (—). Replace with simple commas, colons, or clean periods."
+      });
+      scrubbed = scrubbed.replace(/\s*—\s*/g, ", ").replace(/\s*--\s*/g, ", ");
+    }
+    const totalViolations = clich_s.reduce((acc, c) => acc + c.count, 0);
+    const penalty = Math.min(80, totalViolations * 8);
+    const humanityScore = Math.max(15, 100 - penalty);
+    const aiProbabilityScore = 100 - humanityScore;
+    const isHumanSounding = humanityScore >= 80;
+    if (humanityScore < 80) {
+      recommendations.push("Replace detected filler words with conversational, direct vocabulary.");
+    }
+    if (emDashCount > 2) {
+      recommendations.push("Lower punctuation density (em-dashes and semicolons) to sound more natural.");
+    }
+    if (clich_s.some((c) => c.category === "robotic_intro")) {
+      recommendations.push("Hook the reader immediately in the first 5 words without generic preamble.");
+    }
+    return {
+      humanityScore,
+      aiProbabilityScore,
+      totalWords,
+      clichésDetectedCount: totalViolations,
+      clichés: clich_s,
+      isHumanSounding,
+      scrubbedText: scrubbed.trim(),
+      improvementRecommendations: recommendations
+    };
+  }
+}
+
+// src/serp-length-comparator.ts
+class SerpLengthComparator {
+  static compareLength(userWordCount, targetQuery, competitors) {
+    const comps = competitors && competitors.length > 0 ? competitors : [
+      { url: "https://competitor1.com/guide", rank: 1, wordCount: 2850 },
+      { url: "https://competitor2.com/article", rank: 2, wordCount: 2420 },
+      { url: "https://competitor3.com/blog", rank: 3, wordCount: 3100 },
+      { url: "https://competitor4.com/overview", rank: 4, wordCount: 1950 },
+      { url: "https://competitor5.com/tutorial", rank: 5, wordCount: 2200 },
+      { url: "https://competitor6.com/review", rank: 6, wordCount: 1800 },
+      { url: "https://competitor7.com/best-tools", rank: 7, wordCount: 2600 },
+      { url: "https://competitor8.com/strategies", rank: 8, wordCount: 1750 },
+      { url: "https://competitor9.com/case-study", rank: 9, wordCount: 1600 },
+      { url: "https://competitor10.com/list", rank: 10, wordCount: 2100 }
+    ];
+    const sortedCounts = comps.map((c) => c.wordCount).sort((a, b) => a - b);
+    const count = sortedCounts.length;
+    const min = sortedCounts[0];
+    const max = sortedCounts[count - 1];
+    const median = sortedCounts[Math.floor(count / 2)];
+    const p75 = sortedCounts[Math.floor(count * 0.75)];
+    const top3 = comps.filter((c) => c.rank <= 3);
+    const top3Average = Math.round(top3.reduce((acc, c) => acc + c.wordCount, 0) / Math.max(1, top3.length));
+    const recommendedTargetWords = Math.round(Math.max(median, top3Average) * 1.1);
+    const gapToTarget = recommendedTargetWords - userWordCount;
+    let status = "optimal";
+    let actionPlan = `Content length is aligned with top-ranking competitors (Recommended: ~${recommendedTargetWords} words).`;
+    if (gapToTarget > 300) {
+      status = "insufficient";
+      actionPlan = `Content has a deficit of ${gapToTarget} words compared to top 3 SERP average (~${top3Average} words). Expand with 2-3 detailed sub-sections, case studies, or step-by-step FAQs.`;
+    } else if (gapToTarget < -1500) {
+      status = "excessive";
+      actionPlan = `Content exceeds the 75th percentile by ${Math.abs(gapToTarget)} words. Ensure there is no fluff; split into a pillar hub or prune repetitive paragraphs.`;
+    }
+    return {
+      userWordCount,
+      targetQuery,
+      competitorCount: comps.length,
+      competitors: comps,
+      stats: {
+        min,
+        max,
+        median,
+        p75,
+        top3Average,
+        recommendedTargetWords
+      },
+      gapToTarget,
+      status,
+      actionPlan
+    };
+  }
+}
+
+// src/passive-voice-complexity.ts
+class PassiveVoiceComplexityAnalyzer {
+  static PASSIVE_PATTERNS = {
+    en: [
+      /\b(is|are|was|were|been|being|be)\s+([a-z]+ed|built|written|made|done|seen|found|given|taken|chosen)\b/i,
+      /\bby\s+(the|a|an|our|their|users|google)\b/i
+    ],
+    fr: [
+      /\b(est|sont|a été|ont été|étant|fut|seront)\s+([a-z]+é|[a-z]+ée|[a-z]+és|[a-z]+ées|fait|pris|écrit|construit)\b/i,
+      /\bpar\s+(le|la|les|un|une|des|notre)\b/i
+    ],
+    es: [
+      /\b(es|son|fue|fueron|sido|siendo)\s+([a-z]+ado|[a-z]+ados|[a-z]+ada|[a-z]+adas|hecho|escrito|visto)\b/i,
+      /\bpor\s+(el|la|los|las|un|una)\b/i
+    ],
+    de: [
+      /\b(wird|wurden|wurde|worden|geworden)\s+([a-z]+t|[a-z]+en)\b/i,
+      /\bvon\s+(dem|der|den|einem|einer)\b/i
+    ]
+  };
+  static analyze(text, language = "en") {
+    if (!text || text.trim().length === 0) {
+      return {
+        totalSentences: 0,
+        totalWords: 0,
+        averageWordsPerSentence: 0,
+        passiveVoiceRatio: 0,
+        passiveSentencesCount: 0,
+        complexSentencesCount: 0,
+        gradeLevelEstimate: 0,
+        readabilityEaseScore: 100,
+        status: "clear_and_punchy",
+        keyWarnings: [],
+        sentences: []
+      };
+    }
+    const rawSentences = text.replace(/([.?!])\s*(?=[A-Z0-9À-ÖØ-ß])/g, "$1|").split("|").map((s) => s.trim()).filter((s) => s.length > 3);
+    const patterns = this.PASSIVE_PATTERNS[language] || this.PASSIVE_PATTERNS.en;
+    const sentenceDetails = [];
+    let totalWords = 0;
+    let passiveCount = 0;
+    let complexCount = 0;
+    for (const sentence of rawSentences) {
+      const words = sentence.split(/\s+/).filter(Boolean);
+      const wCount = words.length;
+      totalWords += wCount;
+      const isPassive = patterns.some((regex) => regex.test(sentence));
+      const isTooLong = wCount > 22;
+      if (isPassive)
+        passiveCount++;
+      if (isTooLong)
+        complexCount++;
+      sentenceDetails.push({
+        text: sentence,
+        wordCount: wCount,
+        isPassive,
+        isTooLong
+      });
+    }
+    const totalSentences = Math.max(1, rawSentences.length);
+    const avgWordsPerSentence = Math.round(totalWords / totalSentences * 10) / 10;
+    const passiveVoiceRatio = Math.round(passiveCount / totalSentences * 100) / 100;
+    const syllableEstimate = totalWords * 1.4;
+    const ease = Math.max(10, Math.min(100, Math.round(206.835 - 1.015 * avgWordsPerSentence - 84.6 * (syllableEstimate / totalWords))));
+    const gradeLevel = Math.max(4, Math.round(0.39 * avgWordsPerSentence + 11.8 * (syllableEstimate / totalWords) - 15.59));
+    const warnings = [];
+    if (passiveVoiceRatio > 0.15) {
+      warnings.push(`Passive voice is ${Math.round(passiveVoiceRatio * 100)}% (Target: < 10%). Convert passive constructions to active voice.`);
+    }
+    if (complexCount > totalSentences * 0.25) {
+      warnings.push(`${complexCount} sentences exceed 22 words. Break long compound sentences into shorter, punchier statements.`);
+    }
+    if (avgWordsPerSentence > 18) {
+      warnings.push(`Average sentence length is ${avgWordsPerSentence} words (Target: 12-16 words).`);
+    }
+    let status = "clear_and_punchy";
+    if (ease < 50 || passiveVoiceRatio > 0.2) {
+      status = "hard_to_read";
+    } else if (ease < 65 || passiveVoiceRatio > 0.12) {
+      status = "acceptable";
+    }
+    return {
+      totalSentences,
+      totalWords,
+      averageWordsPerSentence: avgWordsPerSentence,
+      passiveVoiceRatio,
+      passiveSentencesCount: passiveCount,
+      complexSentencesCount: complexCount,
+      gradeLevelEstimate: gradeLevel,
+      readabilityEaseScore: ease,
+      status,
+      keyWarnings: warnings,
+      sentences: sentenceDetails
+    };
+  }
+}
+
+// src/above-fold-cro-auditor.ts
+class AboveFoldCroAuditor {
+  static STRONG_ACTION_VERBS = [
+    /start/i,
+    /get/i,
+    /try/i,
+    /claim/i,
+    /launch/i,
+    /boost/i,
+    /automate/i,
+    /démarrer/i,
+    /essayer/i,
+    /obtenir/i,
+    /profiter/i,
+    /iniciar/i,
+    /probar/i,
+    /jetzt/i,
+    /kostenlos/i
+  ];
+  static WEAK_ACTION_VERBS = [
+    /^submit$/i,
+    /^click here$/i,
+    /^learn more$/i,
+    /^envoyer$/i,
+    /^cliquez ici$/i,
+    /^en savoir plus$/i,
+    /^weiter$/i,
+    /^leer más$/i
+  ];
+  static auditHero(input) {
+    const criteria = [];
+    const fixes = [];
+    const h1Words = input.h1.trim().split(/\s+/).length;
+    const isH1Clear = h1Words >= 4 && h1Words <= 14;
+    let h1Score = isH1Clear ? 25 : 12;
+    if (!isH1Clear) {
+      fixes.push("Optimize H1 length between 4 and 12 words. Make the specific outcome and audience explicit.");
+    }
+    criteria.push({
+      name: "Headline Clarity & Value Proposition",
+      passed: isH1Clear,
+      score: h1Score,
+      feedback: isH1Clear ? "Headline is concise, outcome-oriented, and immediately readable in < 3 seconds." : "Headline is either too vague (< 4 words) or too dense (> 14 words)."
+    });
+    const hasStrongVerb = this.STRONG_ACTION_VERBS.some((r) => r.test(input.primaryCtaText));
+    const hasWeakVerb = this.WEAK_ACTION_VERBS.some((r) => r.test(input.primaryCtaText.trim()));
+    const isCtaEffective = hasStrongVerb && !hasWeakVerb;
+    let ctaScore = isCtaEffective ? 25 : hasWeakVerb ? 5 : 15;
+    if (!isCtaEffective) {
+      fixes.push(`Replace generic CTA "${input.primaryCtaText}" with an outcome-focused action verb (e.g. "Start Free Trial", "Get Instant Access", "Démarrer Gratuitement").`);
+    }
+    criteria.push({
+      name: "Primary CTA Contrast & Action Verb",
+      passed: isCtaEffective,
+      score: ctaScore,
+      feedback: isCtaEffective ? `CTA "${input.primaryCtaText}" uses a strong, high-conversion action trigger.` : `CTA "${input.primaryCtaText}" lacks urgency or is too generic.`
+    });
+    const hasProof = Boolean(input.hasTestimonialsOrStars || input.hasCustomerLogos);
+    let proofScore = hasProof ? 20 : 0;
+    if (!hasProof) {
+      fixes.push("Add social proof above the fold (e.g. 'Rated 4.9/5 by 1,200+ teams' or client logos).");
+    }
+    criteria.push({
+      name: "Above-the-Fold Social Proof & Ratings",
+      passed: hasProof,
+      score: proofScore,
+      feedback: hasProof ? "Trust signals and social proof are visible immediately above the fold." : "Missing social proof above the fold. Increases visitor bounce risk."
+    });
+    const hasReversal = Boolean(input.hasRiskReversalOrGuarantee);
+    let reversalScore = hasReversal ? 20 : 5;
+    if (!hasReversal) {
+      fixes.push("Add a friction-killer under the CTA (e.g. 'No credit card required • Cancel anytime • 14-day free trial').");
+    }
+    criteria.push({
+      name: "Risk Reversal & Friction Elimination",
+      passed: hasReversal,
+      score: reversalScore,
+      feedback: hasReversal ? "Zero-risk micro-copy present under the main action trigger." : "No risk reversal micro-copy found under CTA."
+    });
+    const subWords = (input.subheadline || "").trim().split(/\s+/).length;
+    const isSubheadlineSolid = subWords >= 8 && subWords <= 30;
+    let subScore = isSubheadlineSolid ? 10 : 5;
+    if (!isSubheadlineSolid) {
+      fixes.push("Add a supporting subheadline (12-25 words) explaining HOW the product solves the pain point.");
+    }
+    criteria.push({
+      name: "Subheadline Supporting Context",
+      passed: isSubheadlineSolid,
+      score: subScore,
+      feedback: isSubheadlineSolid ? "Subheadline reinforces the value proposition with concrete details." : "Subheadline is missing or insufficient."
+    });
+    const croScore = h1Score + ctaScore + proofScore + reversalScore + subScore;
+    const rating = croScore >= 80 ? "high_converting" : croScore >= 55 ? "solid" : "high_friction";
+    return {
+      croScore,
+      rating,
+      criteria,
+      recommendedFixes: fixes,
+      suggestedHeroVariant: {
+        h1: input.h1.includes("—") ? input.h1 : `${input.h1} — Built for Fast Growing Teams`,
+        subheadline: input.subheadline || "Automate operational workflows, boost organic search traffic, and cut manual workload in half with instant setup.",
+        ctaText: "Start Free Trial — Instant Setup",
+        reassuranceBadge: "No credit card required • 14-day trial • 100% Free migration"
+      }
+    };
+  }
+}
+
+// src/context-templates-generator.ts
+class ContextTemplatesGenerator {
+  static generateAllContextFiles(input) {
+    return {
+      "context/brand-voice.md": this.generateBrandVoice(input),
+      "context/features.md": this.generateFeatures(input),
+      "context/internal-links-map.md": this.generateInternalLinksMap(input),
+      "context/style-guide.md": this.generateStyleGuide(input),
+      "context/target-keywords.md": this.generateTargetKeywords(input),
+      "context/competitor-analysis.md": this.generateCompetitorAnalysis(input),
+      "context/seo-guidelines.md": this.generateSeoGuidelines(input),
+      "context/cro-best-practices.md": this.generateCroBestPractices(input)
+    };
+  }
+  static generateBrandVoice(input) {
+    return `# Brand Voice & Messaging Framework — ${input.brandName}
+
+## 1. Core Voice Pillars
+- **Authoritative yet Approachable:** Speak with deep domain expertise in ${input.industry}, without academic jargon.
+- **Direct & Action-Oriented:** Get straight to the solution in the first 5 words. No fluff or generic preambles.
+- **Outcome-Focused:** Emphasize time saved, revenue recovered, and operational ease for ${input.targetAudience}.
+
+## 2. Terminology & Word Preferences
+- **Preferred Words:** Streamlined, automated, verified, instant, high-performance, precision.
+- **Banned Words:** Delve, tapestry, testament, crucial, groundbreaking, revolutionize, in today's fast-paced world.
+
+## 3. Core Audience
+- **Primary Persona:** ${input.targetAudience}
+- **Primary Domain:** ${input.domain}
+`.trim();
+  }
+  static generateFeatures(input) {
+    const list = input.coreFeatures.map((f) => `- **${f}:** Enterprise-grade workflow automation and real-time synchronization.`).join(`
+`);
+    return `# Product Features & Capabilities — ${input.brandName}
+
+## 1. Feature Catalog
+${list}
+
+## 2. Competitive Value Proposition
+- Instant setup (< 3 minutes).
+- Zero complex infrastructure requirements.
+- 100% scalable in-memory architecture.
+`.trim();
+  }
+  static generateInternalLinksMap(input) {
+    return `# Internal Links Architecture Map — ${input.domain}
+
+## 1. Core Pillar Hubs
+- **Homepage:** \`${input.domain}/\` (Anchor: "${input.brandName}", "${input.industry} Software")
+- **Solutions & PSEO Hub:** \`${input.domain}/solutions\` (Anchor: "Explore all solutions", "Platform features")
+- **Pricing & Plans:** \`${input.domain}/pricing\` (Anchor: "View pricing plans", "Compare tiers")
+- **Free Tools:** \`${input.domain}/tools\` (Anchor: "Free interactive calculators", "SEO tools")
+
+## 2. Linking Best Practices
+- Add 3-5 relevant internal links per 2,000 words.
+- Use descriptive, keyword-rich anchor text rather than "click here".
+`.trim();
+  }
+  static generateStyleGuide(input) {
+    return `# Editorial & Style Guide — ${input.brandName}
+
+## 1. Formatting Rules
+- **Sentence Length:** 12 to 18 words on average. Never exceed 24 words in a single sentence.
+- **Paragraphs:** 2 to 4 sentences maximum for high mobile readability.
+- **Subheadings:** Introduce an H2 or H3 every 250-350 words.
+- **Punctuation:** Limit em-dashes (—) to 1 per 500 words. Use clear periods and commas.
+
+## 2. Readability Target
+- **Flesch Reading Ease:** 65 to 80.
+- **Reading Level:** 7th to 9th grade.
+`.trim();
+  }
+  static generateTargetKeywords(input) {
+    const kwList = input.primaryKeywords.map((k) => `- \`${k}\` (Intent: Commercial/Transactional)`).join(`
+`);
+    return `# Target Keywords & Topic Clusters — ${input.brandName}
+
+## 1. Primary Keywords
+${kwList}
+
+## 2. Secondary Modifiers & Long-Tail
+- Best ${input.industry} software for ${input.targetAudience}
+- How to automate ${input.industry} workflows in 2026
+- ${input.brandName} pricing and alternatives
+`.trim();
+  }
+  static generateCompetitorAnalysis(input) {
+    return `# Competitor Analysis & Differentiation — ${input.brandName}
+
+## 1. Market Overview
+- **Our Positioning:** The fastest, lightest, in-memory automation platform for ${input.industry}.
+- **Key Differentiator:** 100% cloud-native, sub-millisecond response time, no heavy legacy bloat.
+
+## 2. Comparison Angles
+- Transparent pricing with zero hidden add-on fees.
+- Modern API & MCP integrations (Claude Code, Cursor, Antigravity).
+`.trim();
+  }
+  static generateSeoGuidelines(input) {
+    return `# SEO Technical & On-Page Requirements — ${input.brandName}
+
+## 1. Title & Meta Descriptions
+- **Title Tag:** 50-60 characters, primary keyword in front.
+- **Meta Description:** 140-155 characters, includes value prop and soft CTA.
+
+## 2. Schema.org Graphs
+- Inject valid JSON-LD graph on all programmatic pages (SoftwareApplication, LocalBusiness, FAQPage, Breadcrumbs).
+- Zero syntax errors or missing required fields.
+`.trim();
+  }
+  static generateCroBestPractices(input) {
+    return `# Conversion Rate Optimization (CRO) Standards — ${input.brandName}
+
+## 1. Above-The-Fold Checklist
+- [ ] Clear H1 communicating the specific outcome in < 3 seconds.
+- [ ] High-contrast primary CTA with strong action verb.
+- [ ] Social proof visible without scrolling (star ratings, reviews, client logos).
+- [ ] Risk reversal micro-copy directly beneath the main button ("No credit card required").
+`.trim();
+  }
+}
+
 // src/index.ts
 function createLynxSeoEngine(config) {
   return new LynxSeoEngine(config);
@@ -9916,6 +10407,11 @@ var LynxSeo = {
   googleIndexing: GoogleIndexingClient,
   aeoSnippet: AeoSnippetSynthesizer,
   cannibalization: SemanticCannibalizationDetector,
+  humanityScrubber: HumanityAiScrubber,
+  serpLength: SerpLengthComparator,
+  readabilityComplexity: PassiveVoiceComplexityAnalyzer,
+  aboveFoldCro: AboveFoldCroAuditor,
+  contextTemplates: ContextTemplatesGenerator,
   inspectMeta: SiteAuditor.inspectMeta,
   crawlDomain: DeepCrawlerAuditor.crawlAndAuditDomain,
   inspectHtmlSnapshot: DeepCrawlerAuditor.inspectHtmlSnapshot,
@@ -9984,6 +10480,7 @@ export {
   SocialAdsSocialSeoEngine,
   SiteAuditor,
   SerpRankHistoryEngine,
+  SerpLengthComparator,
   SerpClient,
   SeoOpportunitiesDecayDetector,
   SemanticCannibalizationDetector,
@@ -9996,6 +10493,7 @@ export {
   PublicRoutesManifestEngine,
   PseoMatrixEngine,
   PowerWordsPsychologyEngine,
+  PassiveVoiceComplexityAnalyzer,
   PageRegenerationTracker,
   PSEO_AGENT_SYSTEM_PROMPT,
   OgImageGenerator,
@@ -10024,6 +10522,7 @@ export {
   IndexNowClient,
   I18nDetector,
   HyperswitchGateway,
+  HumanityAiScrubber,
   GoogleIndexingClient,
   GoogleBusinessProfileEngine,
   GeoMeshLinkingEngine,
@@ -10037,6 +10536,7 @@ export {
   CrosslinkScorerEngine,
   CroCopywritingEngine,
   CopywritingFrameworksMaster,
+  ContextTemplatesGenerator,
   CONTENT_AI_40_TOOLS,
   BrandDnaCalendarEngine,
   BacklinksClient,
@@ -10046,5 +10546,6 @@ export {
   AiCopilotClient,
   AiBotsLogAnalyzer,
   AeoSnippetSynthesizer,
-  AdIntelligenceCroEngine
+  AdIntelligenceCroEngine,
+  AboveFoldCroAuditor
 };

package/dist/passive-voice-complexity.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ✍️ Readability, Passive Voice & Sentence Complexity Analyzer
+ * Analyzes sentence length variance, passive voice frequency, and paragraph density
+ * across English, French, German, and Spanish.
+ */
+export interface SentenceDetail {
+    text: string;
+    wordCount: number;
+    isPassive: boolean;
+    isTooLong: boolean;
+}
+export interface ReadabilityComplexityReport {
+    totalSentences: number;
+    totalWords: number;
+    averageWordsPerSentence: number;
+    passiveVoiceRatio: number;
+    passiveSentencesCount: number;
+    complexSentencesCount: number;
+    gradeLevelEstimate: number;
+    readabilityEaseScore: number;
+    status: "clear_and_punchy" | "acceptable" | "hard_to_read";
+    keyWarnings: string[];
+    sentences: SentenceDetail[];
+}
+export declare class PassiveVoiceComplexityAnalyzer {
+    private static readonly PASSIVE_PATTERNS;
+    /**
+     * Analyzes text for passive voice, sentence complexity, and readability.
+     */
+    static analyze(text: string, language?: string): ReadabilityComplexityReport;
+}

package/dist/serp-length-comparator.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 📏 SERP Content Length Comparator
+ * Analyzes top 10-20 SERP competitor word counts, computes statistical benchmarks
+ * (Median, 75th Percentile, Top 3 Average), and recommends the optimal content length.
+ */
+export interface CompetitorWordCount {
+    url: string;
+    title?: string;
+    rank: number;
+    wordCount: number;
+}
+export interface SerpLengthAnalysis {
+    userWordCount: number;
+    targetQuery: string;
+    competitorCount: number;
+    competitors: CompetitorWordCount[];
+    stats: {
+        min: number;
+        max: number;
+        median: number;
+        p75: number;
+        top3Average: number;
+        recommendedTargetWords: number;
+    };
+    gapToTarget: number;
+    status: "insufficient" | "optimal" | "excessive";
+    actionPlan: string;
+}
+export declare class SerpLengthComparator {
+    /**
+     * Evaluates content length against real or simulated SERP competitor word counts.
+     */
+    static compareLength(userWordCount: number, targetQuery: string, competitors?: CompetitorWordCount[]): SerpLengthAnalysis;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynxflow/seo-engine",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "High-Performance Universal Programmatic SEO & AI Search Engine SDK",
   "main": "dist/index.js",
   "module": "dist/index.mjs",