recker 1.0.43 → 1.0.44

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

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

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

@@ -0,0 +1,299 @@
+import { createResult } from './types.js';
+export const pwaRules = [
+    {
+        id: 'pwa-manifest-link',
+        name: 'Web App Manifest',
+        category: 'technical',
+        severity: 'info',
+        description: 'Pages should link to a web app manifest for PWA support',
+        check: (ctx) => {
+            if (!ctx.hasManifest) {
+                return createResult({ id: 'pwa-manifest-link', name: 'Web App Manifest', category: 'technical', severity: 'info' }, 'info', 'No web app manifest linked', {
+                    recommendation: 'Add a manifest.json for PWA installability',
+                    evidence: {
+                        expected: '<link rel="manifest" href="/manifest.json">',
+                        impact: 'Required for "Add to Home Screen" and PWA features',
+                        learnMore: 'https://web.dev/add-manifest/',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-manifest-link', name: 'Web App Manifest', category: 'technical', severity: 'info' }, 'pass', `Manifest linked${ctx.manifestUrl ? `: ${ctx.manifestUrl}` : ''}`);
+        },
+    },
+    {
+        id: 'pwa-theme-color',
+        name: 'Theme Color',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Pages should define a theme color for browser UI',
+        check: (ctx) => {
+            if (!ctx.themeColor) {
+                return createResult({ id: 'pwa-theme-color', name: 'Theme Color', category: 'mobile', severity: 'info' }, 'info', 'No theme-color meta tag', {
+                    recommendation: 'Add theme-color for browser UI customization',
+                    evidence: {
+                        expected: '<meta name="theme-color" content="#4285f4">',
+                        impact: 'Controls browser toolbar color on mobile devices',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-theme-color', name: 'Theme Color', category: 'mobile', severity: 'info' }, 'pass', `Theme color: ${ctx.themeColor}`);
+        },
+    },
+    {
+        id: 'pwa-apple-touch-icon',
+        name: 'Apple Touch Icon',
+        category: 'mobile',
+        severity: 'info',
+        description: 'iOS devices need apple-touch-icon for home screen',
+        check: (ctx) => {
+            if (!ctx.hasAppleTouchIcon) {
+                return createResult({ id: 'pwa-apple-touch-icon', name: 'Apple Touch Icon', category: 'mobile', severity: 'info' }, 'info', 'No apple-touch-icon found', {
+                    recommendation: 'Add apple-touch-icon for iOS home screen',
+                    evidence: {
+                        expected: '<link rel="apple-touch-icon" href="/apple-touch-icon.png">',
+                        impact: 'iOS uses this icon when user adds site to home screen',
+                        example: 'Recommended size: 180x180 pixels',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-apple-touch-icon', name: 'Apple Touch Icon', category: 'mobile', severity: 'info' }, 'pass', 'Apple touch icon present');
+        },
+    },
+    {
+        id: 'pwa-apple-mobile-capable',
+        name: 'Apple Mobile Web App',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Enable standalone mode on iOS devices',
+        check: (ctx) => {
+            if (!ctx.hasAppleMobileWebAppCapable) {
+                return createResult({ id: 'pwa-apple-mobile-capable', name: 'Apple Mobile Web App', category: 'mobile', severity: 'info' }, 'info', 'No apple-mobile-web-app-capable meta tag', {
+                    recommendation: 'Add for full-screen iOS experience',
+                    evidence: {
+                        expected: '<meta name="apple-mobile-web-app-capable" content="yes">',
+                        impact: 'Enables standalone app mode when launched from home screen',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-apple-mobile-capable', name: 'Apple Mobile Web App', category: 'mobile', severity: 'info' }, 'pass', 'Apple mobile web app capable enabled');
+        },
+    },
+    {
+        id: 'pwa-apple-status-bar',
+        name: 'Apple Status Bar Style',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Configure iOS status bar appearance',
+        check: (ctx) => {
+            if (!ctx.hasAppleMobileWebAppCapable) {
+                return createResult({ id: 'pwa-apple-status-bar', name: 'Apple Status Bar Style', category: 'mobile', severity: 'info' }, 'info', 'Not applicable (apple-mobile-web-app-capable not set)', {
+                    recommendation: 'First enable apple-mobile-web-app-capable, then configure status bar',
+                });
+            }
+            if (!ctx.appleStatusBarStyle) {
+                return createResult({ id: 'pwa-apple-status-bar', name: 'Apple Status Bar Style', category: 'mobile', severity: 'info' }, 'info', 'No apple-mobile-web-app-status-bar-style defined', {
+                    recommendation: 'Define status bar style for iOS',
+                    evidence: {
+                        expected: '<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">',
+                        example: 'Options: default, black, black-translucent',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-apple-status-bar', name: 'Apple Status Bar Style', category: 'mobile', severity: 'info' }, 'pass', `Status bar style: ${ctx.appleStatusBarStyle}`);
+        },
+    },
+    {
+        id: 'pwa-maskable-icon',
+        name: 'Maskable Icon',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Manifest should include maskable icons for Android',
+        check: (ctx) => {
+            if (!ctx.hasMaskableIcon) {
+                return createResult({ id: 'pwa-maskable-icon', name: 'Maskable Icon', category: 'mobile', severity: 'info' }, 'info', 'No maskable icon in manifest', {
+                    recommendation: 'Add maskable icon for adaptive icons on Android',
+                    evidence: {
+                        example: `{
+  "icons": [{
+    "src": "/icon-maskable.png",
+    "sizes": "512x512",
+    "type": "image/png",
+    "purpose": "maskable"
+  }]
+}`,
+                        impact: 'Maskable icons adapt to different Android icon shapes',
+                        learnMore: 'https://web.dev/maskable-icon/',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-maskable-icon', name: 'Maskable Icon', category: 'mobile', severity: 'info' }, 'pass', 'Maskable icon defined');
+        },
+    },
+    {
+        id: 'pwa-start-url',
+        name: 'Start URL',
+        category: 'technical',
+        severity: 'info',
+        description: 'Manifest should define a start_url',
+        check: (ctx) => {
+            if (!ctx.hasManifest) {
+                return createResult({ id: 'pwa-start-url', name: 'Start URL', category: 'technical', severity: 'info' }, 'info', 'Not applicable (no manifest)', {
+                    recommendation: 'First add a web app manifest, then define start_url',
+                });
+            }
+            if (!ctx.manifestStartUrl) {
+                return createResult({ id: 'pwa-start-url', name: 'Start URL', category: 'technical', severity: 'info' }, 'info', 'Manifest missing start_url', {
+                    recommendation: 'Define start_url in manifest for PWA launch',
+                    evidence: {
+                        expected: '"start_url": "/?source=pwa"',
+                        impact: 'Controls which page opens when PWA is launched',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-start-url', name: 'Start URL', category: 'technical', severity: 'info' }, 'pass', `Start URL: ${ctx.manifestStartUrl}`);
+        },
+    },
+    {
+        id: 'pwa-display-mode',
+        name: 'Display Mode',
+        category: 'technical',
+        severity: 'info',
+        description: 'Manifest should define display mode',
+        check: (ctx) => {
+            if (!ctx.hasManifest) {
+                return createResult({ id: 'pwa-display-mode', name: 'Display Mode', category: 'technical', severity: 'info' }, 'info', 'Not applicable (no manifest)', {
+                    recommendation: 'First add a web app manifest, then define display mode',
+                });
+            }
+            const display = ctx.manifestDisplay;
+            if (!display) {
+                return createResult({ id: 'pwa-display-mode', name: 'Display Mode', category: 'technical', severity: 'info' }, 'info', 'Manifest missing display mode', {
+                    recommendation: 'Set display mode for app-like experience',
+                    evidence: {
+                        expected: '"display": "standalone"',
+                        example: 'Options: fullscreen, standalone, minimal-ui, browser',
+                    },
+                });
+            }
+            const goodModes = ['standalone', 'fullscreen', 'minimal-ui'];
+            if (!goodModes.includes(display)) {
+                return createResult({ id: 'pwa-display-mode', name: 'Display Mode', category: 'technical', severity: 'info' }, 'info', `Display mode: ${display} (browser-like)`, {
+                    recommendation: 'Consider standalone or fullscreen for app-like experience',
+                });
+            }
+            return createResult({ id: 'pwa-display-mode', name: 'Display Mode', category: 'technical', severity: 'info' }, 'pass', `Display mode: ${display}`);
+        },
+    },
+    {
+        id: 'pwa-scope',
+        name: 'Navigation Scope',
+        category: 'technical',
+        severity: 'info',
+        description: 'Manifest should define navigation scope',
+        check: (ctx) => {
+            if (!ctx.hasManifest) {
+                return createResult({ id: 'pwa-scope', name: 'Navigation Scope', category: 'technical', severity: 'info' }, 'info', 'Not applicable (no manifest)', {
+                    recommendation: 'First add a web app manifest, then define scope',
+                });
+            }
+            if (!ctx.manifestScope) {
+                return createResult({ id: 'pwa-scope', name: 'Navigation Scope', category: 'technical', severity: 'info' }, 'info', 'Manifest missing scope', {
+                    recommendation: 'Define scope to control PWA navigation boundaries',
+                    evidence: {
+                        expected: '"scope": "/"',
+                        impact: 'Limits which URLs are part of the app experience',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-scope', name: 'Navigation Scope', category: 'technical', severity: 'info' }, 'pass', `Scope: ${ctx.manifestScope}`);
+        },
+    },
+    {
+        id: 'pwa-icons-sizes',
+        name: 'Icon Sizes',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Manifest should include multiple icon sizes',
+        check: (ctx) => {
+            if (!ctx.hasManifest) {
+                return createResult({ id: 'pwa-icons-sizes', name: 'Icon Sizes', category: 'mobile', severity: 'info' }, 'info', 'Not applicable (no manifest)', {
+                    recommendation: 'First add a web app manifest with icons',
+                });
+            }
+            const sizes = ctx.manifestIconSizes || [];
+            const requiredSizes = [192, 512];
+            const missingSizes = requiredSizes.filter(s => !sizes.includes(s));
+            if (missingSizes.length > 0) {
+                return createResult({ id: 'pwa-icons-sizes', name: 'Icon Sizes', category: 'mobile', severity: 'info' }, 'info', `Missing icon sizes: ${missingSizes.join(', ')}px`, {
+                    recommendation: 'Add icons in required sizes',
+                    evidence: {
+                        found: sizes.length > 0 ? sizes.map(s => `${s}px`).join(', ') : 'No icons',
+                        expected: '192x192 and 512x512 minimum',
+                        impact: 'Required for Chrome "Add to Home Screen" prompt',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-icons-sizes', name: 'Icon Sizes', category: 'mobile', severity: 'info' }, 'pass', `Icon sizes: ${sizes.map(s => `${s}px`).join(', ')}`);
+        },
+    },
+    {
+        id: 'pwa-short-name',
+        name: 'Short Name',
+        category: 'technical',
+        severity: 'info',
+        description: 'Manifest should have a short_name for home screen',
+        check: (ctx) => {
+            if (!ctx.hasManifest) {
+                return createResult({ id: 'pwa-short-name', name: 'Short Name', category: 'technical', severity: 'info' }, 'info', 'Not applicable (no manifest)', {
+                    recommendation: 'First add a web app manifest with name/short_name',
+                });
+            }
+            const shortName = ctx.manifestShortName;
+            const name = ctx.manifestName;
+            if (!shortName && !name) {
+                return createResult({ id: 'pwa-short-name', name: 'Short Name', category: 'technical', severity: 'info' }, 'info', 'Manifest missing name and short_name', {
+                    recommendation: 'Add short_name (max 12 chars) for home screen label',
+                    evidence: {
+                        expected: '"short_name": "MyApp"',
+                        impact: 'Used as app label on home screen',
+                    },
+                });
+            }
+            if (shortName && shortName.length > 12) {
+                return createResult({ id: 'pwa-short-name', name: 'Short Name', category: 'technical', severity: 'info' }, 'info', `Short name too long: ${shortName.length} chars`, {
+                    recommendation: 'Keep short_name under 12 characters',
+                    evidence: {
+                        found: shortName,
+                        expected: 'Max 12 characters',
+                        impact: 'May be truncated on home screen',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-short-name', name: 'Short Name', category: 'technical', severity: 'info' }, 'pass', `App name: ${shortName || name}`);
+        },
+    },
+    {
+        id: 'pwa-background-color',
+        name: 'Background Color',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Manifest should define background_color for splash screen',
+        check: (ctx) => {
+            if (!ctx.hasManifest) {
+                return createResult({ id: 'pwa-background-color', name: 'Background Color', category: 'mobile', severity: 'info' }, 'info', 'Not applicable (no manifest)', {
+                    recommendation: 'First add a web app manifest, then define background_color',
+                });
+            }
+            if (!ctx.manifestBackgroundColor) {
+                return createResult({ id: 'pwa-background-color', name: 'Background Color', category: 'mobile', severity: 'info' }, 'info', 'Manifest missing background_color', {
+                    recommendation: 'Define background_color for splash screen',
+                    evidence: {
+                        expected: '"background_color": "#ffffff"',
+                        impact: 'Shown as splash screen background during app launch',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-background-color', name: 'Background Color', category: 'mobile', severity: 'info' }, 'pass', `Background color: ${ctx.manifestBackgroundColor}`);
+        },
+    },
+];

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

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

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

@@ -0,0 +1,264 @@
+import { createResult } from './types.js';
+export const readabilityRules = [
+    {
+        id: 'readability-flesch-score',
+        name: 'Flesch Reading Ease',
+        category: 'content',
+        severity: 'info',
+        description: 'Content should be easy to read for the target audience',
+        check: (ctx) => {
+            if (ctx.fleschReadingEase === undefined) {
+                return createResult({ id: 'readability-flesch-score', name: 'Flesch Reading Ease', category: 'content', severity: 'info' }, 'info', 'Not applicable (Flesch Reading Ease data unavailable)', { recommendation: 'This rule analyzes content readability using the Flesch Reading Ease formula' });
+            }
+            const score = ctx.fleschReadingEase;
+            let level;
+            let status;
+            if (score >= 60) {
+                level = score >= 80 ? 'Easy' : score >= 70 ? 'Fairly Easy' : 'Standard';
+                status = 'pass';
+            }
+            else if (score >= 50) {
+                level = 'Fairly Difficult';
+                status = 'info';
+            }
+            else if (score >= 30) {
+                level = 'Difficult';
+                status = 'warn';
+            }
+            else {
+                level = 'Very Difficult';
+                status = 'warn';
+            }
+            if (status === 'warn') {
+                return createResult({ id: 'readability-flesch-score', name: 'Flesch Reading Ease', category: 'content', severity: 'info' }, status, `Flesch score: ${Math.round(score)} (${level})`, {
+                    recommendation: 'Simplify content for better readability',
+                    evidence: {
+                        found: Math.round(score),
+                        expected: '60-70 for general web content',
+                        impact: 'Difficult content has higher bounce rates',
+                        learnMore: 'https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests',
+                    },
+                });
+            }
+            return createResult({ id: 'readability-flesch-score', name: 'Flesch Reading Ease', category: 'content', severity: 'info' }, status, `Flesch score: ${Math.round(score)} (${level})`);
+        },
+    },
+    {
+        id: 'readability-sentence-length',
+        name: 'Sentence Length',
+        category: 'content',
+        severity: 'info',
+        description: 'Sentences should be concise for better readability',
+        check: (ctx) => {
+            if (ctx.avgSentenceLength === undefined) {
+                return createResult({ id: 'readability-sentence-length', name: 'Sentence Length', category: 'content', severity: 'info' }, 'info', 'Not applicable (sentence length data unavailable)', { recommendation: 'This rule checks average sentence length for optimal readability' });
+            }
+            const avgLength = ctx.avgSentenceLength;
+            if (avgLength > 30) {
+                return createResult({ id: 'readability-sentence-length', name: 'Sentence Length', category: 'content', severity: 'info' }, 'warn', `Average sentence length: ${Math.round(avgLength)} words (too long)`, {
+                    recommendation: 'Break long sentences into shorter ones',
+                    evidence: {
+                        found: Math.round(avgLength),
+                        expected: '15-20 words per sentence ideal, max 25',
+                        impact: 'Long sentences are harder to understand on mobile',
+                    },
+                });
+            }
+            if (avgLength > 25) {
+                return createResult({ id: 'readability-sentence-length', name: 'Sentence Length', category: 'content', severity: 'info' }, 'info', `Average sentence length: ${Math.round(avgLength)} words (slightly long)`, {
+                    recommendation: 'Consider shortening some sentences',
+                    evidence: {
+                        found: Math.round(avgLength),
+                        expected: '15-20 words per sentence',
+                    },
+                });
+            }
+            return createResult({ id: 'readability-sentence-length', name: 'Sentence Length', category: 'content', severity: 'info' }, 'pass', `Average sentence length: ${Math.round(avgLength)} words`);
+        },
+    },
+    {
+        id: 'readability-paragraph-length',
+        name: 'Paragraph Length',
+        category: 'content',
+        severity: 'info',
+        description: 'Paragraphs should be short for web readability',
+        check: (ctx) => {
+            if (ctx.avgParagraphLength === undefined) {
+                return createResult({ id: 'readability-paragraph-length', name: 'Paragraph Length', category: 'content', severity: 'info' }, 'info', 'Not applicable (paragraph length data unavailable)', { recommendation: 'This rule checks average paragraph length for web readability' });
+            }
+            const avgLength = ctx.avgParagraphLength;
+            if (avgLength > 150) {
+                return createResult({ id: 'readability-paragraph-length', name: 'Paragraph Length', category: 'content', severity: 'info' }, 'warn', `Average paragraph length: ${Math.round(avgLength)} words (too long)`, {
+                    recommendation: 'Break paragraphs into smaller chunks',
+                    evidence: {
+                        found: Math.round(avgLength),
+                        expected: '40-80 words per paragraph for web',
+                        impact: 'Wall of text reduces engagement and increases bounce rate',
+                    },
+                });
+            }
+            if (avgLength > 100) {
+                return createResult({ id: 'readability-paragraph-length', name: 'Paragraph Length', category: 'content', severity: 'info' }, 'info', `Average paragraph length: ${Math.round(avgLength)} words`, {
+                    recommendation: 'Consider breaking longer paragraphs',
+                });
+            }
+            return createResult({ id: 'readability-paragraph-length', name: 'Paragraph Length', category: 'content', severity: 'info' }, 'pass', `Average paragraph length: ${Math.round(avgLength)} words`);
+        },
+    },
+    {
+        id: 'readability-passive-voice',
+        name: 'Passive Voice',
+        category: 'content',
+        severity: 'info',
+        description: 'Limit passive voice for clearer writing',
+        check: (ctx) => {
+            if (ctx.passiveVoicePercentage === undefined) {
+                return createResult({ id: 'readability-passive-voice', name: 'Passive Voice', category: 'content', severity: 'info' }, 'info', 'Not applicable (passive voice data unavailable)', { recommendation: 'This rule checks passive voice usage for clearer writing' });
+            }
+            const percentage = ctx.passiveVoicePercentage;
+            if (percentage > 20) {
+                return createResult({ id: 'readability-passive-voice', name: 'Passive Voice', category: 'content', severity: 'info' }, 'warn', `Passive voice: ${Math.round(percentage)}% of sentences`, {
+                    recommendation: 'Convert passive sentences to active voice',
+                    evidence: {
+                        found: `${Math.round(percentage)}%`,
+                        expected: 'Less than 10% passive voice',
+                        example: 'Instead of "The button was clicked by the user" → "The user clicked the button"',
+                    },
+                });
+            }
+            if (percentage > 15) {
+                return createResult({ id: 'readability-passive-voice', name: 'Passive Voice', category: 'content', severity: 'info' }, 'info', `Passive voice: ${Math.round(percentage)}% of sentences`, {
+                    recommendation: 'Consider reducing passive voice usage',
+                });
+            }
+            return createResult({ id: 'readability-passive-voice', name: 'Passive Voice', category: 'content', severity: 'info' }, 'pass', `Passive voice usage acceptable (${Math.round(percentage)}%)`);
+        },
+    },
+    {
+        id: 'readability-transition-words',
+        name: 'Transition Words',
+        category: 'content',
+        severity: 'info',
+        description: 'Use transition words for better flow',
+        check: (ctx) => {
+            if (ctx.transitionWordPercentage === undefined) {
+                return createResult({ id: 'readability-transition-words', name: 'Transition Words', category: 'content', severity: 'info' }, 'info', 'Not applicable (transition word data unavailable)', { recommendation: 'This rule checks for transition words that improve content flow' });
+            }
+            const percentage = ctx.transitionWordPercentage;
+            if (percentage < 20) {
+                return createResult({ id: 'readability-transition-words', name: 'Transition Words', category: 'content', severity: 'info' }, 'info', `Transition words: ${Math.round(percentage)}% of sentences`, {
+                    recommendation: 'Add transition words for better content flow',
+                    evidence: {
+                        found: `${Math.round(percentage)}%`,
+                        expected: 'At least 30% of sentences',
+                        example: 'Words like: however, therefore, additionally, furthermore, for example',
+                        impact: 'Transition words improve comprehension and engagement',
+                    },
+                });
+            }
+            return createResult({ id: 'readability-transition-words', name: 'Transition Words', category: 'content', severity: 'info' }, 'pass', `Transition words: ${Math.round(percentage)}% of sentences`);
+        },
+    },
+    {
+        id: 'readability-subheading-distribution',
+        name: 'Subheading Distribution',
+        category: 'content',
+        severity: 'info',
+        description: 'Break content with subheadings every 300 words',
+        check: (ctx) => {
+            if (!ctx.wordCount || !ctx.h2Count) {
+                return createResult({ id: 'readability-subheading-distribution', name: 'Subheading Distribution', category: 'content', severity: 'info' }, 'info', 'Not applicable (word count or heading data unavailable)', { recommendation: 'This rule checks for proper subheading distribution to break up content' });
+            }
+            const wordsPerSubheading = ctx.wordCount / (ctx.h2Count + 1);
+            if (ctx.wordCount > 500 && wordsPerSubheading > 400) {
+                return createResult({ id: 'readability-subheading-distribution', name: 'Subheading Distribution', category: 'content', severity: 'info' }, 'warn', `${Math.round(wordsPerSubheading)} words between subheadings (too many)`, {
+                    recommendation: 'Add more H2/H3 subheadings to break up content',
+                    evidence: {
+                        found: `${ctx.h2Count} subheadings for ${ctx.wordCount} words`,
+                        expected: 'One subheading every 250-350 words',
+                        impact: 'Subheadings improve scannability and featured snippet eligibility',
+                    },
+                });
+            }
+            if (ctx.wordCount > 300 && wordsPerSubheading > 300) {
+                return createResult({ id: 'readability-subheading-distribution', name: 'Subheading Distribution', category: 'content', severity: 'info' }, 'info', `${Math.round(wordsPerSubheading)} words per section`, {
+                    recommendation: 'Consider adding more subheadings',
+                });
+            }
+            return createResult({ id: 'readability-subheading-distribution', name: 'Subheading Distribution', category: 'content', severity: 'info' }, 'pass', `${Math.round(wordsPerSubheading)} words per section (good)`);
+        },
+    },
+    {
+        id: 'readability-text-variety',
+        name: 'Text Variety',
+        category: 'content',
+        severity: 'info',
+        description: 'Use varied sentence structures and word choices',
+        check: (ctx) => {
+            if (ctx.consecutiveSentenceStarts === undefined) {
+                return createResult({ id: 'readability-text-variety', name: 'Text Variety', category: 'content', severity: 'info' }, 'info', 'Not applicable (sentence variety data unavailable)', { recommendation: 'This rule checks for varied sentence structures and beginnings' });
+            }
+            if (ctx.consecutiveSentenceStarts > 3) {
+                return createResult({ id: 'readability-text-variety', name: 'Text Variety', category: 'content', severity: 'info' }, 'info', `${ctx.consecutiveSentenceStarts} consecutive sentences start similarly`, {
+                    recommendation: 'Vary sentence beginnings for better flow',
+                    evidence: {
+                        impact: 'Repetitive sentence structures feel monotonous',
+                    },
+                });
+            }
+            return createResult({ id: 'readability-text-variety', name: 'Text Variety', category: 'content', severity: 'info' }, 'pass', 'Good sentence variety');
+        },
+    },
+    {
+        id: 'readability-word-complexity',
+        name: 'Word Complexity',
+        category: 'content',
+        severity: 'info',
+        description: 'Avoid overly complex vocabulary',
+        check: (ctx) => {
+            if (ctx.complexWordPercentage === undefined) {
+                return createResult({ id: 'readability-word-complexity', name: 'Word Complexity', category: 'content', severity: 'info' }, 'info', 'Not applicable (word complexity data unavailable)', { recommendation: 'This rule checks for complex vocabulary that may reduce readability' });
+            }
+            if (ctx.complexWordPercentage > 15) {
+                return createResult({ id: 'readability-word-complexity', name: 'Word Complexity', category: 'content', severity: 'info' }, 'warn', `Complex words: ${Math.round(ctx.complexWordPercentage)}%`, {
+                    recommendation: 'Use simpler vocabulary where possible',
+                    evidence: {
+                        found: `${Math.round(ctx.complexWordPercentage)}% words with 3+ syllables`,
+                        expected: 'Less than 10% complex words for general audience',
+                        impact: 'Complex vocabulary reduces comprehension',
+                    },
+                });
+            }
+            if (ctx.complexWordPercentage > 10) {
+                return createResult({ id: 'readability-word-complexity', name: 'Word Complexity', category: 'content', severity: 'info' }, 'info', `Complex words: ${Math.round(ctx.complexWordPercentage)}%`);
+            }
+            return createResult({ id: 'readability-word-complexity', name: 'Word Complexity', category: 'content', severity: 'info' }, 'pass', `Word complexity acceptable (${Math.round(ctx.complexWordPercentage)}%)`);
+        },
+    },
+    {
+        id: 'readability-list-usage',
+        name: 'List Usage',
+        category: 'content',
+        severity: 'info',
+        description: 'Use lists to improve scannability',
+        check: (ctx) => {
+            if (!ctx.wordCount || ctx.listCount === undefined) {
+                return createResult({ id: 'readability-list-usage', name: 'List Usage', category: 'content', severity: 'info' }, 'info', 'Not applicable (word count or list data unavailable)', { recommendation: 'This rule checks for proper use of lists to improve scannability' });
+            }
+            if (ctx.wordCount > 500 && ctx.listCount === 0) {
+                return createResult({ id: 'readability-list-usage', name: 'List Usage', category: 'content', severity: 'info' }, 'info', 'No lists found in long-form content', {
+                    recommendation: 'Consider using bullet points or numbered lists',
+                    evidence: {
+                        found: `${ctx.wordCount} words with 0 lists`,
+                        expected: 'At least 1 list per 500 words for long content',
+                        impact: 'Lists improve scannability and featured snippet eligibility',
+                    },
+                });
+            }
+            if (ctx.listCount > 0) {
+                return createResult({ id: 'readability-list-usage', name: 'List Usage', category: 'content', severity: 'info' }, 'pass', `${ctx.listCount} list(s) found`);
+            }
+            return createResult({ id: 'readability-list-usage', name: 'List Usage', category: 'content', severity: 'info' }, 'pass', 'Content length does not require lists');
+        },
+    },
+];

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

@@ -0,0 +1,16 @@
+import { SeoRule } from './types.js';
+export declare const redirectRules: SeoRule[];
+declare module './types.js' {
+    interface RuleContext {
+        redirectChain?: Array<{
+            status: number;
+            from: string;
+            to: string;
+        }>;
+        wwwConsistency?: {
+            canonicalHasWww: boolean;
+            urlHasWww: boolean;
+            redirectsToCanonical: boolean;
+        };
+    }
+}