recker 1.0.28 → 1.0.29

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

@@ -0,0 +1,375 @@
+import { createResult } from './types.js';
+export const internalLinkingRules = [
+    {
+        id: 'linking-internal-count',
+        name: 'Internal Link Count',
+        category: 'links',
+        severity: 'warning',
+        description: 'Pages should have a healthy number of internal links',
+        check: (ctx) => {
+            if (ctx.internalLinks === undefined)
+                return null;
+            const count = ctx.internalLinks;
+            if (count === 0) {
+                return createResult({ id: 'linking-internal-count', name: 'Internal Link Count', category: 'links', severity: 'warning' }, 'warn', 'No internal links found', {
+                    recommendation: 'Add internal links to improve navigation and crawlability',
+                    evidence: {
+                        found: 0,
+                        expected: 'At least 3-5 internal links per page',
+                        impact: 'Pages without internal links are harder to discover and may not pass link equity',
+                    },
+                });
+            }
+            if (count < 3) {
+                return createResult({ id: 'linking-internal-count', name: 'Internal Link Count', category: 'links', severity: 'warning' }, 'info', `Only ${count} internal link(s)`, {
+                    recommendation: 'Consider adding more internal links',
+                    evidence: {
+                        found: count,
+                        expected: 'At least 3-5 internal links',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-internal-count', name: 'Internal Link Count', category: 'links', severity: 'warning' }, 'pass', `${count} internal links`);
+        },
+    },
+    {
+        id: 'linking-internal-ratio',
+        name: 'Internal/External Link Ratio',
+        category: 'links',
+        severity: 'info',
+        description: 'Pages should have more internal than external links',
+        check: (ctx) => {
+            if (ctx.internalLinks === undefined || ctx.externalLinks === undefined)
+                return null;
+            if (ctx.totalLinks === undefined || ctx.totalLinks === 0)
+                return null;
+            const internal = ctx.internalLinks;
+            const external = ctx.externalLinks;
+            const ratio = internal / (external || 1);
+            if (external > internal && external > 5) {
+                return createResult({ id: 'linking-internal-ratio', name: 'Internal/External Link Ratio', category: 'links', severity: 'info' }, 'info', `More external (${external}) than internal (${internal}) links`, {
+                    recommendation: 'Consider adding more internal links for better link equity',
+                    evidence: {
+                        found: `${internal} internal, ${external} external`,
+                        expected: 'Internal links should exceed external links',
+                        impact: 'External links pass PageRank to other sites',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-internal-ratio', name: 'Internal/External Link Ratio', category: 'links', severity: 'info' }, 'pass', `Ratio: ${ratio.toFixed(1)}:1 (internal:external)`);
+        },
+    },
+    {
+        id: 'linking-anchor-diversity',
+        name: 'Anchor Text Diversity',
+        category: 'links',
+        severity: 'info',
+        description: 'Internal links should use diverse, descriptive anchor text',
+        check: (ctx) => {
+            if (!ctx.allLinks || ctx.allLinks.length === 0)
+                return null;
+            const internalLinks = ctx.allLinks.filter(l => l.type === 'internal');
+            if (internalLinks.length < 3)
+                return null;
+            const anchorCounts = {};
+            for (const link of internalLinks) {
+                const anchor = (link.text || '').toLowerCase().trim();
+                if (anchor && anchor.length > 2) {
+                    anchorCounts[anchor] = (anchorCounts[anchor] || 0) + 1;
+                }
+            }
+            const overused = Object.entries(anchorCounts)
+                .filter(([_, count]) => count >= 3)
+                .map(([anchor, count]) => `"${anchor}" (${count}x)`);
+            if (overused.length > 0) {
+                return createResult({ id: 'linking-anchor-diversity', name: 'Anchor Text Diversity', category: 'links', severity: 'info' }, 'info', `Some anchor texts overused`, {
+                    recommendation: 'Vary anchor text for better SEO signal distribution',
+                    evidence: {
+                        found: overused.slice(0, 3),
+                        impact: 'Repetitive anchors may look spammy to search engines',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-anchor-diversity', name: 'Anchor Text Diversity', category: 'links', severity: 'info' }, 'pass', 'Good anchor text diversity');
+        },
+    },
+    {
+        id: 'linking-deep-links',
+        name: 'Deep Linking',
+        category: 'links',
+        severity: 'info',
+        description: 'Pages should link to deep content, not just homepage',
+        check: (ctx) => {
+            if (!ctx.allLinks || ctx.allLinks.length === 0)
+                return null;
+            const internalLinks = ctx.allLinks.filter(l => l.type === 'internal');
+            if (internalLinks.length === 0)
+                return null;
+            let rootLinks = 0;
+            let deepLinks = 0;
+            for (const link of internalLinks) {
+                try {
+                    const url = new URL(link.href, ctx.url);
+                    if (url.pathname === '/' || url.pathname === '') {
+                        rootLinks++;
+                    }
+                    else {
+                        deepLinks++;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            const deepRatio = deepLinks / internalLinks.length;
+            if (rootLinks > deepLinks && internalLinks.length > 5) {
+                return createResult({ id: 'linking-deep-links', name: 'Deep Linking', category: 'links', severity: 'info' }, 'info', `Most internal links go to homepage`, {
+                    recommendation: 'Add more links to inner pages',
+                    evidence: {
+                        found: `${rootLinks} homepage links, ${deepLinks} deep links`,
+                        expected: 'More deep links than homepage links',
+                        impact: 'Deep linking improves crawlability of inner pages',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-deep-links', name: 'Deep Linking', category: 'links', severity: 'info' }, 'pass', `${Math.round(deepRatio * 100)}% deep links`);
+        },
+    },
+    {
+        id: 'linking-nav-links',
+        name: 'Navigation Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Check for proper navigation link structure',
+        check: (ctx) => {
+            if (!ctx.hasNav)
+                return null;
+            if (ctx.navLinkCount === undefined)
+                return null;
+            if (ctx.navLinkCount === 0) {
+                return createResult({ id: 'linking-nav-links', name: 'Navigation Links', category: 'links', severity: 'info' }, 'warn', 'Navigation element has no links', {
+                    recommendation: 'Add links to navigation for user experience and SEO',
+                    evidence: {
+                        found: '<nav> element with no links',
+                        expected: 'Navigation should contain meaningful links',
+                    },
+                });
+            }
+            if (ctx.navLinkCount > 20) {
+                return createResult({ id: 'linking-nav-links', name: 'Navigation Links', category: 'links', severity: 'info' }, 'info', `Navigation has ${ctx.navLinkCount} links (high)`, {
+                    recommendation: 'Consider simplifying navigation',
+                    evidence: {
+                        found: ctx.navLinkCount,
+                        expected: 'Under 20 links for optimal UX',
+                        impact: 'Too many nav links may dilute link equity',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-nav-links', name: 'Navigation Links', category: 'links', severity: 'info' }, 'pass', `${ctx.navLinkCount} navigation links`);
+        },
+    },
+    {
+        id: 'linking-footer-links',
+        name: 'Footer Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Footer should contain important site-wide links',
+        check: (ctx) => {
+            if (!ctx.hasFooter)
+                return null;
+            if (ctx.footerLinkCount === undefined)
+                return null;
+            if (ctx.footerLinkCount === 0) {
+                return createResult({ id: 'linking-footer-links', name: 'Footer Links', category: 'links', severity: 'info' }, 'info', 'Footer has no links', {
+                    recommendation: 'Add important links to footer',
+                    evidence: {
+                        expected: 'Links to privacy policy, terms, contact, sitemap',
+                    },
+                });
+            }
+            if (ctx.footerLinkCount > 50) {
+                return createResult({ id: 'linking-footer-links', name: 'Footer Links', category: 'links', severity: 'info' }, 'info', `Footer has ${ctx.footerLinkCount} links (excessive)`, {
+                    recommendation: 'Reduce footer links to essential pages',
+                    evidence: {
+                        found: ctx.footerLinkCount,
+                        impact: 'Excessive footer links may be seen as link spam',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-footer-links', name: 'Footer Links', category: 'links', severity: 'info' }, 'pass', `${ctx.footerLinkCount} footer links`);
+        },
+    },
+    {
+        id: 'linking-contextual',
+        name: 'Contextual Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Check for in-content contextual links',
+        check: (ctx) => {
+            if (ctx.contextualLinkCount === undefined)
+                return null;
+            if (!ctx.wordCount || ctx.wordCount < 300)
+                return null;
+            const count = ctx.contextualLinkCount;
+            if (count === 0) {
+                return createResult({ id: 'linking-contextual', name: 'Contextual Links', category: 'links', severity: 'info' }, 'info', 'No contextual links in content', {
+                    recommendation: 'Add links within body content to related pages',
+                    evidence: {
+                        expected: 'At least 2-3 contextual links per 500 words',
+                        impact: 'Contextual links pass more link equity than navigation links',
+                    },
+                });
+            }
+            const linksPerWords = (count / ctx.wordCount) * 500;
+            if (linksPerWords < 1 && ctx.wordCount > 500) {
+                return createResult({ id: 'linking-contextual', name: 'Contextual Links', category: 'links', severity: 'info' }, 'info', `Only ${count} contextual link(s) in ${ctx.wordCount} words`, {
+                    recommendation: 'Add more in-content links',
+                    evidence: {
+                        found: `${linksPerWords.toFixed(1)} links per 500 words`,
+                        expected: '2-3 links per 500 words',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-contextual', name: 'Contextual Links', category: 'links', severity: 'info' }, 'pass', `${count} contextual links`);
+        },
+    },
+    {
+        id: 'linking-orphan-page',
+        name: 'Orphan Page Detection',
+        category: 'links',
+        severity: 'warning',
+        description: 'Pages should be linked from other pages on the site',
+        check: (ctx) => {
+            if (ctx.incomingInternalLinks === undefined)
+                return null;
+            if (ctx.incomingInternalLinks === 0) {
+                return createResult({ id: 'linking-orphan-page', name: 'Orphan Page Detection', category: 'links', severity: 'warning' }, 'warn', 'Page may be an orphan (no incoming internal links)', {
+                    recommendation: 'Link to this page from other pages on your site',
+                    evidence: {
+                        found: '0 incoming internal links detected',
+                        impact: 'Orphan pages are harder for search engines to discover',
+                        learnMore: 'https://ahrefs.com/blog/orphan-pages/',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-orphan-page', name: 'Orphan Page Detection', category: 'links', severity: 'warning' }, 'pass', `${ctx.incomingInternalLinks} incoming internal link(s)`);
+        },
+    },
+    {
+        id: 'linking-self-referencing',
+        name: 'Self-Referencing Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Avoid excessive self-referencing links',
+        check: (ctx) => {
+            if (ctx.selfReferencingLinks === undefined)
+                return null;
+            if (ctx.selfReferencingLinks > 3) {
+                return createResult({ id: 'linking-self-referencing', name: 'Self-Referencing Links', category: 'links', severity: 'info' }, 'info', `${ctx.selfReferencingLinks} self-referencing links`, {
+                    recommendation: 'Reduce links that point to the current page',
+                    evidence: {
+                        found: ctx.selfReferencingLinks,
+                        expected: '0-1 self-referencing links (e.g., canonical only)',
+                        impact: 'Self-links waste crawl budget and confuse users',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'linking-broken-internal',
+        name: 'Broken Internal Links',
+        category: 'links',
+        severity: 'error',
+        description: 'Internal links should not be broken',
+        check: (ctx) => {
+            if (ctx.brokenInternalLinks === undefined)
+                return null;
+            if (ctx.brokenInternalLinks > 0) {
+                return createResult({ id: 'linking-broken-internal', name: 'Broken Internal Links', category: 'links', severity: 'error' }, 'fail', `${ctx.brokenInternalLinks} broken internal link(s)`, {
+                    recommendation: 'Fix or remove broken internal links',
+                    evidence: {
+                        found: ctx.brokenInternalLinks,
+                        expected: '0 broken links',
+                        impact: 'Broken links waste crawl budget and harm user experience',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-broken-internal', name: 'Broken Internal Links', category: 'links', severity: 'error' }, 'pass', 'No broken internal links');
+        },
+    },
+    {
+        id: 'linking-redirect-chains',
+        name: 'Redirect Chains',
+        category: 'links',
+        severity: 'warning',
+        description: 'Internal links should not go through redirect chains',
+        check: (ctx) => {
+            if (ctx.redirectChainLinks === undefined)
+                return null;
+            if (ctx.redirectChainLinks > 0) {
+                return createResult({ id: 'linking-redirect-chains', name: 'Redirect Chains', category: 'links', severity: 'warning' }, 'warn', `${ctx.redirectChainLinks} link(s) go through redirects`, {
+                    recommendation: 'Update links to point to final destination URLs',
+                    evidence: {
+                        found: ctx.redirectChainLinks,
+                        expected: '0 redirect chain links',
+                        impact: 'Redirect chains slow down crawling and lose link equity',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-redirect-chains', name: 'Redirect Chains', category: 'links', severity: 'warning' }, 'pass', 'No redirect chain links');
+        },
+    },
+    {
+        id: 'linking-nofollow-internal',
+        name: 'Nofollow Internal Links',
+        category: 'links',
+        severity: 'warning',
+        description: 'Internal links should not use nofollow',
+        check: (ctx) => {
+            if (!ctx.allLinks)
+                return null;
+            const nofollowInternal = ctx.allLinks.filter(l => l.type === 'internal' && l.rel?.includes('nofollow'));
+            if (nofollowInternal.length > 0) {
+                return createResult({ id: 'linking-nofollow-internal', name: 'Nofollow Internal Links', category: 'links', severity: 'warning' }, 'warn', `${nofollowInternal.length} internal link(s) have nofollow`, {
+                    recommendation: 'Remove nofollow from internal links',
+                    evidence: {
+                        found: nofollowInternal.slice(0, 3).map(l => l.href),
+                        impact: 'Nofollow on internal links wastes PageRank',
+                        learnMore: 'https://developers.google.com/search/docs/crawling-indexing/qualify-outbound-links',
+                    },
+                });
+            }
+            return createResult({ id: 'linking-nofollow-internal', name: 'Nofollow Internal Links', category: 'links', severity: 'warning' }, 'pass', 'No nofollow on internal links');
+        },
+    },
+    {
+        id: 'linking-click-depth',
+        name: 'Click Depth',
+        category: 'links',
+        severity: 'info',
+        description: 'Important pages should be reachable in few clicks',
+        check: (ctx) => {
+            if (ctx.pageClickDepth === undefined)
+                return null;
+            const depth = ctx.pageClickDepth;
+            if (depth > 4) {
+                return createResult({ id: 'linking-click-depth', name: 'Click Depth', category: 'links', severity: 'info' }, 'warn', `Page is ${depth} clicks from homepage`, {
+                    recommendation: 'Improve site architecture for better accessibility',
+                    evidence: {
+                        found: `${depth} clicks deep`,
+                        expected: 'Under 4 clicks from homepage',
+                        impact: 'Deep pages receive less crawl priority and link equity',
+                    },
+                });
+            }
+            if (depth > 3) {
+                return createResult({ id: 'linking-click-depth', name: 'Click Depth', category: 'links', severity: 'info' }, 'info', `Page is ${depth} clicks from homepage`, {
+                    recommendation: 'Consider adding shortcuts to this page',
+                });
+            }
+            return createResult({ id: 'linking-click-depth', name: 'Click Depth', category: 'links', severity: 'info' }, 'pass', `${depth} click(s) from homepage`);
+        },
+    },
+];

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

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

package/dist/seo/rules/local.js

@@ -0,0 +1,265 @@
+import { createResult } from './types.js';
+export const localRules = [
+    {
+        id: 'local-business-schema',
+        name: 'LocalBusiness Schema',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Local businesses should have LocalBusiness schema',
+        check: (ctx) => {
+            if (!ctx.jsonLdTypes)
+                return null;
+            const localBusinessTypes = [
+                'LocalBusiness', 'Restaurant', 'Store', 'MedicalBusiness',
+                'FinancialService', 'FoodEstablishment', 'HealthAndBeautyBusiness',
+                'HomeAndConstructionBusiness', 'LegalService', 'RealEstateAgent',
+                'SportingGoodsStore', 'AutoDealer', 'AutoRepair', 'Bakery',
+                'BarOrPub', 'BeautySalon', 'CafeOrCoffeeShop', 'Dentist',
+                'DryCleaningOrLaundry', 'Florist', 'GasStation', 'GroceryStore',
+                'HairSalon', 'HardwareStore', 'Hospital', 'Hotel', 'InsuranceAgency',
+                'LodgingBusiness', 'MovingCompany', 'Pharmacy', 'Physician',
+                'PlaceOfWorship', 'Plumber', 'RealEstateAgent', 'ShoppingCenter',
+            ];
+            const hasLocalBusiness = ctx.jsonLdTypes.some(t => localBusinessTypes.includes(t));
+            if (!hasLocalBusiness && ctx.hasLocalBusinessSignals) {
+                return createResult({ id: 'local-business-schema', name: 'LocalBusiness Schema', category: 'structured-data', severity: 'info' }, 'info', 'Page may benefit from LocalBusiness schema', {
+                    recommendation: 'Add LocalBusiness structured data for local search visibility',
+                    evidence: {
+                        expected: 'LocalBusiness schema with name, address, phone, hours',
+                        example: `{
+  "@type": "LocalBusiness",
+  "name": "Business Name",
+  "address": {
+    "@type": "PostalAddress",
+    "streetAddress": "123 Main St",
+    "addressLocality": "City",
+    "addressRegion": "State",
+    "postalCode": "12345"
+  },
+  "telephone": "+1-234-567-8900"
+}`,
+                        learnMore: 'https://developers.google.com/search/docs/appearance/structured-data/local-business',
+                    },
+                });
+            }
+            if (hasLocalBusiness) {
+                const foundTypes = ctx.jsonLdTypes.filter(t => localBusinessTypes.includes(t));
+                return createResult({ id: 'local-business-schema', name: 'LocalBusiness Schema', category: 'structured-data', severity: 'info' }, 'pass', `LocalBusiness schema found: ${foundTypes.join(', ')}`);
+            }
+            return null;
+        },
+    },
+    {
+        id: 'local-business-address',
+        name: 'Business Address',
+        category: 'structured-data',
+        severity: 'warning',
+        description: 'LocalBusiness schema should include complete address',
+        check: (ctx) => {
+            if (!ctx.localBusinessSchema)
+                return null;
+            const address = ctx.localBusinessSchema.address;
+            if (!address) {
+                return createResult({ id: 'local-business-address', name: 'Business Address', category: 'structured-data', severity: 'warning' }, 'warn', 'LocalBusiness schema missing address', {
+                    recommendation: 'Add PostalAddress for Google Maps and local search',
+                    evidence: {
+                        expected: 'address with streetAddress, addressLocality, addressRegion, postalCode',
+                        impact: 'Businesses without address may not appear in local pack results',
+                    },
+                });
+            }
+            const missingFields = [];
+            if (!address.streetAddress)
+                missingFields.push('streetAddress');
+            if (!address.addressLocality)
+                missingFields.push('addressLocality (city)');
+            if (!address.addressRegion)
+                missingFields.push('addressRegion (state)');
+            if (!address.postalCode)
+                missingFields.push('postalCode');
+            if (missingFields.length > 0) {
+                return createResult({ id: 'local-business-address', name: 'Business Address', category: 'structured-data', severity: 'warning' }, 'warn', `Address incomplete: missing ${missingFields.join(', ')}`, {
+                    recommendation: 'Complete address for better local SEO',
+                    evidence: {
+                        found: Object.keys(address).join(', '),
+                        expected: 'streetAddress, addressLocality, addressRegion, postalCode, addressCountry',
+                    },
+                });
+            }
+            return createResult({ id: 'local-business-address', name: 'Business Address', category: 'structured-data', severity: 'warning' }, 'pass', 'Complete address in LocalBusiness schema');
+        },
+    },
+    {
+        id: 'local-business-phone',
+        name: 'Business Phone',
+        category: 'structured-data',
+        severity: 'warning',
+        description: 'LocalBusiness schema should include phone number',
+        check: (ctx) => {
+            if (!ctx.localBusinessSchema)
+                return null;
+            const phone = ctx.localBusinessSchema.telephone;
+            if (!phone) {
+                return createResult({ id: 'local-business-phone', name: 'Business Phone', category: 'structured-data', severity: 'warning' }, 'warn', 'LocalBusiness schema missing phone number', {
+                    recommendation: 'Add telephone for click-to-call functionality',
+                    evidence: {
+                        expected: 'telephone in E.164 format: +1-234-567-8900',
+                        impact: 'Phone number is crucial for local search and mobile users',
+                    },
+                });
+            }
+            const phoneStr = String(phone);
+            const hasCountryCode = phoneStr.startsWith('+');
+            if (!hasCountryCode) {
+                return createResult({ id: 'local-business-phone', name: 'Business Phone', category: 'structured-data', severity: 'warning' }, 'info', 'Phone number should include country code', {
+                    evidence: {
+                        found: phoneStr,
+                        expected: 'E.164 format with country code: +1-234-567-8900',
+                    },
+                });
+            }
+            return createResult({ id: 'local-business-phone', name: 'Business Phone', category: 'structured-data', severity: 'warning' }, 'pass', `Phone: ${phoneStr}`);
+        },
+    },
+    {
+        id: 'local-business-hours',
+        name: 'Business Hours',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'LocalBusiness schema should include opening hours',
+        check: (ctx) => {
+            if (!ctx.localBusinessSchema)
+                return null;
+            const hours = ctx.localBusinessSchema.openingHoursSpecification ||
+                ctx.localBusinessSchema.openingHours;
+            if (!hours) {
+                return createResult({ id: 'local-business-hours', name: 'Business Hours', category: 'structured-data', severity: 'info' }, 'info', 'LocalBusiness schema missing opening hours', {
+                    recommendation: 'Add openingHoursSpecification for "open now" filters',
+                    evidence: {
+                        example: `"openingHoursSpecification": [{
+  "@type": "OpeningHoursSpecification",
+  "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+  "opens": "09:00",
+  "closes": "17:00"
+}]`,
+                        impact: 'Opening hours help users find open businesses',
+                    },
+                });
+            }
+            return createResult({ id: 'local-business-hours', name: 'Business Hours', category: 'structured-data', severity: 'info' }, 'pass', 'Opening hours specified');
+        },
+    },
+    {
+        id: 'local-business-geo',
+        name: 'Business Coordinates',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'LocalBusiness schema should include geo coordinates',
+        check: (ctx) => {
+            if (!ctx.localBusinessSchema)
+                return null;
+            const geo = ctx.localBusinessSchema.geo;
+            if (!geo) {
+                return createResult({ id: 'local-business-geo', name: 'Business Coordinates', category: 'structured-data', severity: 'info' }, 'info', 'LocalBusiness schema missing geo coordinates', {
+                    recommendation: 'Add latitude/longitude for precise map placement',
+                    evidence: {
+                        example: `"geo": {
+  "@type": "GeoCoordinates",
+  "latitude": "40.7128",
+  "longitude": "-74.0060"
+}`,
+                        impact: 'Coordinates ensure accurate Google Maps integration',
+                    },
+                });
+            }
+            const lat = geo.latitude;
+            const lng = geo.longitude;
+            if (!lat || !lng) {
+                return createResult({ id: 'local-business-geo', name: 'Business Coordinates', category: 'structured-data', severity: 'info' }, 'warn', 'Geo coordinates incomplete', {
+                    evidence: {
+                        found: `lat: ${lat}, lng: ${lng}`,
+                        expected: 'Both latitude and longitude required',
+                    },
+                });
+            }
+            return createResult({ id: 'local-business-geo', name: 'Business Coordinates', category: 'structured-data', severity: 'info' }, 'pass', `Geo: ${lat}, ${lng}`);
+        },
+    },
+    {
+        id: 'local-nap-presence',
+        name: 'NAP Presence',
+        category: 'content',
+        severity: 'info',
+        description: 'Local business pages should display Name, Address, Phone (NAP)',
+        check: (ctx) => {
+            if (!ctx.hasLocalBusinessSignals)
+                return null;
+            const missing = [];
+            if (!ctx.hasPhoneOnPage)
+                missing.push('Phone');
+            if (!ctx.hasAddressOnPage)
+                missing.push('Address');
+            if (missing.length > 0) {
+                return createResult({ id: 'local-nap-presence', name: 'NAP Presence', category: 'content', severity: 'info' }, 'info', `Missing visible NAP elements: ${missing.join(', ')}`, {
+                    recommendation: 'Display business name, address, and phone prominently on page',
+                    evidence: {
+                        issue: 'NAP should be visible to users, not just in schema',
+                        impact: 'Visible NAP improves trust and local SEO consistency',
+                    },
+                });
+            }
+            return createResult({ id: 'local-nap-presence', name: 'NAP Presence', category: 'content', severity: 'info' }, 'pass', 'NAP information visible on page');
+        },
+    },
+    {
+        id: 'local-service-area',
+        name: 'Service Area',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Service area businesses should specify their coverage',
+        check: (ctx) => {
+            if (!ctx.localBusinessSchema)
+                return null;
+            const isServiceArea = ctx.localBusinessSchema['@type'] === 'ServiceAreaBusiness' ||
+                ctx.localBusinessSchema.areaServed !== undefined;
+            if (!isServiceArea)
+                return null;
+            const areaServed = ctx.localBusinessSchema.areaServed;
+            if (!areaServed) {
+                return createResult({ id: 'local-service-area', name: 'Service Area', category: 'structured-data', severity: 'info' }, 'info', 'Service area business missing areaServed', {
+                    recommendation: 'Define the geographic area you serve',
+                    evidence: {
+                        example: `"areaServed": {
+  "@type": "GeoCircle",
+  "geoMidpoint": { "latitude": "40.7128", "longitude": "-74.0060" },
+  "geoRadius": "50 mi"
+}`,
+                    },
+                });
+            }
+            return createResult({ id: 'local-service-area', name: 'Service Area', category: 'structured-data', severity: 'info' }, 'pass', 'Service area defined');
+        },
+    },
+    {
+        id: 'local-pricerange',
+        name: 'Price Range',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'LocalBusiness can include price range for user expectations',
+        check: (ctx) => {
+            if (!ctx.localBusinessSchema)
+                return null;
+            const priceRange = ctx.localBusinessSchema.priceRange;
+            if (!priceRange) {
+                return createResult({ id: 'local-pricerange', name: 'Price Range', category: 'structured-data', severity: 'info' }, 'info', 'LocalBusiness missing price range', {
+                    recommendation: 'Add priceRange (e.g., "$$", "$$$") for user expectations',
+                    evidence: {
+                        example: '"priceRange": "$$" (uses $ symbols: $, $$, $$$, $$$$)',
+                        impact: 'Helps users filter by budget in search results',
+                    },
+                });
+            }
+            return createResult({ id: 'local-pricerange', name: 'Price Range', category: 'structured-data', severity: 'info' }, 'pass', `Price range: ${priceRange}`);
+        },
+    },
+];

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

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