recker 1.0.43 → 1.0.44

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

@@ -0,0 +1,223 @@
+import { createResult } from './types.js';
+import { SEO_THRESHOLDS } from './thresholds.js';
+export const structuralRules = [
+    {
+        id: 'h1-exists',
+        name: 'H1 Exists',
+        category: 'headings',
+        severity: 'error',
+        description: 'Page must have exactly one H1 heading',
+        check: (ctx) => {
+            if (ctx.h1Count === undefined) {
+                return createResult({ id: 'h1-exists', name: 'H1 Tag', category: 'headings', severity: 'error' }, 'info', 'Unable to check H1 (data unavailable)', { recommendation: 'Ensure HTML content is properly parsed' });
+            }
+            if (ctx.h1Count === 0) {
+                return createResult({ id: 'h1-exists', name: 'H1 Tag', category: 'headings', severity: 'error' }, 'fail', 'Missing H1 heading', {
+                    recommendation: 'Add a single H1 heading. It should be the main headline and include your primary keyword.',
+                    evidence: {
+                        found: 'No H1 tags detected on the page',
+                        expected: 'Exactly one <h1> tag',
+                        impact: 'The H1 tag is the most important heading for SEO. It tells search engines and users what the main topic of the page is. Pages without an H1 have poor semantic structure and may rank lower.',
+                        example: '<h1>Your Main Page Title Here</h1>'
+                    }
+                });
+            }
+            if (ctx.h1Count > 1) {
+                return createResult({ id: 'h1-exists', name: 'H1 Tag', category: 'headings', severity: 'error' }, 'warn', `Multiple H1 tags (${ctx.h1Count} found)`, {
+                    value: ctx.h1Count,
+                    recommendation: 'Use only one H1 per page to clearly signal the main topic.',
+                    evidence: {
+                        found: `${ctx.h1Count} H1 tags on the page`,
+                        expected: 'Exactly one <h1> tag',
+                        impact: 'Multiple H1 tags dilute the main topic signal and confuse search engines about which heading is the primary page title. This can hurt topical relevance and rankings.',
+                        example: '<h1>Main Title</h1>\n<!-- Use H2 for subtopics instead -->\n<h2>Subtopic One</h2>\n<h2>Subtopic Two</h2>'
+                    }
+                });
+            }
+            return createResult({ id: 'h1-exists', name: 'H1 Tag', category: 'headings', severity: 'error' }, 'pass', 'Single H1 tag present');
+        },
+    },
+    {
+        id: 'h1-length',
+        name: 'H1 Length',
+        category: 'headings',
+        severity: 'warning',
+        description: 'H1 should be 20-70 characters',
+        check: (ctx) => {
+            if (!ctx.h1Text) {
+                return createResult({ id: 'h1-length', name: 'H1 Length', category: 'headings', severity: 'warning' }, 'info', 'No H1 text to analyze', { recommendation: 'First add an H1 heading to the page' });
+            }
+            const len = ctx.h1Length ?? ctx.h1Text.length;
+            const { minLength, maxLength } = SEO_THRESHOLDS.headings.h1;
+            if (len < minLength) {
+                return createResult({ id: 'h1-length', name: 'H1 Length', category: 'headings', severity: 'warning' }, 'warn', `H1 too short (${len} chars, min: ${minLength})`, {
+                    value: len,
+                    recommendation: `Expand H1 to at least ${minLength} characters`,
+                    evidence: {
+                        found: `H1 with ${len} characters: "${ctx.h1Text}"`,
+                        expected: `${minLength}-${maxLength} characters`,
+                        impact: 'Very short H1 tags may not provide enough context for search engines and users to understand the page topic. Descriptive H1s improve relevance signals and click-through rates.',
+                        example: '<h1>Complete Guide to SEO Best Practices</h1>'
+                    }
+                });
+            }
+            if (len > maxLength) {
+                return createResult({ id: 'h1-length', name: 'H1 Length', category: 'headings', severity: 'warning' }, 'warn', `H1 too long (${len} chars, max: ${maxLength})`, {
+                    value: len,
+                    recommendation: `Shorten H1 to under ${maxLength} characters`,
+                    evidence: {
+                        found: `H1 with ${len} characters: "${ctx.h1Text}"`,
+                        expected: `${minLength}-${maxLength} characters`,
+                        impact: 'Overly long H1 tags can be truncated in search results and may appear unfocused. Concise H1s are more scannable and effective for both users and search engines.',
+                        example: '<h1>SEO Guide: On-Page Optimization Tips</h1>'
+                    }
+                });
+            }
+            return createResult({ id: 'h1-length', name: 'H1 Length', category: 'headings', severity: 'warning' }, 'pass', `H1 length OK (${len} chars)`, { value: len });
+        },
+    },
+    {
+        id: 'heading-hierarchy',
+        name: 'Heading Hierarchy',
+        category: 'headings',
+        severity: 'warning',
+        description: 'Headings should follow sequential order (H1 → H2 → H3)',
+        check: (ctx) => {
+            if (ctx.headingHierarchyValid === undefined) {
+                return createResult({ id: 'heading-hierarchy', name: 'Heading Hierarchy', category: 'headings', severity: 'warning' }, 'info', 'Unable to check heading hierarchy (data unavailable)', { recommendation: 'Ensure heading analysis completed' });
+            }
+            if (!ctx.headingHierarchyValid) {
+                const skipped = ctx.headingSkippedLevels?.join(', ') || 'unknown';
+                return createResult({ id: 'heading-hierarchy', name: 'Heading Hierarchy', category: 'headings', severity: 'warning' }, 'warn', `Heading levels are skipped (${skipped})`, {
+                    recommendation: 'Use sequential heading levels (H1 → H2 → H3)',
+                    evidence: {
+                        found: `Skipped heading levels: ${skipped}`,
+                        expected: 'Sequential heading structure (H1 → H2 → H3 → H4, etc.)',
+                        impact: 'Skipping heading levels disrupts the document outline and can confuse screen readers and search engine crawlers trying to understand content hierarchy. This weakens accessibility and semantic structure.',
+                        example: '<h1>Main Title</h1>\n<h2>Section Title</h2>\n<h3>Subsection Title</h3>\n<!-- Do NOT skip from H1 to H3 -->'
+                    }
+                });
+            }
+            return createResult({ id: 'heading-hierarchy', name: 'Heading Hierarchy', category: 'headings', severity: 'warning' }, 'pass', 'Heading structure is correct');
+        },
+    },
+    {
+        id: 'h2-count',
+        name: 'H2 Count',
+        category: 'headings',
+        severity: 'info',
+        description: 'Page should have 2-8 H2 headings for good structure',
+        check: (ctx) => {
+            if (ctx.h2Count === undefined) {
+                return createResult({ id: 'h2-count', name: 'H2 Count', category: 'headings', severity: 'info' }, 'info', 'Unable to check H2 count (data unavailable)', { recommendation: 'Ensure heading analysis completed' });
+            }
+            const { min, max } = SEO_THRESHOLDS.headings.h2;
+            if (ctx.h2Count < min) {
+                return createResult({ id: 'h2-count', name: 'H2 Count', category: 'headings', severity: 'info' }, 'info', `Few H2 headings (${ctx.h2Count})`, { value: ctx.h2Count, recommendation: `Consider adding more H2 headings for better structure (${min}-${max} ideal)` });
+            }
+            if (ctx.h2Count > max) {
+                return createResult({ id: 'h2-count', name: 'H2 Count', category: 'headings', severity: 'info' }, 'info', `Many H2 headings (${ctx.h2Count})`, { value: ctx.h2Count, recommendation: 'Consider consolidating sections' });
+            }
+            return createResult({ id: 'h2-count', name: 'H2 Count', category: 'headings', severity: 'info' }, 'pass', `Good H2 count (${ctx.h2Count})`, { value: ctx.h2Count });
+        },
+    },
+    {
+        id: 'html5-header-exists',
+        name: 'HTML5 Header',
+        category: 'technical',
+        severity: 'info',
+        description: 'Page should use a <header> element',
+        check: (ctx) => {
+            if (!ctx.hasHeader) {
+                return createResult({ id: 'html5-header-exists', name: 'HTML5 Header', category: 'technical', severity: 'info' }, 'info', 'Missing <header> element', { recommendation: 'Use <header> for site-wide or page-specific introductory content' });
+            }
+            return createResult({ id: 'html5-header-exists', name: 'HTML5 Header', category: 'technical', severity: 'info' }, 'pass', 'HTML5 <header> element present');
+        },
+    },
+    {
+        id: 'html5-nav-exists',
+        name: 'HTML5 Navigation',
+        category: 'technical',
+        severity: 'info',
+        description: 'Page should use a <nav> element for navigation links',
+        check: (ctx) => {
+            if (!ctx.hasNav) {
+                return createResult({ id: 'html5-nav-exists', name: 'HTML5 Navigation', category: 'technical', severity: 'info' }, 'info', 'Missing <nav> element', { recommendation: 'Use <nav> to define a block of navigation links' });
+            }
+            return createResult({ id: 'html5-nav-exists', name: 'HTML5 Navigation', category: 'technical', severity: 'info' }, 'pass', 'HTML5 <nav> element present');
+        },
+    },
+    {
+        id: 'html5-main-exists',
+        name: 'HTML5 Main Content',
+        category: 'technical',
+        severity: 'info',
+        description: 'Page should use a <main> element for the dominant content',
+        check: (ctx) => {
+            if (!ctx.hasMain) {
+                return createResult({ id: 'html5-main-exists', name: 'HTML5 Main Content', category: 'technical', severity: 'info' }, 'info', 'Missing <main> element', { recommendation: 'Use <main> to enclose the dominant content of the <body>' });
+            }
+            return createResult({ id: 'html5-main-exists', name: 'HTML5 Main Content', category: 'technical', severity: 'info' }, 'pass', 'HTML5 <main> element present');
+        },
+    },
+    {
+        id: 'html5-article-exists',
+        name: 'HTML5 Article',
+        category: 'technical',
+        severity: 'info',
+        description: 'Consider using <article> for independent, self-contained content',
+        check: (ctx) => {
+            if (!ctx.hasArticle && ctx.wordCount && ctx.wordCount > 500) {
+                return createResult({ id: 'html5-article-exists', name: 'HTML5 Article', category: 'technical', severity: 'info' }, 'info', 'Missing <article> element for substantial content', { recommendation: 'Consider using <article> for blog posts, news articles, etc.' });
+            }
+            return createResult({ id: 'html5-article-exists', name: 'HTML5 Article', category: 'technical', severity: 'info' }, 'pass', 'HTML5 <article> element present or not required');
+        },
+    },
+    {
+        id: 'html5-section-exists',
+        name: 'HTML5 Section',
+        category: 'technical',
+        severity: 'info',
+        description: 'Consider using <section> for thematic grouping of content',
+        check: (ctx) => {
+            if (!ctx.hasSection && (ctx.h2Count && ctx.h2Count > 1)) {
+                return createResult({ id: 'html5-section-exists', name: 'HTML5 Section', category: 'technical', severity: 'info' }, 'info', 'Missing <section> element for content grouping', { recommendation: 'Consider using <section> to group related content, usually with a heading' });
+            }
+            return createResult({ id: 'html5-section-exists', name: 'HTML5 Section', category: 'technical', severity: 'info' }, 'pass', 'HTML5 <section> element present or not required');
+        },
+    },
+    {
+        id: 'html5-footer-exists',
+        name: 'HTML5 Footer',
+        category: 'technical',
+        severity: 'info',
+        description: 'Page should use a <footer> element',
+        check: (ctx) => {
+            if (!ctx.hasFooter) {
+                return createResult({ id: 'html5-footer-exists', name: 'HTML5 Footer', category: 'technical', severity: 'info' }, 'info', 'Missing <footer> element', { recommendation: 'Use <footer> for site-wide or page-specific footer content' });
+            }
+            return createResult({ id: 'html5-footer-exists', name: 'HTML5 Footer', category: 'technical', severity: 'info' }, 'pass', 'HTML5 <footer> element present');
+        },
+    },
+    {
+        id: 'keywords-in-h1',
+        name: 'Keywords in H1',
+        category: 'headings',
+        severity: 'warning',
+        description: 'H1 should contain main keywords',
+        check: (ctx) => {
+            if (ctx.keywordsInH1 === false && ctx.topKeywords && ctx.topKeywords.length > 0) {
+                return createResult({ id: 'keywords-in-h1', name: 'Keywords in H1', category: 'headings', severity: 'warning' }, 'warn', 'H1 does not appear to contain top keywords', {
+                    recommendation: 'Ensure your H1 tag includes your main target keyword naturally.',
+                    evidence: {
+                        found: `H1: "${ctx.h1Text}"`,
+                        expected: `Should contain one of: ${ctx.topKeywords.join(', ')}`,
+                        impact: 'Keywords in H1 confirm relevance to the user and search engines. The H1 should naturally include your primary target keyword to reinforce the page topic and improve rankings for that term.',
+                        example: `<h1>Complete Guide to ${ctx.topKeywords?.[0] || 'Your Primary Keyword'}</h1>`
+                    }
+                });
+            }
+            return createResult({ id: 'keywords-in-h1', name: 'Keywords in H1', category: 'headings', severity: 'warning' }, 'pass', 'Keywords present in H1');
+        },
+    },
+];

