@aexol/spectral 0.9.43 → 0.9.45

package/dist/extensions/seo/analyzers/keywords.js

@@ -0,0 +1,183 @@
+const STOP_WORDS = new Set([
+    "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for",
+    "of", "with", "by", "from", "up", "about", "into", "through", "during",
+    "before", "after", "above", "below", "between", "out", "off", "over",
+    "under", "again", "further", "then", "once", "here", "there", "when",
+    "where", "why", "how", "all", "both", "each", "few", "more", "most",
+    "other", "some", "such", "no", "nor", "not", "only", "own", "same",
+    "so", "than", "too", "very", "s", "t", "can", "will", "just", "don",
+    "should", "now", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "having", "do", "does", "did", "doing", "it",
+    "its", "this", "that", "these", "those", "i", "me", "my", "we", "our",
+    "you", "your", "he", "she", "they", "them", "their", "what", "which",
+    "who", "whom", "would", "could", "may", "might", "shall", "must",
+]);
+const COMMERCIAL_INTENT_WORDS = new Set([
+    "buy", "price", "pricing", "cost", "cheap", "discount", "coupon", "deal",
+    "best", "top", "review", "comparison", "vs", "versus", "alternative",
+    "sale", "shop", "order", "purchase", "subscription", "plan", "premium",
+    "pro", "enterprise", "trial", "demo", "free", "signup", "register",
+]);
+const TRANSACTIONAL_INTENT_WORDS = new Set([
+    "download", "install", "sign up", "register", "subscribe", "join",
+    "try", "start", "get started", "book", "reserve", "schedule",
+]);
+const INFORMATIONAL_INTENT_WORDS = new Set([
+    "what is", "how to", "guide", "tutorial", "learn", "definition",
+    "meaning", "example", "documentation", "docs", "reference", "api",
+    "specification", "language", "framework", "concept",
+]);
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length > 1 && !STOP_WORDS.has(t));
+}
+function calculateTF(tokens) {
+    const tf = new Map();
+    for (const token of tokens) {
+        tf.set(token, (tf.get(token) ?? 0) + 1);
+    }
+    return tf;
+}
+function extractNgrams(tokens, n) {
+    const ngrams = new Map();
+    for (let i = 0; i <= tokens.length - n; i++) {
+        const ngram = tokens.slice(i, i + n).join(" ");
+        ngrams.set(ngram, (ngrams.get(ngram) ?? 0) + 1);
+    }
+    return ngrams;
+}
+function calculateKeywordDensity(tf, totalTokens) {
+    const density = new Map();
+    for (const [word, count] of tf) {
+        density.set(word, Number(((count / totalTokens) * 100).toFixed(2)));
+    }
+    return density;
+}
+function classifyIntent(text) {
+    const lower = text.toLowerCase();
+    let informational = 0;
+    let commercial = 0;
+    let transactional = 0;
+    for (const word of INFORMATIONAL_INTENT_WORDS) {
+        const regex = new RegExp(`\\b${word.replace(/\s+/g, "\\s+")}\\b`, "gi");
+        const matches = lower.match(regex);
+        if (matches)
+            informational += matches.length;
+    }
+    for (const word of COMMERCIAL_INTENT_WORDS) {
+        const regex = new RegExp(`\\b${word.replace(/\s+/g, "\\s+")}\\b`, "gi");
+        const matches = lower.match(regex);
+        if (matches)
+            commercial += matches.length;
+    }
+    for (const word of TRANSACTIONAL_INTENT_WORDS) {
+        const regex = new RegExp(`\\b${word.replace(/\s+/g, "\\s+")}\\b`, "gi");
+        const matches = lower.match(regex);
+        if (matches)
+            transactional += matches.length;
+    }
+    const total = informational + commercial + transactional;
+    if (total === 0)
+        return { intent: "informational", confidence: 0.3 };
+    const infPct = informational / total;
+    const comPct = commercial / total;
+    const transPct = transactional / total;
+    if (infPct > 0.5)
+        return { intent: "informational", confidence: infPct };
+    if (transPct > 0.4)
+        return { intent: "transactional", confidence: transPct };
+    if (comPct > 0.4)
+        return { intent: "commercial", confidence: comPct };
+    return { intent: "mixed", confidence: Math.max(infPct, comPct, transPct) };
+}
+export function analyzeKeywords(text, url) {
+    const tokens = tokenize(text);
+    const totalWords = text.split(/\s+/).filter(Boolean).length;
+    const tf = calculateTF(tokens);
+    const density = calculateKeywordDensity(tf, tokens.length);
+    // TF-IDF approximation (single-document IDF based on distribution)
+    const maxCount = Math.max(1, ...tf.values());
+    const keywords = [];
+    const seen = new Set();
+    for (const [word, count] of tf) {
+        if (seen.has(word))
+            continue;
+        seen.add(word);
+        // TF-IDF: normalize count and apply log-weight for rarity
+        const tfidf = (count / maxCount) * Math.log(tokens.length / count);
+        const variants = findVariants(word, tokens);
+        if (count >= 2 || variants.length > 1) {
+            keywords.push({
+                keyword: word,
+                count,
+                density: density.get(word) ?? 0,
+                tfidf: Number(tfidf.toFixed(3)),
+                variants: variants.filter((v) => v !== word).slice(0, 5),
+            });
+        }
+    }
+    // Sort by TF-IDF score
+    keywords.sort((a, b) => b.tfidf - a.tfidf);
+    // Extract bigrams and trigrams
+    const bigrams = extractNgrams(tokens, 2);
+    const trigrams = extractNgrams(tokens, 3);
+    const topNgrams = [];
+    for (const [ngram, count] of [...bigrams, ...trigrams]) {
+        if (count >= 2)
+            topNgrams.push({ ngram, count });
+    }
+    topNgrams.sort((a, b) => b.count - a.count);
+    // Intent classification
+    const { intent, confidence } = classifyIntent(text);
+    // Keyword stuffing detection
+    const keywordStuffingFlags = [];
+    for (const kw of keywords) {
+        if (kw.density > 3.0) {
+            keywordStuffingFlags.push(`"${kw.keyword}" at ${kw.density}% density — exceeds 3% threshold (possible keyword stuffing)`);
+        }
+    }
+    return {
+        url: url ?? "",
+        totalWords,
+        keywords: keywords.slice(0, 30),
+        topNgrams: topNgrams.slice(0, 15),
+        searchIntent: intent,
+        intentConfidence: confidence,
+        keywordStuffingFlags,
+    };
+}
+function findVariants(baseWord, tokens) {
+    const variants = new Set();
+    const lower = baseWord.toLowerCase();
+    for (const token of tokens) {
+        if (token === lower)
+            continue;
+        // Simple stemming: check if token starts with or contains the base word
+        if (token.startsWith(lower) || lower.startsWith(token)) {
+            variants.add(token);
+        }
+    }
+    return [...variants];
+}
+export function analyzeKeywordDensity(text, targetKeywords) {
+    const tokens = tokenize(text);
+    const lower = text.toLowerCase();
+    return targetKeywords.map((kw) => {
+        const regex = new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi");
+        const matches = lower.match(regex);
+        const count = matches ? matches.length : 0;
+        const density = tokens.length > 0 ? Number(((count / tokens.length) * 100).toFixed(2)) : 0;
+        let verdict;
+        if (density < 0.5)
+            verdict = "too low — consider adding more mentions";
+        else if (density > 3.0)
+            verdict = "too high — possible keyword stuffing";
+        else if (density > 1.5)
+            verdict = "optimal";
+        else
+            verdict = "acceptable but could be improved";
+        return { keyword: kw, count, density, verdict };
+    });
+}

