recker 1.0.43 → 1.0.44

package/dist/browser/seo/rules/index.js

@@ -0,0 +1,159 @@
+import { metaRules } from './meta.js';
+import { structuralRules } from './structural.js';
+import { contentRules } from './content.js';
+import { imageRules } from './images.js';
+import { linkRules } from './links.js';
+import { performanceRules } from './performance.js';
+import { technicalRules } from './technical.js';
+import { securityRules } from './security.js';
+import { schemaRules } from './schema.js';
+import { accessibilityRules } from './accessibility.js';
+import { mobileRules } from './mobile.js';
+import { i18nRules } from './i18n.js';
+import { ecommerceRules } from './ecommerce.js';
+import { localRules } from './local.js';
+import { cwvRules } from './cwv.js';
+import { crawlRules } from './crawl.js';
+import { readabilityRules } from './readability.js';
+import { pwaRules } from './pwa.js';
+import { socialRules } from './social.js';
+import { internalLinkingRules } from './internal-linking.js';
+import { bestPracticesRules } from './best-practices.js';
+import { aiSearchRules } from './ai-search.js';
+import { resourceRules } from './resources.js';
+import { technicalAdvancedRules } from './technical-advanced.js';
+import { redirectRules } from './redirects.js';
+import { canonicalRules } from './canonical.js';
+import { analyticsRules } from './analytics.js';
+export * from './types.js';
+export * from './thresholds.js';
+export const ALL_SEO_RULES = [
+    ...metaRules,
+    ...structuralRules,
+    ...contentRules,
+    ...imageRules,
+    ...linkRules,
+    ...performanceRules,
+    ...technicalRules,
+    ...securityRules,
+    ...schemaRules,
+    ...accessibilityRules,
+    ...mobileRules,
+    ...i18nRules,
+    ...ecommerceRules,
+    ...localRules,
+    ...cwvRules,
+    ...crawlRules,
+    ...readabilityRules,
+    ...pwaRules,
+    ...socialRules,
+    ...internalLinkingRules,
+    ...bestPracticesRules,
+    ...aiSearchRules,
+    ...resourceRules,
+    ...technicalAdvancedRules,
+    ...redirectRules,
+    ...canonicalRules,
+    ...analyticsRules,
+];
+export const SCORING_WEIGHTS = {
+    severity: {
+        error: { pass: 10, fail: -15, warn: -10, info: 0 },
+        warning: { pass: 5, fail: -8, warn: -5, info: 0 },
+        info: { pass: 2, fail: -3, warn: -2, info: 0 },
+    },
+    category: {
+        title: 1.5,
+        meta: 1.3,
+        og: 1.0,
+        twitter: 0.8,
+        headings: 1.2,
+        images: 1.0,
+        links: 1.1,
+        content: 1.2,
+        technical: 1.3,
+        security: 0.9,
+        mobile: 1.2,
+        'structured-data': 1.0,
+        performance: 1.4,
+        accessibility: 0.8,
+        'ai-search': 0.7,
+        resources: 1.1,
+        crawlability: 1.3,
+        canonicalization: 1.2,
+    },
+};
+export function calculateWeightedScore(results) {
+    const categoryScores = {};
+    for (const result of results) {
+        const severityWeight = SCORING_WEIGHTS.severity[result.severity];
+        const statusScore = severityWeight[result.status] ?? 0;
+        if (!categoryScores[result.category]) {
+            categoryScores[result.category] = { score: 0, count: 0 };
+        }
+        categoryScores[result.category].score += statusScore;
+        categoryScores[result.category].count++;
+    }
+    let totalScore = 0;
+    let totalWeight = 0;
+    const details = [];
+    for (const [cat, data] of Object.entries(categoryScores)) {
+        const category = cat;
+        const categoryWeight = SCORING_WEIGHTS.category[category] ?? 1;
+        const normalizedScore = data.count > 0 ? data.score / data.count : 0;
+        const weightedScore = normalizedScore * categoryWeight;
+        details.push({ category, score: normalizedScore, weight: categoryWeight });
+        totalScore += weightedScore;
+        totalWeight += categoryWeight;
+    }
+    const maxPossible = 100;
+    const baseScore = 70;
+    const adjustedScore = Math.max(0, Math.min(100, baseScore + totalScore));
+    return { score: Math.round(adjustedScore), maxPossible, details };
+}
+export class SeoRulesEngine {
+    rules;
+    constructor(options = {}) {
+        let rules = [...ALL_SEO_RULES];
+        if (options.categories?.length) {
+            rules = rules.filter((r) => options.categories.includes(r.category));
+        }
+        if (options.excludeCategories?.length) {
+            rules = rules.filter((r) => !options.excludeCategories.includes(r.category));
+        }
+        if (options.rules?.length) {
+            rules = rules.filter((r) => options.rules.includes(r.id));
+        }
+        if (options.excludeRules?.length) {
+            rules = rules.filter((r) => !options.excludeRules.includes(r.id));
+        }
+        if (options.minSeverity) {
+            const severityOrder = ['info', 'warning', 'error'];
+            const minIndex = severityOrder.indexOf(options.minSeverity);
+            rules = rules.filter((r) => severityOrder.indexOf(r.severity) >= minIndex);
+        }
+        this.rules = rules;
+    }
+    evaluate(context) {
+        const results = [];
+        for (const rule of this.rules) {
+            const result = rule.check(context);
+            if (result) {
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    getRules() {
+        return [...this.rules];
+    }
+    getRulesByCategory(category) {
+        return this.rules.filter((r) => r.category === category);
+    }
+    getCategories() {
+        return [...new Set(this.rules.map((r) => r.category))];
+    }
+}
+export function createRulesEngine(options) {
+    return new SeoRulesEngine(options);
+}

package/dist/browser/seo/rules/internal-linking.d.ts

@@ -0,0 +1,2 @@
+import { SeoRule } from './types.js';
+export declare const internalLinkingRules: SeoRule[];

package/dist/browser/seo/rules/internal-linking.js

@@ -0,0 +1,394 @@
+import { createResult } from './types.js';
+export const internalLinkingRules = [
+    {
+        id: 'linking-internal-count',
+        name: 'Internal Link Count',
+        category: 'links',
+        severity: 'warning',
+        description: 'Pages should have a healthy number of internal links',
+        check: (ctx) => {
+            if (ctx.internalLinks === undefined) {
+                return createResult({ id: 'linking-internal-count', name: 'Internal Link Count', category: 'links', severity: 'warning' }, 'info', 'Not applicable (internal links data unavailable)', { recommendation: 'This rule checks internal link count to ensure proper site navigation and link equity distribution' });
+            }
+            const count = ctx.internalLinks;
+            if (count === 0) {
+                return createResult({ id: 'linking-internal-count', name: 'Internal Link Count', category: 'links', severity: 'warning' }, 'warn', 'No internal links found', {
+                    recommendation: 'Add internal links to improve navigation and crawlability',
+                    evidence: {
+                        found: 0,
+                        expected: 'At least 3-5 internal links per page',
+                        impact: 'Pages without internal links are harder to discover and may not pass link equity',
+                    },
+                });
+            }
+            if (count < 3) {
+                return createResult({ id: 'linking-internal-count', name: 'Internal Link Count', category: 'links', severity: 'warning' }, 'info', `Only ${count} internal link(s)`, {
+                    recommendation: 'Consider adding more internal links',
+                    evidence: {
+                        found: count,
+                        expected: 'At least 3-5 internal links',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-internal-count', name: 'Internal Link Count', category: 'links', severity: 'warning' }, 'pass', `${count} internal links`);
+        },
+    },
+    {
+        id: 'linking-internal-ratio',
+        name: 'Internal/External Link Ratio',
+        category: 'links',
+        severity: 'info',
+        description: 'Pages should have more internal than external links',
+        check: (ctx) => {
+            if (ctx.internalLinks === undefined || ctx.externalLinks === undefined) {
+                return createResult({ id: 'linking-internal-ratio', name: 'Internal/External Link Ratio', category: 'links', severity: 'info' }, 'info', 'Not applicable (link data unavailable)', { recommendation: 'This rule checks the balance between internal and external links' });
+            }
+            if (ctx.totalLinks === undefined || ctx.totalLinks === 0) {
+                return createResult({ id: 'linking-internal-ratio', name: 'Internal/External Link Ratio', category: 'links', severity: 'info' }, 'info', 'Not applicable (no links detected)', { recommendation: 'This rule requires at least some links to analyze the internal/external ratio' });
+            }
+            const internal = ctx.internalLinks;
+            const external = ctx.externalLinks;
+            const ratio = internal / (external || 1);
+            if (external > internal && external > 5) {
+                return createResult({ id: 'linking-internal-ratio', name: 'Internal/External Link Ratio', category: 'links', severity: 'info' }, 'info', `More external (${external}) than internal (${internal}) links`, {
+                    recommendation: 'Consider adding more internal links for better link equity',
+                    evidence: {
+                        found: `${internal} internal, ${external} external`,
+                        expected: 'Internal links should exceed external links',
+                        impact: 'External links pass PageRank to other sites',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-internal-ratio', name: 'Internal/External Link Ratio', category: 'links', severity: 'info' }, 'pass', `Ratio: ${ratio.toFixed(1)}:1 (internal:external)`);
+        },
+    },
+    {
+        id: 'linking-anchor-diversity',
+        name: 'Anchor Text Diversity',
+        category: 'links',
+        severity: 'info',
+        description: 'Internal links should use diverse, descriptive anchor text',
+        check: (ctx) => {
+            if (!ctx.allLinks || ctx.allLinks.length === 0) {
+                return createResult({ id: 'linking-anchor-diversity', name: 'Anchor Text Diversity', category: 'links', severity: 'info' }, 'info', 'Not applicable (no links detected)', { recommendation: 'This rule checks anchor text diversity to prevent over-optimization' });
+            }
+            const internalLinks = ctx.allLinks.filter(l => l.type === 'internal');
+            if (internalLinks.length < 3) {
+                return createResult({ id: 'linking-anchor-diversity', name: 'Anchor Text Diversity', category: 'links', severity: 'info' }, 'info', 'Not applicable (insufficient internal links)', { recommendation: 'This rule requires at least 3 internal links to analyze anchor text diversity' });
+            }
+            const anchorCounts = {};
+            for (const link of internalLinks) {
+                const anchor = (link.text || '').toLowerCase().trim();
+                if (anchor && anchor.length > 2) {
+                    anchorCounts[anchor] = (anchorCounts[anchor] || 0) + 1;
+                }
+            }
+            const overused = Object.entries(anchorCounts)
+                .filter(([_, count]) => count >= 3)
+                .map(([anchor, count]) => `"${anchor}" (${count}x)`);
+            if (overused.length > 0) {
+                return createResult({ id: 'linking-anchor-diversity', name: 'Anchor Text Diversity', category: 'links', severity: 'info' }, 'info', `Some anchor texts overused`, {
+                    recommendation: 'Vary anchor text for better SEO signal distribution',
+                    evidence: {
+                        found: overused.slice(0, 3),
+                        impact: 'Repetitive anchors may look spammy to search engines',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-anchor-diversity', name: 'Anchor Text Diversity', category: 'links', severity: 'info' }, 'pass', 'Good anchor text diversity');
+        },
+    },
+    {
+        id: 'linking-deep-links',
+        name: 'Deep Linking',
+        category: 'links',
+        severity: 'info',
+        description: 'Pages should link to deep content, not just homepage',
+        check: (ctx) => {
+            if (!ctx.allLinks || ctx.allLinks.length === 0) {
+                return createResult({ id: 'linking-deep-links', name: 'Deep Linking', category: 'links', severity: 'info' }, 'info', 'Not applicable (no links detected)', { recommendation: 'This rule checks for deep linking patterns to ensure inner pages are properly linked' });
+            }
+            const internalLinks = ctx.allLinks.filter(l => l.type === 'internal');
+            if (internalLinks.length === 0) {
+                return createResult({ id: 'linking-deep-links', name: 'Deep Linking', category: 'links', severity: 'info' }, 'info', 'Not applicable (no internal links detected)', { recommendation: 'This rule requires internal links to analyze deep linking patterns' });
+            }
+            let rootLinks = 0;
+            let deepLinks = 0;
+            for (const link of internalLinks) {
+                try {
+                    const url = new URL(link.href, ctx.url);
+                    if (url.pathname === '/' || url.pathname === '') {
+                        rootLinks++;
+                    }
+                    else {
+                        deepLinks++;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            const deepRatio = deepLinks / internalLinks.length;
+            if (rootLinks > deepLinks && internalLinks.length > 5) {
+                return createResult({ id: 'linking-deep-links', name: 'Deep Linking', category: 'links', severity: 'info' }, 'info', `Most internal links go to homepage`, {
+                    recommendation: 'Add more links to inner pages',
+                    evidence: {
+                        found: `${rootLinks} homepage links, ${deepLinks} deep links`,
+                        expected: 'More deep links than homepage links',
+                        impact: 'Deep linking improves crawlability of inner pages',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-deep-links', name: 'Deep Linking', category: 'links', severity: 'info' }, 'pass', `${Math.round(deepRatio * 100)}% deep links`);
+        },
+    },
+    {
+        id: 'linking-nav-links',
+        name: 'Navigation Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Check for proper navigation link structure',
+        check: (ctx) => {
+            if (!ctx.hasNav) {
+                return createResult({ id: 'linking-nav-links', name: 'Navigation Links', category: 'links', severity: 'info' }, 'info', 'Not applicable (no navigation element detected)', { recommendation: 'This rule checks navigation link structure when a <nav> element is present' });
+            }
+            if (ctx.navLinkCount === undefined) {
+                return createResult({ id: 'linking-nav-links', name: 'Navigation Links', category: 'links', severity: 'info' }, 'info', 'Not applicable (navigation link count unavailable)', { recommendation: 'This rule checks the number of links in navigation elements' });
+            }
+            if (ctx.navLinkCount === 0) {
+                return createResult({ id: 'linking-nav-links', name: 'Navigation Links', category: 'links', severity: 'info' }, 'warn', 'Navigation element has no links', {
+                    recommendation: 'Add links to navigation for user experience and SEO',
+                    evidence: {
+                        found: '<nav> element with no links',
+                        expected: 'Navigation should contain meaningful links',
+                    },
+                });
+            }
+            if (ctx.navLinkCount > 20) {
+                return createResult({ id: 'linking-nav-links', name: 'Navigation Links', category: 'links', severity: 'info' }, 'info', `Navigation has ${ctx.navLinkCount} links (high)`, {
+                    recommendation: 'Consider simplifying navigation',
+                    evidence: {
+                        found: ctx.navLinkCount,
+                        expected: 'Under 20 links for optimal UX',
+                        impact: 'Too many nav links may dilute link equity',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-nav-links', name: 'Navigation Links', category: 'links', severity: 'info' }, 'pass', `${ctx.navLinkCount} navigation links`);
+        },
+    },
+    {
+        id: 'linking-footer-links',
+        name: 'Footer Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Footer should contain important site-wide links',
+        check: (ctx) => {
+            if (!ctx.hasFooter) {
+                return createResult({ id: 'linking-footer-links', name: 'Footer Links', category: 'links', severity: 'info' }, 'info', 'Not applicable (no footer element detected)', { recommendation: 'This rule checks footer link structure when a <footer> element is present' });
+            }
+            if (ctx.footerLinkCount === undefined) {
+                return createResult({ id: 'linking-footer-links', name: 'Footer Links', category: 'links', severity: 'info' }, 'info', 'Not applicable (footer link count unavailable)', { recommendation: 'This rule checks the number of links in footer elements' });
+            }
+            if (ctx.footerLinkCount === 0) {
+                return createResult({ id: 'linking-footer-links', name: 'Footer Links', category: 'links', severity: 'info' }, 'info', 'Footer has no links', {
+                    recommendation: 'Add important links to footer',
+                    evidence: {
+                        expected: 'Links to privacy policy, terms, contact, sitemap',
+                    },
+                });
+            }
+            if (ctx.footerLinkCount > 50) {
+                return createResult({ id: 'linking-footer-links', name: 'Footer Links', category: 'links', severity: 'info' }, 'info', `Footer has ${ctx.footerLinkCount} links (excessive)`, {
+                    recommendation: 'Reduce footer links to essential pages',
+                    evidence: {
+                        found: ctx.footerLinkCount,
+                        impact: 'Excessive footer links may be seen as link spam',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-footer-links', name: 'Footer Links', category: 'links', severity: 'info' }, 'pass', `${ctx.footerLinkCount} footer links`);
+        },
+    },
+    {
+        id: 'linking-contextual',
+        name: 'Contextual Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Check for in-content contextual links',
+        check: (ctx) => {
+            if (ctx.contextualLinkCount === undefined) {
+                return createResult({ id: 'linking-contextual', name: 'Contextual Links', category: 'links', severity: 'info' }, 'info', 'Not applicable (contextual link count unavailable)', { recommendation: 'This rule checks for in-content contextual links that pass more link equity' });
+            }
+            if (!ctx.wordCount || ctx.wordCount < 300) {
+                return createResult({ id: 'linking-contextual', name: 'Contextual Links', category: 'links', severity: 'info' }, 'info', 'Not applicable (insufficient content for contextual link analysis)', { recommendation: 'This rule requires at least 300 words to analyze contextual link patterns' });
+            }
+            const count = ctx.contextualLinkCount;
+            if (count === 0) {
+                return createResult({ id: 'linking-contextual', name: 'Contextual Links', category: 'links', severity: 'info' }, 'info', 'No contextual links in content', {
+                    recommendation: 'Add links within body content to related pages',
+                    evidence: {
+                        expected: 'At least 2-3 contextual links per 500 words',
+                        impact: 'Contextual links pass more link equity than navigation links',
+                    },
+                });
+            }
+            const linksPerWords = (count / ctx.wordCount) * 500;
+            if (linksPerWords < 1 && ctx.wordCount > 500) {
+                return createResult({ id: 'linking-contextual', name: 'Contextual Links', category: 'links', severity: 'info' }, 'info', `Only ${count} contextual link(s) in ${ctx.wordCount} words`, {
+                    recommendation: 'Add more in-content links',
+                    evidence: {
+                        found: `${linksPerWords.toFixed(1)} links per 500 words`,
+                        expected: '2-3 links per 500 words',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-contextual', name: 'Contextual Links', category: 'links', severity: 'info' }, 'pass', `${count} contextual links`);
+        },
+    },
+    {
+        id: 'linking-orphan-page',
+        name: 'Orphan Page Detection',
+        category: 'links',
+        severity: 'warning',
+        description: 'Pages should be linked from other pages on the site',
+        check: (ctx) => {
+            if (ctx.incomingInternalLinks === undefined) {
+                return createResult({ id: 'linking-orphan-page', name: 'Orphan Page Detection', category: 'links', severity: 'warning' }, 'info', 'Not applicable (incoming internal links data unavailable)', { recommendation: 'This rule checks if pages receive incoming internal links to prevent orphan pages' });
+            }
+            if (ctx.incomingInternalLinks === 0) {
+                return createResult({ id: 'linking-orphan-page', name: 'Orphan Page Detection', category: 'links', severity: 'warning' }, 'warn', 'Page may be an orphan (no incoming internal links)', {
+                    recommendation: 'Link to this page from other pages on your site',
+                    evidence: {
+                        found: '0 incoming internal links detected',
+                        impact: 'Orphan pages are harder for search engines to discover',
+                        learnMore: 'https://ahrefs.com/blog/orphan-pages/',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-orphan-page', name: 'Orphan Page Detection', category: 'links', severity: 'warning' }, 'pass', `${ctx.incomingInternalLinks} incoming internal link(s)`);
+        },
+    },
+    {
+        id: 'linking-self-referencing',
+        name: 'Self-Referencing Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Avoid excessive self-referencing links',
+        check: (ctx) => {
+            if (ctx.selfReferencingLinks === undefined) {
+                return createResult({ id: 'linking-self-referencing', name: 'Self-Referencing Links', category: 'links', severity: 'info' }, 'info', 'Not applicable (self-referencing links data unavailable)', { recommendation: 'This rule checks for excessive self-referencing links that waste crawl budget' });
+            }
+            if (ctx.selfReferencingLinks > 3) {
+                return createResult({ id: 'linking-self-referencing', name: 'Self-Referencing Links', category: 'links', severity: 'info' }, 'info', `${ctx.selfReferencingLinks} self-referencing links`, {
+                    recommendation: 'Reduce links that point to the current page',
+                    evidence: {
+                        found: ctx.selfReferencingLinks,
+                        expected: '0-1 self-referencing links (e.g., canonical only)',
+                        impact: 'Self-links waste crawl budget and confuse users',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-self-referencing', name: 'Self-Referencing Links', category: 'links', severity: 'info' }, 'info', 'Not applicable (acceptable self-referencing link count)', { recommendation: 'Self-referencing links are acceptable at current level (0-3 links)' });
+        },
+    },
+    {
+        id: 'linking-broken-internal',
+        name: 'Broken Internal Links',
+        category: 'links',
+        severity: 'error',
+        description: 'Internal links should not be broken',
+        check: (ctx) => {
+            if (ctx.brokenInternalLinks === undefined) {
+                return createResult({ id: 'linking-broken-internal', name: 'Broken Internal Links', category: 'links', severity: 'error' }, 'info', 'Not applicable (broken internal links data unavailable)', { recommendation: 'This rule checks for broken internal links that harm user experience and waste crawl budget' });
+            }
+            if (ctx.brokenInternalLinks.length > 0) {
+                return createResult({ id: 'linking-broken-internal', name: 'Broken Internal Links', category: 'links', severity: 'error' }, 'fail', `${ctx.brokenInternalLinks.length} broken internal link(s)`, {
+                    recommendation: 'Fix or remove broken internal links',
+                    evidence: {
+                        found: ctx.brokenInternalLinks.slice(0, 5),
+                        expected: '0 broken links',
+                        impact: 'Broken links waste crawl budget and harm user experience',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-broken-internal', name: 'Broken Internal Links', category: 'links', severity: 'error' }, 'pass', 'No broken internal links');
+        },
+    },
+    {
+        id: 'linking-redirect-chains',
+        name: 'Redirect Chains',
+        category: 'links',
+        severity: 'warning',
+        description: 'Internal links should not go through redirect chains',
+        check: (ctx) => {
+            if (ctx.redirectChainLinks === undefined) {
+                return createResult({ id: 'linking-redirect-chains', name: 'Redirect Chains', category: 'links', severity: 'warning' }, 'info', 'Not applicable (redirect chain data unavailable)', { recommendation: 'This rule checks for redirect chains that slow crawling and lose link equity' });
+            }
+            if (ctx.redirectChainLinks.length > 0) {
+                return createResult({ id: 'linking-redirect-chains', name: 'Redirect Chains', category: 'links', severity: 'warning' }, 'warn', `${ctx.redirectChainLinks.length} link(s) go through redirects`, {
+                    recommendation: 'Update links to point to final destination URLs',
+                    evidence: {
+                        found: ctx.redirectChainLinks.slice(0, 5).map(r => `${r.from} → ${r.to} (${r.hops} hops)`),
+                        expected: '0 redirect chain links',
+                        impact: 'Redirect chains slow down crawling and lose link equity',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-redirect-chains', name: 'Redirect Chains', category: 'links', severity: 'warning' }, 'pass', 'No redirect chain links');
+        },
+    },
+    {
+        id: 'linking-nofollow-internal',
+        name: 'Nofollow Internal Links',
+        category: 'links',
+        severity: 'warning',
+        description: 'Internal links should not use nofollow',
+        check: (ctx) => {
+            if (!ctx.allLinks) {
+                return createResult({ id: 'linking-nofollow-internal', name: 'Nofollow Internal Links', category: 'links', severity: 'warning' }, 'info', 'Not applicable (links data unavailable)', { recommendation: 'This rule checks for nofollow attributes on internal links which waste PageRank' });
+            }
+            const nofollowInternal = ctx.allLinks.filter(l => l.type === 'internal' && l.rel?.includes('nofollow'));
+            if (nofollowInternal.length > 0) {
+                return createResult({ id: 'linking-nofollow-internal', name: 'Nofollow Internal Links', category: 'links', severity: 'warning' }, 'warn', `${nofollowInternal.length} internal link(s) have nofollow`, {
+                    recommendation: 'Remove nofollow from internal links',
+                    evidence: {
+                        found: nofollowInternal.slice(0, 3).map(l => l.href),
+                        impact: 'Nofollow on internal links wastes PageRank',
+                        learnMore: 'https://developers.google.com/search/docs/crawling-indexing/qualify-outbound-links',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-nofollow-internal', name: 'Nofollow Internal Links', category: 'links', severity: 'warning' }, 'pass', 'No nofollow on internal links');
+        },
+    },
+    {
+        id: 'linking-click-depth',
+        name: 'Click Depth',
+        category: 'links',
+        severity: 'info',
+        description: 'Important pages should be reachable in few clicks',
+        check: (ctx) => {
+            if (ctx.pageClickDepth === undefined) {
+                return createResult({ id: 'linking-click-depth', name: 'Click Depth', category: 'links', severity: 'info' }, 'info', 'Not applicable (click depth data unavailable)', { recommendation: 'This rule checks how many clicks from homepage, affecting crawl priority and link equity' });
+            }
+            const depth = ctx.pageClickDepth;
+            if (depth > 4) {
+                return createResult({ id: 'linking-click-depth', name: 'Click Depth', category: 'links', severity: 'info' }, 'warn', `Page is ${depth} clicks from homepage`, {
+                    recommendation: 'Improve site architecture for better accessibility',
+                    evidence: {
+                        found: `${depth} clicks deep`,
+                        expected: 'Under 4 clicks from homepage',
+                        impact: 'Deep pages receive less crawl priority and link equity',
+                    },
+                });
+            }
+            if (depth > 3) {
+                return createResult({ id: 'linking-click-depth', name: 'Click Depth', category: 'links', severity: 'info' }, 'info', `Page is ${depth} clicks from homepage`, {
+                    recommendation: 'Consider adding shortcuts to this page',
+                });
+            }
+            return createResult({ id: 'linking-click-depth', name: 'Click Depth', category: 'links', severity: 'info' }, 'pass', `${depth} click(s) from homepage`);
+        },
+    },
+];

package/dist/browser/seo/rules/links.d.ts

@@ -0,0 +1,2 @@
+import { SeoRule } from './types.js';
+export declare const linkRules: SeoRule[];