recker 1.0.27 → 1.0.28-next.c61382b

package/dist/seo/rules/security.js

@@ -0,0 +1,147 @@
+import { createResult } from './types.js';
+export const securityRules = [
+    {
+        id: 'https-required',
+        name: 'HTTPS',
+        category: 'security',
+        severity: 'error',
+        description: 'Page must be served over HTTPS',
+        check: (ctx) => {
+            if (ctx.isHttps === false) {
+                return createResult({ id: 'https-required', name: 'HTTPS', category: 'security', severity: 'error' }, 'fail', 'Page is not served over HTTPS', { recommendation: 'Enable HTTPS for all pages' });
+            }
+            if (ctx.isHttps === true) {
+                return createResult({ id: 'https-required', name: 'HTTPS', category: 'security', severity: 'error' }, 'pass', 'Page is served over HTTPS');
+            }
+            return null;
+        },
+    },
+    {
+        id: 'mixed-content',
+        name: 'Mixed Content',
+        category: 'security',
+        severity: 'error',
+        description: 'HTTPS pages should not load HTTP resources',
+        check: (ctx) => {
+            if (ctx.hasMixedContent) {
+                return createResult({ id: 'mixed-content', name: 'Mixed Content', category: 'security', severity: 'error' }, 'fail', 'Page has mixed content (HTTP resources on HTTPS page)', { recommendation: 'Update all resources to use HTTPS' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'security-csp-exists',
+        name: 'Content Security Policy (CSP)',
+        category: 'security',
+        severity: 'warning',
+        description: 'Content Security Policy header should be present to mitigate XSS attacks.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const cspHeader = ctx.responseHeaders['content-security-policy'] || ctx.responseHeaders['Content-Security-Policy'];
+            if (!cspHeader) {
+                return createResult({ id: 'security-csp-exists', name: 'Content Security Policy', category: 'security', severity: 'warning' }, 'warn', 'Content-Security-Policy header is missing', { recommendation: 'Implement a strong Content-Security-Policy to prevent XSS attacks.' });
+            }
+            return createResult({ id: 'security-csp-exists', name: 'Content Security Policy', category: 'security', severity: 'warning' }, 'pass', 'Content-Security-Policy header is present');
+        },
+    },
+    {
+        id: 'security-xfo-exists',
+        name: 'X-Frame-Options',
+        category: 'security',
+        severity: 'warning',
+        description: 'X-Frame-Options header should be present to prevent clickjacking.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const xfoHeader = ctx.responseHeaders['x-frame-options'] || ctx.responseHeaders['X-Frame-Options'];
+            if (!xfoHeader) {
+                return createResult({ id: 'security-xfo-exists', name: 'X-Frame-Options', category: 'security', severity: 'warning' }, 'warn', 'X-Frame-Options header is missing', { recommendation: 'Implement X-Frame-Options to prevent clickjacking attacks.' });
+            }
+            return createResult({ id: 'security-xfo-exists', name: 'X-Frame-Options', category: 'security', severity: 'warning' }, 'pass', `X-Frame-Options header is present: ${xfoHeader}`);
+        },
+    },
+    {
+        id: 'security-cors-config',
+        name: 'CORS Configuration',
+        category: 'security',
+        severity: 'warning',
+        description: 'Review Access-Control-Allow-Origin header for proper CORS configuration.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const acaoHeader = ctx.responseHeaders['access-control-allow-origin'] || ctx.responseHeaders['Access-Control-Allow-Origin'];
+            if (acaoHeader === '*') {
+                return createResult({ id: 'security-cors-config', name: 'CORS Configuration', category: 'security', severity: 'warning' }, 'warn', 'Access-Control-Allow-Origin is set to "*"', { recommendation: 'Avoid wildcard (*) in Access-Control-Allow-Origin for sensitive content. Specify allowed origins.' });
+            }
+            if (!acaoHeader) {
+                return createResult({ id: 'security-cors-config', name: 'CORS Configuration', category: 'security', severity: 'warning' }, 'info', 'Access-Control-Allow-Origin header is missing', { recommendation: 'Consider explicit CORS configuration if resources are consumed cross-origin.' });
+            }
+            return createResult({ id: 'security-cors-config', name: 'CORS Configuration', category: 'security', severity: 'warning' }, 'pass', `Access-Control-Allow-Origin: ${acaoHeader}`);
+        },
+    },
+    {
+        id: 'security-hsts-exists',
+        name: 'Strict-Transport-Security (HSTS)',
+        category: 'security',
+        severity: 'warning',
+        description: 'HSTS header forces secure connections and improves SEO indirectly.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const hstsHeader = ctx.responseHeaders['strict-transport-security'] || ctx.responseHeaders['Strict-Transport-Security'];
+            if (!hstsHeader) {
+                return createResult({ id: 'security-hsts-exists', name: 'HSTS Header', category: 'security', severity: 'warning' }, 'warn', 'Strict-Transport-Security header is missing', { recommendation: 'Implement HSTS to force secure connections and benefit SEO.' });
+            }
+            return createResult({ id: 'security-hsts-exists', name: 'HSTS Header', category: 'security', severity: 'warning' }, 'pass', `Strict-Transport-Security header is present: ${hstsHeader}`);
+        },
+    },
+    {
+        id: 'security-xcto-exists',
+        name: 'X-Content-Type-Options',
+        category: 'security',
+        severity: 'warning',
+        description: 'X-Content-Type-Options header prevents MIME sniffing attacks.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const xctoHeader = ctx.responseHeaders['x-content-type-options'] || ctx.responseHeaders['X-Content-Type-Options'];
+            if (!xctoHeader) {
+                return createResult({ id: 'security-xcto-exists', name: 'X-Content-Type-Options', category: 'security', severity: 'warning' }, 'warn', 'X-Content-Type-Options header is missing', { recommendation: 'Implement X-Content-Type-Options: nosniff to prevent MIME sniffing.' });
+            }
+            return createResult({ id: 'security-xcto-exists', name: 'X-Content-Type-Options', category: 'security', severity: 'warning' }, 'pass', `X-Content-Type-Options header is present: ${xctoHeader}`);
+        },
+    },
+    {
+        id: 'security-rp-exists',
+        name: 'Referrer-Policy',
+        category: 'security',
+        severity: 'info',
+        description: 'Referrer-Policy controls how much referrer information is sent with requests.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const rpHeader = ctx.responseHeaders['referrer-policy'] || ctx.responseHeaders['Referrer-Policy'];
+            if (!rpHeader) {
+                return createResult({ id: 'security-rp-exists', name: 'Referrer-Policy', category: 'security', severity: 'info' }, 'info', 'Referrer-Policy header is missing', { recommendation: 'Consider implementing a Referrer-Policy for better privacy and control (e.g., strict-origin-when-cross-origin).' });
+            }
+            return createResult({ id: 'security-rp-exists', name: 'Referrer-Policy', category: 'security', severity: 'info' }, 'pass', `Referrer-Policy header is present: ${rpHeader}`);
+        },
+    },
+    {
+        id: 'security-pp-exists',
+        name: 'Permissions-Policy',
+        category: 'security',
+        severity: 'info',
+        description: 'Permissions-Policy controls browser features available to the page and iframes.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const ppHeader = ctx.responseHeaders['permissions-policy'] || ctx.responseHeaders['Permissions-Policy'];
+            if (!ppHeader) {
+                return createResult({ id: 'security-pp-exists', name: 'Permissions-Policy', category: 'security', severity: 'info' }, 'info', 'Permissions-Policy header is missing', { recommendation: 'Consider implementing a Permissions-Policy to disable unused browser features and enhance security (e.g., camera=(), microphone=()).' });
+            }
+            return createResult({ id: 'security-pp-exists', name: 'Permissions-Policy', category: 'security', severity: 'info' }, 'pass', `Permissions-Policy header is present: ${ppHeader}`);
+        },
+    },
+];

