recker 1.0.30 → 1.0.32-next.02f2bae

package/dist/seo/rules/canonical.js

@@ -0,0 +1,249 @@
+import { createResult } from './types.js';
+export const canonicalRules = [
+    {
+        id: 'canonical-present',
+        name: 'Canonical Tag Present',
+        category: 'canonicalization',
+        severity: 'warning',
+        description: 'Pages should have a canonical URL defined',
+        check: (ctx) => {
+            if (ctx.hasCanonical === undefined)
+                return null;
+            if (!ctx.hasCanonical) {
+                return createResult({ id: 'canonical-present', name: 'Canonical Tag Present', category: 'canonicalization', severity: 'warning' }, 'warn', 'Page is missing canonical tag', {
+                    recommendation: 'Add <link rel="canonical" href="..."> to specify the preferred URL',
+                    evidence: {
+                        expected: '<link rel="canonical" href="https://example.com/page">',
+                        impact: 'Without canonical, search engines may index duplicate versions'
+                    }
+                });
+            }
+            return createResult({ id: 'canonical-present', name: 'Canonical Tag Present', category: 'canonicalization', severity: 'warning' }, 'pass', 'Canonical tag is present');
+        },
+    },
+    {
+        id: 'canonical-multiple',
+        name: 'Multiple Canonical Tags',
+        category: 'canonicalization',
+        severity: 'error',
+        description: 'Page should have only one canonical tag',
+        check: (ctx) => {
+            if (ctx.canonicalCount === undefined)
+                return null;
+            if (ctx.canonicalCount > 1) {
+                return createResult({ id: 'canonical-multiple', name: 'Multiple Canonical Tags', category: 'canonicalization', severity: 'error' }, 'fail', `Page has ${ctx.canonicalCount} canonical tags`, {
+                    value: ctx.canonicalCount,
+                    recommendation: 'Remove duplicate canonical tags; keep only one',
+                    evidence: {
+                        found: ctx.canonicalUrls || [],
+                        expected: 'Single canonical tag',
+                        impact: 'Multiple canonicals confuse search engines about preferred URL'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'canonical-self-referencing',
+        name: 'Canonical Self-Reference',
+        category: 'canonicalization',
+        severity: 'info',
+        description: 'Canonical should typically point to the current page URL',
+        check: (ctx) => {
+            if (!ctx.canonicalUrl || !ctx.url)
+                return null;
+            const isSelfReferencing = normalizeUrl(ctx.canonicalUrl) === normalizeUrl(ctx.url);
+            if (!isSelfReferencing) {
+                return createResult({ id: 'canonical-self-referencing', name: 'Canonical Self-Reference', category: 'canonicalization', severity: 'info' }, 'info', 'Canonical points to different URL', {
+                    recommendation: 'Verify this is intentional canonicalization',
+                    evidence: {
+                        found: ctx.canonicalUrl,
+                        expected: ctx.url,
+                        impact: 'This page signals to search engines that another URL is preferred'
+                    }
+                });
+            }
+            return createResult({ id: 'canonical-self-referencing', name: 'Canonical Self-Reference', category: 'canonicalization', severity: 'info' }, 'pass', 'Canonical is self-referencing');
+        },
+    },
+    {
+        id: 'canonical-broken',
+        name: 'Broken Canonical URL',
+        category: 'canonicalization',
+        severity: 'error',
+        description: 'Canonical URL should be accessible (not 404)',
+        check: (ctx) => {
+            if (ctx.canonicalStatus === undefined)
+                return null;
+            if (ctx.canonicalStatus === 404) {
+                return createResult({ id: 'canonical-broken', name: 'Broken Canonical URL', category: 'canonicalization', severity: 'error' }, 'fail', 'Canonical URL returns 404', {
+                    value: ctx.canonicalUrl,
+                    recommendation: 'Fix canonical to point to an existing, accessible page',
+                    evidence: {
+                        found: `${ctx.canonicalUrl} → 404`,
+                        expected: '200 OK',
+                        impact: 'Broken canonical prevents proper indexing'
+                    }
+                });
+            }
+            if (ctx.canonicalStatus >= 400) {
+                return createResult({ id: 'canonical-broken', name: 'Broken Canonical URL', category: 'canonicalization', severity: 'error' }, 'fail', `Canonical URL returns error (${ctx.canonicalStatus})`, {
+                    value: ctx.canonicalUrl,
+                    recommendation: 'Fix canonical to point to an accessible page',
+                    evidence: {
+                        found: `${ctx.canonicalUrl} → ${ctx.canonicalStatus}`,
+                        expected: '200 OK',
+                        impact: 'Canonical errors prevent proper indexing'
+                    }
+                });
+            }
+            if (ctx.canonicalStatus >= 300 && ctx.canonicalFinalUrl) {
+                return createResult({ id: 'canonical-broken', name: 'Broken Canonical URL', category: 'canonicalization', severity: 'error' }, 'warn', 'Canonical URL redirects', {
+                    value: ctx.canonicalUrl,
+                    recommendation: 'Update canonical to final destination URL',
+                    evidence: {
+                        found: `${ctx.canonicalUrl} → ${ctx.canonicalFinalUrl}`,
+                        expected: 'Direct URL without redirect',
+                        impact: 'Canonical redirects waste crawl budget'
+                    }
+                });
+            }
+            return createResult({ id: 'canonical-broken', name: 'Broken Canonical URL', category: 'canonicalization', severity: 'error' }, 'pass', 'Canonical URL is accessible');
+        },
+    },
+    {
+        id: 'canonical-protocol',
+        name: 'Canonical Protocol',
+        category: 'canonicalization',
+        severity: 'warning',
+        description: 'Canonical should use HTTPS protocol',
+        check: (ctx) => {
+            if (!ctx.canonicalUrl)
+                return null;
+            if (ctx.canonicalUrl.startsWith('http://')) {
+                return createResult({ id: 'canonical-protocol', name: 'Canonical Protocol', category: 'canonicalization', severity: 'warning' }, 'warn', 'Canonical uses HTTP instead of HTTPS', {
+                    value: ctx.canonicalUrl,
+                    recommendation: 'Update canonical to use HTTPS',
+                    evidence: {
+                        found: ctx.canonicalUrl,
+                        expected: ctx.canonicalUrl.replace('http://', 'https://'),
+                        impact: 'HTTP canonicals may cause indexing preference issues'
+                    }
+                });
+            }
+            return createResult({ id: 'canonical-protocol', name: 'Canonical Protocol', category: 'canonicalization', severity: 'warning' }, 'pass', 'Canonical uses HTTPS');
+        },
+    },
+    {
+        id: 'canonical-absolute',
+        name: 'Canonical Absolute URL',
+        category: 'canonicalization',
+        severity: 'warning',
+        description: 'Canonical URL should be absolute, not relative',
+        check: (ctx) => {
+            if (!ctx.canonicalUrl)
+                return null;
+            const isRelative = !ctx.canonicalUrl.startsWith('http://') &&
+                !ctx.canonicalUrl.startsWith('https://') &&
+                !ctx.canonicalUrl.startsWith('//');
+            if (isRelative) {
+                return createResult({ id: 'canonical-absolute', name: 'Canonical Absolute URL', category: 'canonicalization', severity: 'warning' }, 'warn', 'Canonical URL is relative', {
+                    value: ctx.canonicalUrl,
+                    recommendation: 'Use absolute URL including protocol and domain',
+                    evidence: {
+                        found: ctx.canonicalUrl,
+                        expected: 'https://example.com/page',
+                        impact: 'Relative canonicals may be misinterpreted by crawlers'
+                    }
+                });
+            }
+            return createResult({ id: 'canonical-absolute', name: 'Canonical Absolute URL', category: 'canonicalization', severity: 'warning' }, 'pass', 'Canonical URL is absolute');
+        },
+    },
+    {
+        id: 'canonical-chain',
+        name: 'Canonical Chain',
+        category: 'canonicalization',
+        severity: 'warning',
+        description: 'Canonical should not create chains',
+        check: (ctx) => {
+            if (ctx.canonicalChainLength === undefined)
+                return null;
+            if (ctx.canonicalChainLength > 1) {
+                return createResult({ id: 'canonical-chain', name: 'Canonical Chain', category: 'canonicalization', severity: 'warning' }, 'warn', `Canonical chain detected (${ctx.canonicalChainLength} hops)`, {
+                    value: ctx.canonicalChainLength,
+                    recommendation: 'Update canonical to point directly to final canonical URL',
+                    evidence: {
+                        found: ctx.canonicalChain || [],
+                        expected: 'Direct canonical to final URL',
+                        impact: 'Canonical chains may cause consolidation issues'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'canonical-parameters',
+        name: 'Canonical Query Parameters',
+        category: 'canonicalization',
+        severity: 'info',
+        description: 'Canonical URLs with query parameters should be intentional',
+        check: (ctx) => {
+            if (!ctx.canonicalUrl)
+                return null;
+            try {
+                const url = new URL(ctx.canonicalUrl);
+                if (url.search && url.search.length > 1) {
+                    return createResult({ id: 'canonical-parameters', name: 'Canonical Query Parameters', category: 'canonicalization', severity: 'info' }, 'info', 'Canonical contains query parameters', {
+                        value: ctx.canonicalUrl,
+                        recommendation: 'Verify query parameters in canonical are intentional',
+                        evidence: {
+                            found: url.search,
+                            impact: 'Query parameters in canonicals may indicate tracking or filtering'
+                        }
+                    });
+                }
+            }
+            catch {
+            }
+            return null;
+        },
+    },
+    {
+        id: 'canonical-noindex-conflict',
+        name: 'Canonical + Noindex Conflict',
+        category: 'canonicalization',
+        severity: 'warning',
+        description: 'Pages with noindex should not have canonical to indexed page',
+        check: (ctx) => {
+            if (!ctx.hasCanonical || ctx.metaRobots === undefined)
+                return null;
+            const robots = Array.isArray(ctx.metaRobots) ? ctx.metaRobots : [ctx.metaRobots];
+            const hasNoindex = robots.some(r => r.toLowerCase().includes('noindex'));
+            if (hasNoindex && ctx.canonicalUrl) {
+                const isSelfReferencing = ctx.url && normalizeUrl(ctx.canonicalUrl) === normalizeUrl(ctx.url);
+                if (isSelfReferencing) {
+                    return createResult({ id: 'canonical-noindex-conflict', name: 'Canonical + Noindex Conflict', category: 'canonicalization', severity: 'warning' }, 'warn', 'Page has both noindex and self-referencing canonical', {
+                        recommendation: 'Remove canonical or noindex - conflicting signals',
+                        evidence: {
+                            found: `noindex + canonical to self (${ctx.canonicalUrl})`,
+                            impact: 'Google ignores noindex if page has canonical to itself'
+                        }
+                    });
+                }
+            }
+            return null;
+        },
+    },
+];
+function normalizeUrl(url) {
+    try {
+        const u = new URL(url);
+        return `${u.protocol}//${u.hostname}${u.pathname.replace(/\/$/, '')}${u.search}`.toLowerCase();
+    }
+    catch {
+        return url.toLowerCase();
+    }
+}

package/dist/seo/rules/crawl.js

@@ -304,4 +304,117 @@ export const crawlRules = [
             return null;
         },
     },
+    {
+        id: 'robots-txt-exists',
+        name: 'robots.txt Exists',
+        category: 'crawlability',
+        severity: 'info',
+        description: 'Website should have a robots.txt file',
+        check: (ctx) => {
+            if (ctx.robotsTxtExists === undefined)
+                return null;
+            if (!ctx.robotsTxtExists) {
+                return createResult({ id: 'robots-txt-exists', name: 'robots.txt Exists', category: 'crawlability', severity: 'info' }, 'info', 'No robots.txt file found', {
+                    recommendation: 'Create a robots.txt file to control search engine crawling',
+                    evidence: {
+                        expected: '/robots.txt',
+                        impact: 'Without robots.txt, search engines will crawl everything by default',
+                        learnMore: 'https://developers.google.com/search/docs/crawling-indexing/robots/intro'
+                    }
+                });
+            }
+            return createResult({ id: 'robots-txt-exists', name: 'robots.txt Exists', category: 'crawlability', severity: 'info' }, 'pass', 'robots.txt file exists');
+        },
+    },
+    {
+        id: 'sitemap-in-robots',
+        name: 'Sitemap Reference in robots.txt',
+        category: 'crawlability',
+        severity: 'warning',
+        description: 'robots.txt should reference sitemap.xml location',
+        check: (ctx) => {
+            if (ctx.robotsTxtHasSitemap === undefined)
+                return null;
+            if (!ctx.robotsTxtHasSitemap) {
+                return createResult({ id: 'sitemap-in-robots', name: 'Sitemap Reference in robots.txt', category: 'crawlability', severity: 'warning' }, 'warn', 'robots.txt does not reference sitemap.xml', {
+                    recommendation: 'Add sitemap location to robots.txt',
+                    evidence: {
+                        expected: 'Sitemap: https://example.com/sitemap.xml',
+                        impact: 'Search engines may not discover your sitemap automatically',
+                        learnMore: 'https://developers.google.com/search/docs/crawling-indexing/sitemaps/build-sitemap'
+                    }
+                });
+            }
+            return createResult({ id: 'sitemap-in-robots', name: 'Sitemap Reference in robots.txt', category: 'crawlability', severity: 'warning' }, 'pass', 'Sitemap is referenced in robots.txt');
+        },
+    },
+    {
+        id: 'blocked-resources',
+        name: 'Blocked Resources',
+        category: 'crawlability',
+        severity: 'warning',
+        description: 'CSS/JS resources should not be blocked by robots.txt',
+        check: (ctx) => {
+            if (ctx.blockedResources === undefined)
+                return null;
+            if (ctx.blockedResources > 0) {
+                return createResult({ id: 'blocked-resources', name: 'Blocked Resources', category: 'crawlability', severity: 'warning' }, 'warn', `${ctx.blockedResources} resources blocked by robots.txt`, {
+                    value: ctx.blockedResources,
+                    recommendation: 'Update robots.txt to allow crawling of CSS and JS files',
+                    evidence: {
+                        found: `${ctx.blockedResources} blocked resources`,
+                        expected: 'CSS, JS, and image files should be crawlable',
+                        impact: 'Blocked resources prevent proper page rendering and indexing',
+                        learnMore: 'https://developers.google.com/search/docs/crawling-indexing/robots/intro'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'x-robots-tag-noindex',
+        name: 'X-Robots-Tag Noindex',
+        category: 'crawlability',
+        severity: 'warning',
+        description: 'X-Robots-Tag should not block important pages',
+        check: (ctx) => {
+            if (!ctx.xRobotsTag)
+                return null;
+            const tag = ctx.xRobotsTag.toLowerCase();
+            if (tag.includes('noindex')) {
+                return createResult({ id: 'x-robots-tag-noindex', name: 'X-Robots-Tag Noindex', category: 'crawlability', severity: 'warning' }, 'warn', 'Page blocked by X-Robots-Tag: noindex', {
+                    value: ctx.xRobotsTag,
+                    recommendation: 'Verify this page should not be indexed; remove X-Robots-Tag if unintentional',
+                    evidence: {
+                        found: `X-Robots-Tag: ${ctx.xRobotsTag}`,
+                        impact: 'This page will not appear in search results'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'blocked-external-resources',
+        name: 'Blocked External Resources',
+        category: 'crawlability',
+        severity: 'info',
+        description: 'External resources blocked by robots.txt may affect rendering',
+        check: (ctx) => {
+            if (ctx.blockedExternalResources === undefined)
+                return null;
+            if (ctx.blockedExternalResources > 0) {
+                return createResult({ id: 'blocked-external-resources', name: 'Blocked External Resources', category: 'crawlability', severity: 'info' }, 'info', `${ctx.blockedExternalResources} external resources blocked by robots.txt`, {
+                    value: ctx.blockedExternalResources,
+                    recommendation: 'Verify blocked resources are not critical for page rendering',
+                    evidence: {
+                        found: `${ctx.blockedExternalResources} blocked external resources`,
+                        impact: 'If critical resources are blocked, search engines may not render pages correctly'
+                    }
+                });
+            }
+            return null;
+        },
+    },
 ];

package/dist/seo/rules/cwv.js

@@ -152,36 +152,6 @@ export const cwvRules = [
             return null;
         },
     },
-    {
-        id: 'cwv-cls-dynamic-content',
-        name: 'Dynamic Content Space',
-        category: 'performance',
-        severity: 'info',
-        description: 'Reserve space for dynamically injected content',
-        check: (ctx) => {
-            const potentialShifts = [];
-            if (ctx.hasAdsWithoutReservedSpace) {
-                potentialShifts.push('Ads without reserved space');
-            }
-            if (ctx.hasBannersWithoutMinHeight) {
-                potentialShifts.push('Banners/alerts without min-height');
-            }
-            if (ctx.hasInfiniteScroll) {
-                potentialShifts.push('Infinite scroll may cause shifts');
-            }
-            if (potentialShifts.length > 0) {
-                return createResult({ id: 'cwv-cls-dynamic-content', name: 'Dynamic Content Space', category: 'performance', severity: 'info' }, 'info', 'Potential layout shift sources detected', {
-                    recommendation: 'Reserve space for dynamic content with min-height or skeleton loaders',
-                    evidence: {
-                        found: potentialShifts,
-                        example: '.ad-slot { min-height: 250px; }',
-                        impact: 'Dynamic content is a major source of CLS',
-                    },
-                });
-            }
-            return null;
-        },
-    },
     {
         id: 'cwv-cls-font-fallback',
         name: 'Font Fallback Metrics',
@@ -210,71 +180,6 @@ export const cwvRules = [
             return null;
         },
     },
-    {
-        id: 'cwv-inp-main-thread',
-        name: 'Main Thread Blocking',
-        category: 'performance',
-        severity: 'warning',
-        description: 'Large inline scripts can block the main thread',
-        check: (ctx) => {
-            if (ctx.largeInlineScripts === undefined)
-                return null;
-            if (ctx.largeInlineScripts > 0) {
-                return createResult({ id: 'cwv-inp-main-thread', name: 'Main Thread Blocking', category: 'performance', severity: 'warning' }, 'warn', `${ctx.largeInlineScripts} large inline script(s) may block main thread`, {
-                    recommendation: 'Move large scripts to external files with defer',
-                    evidence: {
-                        found: `${ctx.largeInlineScripts} inline scripts > 10KB`,
-                        expected: 'Small inline scripts only for critical initialization',
-                        impact: 'Large scripts block main thread and delay interactions',
-                        learnMore: 'https://web.dev/optimize-inp/',
-                    },
-                });
-            }
-            return null;
-        },
-    },
-    {
-        id: 'cwv-inp-event-handlers',
-        name: 'Inline Event Handlers',
-        category: 'performance',
-        severity: 'info',
-        description: 'Avoid inline event handlers for better performance',
-        check: (ctx) => {
-            if (ctx.inlineEventHandlers === undefined)
-                return null;
-            if (ctx.inlineEventHandlers > 10) {
-                return createResult({ id: 'cwv-inp-event-handlers', name: 'Inline Event Handlers', category: 'performance', severity: 'info' }, 'info', `${ctx.inlineEventHandlers} inline event handlers found`, {
-                    recommendation: 'Use event delegation instead of inline handlers',
-                    evidence: {
-                        found: ctx.inlineEventHandlers,
-                        expected: 'Minimal inline handlers, prefer addEventListener',
-                        example: 'document.addEventListener("click", handleClick)',
-                        impact: 'Many inline handlers increase parsing time',
-                    },
-                });
-            }
-            return null;
-        },
-    },
-    {
-        id: 'cwv-inp-heavy-animations',
-        name: 'Heavy Animations',
-        category: 'performance',
-        severity: 'info',
-        description: 'Animations should use transform/opacity for best performance',
-        check: (ctx) => {
-            if (!ctx.hasHeavyAnimations)
-                return null;
-            return createResult({ id: 'cwv-inp-heavy-animations', name: 'Heavy Animations', category: 'performance', severity: 'info' }, 'info', 'Potentially expensive animations detected', {
-                recommendation: 'Use transform and opacity for animations, avoid layout properties',
-                evidence: {
-                    issue: 'Animating width, height, top, left triggers layout',
-                    expected: 'Animate transform: translate(), scale(), rotate() and opacity',
-                    learnMore: 'https://web.dev/animations-guide/',
-                },
-            });
-        },
-    },
     {
         id: 'cwv-resource-hints',
         name: 'Resource Hints',

package/dist/seo/rules/i18n.js

@@ -219,4 +219,31 @@ export const i18nRules = [
             return null;
         },
     },
+    {
+        id: 'hreflang-language-mismatch',
+        name: 'Hreflang Language Mismatch',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Hreflang language should match page content language',
+        check: (ctx) => {
+            if (!ctx.hreflangTags || !ctx.detectedLanguage)
+                return null;
+            const selfHreflang = ctx.hreflangTags.find(tag => tag.href === ctx.url || tag.href === ctx.canonicalUrl);
+            if (selfHreflang && ctx.detectedLanguage) {
+                const hreflangLang = selfHreflang.lang.split('-')[0].toLowerCase();
+                const detectedLang = ctx.detectedLanguage.toLowerCase();
+                if (hreflangLang !== detectedLang && hreflangLang !== 'x-default') {
+                    return createResult({ id: 'hreflang-language-mismatch', name: 'Hreflang Language Mismatch', category: 'technical', severity: 'warning' }, 'warn', `Hreflang declares "${selfHreflang.lang}" but content appears to be "${ctx.detectedLanguage}"`, {
+                        recommendation: 'Verify the hreflang attribute matches the actual page language',
+                        evidence: {
+                            found: `hreflang="${selfHreflang.lang}"`,
+                            expected: `Content language: ${ctx.detectedLanguage}`,
+                            impact: 'Language mismatch may confuse search engines and affect international SEO'
+                        }
+                    });
+                }
+            }
+            return null;
+        },
+    },
 ];

package/dist/seo/rules/images.js

@@ -81,33 +81,6 @@ export const imageRules = [
             return null;
         },
     },
-    {
-        id: 'images-alt-length',
-        name: 'Alt Text Length',
-        category: 'images',
-        severity: 'warning',
-        description: 'Alt text should be descriptive (min 10, max 125 chars)',
-        check: (ctx) => {
-            if (!ctx.altTextLengths || ctx.altTextLengths.length === 0)
-                return null;
-            const { minLength, maxLength } = SEO_THRESHOLDS.images.alt;
-            let shortAlts = 0;
-            let longAlts = 0;
-            ctx.altTextLengths.forEach(len => {
-                if (len < minLength)
-                    shortAlts++;
-                if (len > maxLength)
-                    longAlts++;
-            });
-            if (shortAlts > 0) {
-                return createResult({ id: 'images-alt-length', name: 'Alt Text Length', category: 'images', severity: 'warning' }, 'warn', `${shortAlts} alt text(s) are too short (min: ${minLength} chars)`, { value: shortAlts, recommendation: `Make alt texts more descriptive, at least ${minLength} characters.` });
-            }
-            if (longAlts > 0) {
-                return createResult({ id: 'images-alt-length', name: 'Alt Text Length', category: 'images', severity: 'warning' }, 'warn', `${longAlts} alt text(s) are too long (max: ${maxLength} chars)`, { value: longAlts, recommendation: `Shorten alt texts to be concise, under ${maxLength} characters.` });
-            }
-            return null;
-        },
-    },
     {
         id: 'images-alt-length',
         name: 'Alt Text Length',
@@ -177,4 +150,27 @@ export const imageRules = [
             return null;
         },
     },
+    {
+        id: 'broken-external-images',
+        name: 'Broken External Images',
+        category: 'images',
+        severity: 'warning',
+        description: 'External images should be accessible',
+        check: (ctx) => {
+            if (ctx.brokenExternalImages === undefined)
+                return null;
+            if (ctx.brokenExternalImages > 0) {
+                return createResult({ id: 'broken-external-images', name: 'Broken External Images', category: 'images', severity: 'warning' }, 'warn', `${ctx.brokenExternalImages} broken external images`, {
+                    value: ctx.brokenExternalImages,
+                    recommendation: 'Fix or remove broken external image references',
+                    evidence: {
+                        found: ctx.brokenExternalImageUrls?.slice(0, 5) || [],
+                        expected: 'All images should load successfully',
+                        impact: 'Broken images negatively affect user experience and may signal poor maintenance'
+                    }
+                });
+            }
+            return null;
+        },
+    },
 ];

package/dist/seo/rules/index.js

@@ -19,6 +19,11 @@ 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';
 export * from './types.js';
 export * from './thresholds.js';
 export const ALL_SEO_RULES = [
@@ -43,6 +48,11 @@ export const ALL_SEO_RULES = [
     ...socialRules,
     ...internalLinkingRules,
     ...bestPracticesRules,
+    ...aiSearchRules,
+    ...resourceRules,
+    ...technicalAdvancedRules,
+    ...redirectRules,
+    ...canonicalRules,
 ];
 export const SCORING_WEIGHTS = {
     severity: {
@@ -65,6 +75,10 @@ export const SCORING_WEIGHTS = {
         '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) {

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

@@ -286,11 +286,11 @@ export const internalLinkingRules = [
         check: (ctx) => {
             if (ctx.brokenInternalLinks === undefined)
                 return null;
-            if (ctx.brokenInternalLinks > 0) {
-                return createResult({ id: 'linking-broken-internal', name: 'Broken Internal Links', category: 'links', severity: 'error' }, 'fail', `${ctx.brokenInternalLinks} broken internal link(s)`, {
+            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,
+                        found: ctx.brokenInternalLinks.slice(0, 5),
                         expected: '0 broken links',
                         impact: 'Broken links waste crawl budget and harm user experience',
                     },
@@ -308,11 +308,11 @@ export const internalLinkingRules = [
         check: (ctx) => {
             if (ctx.redirectChainLinks === undefined)
                 return null;
-            if (ctx.redirectChainLinks > 0) {
-                return createResult({ id: 'linking-redirect-chains', name: 'Redirect Chains', category: 'links', severity: 'warning' }, 'warn', `${ctx.redirectChainLinks} link(s) go through redirects`, {
+            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,
+                        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',
                     },