recker 1.0.32 → 1.0.33-next.bbc56eb

package/dist/seo/rules/security.js

@@ -522,4 +522,294 @@ export const securityRules = [
             return createResult({ id: 'security-corp', name: 'Cross-Origin-Resource-Policy', category: 'security', severity: 'info' }, 'pass', `CORP: ${corpHeader}`);
         },
     },
+    {
+        id: 'security-ssl-valid',
+        name: 'SSL Certificate Valid',
+        category: 'security',
+        severity: 'error',
+        description: 'SSL certificate must be valid and not expired',
+        check: (ctx) => {
+            if (ctx.sslCertificate === undefined)
+                return null;
+            if (!ctx.sslCertificate.valid) {
+                return createResult({ id: 'security-ssl-valid', name: 'SSL Certificate Valid', category: 'security', severity: 'error' }, 'fail', 'SSL certificate is invalid', {
+                    recommendation: 'Renew or replace the SSL certificate immediately',
+                    evidence: {
+                        found: ctx.sslCertificate.error || 'Invalid certificate',
+                        impact: 'Browsers will show security warnings, users may not trust the site',
+                    },
+                });
+            }
+            return createResult({ id: 'security-ssl-valid', name: 'SSL Certificate Valid', category: 'security', severity: 'error' }, 'pass', 'SSL certificate is valid');
+        },
+    },
+    {
+        id: 'security-ssl-expiry',
+        name: 'SSL Certificate Expiry',
+        category: 'security',
+        severity: 'warning',
+        description: 'SSL certificate should not expire within 30 days',
+        check: (ctx) => {
+            if (!ctx.sslCertificate?.expiryDate)
+                return null;
+            const expiryDate = new Date(ctx.sslCertificate.expiryDate);
+            const now = new Date();
+            const daysUntilExpiry = Math.floor((expiryDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+            if (daysUntilExpiry < 0) {
+                return createResult({ id: 'security-ssl-expiry', name: 'SSL Certificate Expiry', category: 'security', severity: 'warning' }, 'fail', 'SSL certificate has expired', {
+                    recommendation: 'Renew the SSL certificate immediately',
+                    evidence: {
+                        found: `Expired ${Math.abs(daysUntilExpiry)} days ago`,
+                        impact: 'Site is showing security warnings to all visitors',
+                    },
+                });
+            }
+            if (daysUntilExpiry < 7) {
+                return createResult({ id: 'security-ssl-expiry', name: 'SSL Certificate Expiry', category: 'security', severity: 'warning' }, 'fail', `SSL certificate expires in ${daysUntilExpiry} days`, {
+                    recommendation: 'Renew the SSL certificate urgently',
+                    evidence: {
+                        found: `Expires: ${expiryDate.toISOString().split('T')[0]}`,
+                        impact: 'Certificate will expire very soon',
+                    },
+                });
+            }
+            if (daysUntilExpiry < 30) {
+                return createResult({ id: 'security-ssl-expiry', name: 'SSL Certificate Expiry', category: 'security', severity: 'warning' }, 'warn', `SSL certificate expires in ${daysUntilExpiry} days`, {
+                    recommendation: 'Plan to renew the SSL certificate soon',
+                    evidence: {
+                        found: `Expires: ${expiryDate.toISOString().split('T')[0]}`,
+                    },
+                });
+            }
+            return createResult({ id: 'security-ssl-expiry', name: 'SSL Certificate Expiry', category: 'security', severity: 'warning' }, 'pass', `SSL certificate valid for ${daysUntilExpiry} days`);
+        },
+    },
+    {
+        id: 'security-ssl-name-match',
+        name: 'SSL Certificate Name Match',
+        category: 'security',
+        severity: 'error',
+        description: 'SSL certificate CN/SAN must match the domain',
+        check: (ctx) => {
+            if (ctx.sslCertificate?.nameMismatch === undefined)
+                return null;
+            if (ctx.sslCertificate.nameMismatch) {
+                return createResult({ id: 'security-ssl-name-match', name: 'SSL Certificate Name Match', category: 'security', severity: 'error' }, 'fail', 'SSL certificate name mismatch', {
+                    recommendation: 'Get a certificate that matches your domain name',
+                    evidence: {
+                        found: ctx.sslCertificate.commonName || 'Unknown',
+                        expected: ctx.sslCertificate.expectedDomain || 'Domain name',
+                        impact: 'Browsers will show certificate warning',
+                    },
+                });
+            }
+            return createResult({ id: 'security-ssl-name-match', name: 'SSL Certificate Name Match', category: 'security', severity: 'error' }, 'pass', 'SSL certificate matches domain');
+        },
+    },
+    {
+        id: 'security-tls-version',
+        name: 'TLS Version',
+        category: 'security',
+        severity: 'error',
+        description: 'Server should use TLS 1.2 or higher',
+        check: (ctx) => {
+            if (!ctx.tlsVersion)
+                return null;
+            const version = ctx.tlsVersion;
+            const insecureVersions = ['SSLv2', 'SSLv3', 'TLSv1', 'TLSv1.0', 'TLSv1.1'];
+            if (insecureVersions.includes(version)) {
+                return createResult({ id: 'security-tls-version', name: 'TLS Version', category: 'security', severity: 'error' }, 'fail', `Insecure TLS version: ${version}`, {
+                    recommendation: 'Upgrade to TLS 1.2 or TLS 1.3',
+                    evidence: {
+                        found: version,
+                        expected: 'TLSv1.2 or TLSv1.3',
+                        impact: 'Old TLS versions have known vulnerabilities',
+                    },
+                });
+            }
+            return createResult({ id: 'security-tls-version', name: 'TLS Version', category: 'security', severity: 'error' }, 'pass', `Using ${version}`);
+        },
+    },
+    {
+        id: 'security-ssl-issuer',
+        name: 'SSL Certificate Issuer',
+        category: 'security',
+        severity: 'info',
+        description: 'SSL certificate should be from a trusted CA',
+        check: (ctx) => {
+            if (!ctx.sslCertificate?.issuer)
+                return null;
+            const issuer = ctx.sslCertificate.issuer;
+            const selfSigned = issuer.toLowerCase().includes('self-signed') ||
+                ctx.sslCertificate.selfSigned === true;
+            if (selfSigned) {
+                return createResult({ id: 'security-ssl-issuer', name: 'SSL Certificate Issuer', category: 'security', severity: 'info' }, 'warn', 'Self-signed SSL certificate detected', {
+                    recommendation: 'Use a certificate from a trusted Certificate Authority',
+                    evidence: {
+                        found: issuer,
+                        impact: 'Self-signed certificates show warnings in browsers',
+                    },
+                });
+            }
+            return createResult({ id: 'security-ssl-issuer', name: 'SSL Certificate Issuer', category: 'security', severity: 'info' }, 'pass', `Certificate issued by: ${issuer}`);
+        },
+    },
+    {
+        id: 'security-password-on-http',
+        name: 'Password Fields on HTTP',
+        category: 'security',
+        severity: 'error',
+        description: 'Password fields must only appear on HTTPS pages',
+        check: (ctx) => {
+            if (ctx.hasPasswordField === undefined)
+                return null;
+            if (ctx.hasPasswordField && ctx.isHttps === false) {
+                return createResult({ id: 'security-password-on-http', name: 'Password Fields on HTTP', category: 'security', severity: 'error' }, 'fail', 'Password field on insecure HTTP page', {
+                    recommendation: 'Enable HTTPS for all pages with password fields',
+                    evidence: {
+                        impact: 'Passwords sent over HTTP can be intercepted',
+                    },
+                });
+            }
+            if (ctx.hasPasswordField && ctx.isHttps === true) {
+                return createResult({ id: 'security-password-on-http', name: 'Password Fields on HTTP', category: 'security', severity: 'error' }, 'pass', 'Password fields are on HTTPS');
+            }
+            return null;
+        },
+    },
+    {
+        id: 'security-forms-on-http',
+        name: 'Forms on HTTP',
+        category: 'security',
+        severity: 'warning',
+        description: 'Forms should only submit to HTTPS endpoints',
+        check: (ctx) => {
+            if (ctx.formsOnHttp === undefined)
+                return null;
+            if (ctx.formsOnHttp > 0) {
+                return createResult({ id: 'security-forms-on-http', name: 'Forms on HTTP', category: 'security', severity: 'warning' }, 'warn', `${ctx.formsOnHttp} form(s) submit to HTTP`, {
+                    value: ctx.formsOnHttp,
+                    recommendation: 'Update form actions to use HTTPS',
+                    evidence: {
+                        impact: 'Form data sent over HTTP can be intercepted',
+                    },
+                });
+            }
+            return createResult({ id: 'security-forms-on-http', name: 'Forms on HTTP', category: 'security', severity: 'warning' }, 'pass', 'All forms submit to HTTPS');
+        },
+    },
+    {
+        id: 'security-server-disclosure',
+        name: 'Server Version Disclosure',
+        category: 'security',
+        severity: 'info',
+        description: 'Server header should not reveal detailed version information',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const serverHeader = ctx.responseHeaders['server'] || ctx.responseHeaders['Server'];
+            if (!serverHeader)
+                return null;
+            const server = String(serverHeader);
+            if (/\d+\.\d+/.test(server)) {
+                return createResult({ id: 'security-server-disclosure', name: 'Server Version Disclosure', category: 'security', severity: 'info' }, 'info', `Server header reveals version: ${server}`, {
+                    recommendation: 'Configure server to hide version information',
+                    evidence: {
+                        found: server,
+                        impact: 'Attackers can target known vulnerabilities',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'security-x-powered-by',
+        name: 'X-Powered-By Header',
+        category: 'security',
+        severity: 'info',
+        description: 'X-Powered-By header reveals technology stack',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const xPoweredBy = ctx.responseHeaders['x-powered-by'] || ctx.responseHeaders['X-Powered-By'];
+            if (xPoweredBy) {
+                return createResult({ id: 'security-x-powered-by', name: 'X-Powered-By Header', category: 'security', severity: 'info' }, 'info', `X-Powered-By header present: ${xPoweredBy}`, {
+                    recommendation: 'Remove X-Powered-By header to reduce attack surface',
+                    evidence: {
+                        found: String(xPoweredBy),
+                        impact: 'Reveals technology stack to potential attackers',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'ssl-sni-support',
+        name: 'SNI Support',
+        category: 'security',
+        severity: 'info',
+        description: 'Server should support Server Name Indication (SNI)',
+        check: (ctx) => {
+            if (ctx.sniSupported === undefined)
+                return null;
+            if (!ctx.sniSupported) {
+                return createResult({ id: 'ssl-sni-support', name: 'SNI Support', category: 'security', severity: 'info' }, 'info', 'Server may not support SNI', {
+                    recommendation: 'Ensure web server supports SNI for proper HTTPS functionality',
+                    evidence: {
+                        impact: 'Some older browsers may have issues with SSL certificates without SNI support'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'sitemap-https-urls',
+        name: 'HTTPS URLs in Sitemap',
+        category: 'security',
+        severity: 'warning',
+        description: 'Sitemap should only contain HTTPS URLs',
+        check: (ctx) => {
+            if (ctx.sitemapHttpUrls === undefined)
+                return null;
+            if (ctx.sitemapHttpUrls > 0) {
+                return createResult({ id: 'sitemap-https-urls', name: 'HTTPS URLs in Sitemap', category: 'security', severity: 'warning' }, 'warn', `Sitemap contains ${ctx.sitemapHttpUrls} HTTP URLs`, {
+                    value: ctx.sitemapHttpUrls,
+                    recommendation: 'Replace all HTTP URLs in sitemap.xml with HTTPS versions',
+                    evidence: {
+                        found: `${ctx.sitemapHttpUrls} HTTP URLs`,
+                        expected: 'All URLs should use HTTPS',
+                        impact: 'HTTP URLs in sitemap can cause mixed content issues and indexing confusion'
+                    }
+                });
+            }
+            return createResult({ id: 'sitemap-https-urls', name: 'HTTPS URLs in Sitemap', category: 'security', severity: 'warning' }, 'pass', 'All sitemap URLs use HTTPS');
+        },
+    },
+    {
+        id: 'security-hsts',
+        name: 'HSTS Header',
+        category: 'security',
+        severity: 'info',
+        description: 'HTTPS sites should implement HSTS for security',
+        check: (ctx) => {
+            if (!ctx.isHttps)
+                return null;
+            if (ctx.hasHsts === undefined)
+                return null;
+            if (!ctx.hasHsts) {
+                return createResult({ id: 'security-hsts', name: 'HSTS Header', category: 'security', severity: 'info' }, 'info', 'Missing Strict-Transport-Security header', {
+                    recommendation: 'Implement HSTS to enforce HTTPS connections',
+                    evidence: {
+                        expected: 'Strict-Transport-Security: max-age=31536000; includeSubDomains',
+                        impact: 'Without HSTS, browsers may still attempt insecure HTTP connections',
+                        learnMore: 'https://web.dev/strict-transport-security/'
+                    }
+                });
+            }
+            return createResult({ id: 'security-hsts', name: 'HSTS Header', category: 'security', severity: 'info' }, 'pass', 'HSTS header is present');
+        },
+    },
 ];

package/dist/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/seo/rules/technical-advanced.js

@@ -0,0 +1,283 @@
+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 null;
+            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 null;
+        },
+    },
+    {
+        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 null;
+            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 null;
+            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 null;
+            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 null;
+            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 null;
+            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',
+                        impact: 'Invalid URLs cannot be crawled or indexed'
+                    }
+                });
+            }
+        },
+    },
+    {
+        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 null;
+            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/'
+                    }
+                });
+            }
+            if (ctx.hasPasswordField && ctx.isHttps) {
+                return createResult({ id: 'password-on-http', name: 'Password Fields on HTTP', category: 'security', severity: 'error' }, 'pass', 'Password field properly served over HTTPS');
+            }
+            return null;
+        },
+    },
+    {
+        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 null;
+            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 null;
+        },
+    },
+];