package/dist/seo/rules/structural.d.ts

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

package/dist/seo/rules/structural.js

@@ -0,0 +1,155 @@
+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 null;
+            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 that describes the page content' });
+            }
+            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' });
+            }
+            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 null;
+            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` });
+            }
+            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` });
+            }
+            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 null;
+            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)' });
+            }
+            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 null;
+            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 null;
+        },
+    },
+    {
+        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 null;
+        },
+    },
+    {
+        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 null;
+        },
+    },
+    {
+        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 null;
+        },
+    },
+    {
+        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 null;
+        },
+    },
+    {
+        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 null;
+        },
+    },
+];

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

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

package/dist/seo/rules/technical.js

@@ -0,0 +1,223 @@
+import { createResult } from './types.js';
+import { SEO_THRESHOLDS } from './thresholds.js';
+export const technicalRules = [
+    {
+        id: 'canonical-exists',
+        name: 'Canonical URL',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Page should have a canonical URL',
+        check: (ctx) => {
+            if (!ctx.hasCanonical) {
+                return createResult({ id: 'canonical-exists', name: 'Canonical URL', category: 'technical', severity: 'warning' }, 'warn', 'No canonical URL defined', { recommendation: 'Add <link rel="canonical" href="..."> to prevent duplicate content' });
+            }
+            return createResult({ id: 'canonical-exists', name: 'Canonical URL', category: 'technical', severity: 'warning' }, 'pass', 'Canonical URL is defined', { value: ctx.canonicalUrl });
+        },
+    },
+    {
+        id: 'lang-exists',
+        name: 'Language',
+        category: 'technical',
+        severity: 'warning',
+        description: 'HTML should have lang attribute',
+        check: (ctx) => {
+            if (!ctx.hasLang) {
+                return createResult({ id: 'lang-exists', name: 'Language', category: 'technical', severity: 'warning' }, 'warn', 'Missing lang attribute on <html>', { recommendation: 'Add lang attribute: <html lang="en">' });
+            }
+            return createResult({ id: 'lang-exists', name: 'Language', category: 'technical', severity: 'warning' }, 'pass', `Language attribute set (${ctx.langValue})`);
+        },
+    },
+    {
+        id: 'charset-exists',
+        name: 'Charset',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Page should declare character encoding',
+        check: (ctx) => {
+            if (!ctx.hasCharset) {
+                return createResult({ id: 'charset-exists', name: 'Charset', category: 'technical', severity: 'warning' }, 'warn', 'Missing charset declaration', { recommendation: 'Add <meta charset="UTF-8"> in <head>' });
+            }
+            if (ctx.charset && ctx.charset.toLowerCase() !== 'utf-8') {
+                return createResult({ id: 'charset-exists', name: 'Charset', category: 'technical', severity: 'warning' }, 'warn', `Non-UTF-8 charset: ${ctx.charset}`, { recommendation: 'Use UTF-8 charset for best compatibility' });
+            }
+            return createResult({ id: 'charset-exists', name: 'Charset', category: 'technical', severity: 'warning' }, 'pass', 'UTF-8 charset declared');
+        },
+    },
+    {
+        id: 'robots-noindex',
+        name: 'Robots Noindex',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Check if page is set to noindex',
+        check: (ctx) => {
+            if (!ctx.metaRobots || ctx.metaRobots.length === 0)
+                return null;
+            if (ctx.metaRobots.includes('noindex')) {
+                return createResult({ id: 'robots-noindex', name: 'Robots', category: 'technical', severity: 'warning' }, 'warn', 'Page is set to noindex', { value: ctx.metaRobots.join(', '), recommendation: 'Remove noindex if you want the page to be indexed' });
+            }
+            return createResult({ id: 'robots-noindex', name: 'Robots', category: 'technical', severity: 'info' }, 'info', `Robots meta: ${ctx.metaRobots.join(', ')}`);
+        },
+    },
+    {
+        id: 'favicon-exists',
+        name: 'Favicon',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Page should have a favicon defined',
+        check: (ctx) => {
+            if (!ctx.hasFavicon) {
+                return createResult({ id: 'favicon-exists', name: 'Favicon', category: 'technical', severity: 'warning' }, 'warn', 'No favicon defined', { recommendation: 'Add <link rel="icon" href="/favicon.ico"> for browser tab icon' });
+            }
+            return createResult({ id: 'favicon-exists', name: 'Favicon', category: 'technical', severity: 'warning' }, 'pass', 'Favicon is defined', { value: ctx.faviconUrl });
+        },
+    },
+    {
+        id: 'url-length',
+        name: 'URL Length',
+        category: 'technical',
+        severity: 'info',
+        description: 'URL should be under 75 characters',
+        check: (ctx) => {
+            if (!ctx.url)
+                return null;
+            const len = ctx.urlLength ?? ctx.url.length;
+            const max = SEO_THRESHOLDS.url.maxLength;
+            if (len > max) {
+                return createResult({ id: 'url-length', name: 'URL Length', category: 'technical', severity: 'info' }, 'info', `URL is long (${len} chars)`, { value: len, recommendation: `Keep URLs under ${max} characters when possible` });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'url-lowercase',
+        name: 'URL Lowercase',
+        category: 'technical',
+        severity: 'warning',
+        description: 'URLs should be lowercase for consistency',
+        check: (ctx) => {
+            if (ctx.urlHasUppercase) {
+                return createResult({ id: 'url-lowercase', name: 'URL Lowercase', category: 'technical', severity: 'warning' }, 'warn', 'URL contains uppercase characters', { recommendation: 'Use lowercase URLs for better SEO consistency' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'url-clean',
+        name: 'URL Clean',
+        category: 'technical',
+        severity: 'warning',
+        description: 'URLs should not contain special characters or accents',
+        check: (ctx) => {
+            if (ctx.urlHasAccents || ctx.urlHasSpecialChars) {
+                const issues = [];
+                if (ctx.urlHasAccents)
+                    issues.push('accents');
+                if (ctx.urlHasSpecialChars)
+                    issues.push('special characters');
+                return createResult({ id: 'url-clean', name: 'URL Clean', category: 'technical', severity: 'warning' }, 'warn', `URL contains ${issues.join(' and ')}`, { recommendation: 'Use clean URLs without accents or special characters' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'url-no-params',
+        name: 'URL Parameters',
+        category: 'technical',
+        severity: 'warning',
+        description: 'URLs should not contain query parameters',
+        check: (ctx) => {
+            if (!ctx.url)
+                return null;
+            try {
+                const urlObj = new URL(ctx.url);
+                if (urlObj.search && urlObj.search.length > 1) {
+                    return createResult({ id: 'url-no-params', name: 'URL Parameters', category: 'technical', severity: 'warning' }, 'warn', 'URL contains query parameters', { value: urlObj.search, recommendation: 'Use clean URLs (rewritten paths) without query parameters' });
+                }
+            }
+            catch {
+            }
+            return null;
+        },
+    },
+    {
+        id: 'technical-meta-robots-directives',
+        name: 'Meta Robots Directives',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Check for restrictive meta robots directives like noindex, nofollow, noarchive etc.',
+        check: (ctx) => {
+            if (!ctx.metaRobots || ctx.metaRobots.length === 0)
+                return null;
+            const restrictiveDirectives = ['noindex', 'nofollow', 'noarchive', 'nosnippet', 'noimageindex'];
+            const foundRestrictive = ctx.metaRobots.filter(directive => restrictiveDirectives.includes(directive));
+            if (foundRestrictive.length > 0) {
+                return createResult({ id: 'technical-meta-robots-directives', name: 'Meta Robots Directives', category: 'technical', severity: 'warning' }, 'warn', `Restrictive meta robots directives found: ${foundRestrictive.join(', ')}`, { recommendation: 'Ensure these directives are intentional to prevent unintended blocking of indexing or crawling.' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'technical-x-robots-tag',
+        name: 'X-Robots-Tag Header',
+        category: 'technical',
+        severity: 'info',
+        description: 'X-Robots-Tag header can be used to control indexing, especially for non-HTML content.',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const xRobotsTag = ctx.responseHeaders['x-robots-tag'] || ctx.responseHeaders['X-Robots-Tag'];
+            if (xRobotsTag) {
+                return createResult({ id: 'technical-x-robots-tag', name: 'X-Robots-Tag Header', category: 'technical', severity: 'info' }, 'info', `X-Robots-Tag header found: ${xRobotsTag}`, { recommendation: 'Ensure X-Robots-Tag directives (e.g., noindex) are intentional.' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'technical-trust-signals',
+        name: 'Trust Signals (Links)',
+        category: 'technical',
+        severity: 'info',
+        description: 'Presence of links to "About", "Contact", "Privacy Policy", "Terms of Service" pages builds trust.',
+        check: (ctx) => {
+            const missingSignals = [];
+            if (!ctx.hasAboutPageLink)
+                missingSignals.push('About Page');
+            if (!ctx.hasContactPageLink)
+                missingSignals.push('Contact Page');
+            if (!ctx.hasPrivacyPolicyLink)
+                missingSignals.push('Privacy Policy');
+            if (!ctx.hasTermsOfServiceLink)
+                missingSignals.push('Terms of Service');
+            if (missingSignals.length > 0) {
+                return createResult({ id: 'technical-trust-signals', name: 'Trust Signals (Links)', category: 'technical', severity: 'info' }, 'info', `Missing links to key trust pages: ${missingSignals.join(', ')}`, { recommendation: 'Add clear links to "About Us", "Contact", "Privacy Policy", and "Terms of Service" pages to build user and search engine trust.' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'technical-text-html-ratio',
+        name: 'Text/HTML Ratio',
+        category: 'technical',
+        severity: 'info',
+        description: 'A higher text to HTML ratio indicates more content relative to code, which is good for SEO.',
+        check: (ctx) => {
+            if (ctx.textHtmlRatio === undefined)
+                return null;
+            const threshold = 15;
+            if (ctx.textHtmlRatio < threshold) {
+                return createResult({ id: 'technical-text-html-ratio', name: 'Text/HTML Ratio', category: 'technical', severity: 'info' }, 'warn', `Low Text/HTML ratio: ${ctx.textHtmlRatio.toFixed(2)}% (target > ${threshold}%)`, { recommendation: 'Increase text content relative to HTML code. Reduce unnecessary markup, or add more textual content.' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'technical-robots-txt-hint',
+        name: 'Robots.txt Hint',
+        category: 'technical',
+        severity: 'info',
+        description: 'Ensure a robots.txt file exists at the root of the domain to guide crawlers.',
+        check: (ctx) => {
+            return createResult({ id: 'technical-robots-txt-hint', name: 'Robots.txt Hint', category: 'technical', severity: 'info' }, 'info', 'Robots.txt existence cannot be verified from HTML alone.', { recommendation: 'Ensure a valid `robots.txt` file is present at your domain root (e.g., `https://example.com/robots.txt`) to guide search engine crawlers and define your sitemap location.' });
+        },
+    },
+];