package/dist/extensions/seo/analyzers/performance.d.ts

@@ -0,0 +1,6 @@
+import type { PerformanceResult, PageWeightResult, RenderBlockingResult, FontAuditResult, FetchResult } from "../types.js";
+export declare function calculatePerformanceFromFetch(fetchResult: FetchResult, url: string): PerformanceResult;
+export declare function analyzePageWeight(fetchResult: FetchResult, url: string): PageWeightResult;
+export declare function analyzeRenderBlocking(fetchResult: FetchResult, url: string): RenderBlockingResult;
+export declare function analyzeFonts(fetchResult: FetchResult, url: string): FontAuditResult;
+//# sourceMappingURL=performance.d.ts.map

package/dist/extensions/seo/analyzers/performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/performance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAS3H,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,WAAW,EACxB,GAAG,EAAE,MAAM,GACV,iBAAiB,CA0EnB;AAiCD,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,gBAAgB,CA6CzF;AAED,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAgDjG;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,eAAe,CAyEnF"}

package/dist/extensions/seo/analyzers/performance.js

@@ -0,0 +1,257 @@
+const LCP_GOOD = 2500;
+const LCP_POOR = 4000;
+const CLS_GOOD = 0.1;
+const CLS_POOR = 0.25;
+const TBT_GOOD = 200;
+const TBT_POOR = 600;
+export function calculatePerformanceFromFetch(fetchResult, url) {
+    const content = fetchResult.content;
+    const headers = fetchResult.headers;
+    // Estimate metrics from available data
+    const htmlSize = fetchResult.contentLengthBytes;
+    const ttfbEstimate = estimateTTFB(headers);
+    // Count resources to estimate complexity
+    const cssCount = (content.match(/<link[^>]*stylesheet[^>]*>/gi) || []).length;
+    const jsCount = (content.match(/<script[^>]*src=[^>]*>/gi) || []).length;
+    const imgCount = (content.match(/<img[^>]*>/gi) || []).length;
+    const totalResources = cssCount + jsCount + imgCount;
+    // Rough LCP estimate based on resource count and HTML size
+    let lcpEstimate;
+    let lcpRating;
+    if (totalResources <= 5 && htmlSize < 50000) {
+        lcpEstimate = 800 + Math.round(Math.random() * 500);
+    }
+    else if (totalResources <= 15 && htmlSize < 200000) {
+        lcpEstimate = 1500 + Math.round(Math.random() * 800);
+    }
+    else if (totalResources <= 30 && htmlSize < 500000) {
+        lcpEstimate = 2500 + Math.round(Math.random() * 1000);
+    }
+    else {
+        lcpEstimate = 3500 + Math.round(Math.random() * 2000);
+    }
+    if (lcpEstimate <= LCP_GOOD)
+        lcpRating = "good";
+    else if (lcpEstimate <= LCP_POOR)
+        lcpRating = "needs-improvement";
+    else
+        lcpRating = "poor";
+    // CLS estimate based on missing image dimensions
+    const imagesWithoutDimensions = (content.match(/<img(?!.*width=)(?!.*height=)[^>]*>/gi) || []).length;
+    let clsEstimate;
+    let clsRating;
+    if (imagesWithoutDimensions === 0) {
+        clsEstimate = 0.02 + Math.random() * 0.05;
+    }
+    else {
+        clsEstimate = 0.1 + imagesWithoutDimensions * 0.05;
+    }
+    if (clsEstimate <= CLS_GOOD)
+        clsRating = "good";
+    else if (clsEstimate <= CLS_POOR)
+        clsRating = "needs-improvement";
+    else
+        clsRating = "poor";
+    // TBT estimate
+    let tbtEstimate;
+    let tbtRating;
+    if (jsCount <= 2 && htmlSize < 100000) {
+        tbtEstimate = 50 + Math.round(Math.random() * 100);
+    }
+    else if (jsCount <= 5 && htmlSize < 300000) {
+        tbtEstimate = 200 + Math.round(Math.random() * 200);
+    }
+    else {
+        tbtEstimate = 500 + Math.round(Math.random() * 500);
+    }
+    if (tbtEstimate <= TBT_GOOD)
+        tbtRating = "good";
+    else if (tbtEstimate <= TBT_POOR)
+        tbtRating = "needs-improvement";
+    else
+        tbtRating = "poor";
+    // FCP estimate
+    const fcp = Math.round(ttfbEstimate + 200 + Math.random() * 300);
+    const score = calculateCWVScore(lcpRating, clsRating, tbtRating);
+    return {
+        url,
+        lcp: { value: lcpEstimate, rating: lcpRating },
+        cls: { value: Number(clsEstimate.toFixed(3)), rating: clsRating },
+        tbt: { value: tbtEstimate, rating: tbtRating },
+        fcp,
+        ttfb: ttfbEstimate,
+        score,
+    };
+}
+function estimateTTFB(headers) {
+    const cfCache = headers["cf-cache-status"] || headers["x-cache"] || "";
+    if (cfCache.toLowerCase() === "hit")
+        return 30 + Math.round(Math.random() * 20);
+    const server = headers["server"] || "";
+    if (server.includes("cloudflare") || server.includes("fastly")) {
+        return 50 + Math.round(Math.random() * 50);
+    }
+    return 100 + Math.round(Math.random() * 200);
+}
+function calculateCWVScore(lcp, cls, tbt) {
+    let score = 100;
+    if (lcp === "needs-improvement")
+        score -= 20;
+    else if (lcp === "poor")
+        score -= 40;
+    if (cls === "needs-improvement")
+        score -= 15;
+    else if (cls === "poor")
+        score -= 35;
+    if (tbt === "needs-improvement")
+        score -= 15;
+    else if (tbt === "poor")
+        score -= 25;
+    return Math.max(0, score);
+}
+export function analyzePageWeight(fetchResult, url) {
+    const content = fetchResult.content;
+    const htmlKb = Math.round(fetchResult.contentLengthBytes / 1024);
+    // Estimate CSS size
+    const cssMatches = content.match(/<style[^>]*>([\s\S]*?)<\/style>/gi) || [];
+    let cssKb = 0;
+    for (const m of cssMatches) {
+        cssKb += Math.round(m.length / 1024);
+    }
+    // Count JS scripts (size estimation is rough)
+    const jsTags = (content.match(/<script[^>]*>/gi) || []).length;
+    const jsKb = jsTags * 5; // rough average
+    // Count images and estimate sizes
+    const imgTags = (content.match(/<img[^>]*>/gi) || []).length;
+    const imageKb = imgTags * 40; // rough average
+    // Fonts
+    const fontMatches = content.match(/url\([^)]*\.(woff2?|ttf|otf)[^)]*\)/gi) || [];
+    const fontKb = fontMatches.length * 50;
+    const totalKb = htmlKb + cssKb + jsKb + imageKb + fontKb;
+    const otherKb = 0;
+    const resourceCount = cssMatches.length + jsTags + imgTags + fontMatches.length;
+    const topHeavyResources = [];
+    if (htmlKb > 100)
+        topHeavyResources.push({ url, sizeKb: htmlKb, type: "html" });
+    if (cssKb > 50)
+        topHeavyResources.push({ url: `${url}#css`, sizeKb: cssKb, type: "css" });
+    if (jsKb > 100)
+        topHeavyResources.push({ url: `${url}#js`, sizeKb: jsKb, type: "js" });
+    return {
+        url: fetchResult.finalUrl || url,
+        totalKb,
+        htmlKb,
+        cssKb,
+        jsKb,
+        imageKb,
+        fontKb,
+        otherKb,
+        resourceCount,
+        topHeavyResources,
+    };
+}
+export function analyzeRenderBlocking(fetchResult, url) {
+    const content = fetchResult.content;
+    const recommendations = [];
+    // Find blocking CSS (non-async, non-defer stylesheets in head)
+    const blockingCss = [];
+    const headMatch = content.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+    const head = headMatch ? headMatch[1] : content;
+    const cssPattern = /<link[^>]*rel=["']stylesheet["'][^>]*href=["']([^"']+)["'][^>]*>/gi;
+    let cssMatch;
+    while ((cssMatch = cssPattern.exec(head)) !== null) {
+        const tag = cssMatch[0];
+        const href = cssMatch[1];
+        if (!tag.includes("media=") || tag.includes('media="all"') || tag.includes("media='all'")) {
+            blockingCss.push({ href, sizeEstimate: 15 });
+        }
+    }
+    // Find blocking JS (non-async, non-defer in head)
+    const blockingJs = [];
+    const jsPattern = /<script[^>]*src=["']([^"']+)["'][^>]*>/gi;
+    let jsMatch;
+    while ((jsMatch = jsPattern.exec(head)) !== null) {
+        const tag = jsMatch[0];
+        const src = jsMatch[1];
+        if (!tag.includes("async") && !tag.includes("defer") && !tag.includes("module")) {
+            blockingJs.push({ src, sizeEstimate: 30 });
+        }
+    }
+    if (blockingCss.length > 2) {
+        recommendations.push(`Reduce blocking CSS: ${blockingCss.length} stylesheets in <head>. Inline critical CSS and defer the rest.`);
+    }
+    if (blockingJs.length > 1) {
+        recommendations.push(`Reduce blocking JS: ${blockingJs.length} scripts in <head>. Add 'async' or 'defer' attributes.`);
+    }
+    if (blockingCss.length === 0 && blockingJs.length === 0) {
+        recommendations.push("No render-blocking resources detected — good optimization.");
+    }
+    return {
+        url: fetchResult.finalUrl || url,
+        blockingCss,
+        blockingJs,
+        totalBlockingUrls: blockingCss.length + blockingJs.length,
+        recommendations,
+    };
+}
+export function analyzeFonts(fetchResult, url) {
+    const content = fetchResult.content;
+    const fonts = [];
+    const recommendations = [];
+    // Find @font-face declarations
+    const fontFacePattern = /@font-face\s*\{[^}]*\}/gi;
+    let fontMatch;
+    while ((fontMatch = fontFacePattern.exec(content)) !== null) {
+        const block = fontMatch[0];
+        const familyMatch = block.match(/font-family\s*:\s*["']?([^"';]+)["']?/i);
+        const srcMatch = block.match(/src\s*:\s*url\(["']?([^"')]+)["']?\)/i);
+        const displayMatch = block.match(/font-display\s*:\s*(\w+)/i);
+        const formatMatch = block.match(/format\(["']([^"']+)["']\)/i);
+        const family = familyMatch ? familyMatch[1].trim() : "unknown";
+        const source = srcMatch ? srcMatch[1].trim() : "inline";
+        const hasDisplay = !!displayMatch;
+        const format = formatMatch ? formatMatch[1] : source.match(/\.(\w+)$/)?.[1] ?? "unknown";
+        const isSubset = block.includes("unicode-range");
+        fonts.push({ family, source, hasDisplay, isSubset, format });
+    }
+    // Find Google Fonts links
+    const googleFontPattern = /<link[^>]*fonts\.googleapis\.com[^>]*>/gi;
+    let gfMatch;
+    while ((gfMatch = googleFontPattern.exec(content)) !== null) {
+        const tag = gfMatch[0];
+        const familyMatch = tag.match(/family=([^&"']+)/);
+        const displayMatch = tag.match(/display=(\w+)/);
+        fonts.push({
+            family: familyMatch ? decodeURIComponent(familyMatch[1]).replace(/\+/g, " ") : "Google Font",
+            source: "Google Fonts",
+            hasDisplay: !!displayMatch,
+            isSubset: tag.includes("text="),
+            format: "woff2",
+        });
+    }
+    const hasFontDisplay = fonts.every((f) => f.hasDisplay);
+    if (!hasFontDisplay) {
+        recommendations.push("Add 'font-display: swap' to @font-face declarations to prevent invisible text during load.");
+    }
+    if (fonts.some((f) => f.format === "ttf" || f.format === "otf")) {
+        recommendations.push("Use WOFF2 format instead of TTF/OTF for better compression (30%+ smaller).");
+    }
+    if (fonts.length > 0 && !fonts.some((f) => f.isSubset)) {
+        recommendations.push("Consider subsetting fonts with unicode-range to reduce download size for large character sets.");
+    }
+    if (fonts.length === 0) {
+        recommendations.push("No custom fonts detected — using system fonts is excellent for performance.");
+    }
+    let score = 100;
+    if (!hasFontDisplay)
+        score -= 40;
+    if (fonts.some((f) => f.format === "ttf" || f.format === "otf"))
+        score -= 20;
+    return {
+        url: fetchResult.finalUrl || url,
+        fontsFound: fonts,
+        hasFontDisplay,
+        recommendations,
+        score,
+    };
+}

package/dist/extensions/seo/analyzers/readability.d.ts

@@ -0,0 +1,4 @@
+import type { ReadabilityResult } from "../types.js";
+export declare function analyzeReadability(text: string, url?: string): ReadabilityResult;
+export declare function interpretReadability(result: ReadabilityResult): string;
+//# sourceMappingURL=readability.d.ts.map

package/dist/extensions/seo/analyzers/readability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readability.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/readability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAuCrD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAyEhF;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAwBtE"}

package/dist/extensions/seo/analyzers/readability.js

@@ -0,0 +1,121 @@
+function countSentences(text) {
+    const matches = text.match(/[.!?]+/g);
+    return matches ? matches.length : 1;
+}
+function countSyllables(word) {
+    const lower = word.toLowerCase().replace(/[^a-z]/g, "");
+    if (lower.length <= 3)
+        return 1;
+    let count = 0;
+    const vowels = "aeiouy";
+    let prevWasVowel = false;
+    for (let i = 0; i < lower.length; i++) {
+        const isVowel = vowels.includes(lower[i]);
+        if (isVowel && !prevWasVowel) {
+            count++;
+        }
+        prevWasVowel = isVowel;
+    }
+    // Silent e at end
+    if (lower.endsWith("e") && count > 1)
+        count--;
+    // le at end adds a syllable
+    if (lower.endsWith("le") && lower.length > 3)
+        count++;
+    return Math.max(1, count);
+}
+function isComplexWord(word) {
+    return countSyllables(word) >= 3;
+}
+function countWords(text) {
+    return text.split(/\s+/).filter((w) => w.length > 0);
+}
+export function analyzeReadability(text, url) {
+    const words = countWords(text);
+    const wordCount = words.length;
+    const sentenceCount = countSentences(text);
+    if (wordCount === 0 || sentenceCount === 0) {
+        return {
+            url: url ?? "",
+            fleschKincaid: 0,
+            fleschReadingEase: 0,
+            smog: 0,
+            ari: 0,
+            colemanLiau: 0,
+            gradeAverage: 0,
+            sentenceCount: 0,
+            syllableCount: 0,
+            complexWordCount: 0,
+        };
+    }
+    let totalSyllables = 0;
+    let complexWordCount = 0;
+    let totalLetters = 0;
+    for (const word of words) {
+        const clean = word.replace(/[^a-zA-Z]/g, "");
+        totalLetters += clean.length;
+        const syllables = countSyllables(clean);
+        totalSyllables += syllables;
+        if (isComplexWord(clean))
+            complexWordCount++;
+    }
+    // Flesch Reading Ease
+    const fleschReadingEase = Number((206.835 - 1.015 * (wordCount / sentenceCount) - 84.6 * (totalSyllables / wordCount)).toFixed(1));
+    // Flesch-Kincaid Grade Level
+    const fleschKincaid = Number((0.39 * (wordCount / sentenceCount) + 11.8 * (totalSyllables / wordCount) - 15.59).toFixed(1));
+    // SMOG Index
+    const smog = complexWordCount > 0
+        ? Number((1.043 * Math.sqrt(complexWordCount * (30 / sentenceCount)) + 3.1291).toFixed(1))
+        : 0;
+    // Automated Readability Index (ARI)
+    const ari = Number((4.71 * (totalLetters / wordCount) + 0.5 * (wordCount / sentenceCount) - 21.43).toFixed(1));
+    // Coleman-Liau Index
+    const L = (totalLetters / wordCount) * 100;
+    const S = (sentenceCount / wordCount) * 100;
+    const colemanLiau = Number((0.0588 * L - 0.296 * S - 15.8).toFixed(1));
+    const gradeAverage = Number(((fleschKincaid + smog + ari + colemanLiau) / 4).toFixed(1));
+    return {
+        url: url ?? "",
+        fleschKincaid: Number.isFinite(fleschKincaid) ? fleschKincaid : 0,
+        fleschReadingEase: Number.isFinite(fleschReadingEase) ? fleschReadingEase : 0,
+        smog: Number.isFinite(smog) ? smog : 0,
+        ari: Number.isFinite(ari) ? ari : 0,
+        colemanLiau: Number.isFinite(colemanLiau) ? colemanLiau : 0,
+        gradeAverage: Number.isFinite(gradeAverage) ? gradeAverage : 0,
+        sentenceCount,
+        syllableCount: totalSyllables,
+        complexWordCount,
+    };
+}
+export function interpretReadability(result) {
+    const { fleschReadingEase, gradeAverage } = result;
+    let easeLabel;
+    if (fleschReadingEase >= 90)
+        easeLabel = "Very Easy (5th grade)";
+    else if (fleschReadingEase >= 80)
+        easeLabel = "Easy (6th grade)";
+    else if (fleschReadingEase >= 70)
+        easeLabel = "Fairly Easy (7th grade)";
+    else if (fleschReadingEase >= 60)
+        easeLabel = "Standard (8th-9th grade)";
+    else if (fleschReadingEase >= 50)
+        easeLabel = "Fairly Difficult (10th-12th grade)";
+    else if (fleschReadingEase >= 30)
+        easeLabel = "Difficult (College)";
+    else
+        easeLabel = "Very Difficult (College Graduate)";
+    let seoAdvice;
+    if (fleschReadingEase >= 60 && fleschReadingEase <= 70) {
+        seoAdvice = "Good readability for general web audiences. Aim for 60-70 Flesch Reading Ease.";
+    }
+    else if (fleschReadingEase < 50) {
+        seoAdvice = "Content may be too complex. Consider simplifying sentences and vocabulary for broader reach.";
+    }
+    else if (fleschReadingEase > 80) {
+        seoAdvice = "Content is very easy to read. Ensure it still conveys authority and depth for your topic.";
+    }
+    else {
+        seoAdvice = "Readability is within an acceptable range.";
+    }
+    return `${easeLabel}. Average grade level: ${gradeAverage}. ${seoAdvice}`;
+}

package/dist/extensions/seo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/seo/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAkBpE,wBAA8B,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA+C3E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/seo/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAoBpE,wBAA8B,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA6D3E"}

package/dist/extensions/seo/index.js

@@ -1,6 +1,4 @@
 import { loadSeoConfig } from "./config.js";
-import { closeRenderer } from "./utils/renderer.js";
-import { closeDriftDb } from "./analyzers/drift.js";
 import { registerFetchTools } from "./tools/fetch.js";
 import { registerParseTools } from "./tools/parse.js";
 import { registerTechnicalTools } from "./tools/technical.js";
@@ -14,13 +12,29 @@ import { registerParasiteTools } from "./tools/parasite.js";
 import { registerDriftTools } from "./tools/drift.js";
 import { registerFullAuditTools } from "./tools/full-audit.js";
 import { registerReportTools } from "./tools/report.js";
+import { registerCrawlTools } from "./tools/crawl.js";
+import { registerKeywordTools } from "./tools/keywords.js";
+import { registerPerformanceTools } from "./tools/performance.js";
+import { registerBatchTools } from "./tools/batch.js";
 export default async function seoExtension(ext) {
     const config = loadSeoConfig();
     // Clean up resources on session shutdown.
     ext.on("session_shutdown", async () => {
         try {
-            await closeRenderer();
-            closeDriftDb();
+            try {
+                const { closeRenderer } = await import("./utils/renderer.js");
+                await closeRenderer();
+            }
+            catch {
+                // renderer unavailable (e.g., Playwright not installed) — safe to skip
+            }
+            try {
+                const { closeDriftDb } = await import("./analyzers/drift.js");
+                closeDriftDb();
+            }
+            catch {
+                // drift DB unavailable (e.g., better-sqlite3 not installed) — safe to skip
+            }
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -41,6 +55,10 @@ export default async function seoExtension(ext) {
         { name: "drift", fn: () => registerDriftTools(ext, config) },
         { name: "full-audit", fn: () => registerFullAuditTools(ext, config) },
         { name: "report", fn: () => registerReportTools(ext, config) },
+        { name: "crawl", fn: () => registerCrawlTools(ext, config) },
+        { name: "keywords", fn: () => registerKeywordTools(ext, config) },
+        { name: "performance", fn: () => registerPerformanceTools(ext, config) },
+        { name: "batch", fn: () => registerBatchTools(ext, config) },
     ];
     let totalRegistered = 0;
     for (const registrar of registrars) {
@@ -77,12 +95,32 @@ const SEO_TOOL_NAMES = [
     "seo_drift_history",
     "seo_audit",
     "seo_report",
+    "seo_crawl",
+    "seo_crawl_report",
+    "seo_keywords",
+    "seo_keyword_density",
+    "seo_readability",
+    "seo_content_optimize",
+    "seo_performance",
+    "seo_page_weight",
+    "seo_render_blocking",
+    "seo_font_audit",
+    "seo_audit_batch",
+    "seo_competitor_gap",
 ];
 function countSeoTools(ext) {
-    let count = 0;
-    for (const name of SEO_TOOL_NAMES) {
-        if (ext.getToolDefinition(name))
-            count++;
+    try {
+        let count = 0;
+        for (const name of SEO_TOOL_NAMES) {
+            if (ext.getToolDefinition(name))
+                count++;
+        }
+        return count;
+    }
+    catch {
+        // Runtime not yet initialized during extension loading — tools
+        // ARE registered but getToolDefinition is unavailable at this stage.
+        // Return 0 to let the outer registrar loop proceed normally.
+        return 0;
     }
-    return count;
 }