package/dist/browser/seo/rules/technical-advanced.d.ts

@@ -0,0 +1,10 @@
+import { SeoRule } from './types.js';
+export declare const technicalAdvancedRules: SeoRule[];
+declare module './types.js' {
+    interface RuleContext {
+        metaRefresh?: {
+            delay: number;
+            url?: string;
+        };
+    }
+}

package/dist/browser/seo/rules/technical-advanced.js

@@ -0,0 +1,289 @@
+import { createResult } from './types.js';
+export const technicalAdvancedRules = [
+    {
+        id: 'meta-refresh-redirect',
+        name: 'Meta Refresh Redirect',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Pages should not use meta refresh redirects',
+        check: (ctx) => {
+            if (!ctx.metaRefresh) {
+                return createResult({ id: 'meta-refresh-redirect', name: 'Meta Refresh Redirect', category: 'technical', severity: 'warning' }, 'info', 'Not applicable (no meta refresh detected)', { recommendation: 'This rule checks for meta refresh redirects which can impact SEO' });
+            }
+            const { delay, url } = ctx.metaRefresh;
+            if (url) {
+                return createResult({ id: 'meta-refresh-redirect', name: 'Meta Refresh Redirect', category: 'technical', severity: 'warning' }, delay === 0 ? 'warn' : 'fail', `Page uses meta refresh redirect (${delay}s delay)`, {
+                    value: delay,
+                    recommendation: 'Use HTTP 301/302 redirects instead of meta refresh for SEO',
+                    evidence: {
+                        found: `<meta http-equiv="refresh" content="${delay};url=${url}">`,
+                        expected: 'HTTP 301/302 redirect',
+                        impact: delay > 0
+                            ? 'Meta refresh with delay confuses users and search engines'
+                            : 'Meta refresh redirects are not as SEO-friendly as HTTP redirects',
+                        learnMore: 'https://developers.google.com/search/docs/crawling-indexing/http-network-errors#meta-refresh'
+                    }
+                });
+            }
+            else if (delay > 0) {
+                return createResult({ id: 'meta-refresh-redirect', name: 'Meta Refresh Redirect', category: 'technical', severity: 'warning' }, 'warn', `Page auto-refreshes every ${delay} seconds`, {
+                    value: delay,
+                    recommendation: 'Avoid auto-refresh; let users control when to refresh content',
+                    evidence: {
+                        found: `<meta http-equiv="refresh" content="${delay}">`,
+                        expected: 'No auto-refresh',
+                        impact: 'Auto-refresh can be disorienting and wastes bandwidth'
+                    }
+                });
+            }
+            return createResult({ id: 'meta-refresh-redirect', name: 'Meta Refresh Redirect', category: 'technical', severity: 'warning' }, 'info', 'Not applicable (no meta refresh detected)', { recommendation: 'This rule checks for meta refresh redirects which can impact SEO' });
+        },
+    },
+    {
+        id: 'html-page-size',
+        name: 'HTML Page Size',
+        category: 'performance',
+        severity: 'warning',
+        description: 'HTML page should not exceed reasonable size limits',
+        check: (ctx) => {
+            if (ctx.htmlSize === undefined) {
+                return createResult({ id: 'html-page-size', name: 'HTML Page Size', category: 'performance', severity: 'warning' }, 'info', 'Not applicable (HTML size data unavailable)', { recommendation: 'This rule checks if HTML size is within recommended limits for optimal performance' });
+            }
+            const sizeKb = ctx.htmlSize / 1024;
+            const sizeMb = sizeKb / 1024;
+            if (sizeMb > 2) {
+                return createResult({ id: 'html-page-size', name: 'HTML Page Size', category: 'performance', severity: 'warning' }, 'fail', `HTML size ${sizeMb.toFixed(2)}MB exceeds 2MB limit`, {
+                    value: ctx.htmlSize,
+                    recommendation: 'Reduce HTML size by removing inline scripts/styles and optimizing content',
+                    evidence: {
+                        found: `${sizeMb.toFixed(2)}MB`,
+                        expected: '<2MB',
+                        impact: 'Very large HTML files slow down crawling and may not be fully indexed'
+                    }
+                });
+            }
+            if (sizeKb > 500) {
+                return createResult({ id: 'html-page-size', name: 'HTML Page Size', category: 'performance', severity: 'warning' }, 'warn', `HTML size ${sizeKb.toFixed(0)}KB is large`, {
+                    value: ctx.htmlSize,
+                    recommendation: 'Consider reducing HTML size for faster page loads',
+                    evidence: {
+                        found: `${sizeKb.toFixed(0)}KB`,
+                        expected: '<500KB',
+                        impact: 'Large HTML files increase time to first meaningful paint'
+                    }
+                });
+            }
+            return createResult({ id: 'html-page-size', name: 'HTML Page Size', category: 'performance', severity: 'warning' }, 'pass', `HTML size ${sizeKb.toFixed(0)}KB is acceptable`);
+        },
+    },
+    {
+        id: 'total-page-size',
+        name: 'Total Page Size',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Total page weight should be optimized for performance',
+        check: (ctx) => {
+            if (ctx.totalPageSize === undefined) {
+                return createResult({ id: 'total-page-size', name: 'Total Page Size', category: 'performance', severity: 'warning' }, 'info', 'Not applicable (total page size data unavailable)', { recommendation: 'This rule checks total page weight including all resources for optimal load time' });
+            }
+            const sizeMb = ctx.totalPageSize / (1024 * 1024);
+            if (sizeMb > 5) {
+                return createResult({ id: 'total-page-size', name: 'Total Page Size', category: 'performance', severity: 'warning' }, 'fail', `Total page size ${sizeMb.toFixed(2)}MB exceeds 5MB`, {
+                    value: ctx.totalPageSize,
+                    recommendation: 'Optimize images, defer scripts, and reduce overall page weight',
+                    evidence: {
+                        found: `${sizeMb.toFixed(2)}MB`,
+                        expected: '<5MB',
+                        impact: 'Very large pages significantly impact mobile users and Core Web Vitals'
+                    }
+                });
+            }
+            if (sizeMb > 3) {
+                return createResult({ id: 'total-page-size', name: 'Total Page Size', category: 'performance', severity: 'warning' }, 'warn', `Total page size ${sizeMb.toFixed(2)}MB is large`, {
+                    value: ctx.totalPageSize,
+                    recommendation: 'Consider optimizing resources to improve load times',
+                    evidence: {
+                        found: `${sizeMb.toFixed(2)}MB`,
+                        expected: '<3MB',
+                        impact: 'Large pages increase bounce rate, especially on mobile'
+                    }
+                });
+            }
+            return createResult({ id: 'total-page-size', name: 'Total Page Size', category: 'performance', severity: 'warning' }, 'pass', `Total page size ${sizeMb.toFixed(2)}MB is acceptable`);
+        },
+    },
+    {
+        id: 'server-response-time',
+        name: 'Server Response Time',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Server should respond within acceptable time limits',
+        check: (ctx) => {
+            const ttfb = ctx.timings?.ttfb;
+            if (ttfb === undefined) {
+                return createResult({ id: 'server-response-time', name: 'Server Response Time', category: 'performance', severity: 'warning' }, 'info', 'Not applicable (TTFB timing data unavailable)', { recommendation: 'This rule checks server response time (TTFB) for performance optimization' });
+            }
+            if (ttfb > 5000) {
+                return createResult({ id: 'server-response-time', name: 'Server Response Time', category: 'performance', severity: 'warning' }, 'fail', `TTFB ${(ttfb / 1000).toFixed(2)}s exceeds 5s`, {
+                    value: ttfb,
+                    recommendation: 'Investigate server performance, caching, and database queries',
+                    evidence: {
+                        found: `${(ttfb / 1000).toFixed(2)}s`,
+                        expected: '<5s',
+                        impact: 'Very slow server response leads to timeout errors and poor UX'
+                    }
+                });
+            }
+            if (ttfb > 2000) {
+                return createResult({ id: 'server-response-time', name: 'Server Response Time', category: 'performance', severity: 'warning' }, 'warn', `TTFB ${(ttfb / 1000).toFixed(2)}s is slow`, {
+                    value: ttfb,
+                    recommendation: 'Optimize server response time for better Core Web Vitals',
+                    evidence: {
+                        found: `${(ttfb / 1000).toFixed(2)}s`,
+                        expected: '<2s (ideally <600ms)',
+                        impact: 'Slow server response negatively affects LCP and user experience'
+                    }
+                });
+            }
+            return createResult({ id: 'server-response-time', name: 'Server Response Time', category: 'performance', severity: 'warning' }, 'pass', `TTFB ${ttfb}ms is good`);
+        },
+    },
+    {
+        id: 'url-length',
+        name: 'URL Length',
+        category: 'technical',
+        severity: 'warning',
+        description: 'URLs should not be excessively long',
+        check: (ctx) => {
+            if (!ctx.url) {
+                return createResult({ id: 'url-length', name: 'URL Length', category: 'technical', severity: 'warning' }, 'info', 'Not applicable (URL data unavailable)', { recommendation: 'This rule checks URL length to ensure it is within recommended limits' });
+            }
+            const length = ctx.url.length;
+            if (length > 2000) {
+                return createResult({ id: 'url-length', name: 'URL Length', category: 'technical', severity: 'warning' }, 'fail', `URL length ${length} chars exceeds browser limits`, {
+                    value: length,
+                    recommendation: 'Shorten URL to under 2000 characters',
+                    evidence: {
+                        found: `${length} characters`,
+                        expected: '<2000 characters',
+                        impact: 'URLs over 2000 characters may be truncated or rejected by browsers'
+                    }
+                });
+            }
+            if (length > 200) {
+                return createResult({ id: 'url-length', name: 'URL Length', category: 'technical', severity: 'warning' }, 'warn', `URL length ${length} chars is long`, {
+                    value: length,
+                    recommendation: 'Consider using shorter, cleaner URLs for SEO',
+                    evidence: {
+                        found: `${length} characters`,
+                        expected: '<200 characters for best SEO',
+                        impact: 'Long URLs are harder to share and may be truncated in SERPs'
+                    }
+                });
+            }
+            return createResult({ id: 'url-length', name: 'URL Length', category: 'technical', severity: 'warning' }, 'pass', `URL length ${length} chars is acceptable`);
+        },
+    },
+    {
+        id: 'url-special-chars',
+        name: 'URL Special Characters',
+        category: 'technical',
+        severity: 'warning',
+        description: 'URLs should not contain problematic special characters',
+        check: (ctx) => {
+            if (!ctx.url) {
+                return createResult({ id: 'url-special-chars', name: 'URL Special Characters', category: 'technical', severity: 'warning' }, 'info', 'Not applicable (URL data unavailable)', { recommendation: 'This rule checks for problematic special characters in URLs' });
+            }
+            try {
+                const urlObj = new URL(ctx.url);
+                const path = urlObj.pathname + urlObj.search;
+                const issues = [];
+                if (/[A-Z]/.test(path)) {
+                    issues.push('uppercase letters');
+                }
+                if (path.includes(' ') || path.includes('%20')) {
+                    issues.push('spaces');
+                }
+                if (path.includes('_')) {
+                    issues.push('underscores (use hyphens)');
+                }
+                if (/\/\//.test(path)) {
+                    issues.push('double slashes');
+                }
+                if (/[àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ]/i.test(decodeURIComponent(path))) {
+                    issues.push('accented characters');
+                }
+                if (issues.length > 0) {
+                    return createResult({ id: 'url-special-chars', name: 'URL Special Characters', category: 'technical', severity: 'warning' }, 'warn', `URL contains: ${issues.join(', ')}`, {
+                        recommendation: 'Use lowercase letters, hyphens, and avoid special characters',
+                        evidence: {
+                            found: issues,
+                            expected: 'Lowercase letters, numbers, hyphens only',
+                            impact: 'Non-standard URL characters can cause crawling and indexing issues'
+                        }
+                    });
+                }
+                return createResult({ id: 'url-special-chars', name: 'URL Special Characters', category: 'technical', severity: 'warning' }, 'pass', 'URL uses clean, SEO-friendly characters');
+            }
+            catch {
+                return createResult({ id: 'url-special-chars', name: 'URL Special Characters', category: 'technical', severity: 'warning' }, 'fail', 'Invalid URL syntax', {
+                    recommendation: 'Fix URL syntax',
+                    evidence: {
+                        found: ctx.url,
+                        expected: 'Valid URL format (e.g., https://example.com/path)',
+                        impact: 'Invalid URLs cannot be crawled or indexed',
+                        example: 'https://example.com/valid-path-with-hyphens',
+                    }
+                });
+            }
+        },
+    },
+    {
+        id: 'password-on-http',
+        name: 'Password Fields on HTTP',
+        category: 'security',
+        severity: 'error',
+        description: 'Pages with password fields must use HTTPS',
+        check: (ctx) => {
+            if (!ctx.hasPasswordField || ctx.isHttps === undefined) {
+                return createResult({ id: 'password-on-http', name: 'Password Fields on HTTP', category: 'security', severity: 'error' }, 'info', 'Not applicable (no password fields detected)', { recommendation: 'This rule ensures password fields are served over HTTPS for security' });
+            }
+            if (ctx.hasPasswordField && !ctx.isHttps) {
+                return createResult({ id: 'password-on-http', name: 'Password Fields on HTTP', category: 'security', severity: 'error' }, 'fail', 'Password field detected on non-HTTPS page', {
+                    recommendation: 'Serve login/registration pages over HTTPS only',
+                    evidence: {
+                        found: '<input type="password"> on HTTP',
+                        expected: 'HTTPS for all pages with password fields',
+                        impact: 'User credentials can be intercepted in transit',
+                        learnMore: 'https://web.dev/is-on-https/'
+                    }
+                });
+            }
+            return createResult({ id: 'password-on-http', name: 'Password Fields on HTTP', category: 'security', severity: 'error' }, 'pass', 'Password field properly served over HTTPS');
+        },
+    },
+    {
+        id: 'forms-on-http',
+        name: 'Forms on HTTP',
+        category: 'security',
+        severity: 'warning',
+        description: 'Forms should submit data over HTTPS',
+        check: (ctx) => {
+            if (ctx.formsOnHttp === undefined) {
+                return createResult({ id: 'forms-on-http', name: 'Forms on HTTP', category: 'security', severity: 'warning' }, 'info', 'Not applicable (form data unavailable)', { recommendation: 'This rule checks if forms submit data over secure HTTPS connections' });
+            }
+            if (ctx.formsOnHttp > 0) {
+                return createResult({ id: 'forms-on-http', name: 'Forms on HTTP', category: 'security', severity: 'warning' }, 'warn', `${ctx.formsOnHttp} form(s) submit to HTTP URLs`, {
+                    value: ctx.formsOnHttp,
+                    recommendation: 'Update form actions to use HTTPS URLs',
+                    evidence: {
+                        found: ctx.formsOnHttp,
+                        expected: 0,
+                        impact: 'Form data submitted over HTTP can be intercepted'
+                    }
+                });
+            }
+            return createResult({ id: 'forms-on-http', name: 'Forms on HTTP', category: 'security', severity: 'warning' }, 'pass', 'All forms submit over HTTPS or no forms detected');
+        },
+    },
+];

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

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