recker 1.0.28 → 1.0.29-next.72485b7

package/dist/seo/rules/cwv.js

@@ -0,0 +1,337 @@
+import { createResult } from './types.js';
+export const cwvRules = [
+    {
+        id: 'cwv-lcp-hero-image',
+        name: 'LCP Hero Image',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Hero images should be optimized for fast LCP',
+        check: (ctx) => {
+            if (!ctx.lcpCandidate)
+                return null;
+            const issues = [];
+            if (ctx.lcpCandidate.loading === 'lazy') {
+                issues.push('LCP image has loading="lazy" (should be eager or omitted)');
+            }
+            if (!ctx.lcpCandidate.fetchpriority) {
+                issues.push('Missing fetchpriority="high" on LCP image');
+            }
+            if (!ctx.hasLcpPreload) {
+                issues.push('LCP image not preloaded');
+            }
+            if (issues.length > 0) {
+                return createResult({ id: 'cwv-lcp-hero-image', name: 'LCP Hero Image', category: 'performance', severity: 'warning' }, 'warn', `LCP optimization issues: ${issues.length} found`, {
+                    recommendation: 'Optimize LCP image loading',
+                    evidence: {
+                        found: issues,
+                        expected: 'LCP image with fetchpriority="high", no lazy loading, and preload link',
+                        example: `<link rel="preload" as="image" href="hero.webp" fetchpriority="high">
+<img src="hero.webp" fetchpriority="high" alt="Hero">`,
+                        impact: 'LCP is a Core Web Vital - aim for < 2.5s',
+                        learnMore: 'https://web.dev/lcp/',
+                    },
+                });
+            }
+            return createResult({ id: 'cwv-lcp-hero-image', name: 'LCP Hero Image', category: 'performance', severity: 'warning' }, 'pass', 'LCP image appears optimized');
+        },
+    },
+    {
+        id: 'cwv-lcp-text-visible',
+        name: 'LCP Text Visibility',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Text LCP elements should render immediately without font blocking',
+        check: (ctx) => {
+            if (!ctx.webFonts || ctx.webFonts.length === 0)
+                return null;
+            const blockingFonts = ctx.webFonts.filter(f => !f.hasSwap && !f.hasOptional);
+            if (blockingFonts.length > 0) {
+                return createResult({ id: 'cwv-lcp-text-visible', name: 'LCP Text Visibility', category: 'performance', severity: 'warning' }, 'warn', `${blockingFonts.length} web font(s) may block text rendering`, {
+                    recommendation: 'Use font-display: swap or optional for web fonts',
+                    evidence: {
+                        found: blockingFonts.map(f => f.family).filter(Boolean).slice(0, 3),
+                        expected: 'font-display: swap or font-display: optional',
+                        example: '@font-face { font-display: swap; }',
+                        impact: 'Blocking fonts delay LCP for text elements',
+                        learnMore: 'https://web.dev/font-display/',
+                    },
+                });
+            }
+            return createResult({ id: 'cwv-lcp-text-visible', name: 'LCP Text Visibility', category: 'performance', severity: 'warning' }, 'pass', 'Web fonts use non-blocking display');
+        },
+    },
+    {
+        id: 'cwv-render-blocking-css',
+        name: 'Render-Blocking CSS',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Minimize render-blocking CSS for faster LCP',
+        check: (ctx) => {
+            if (ctx.renderBlockingStylesheets === undefined)
+                return null;
+            if (ctx.renderBlockingStylesheets > 3) {
+                return createResult({ id: 'cwv-render-blocking-css', name: 'Render-Blocking CSS', category: 'performance', severity: 'warning' }, 'warn', `${ctx.renderBlockingStylesheets} render-blocking stylesheets`, {
+                    recommendation: 'Reduce render-blocking CSS or use critical CSS inline',
+                    evidence: {
+                        found: ctx.renderBlockingStylesheets,
+                        expected: '1-3 stylesheets or inline critical CSS',
+                        example: '<style>/* critical CSS */</style>\n<link rel="stylesheet" href="main.css" media="print" onload="this.media=\'all\'">',
+                        impact: 'Each blocking stylesheet delays first paint',
+                    },
+                });
+            }
+            return createResult({ id: 'cwv-render-blocking-css', name: 'Render-Blocking CSS', category: 'performance', severity: 'warning' }, 'pass', `${ctx.renderBlockingStylesheets} render-blocking stylesheet(s)`);
+        },
+    },
+    {
+        id: 'cwv-render-blocking-js',
+        name: 'Render-Blocking JavaScript',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Scripts in head should use async or defer',
+        check: (ctx) => {
+            if (ctx.renderBlockingScripts === undefined)
+                return null;
+            if (ctx.renderBlockingScripts > 0) {
+                return createResult({ id: 'cwv-render-blocking-js', name: 'Render-Blocking JavaScript', category: 'performance', severity: 'warning' }, 'warn', `${ctx.renderBlockingScripts} render-blocking script(s) in <head>`, {
+                    recommendation: 'Add async or defer to scripts, or move to end of body',
+                    evidence: {
+                        found: ctx.renderBlockingScripts,
+                        expected: 'Scripts with async, defer, or type="module"',
+                        example: '<script src="app.js" defer></script>',
+                        impact: 'Blocking scripts delay HTML parsing and LCP',
+                    },
+                });
+            }
+            return createResult({ id: 'cwv-render-blocking-js', name: 'Render-Blocking JavaScript', category: 'performance', severity: 'warning' }, 'pass', 'No render-blocking scripts in head');
+        },
+    },
+    {
+        id: 'cwv-cls-image-dimensions',
+        name: 'Image Dimensions',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Images should have explicit width and height to prevent layout shift',
+        check: (ctx) => {
+            if (ctx.imagesMissingDimensions === undefined)
+                return null;
+            if (ctx.imagesMissingDimensions > 0) {
+                const total = ctx.totalImages || 0;
+                const percent = total > 0 ? Math.round((ctx.imagesMissingDimensions / total) * 100) : 0;
+                return createResult({ id: 'cwv-cls-image-dimensions', name: 'Image Dimensions', category: 'performance', severity: 'warning' }, 'warn', `${ctx.imagesMissingDimensions} image(s) missing width/height (${percent}%)`, {
+                    recommendation: 'Add explicit width and height attributes to all images',
+                    evidence: {
+                        found: `${ctx.imagesMissingDimensions} of ${total} images`,
+                        expected: 'width and height on all <img> elements',
+                        example: '<img src="photo.jpg" width="800" height="600" alt="...">',
+                        impact: 'Missing dimensions cause layout shift when images load',
+                        learnMore: 'https://web.dev/cls/',
+                    },
+                });
+            }
+            return createResult({ id: 'cwv-cls-image-dimensions', name: 'Image Dimensions', category: 'performance', severity: 'warning' }, 'pass', 'All images have dimensions');
+        },
+    },
+    {
+        id: 'cwv-cls-aspect-ratio',
+        name: 'Aspect Ratio CSS',
+        category: 'performance',
+        severity: 'info',
+        description: 'Use CSS aspect-ratio for responsive media containers',
+        check: (ctx) => {
+            if (!ctx.hasAspectRatioCss && ctx.hasResponsiveImages) {
+                return createResult({ id: 'cwv-cls-aspect-ratio', name: 'Aspect Ratio CSS', category: 'performance', severity: 'info' }, 'info', 'Consider using CSS aspect-ratio for media containers', {
+                    recommendation: 'Use aspect-ratio CSS property for responsive containers',
+                    evidence: {
+                        example: '.video-container { aspect-ratio: 16 / 9; }',
+                        impact: 'Reserves space before media loads, preventing CLS',
+                        learnMore: 'https://web.dev/aspect-ratio/',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'cwv-cls-dynamic-content',
+        name: 'Dynamic Content Space',
+        category: 'performance',
+        severity: 'info',
+        description: 'Reserve space for dynamically injected content',
+        check: (ctx) => {
+            const potentialShifts = [];
+            if (ctx.hasAdsWithoutReservedSpace) {
+                potentialShifts.push('Ads without reserved space');
+            }
+            if (ctx.hasBannersWithoutMinHeight) {
+                potentialShifts.push('Banners/alerts without min-height');
+            }
+            if (ctx.hasInfiniteScroll) {
+                potentialShifts.push('Infinite scroll may cause shifts');
+            }
+            if (potentialShifts.length > 0) {
+                return createResult({ id: 'cwv-cls-dynamic-content', name: 'Dynamic Content Space', category: 'performance', severity: 'info' }, 'info', 'Potential layout shift sources detected', {
+                    recommendation: 'Reserve space for dynamic content with min-height or skeleton loaders',
+                    evidence: {
+                        found: potentialShifts,
+                        example: '.ad-slot { min-height: 250px; }',
+                        impact: 'Dynamic content is a major source of CLS',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'cwv-cls-font-fallback',
+        name: 'Font Fallback Metrics',
+        category: 'performance',
+        severity: 'info',
+        description: 'Web fonts should have size-matched fallbacks',
+        check: (ctx) => {
+            if (!ctx.webFonts || ctx.webFonts.length === 0)
+                return null;
+            const fontsWithoutMetrics = ctx.webFonts.filter(f => !f.hasSizeAdjust && !f.hasAscentOverride);
+            if (fontsWithoutMetrics.length > 0 && ctx.webFonts.length > 0) {
+                return createResult({ id: 'cwv-cls-font-fallback', name: 'Font Fallback Metrics', category: 'performance', severity: 'info' }, 'info', 'Web fonts may cause layout shift during swap', {
+                    recommendation: 'Use size-adjust or metric overrides for fallback fonts',
+                    evidence: {
+                        example: `@font-face {
+  font-family: 'Custom Font';
+  src: url('custom.woff2') format('woff2');
+  font-display: swap;
+  size-adjust: 92%;  /* Match fallback metrics */
+}`,
+                        impact: 'Font swapping can cause visible layout shift',
+                        learnMore: 'https://web.dev/css-size-adjust/',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'cwv-inp-main-thread',
+        name: 'Main Thread Blocking',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Large inline scripts can block the main thread',
+        check: (ctx) => {
+            if (ctx.largeInlineScripts === undefined)
+                return null;
+            if (ctx.largeInlineScripts > 0) {
+                return createResult({ id: 'cwv-inp-main-thread', name: 'Main Thread Blocking', category: 'performance', severity: 'warning' }, 'warn', `${ctx.largeInlineScripts} large inline script(s) may block main thread`, {
+                    recommendation: 'Move large scripts to external files with defer',
+                    evidence: {
+                        found: `${ctx.largeInlineScripts} inline scripts > 10KB`,
+                        expected: 'Small inline scripts only for critical initialization',
+                        impact: 'Large scripts block main thread and delay interactions',
+                        learnMore: 'https://web.dev/optimize-inp/',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'cwv-inp-event-handlers',
+        name: 'Inline Event Handlers',
+        category: 'performance',
+        severity: 'info',
+        description: 'Avoid inline event handlers for better performance',
+        check: (ctx) => {
+            if (ctx.inlineEventHandlers === undefined)
+                return null;
+            if (ctx.inlineEventHandlers > 10) {
+                return createResult({ id: 'cwv-inp-event-handlers', name: 'Inline Event Handlers', category: 'performance', severity: 'info' }, 'info', `${ctx.inlineEventHandlers} inline event handlers found`, {
+                    recommendation: 'Use event delegation instead of inline handlers',
+                    evidence: {
+                        found: ctx.inlineEventHandlers,
+                        expected: 'Minimal inline handlers, prefer addEventListener',
+                        example: 'document.addEventListener("click", handleClick)',
+                        impact: 'Many inline handlers increase parsing time',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'cwv-inp-heavy-animations',
+        name: 'Heavy Animations',
+        category: 'performance',
+        severity: 'info',
+        description: 'Animations should use transform/opacity for best performance',
+        check: (ctx) => {
+            if (!ctx.hasHeavyAnimations)
+                return null;
+            return createResult({ id: 'cwv-inp-heavy-animations', name: 'Heavy Animations', category: 'performance', severity: 'info' }, 'info', 'Potentially expensive animations detected', {
+                recommendation: 'Use transform and opacity for animations, avoid layout properties',
+                evidence: {
+                    issue: 'Animating width, height, top, left triggers layout',
+                    expected: 'Animate transform: translate(), scale(), rotate() and opacity',
+                    learnMore: 'https://web.dev/animations-guide/',
+                },
+            });
+        },
+    },
+    {
+        id: 'cwv-resource-hints',
+        name: 'Resource Hints',
+        category: 'performance',
+        severity: 'info',
+        description: 'Use resource hints to speed up critical resources',
+        check: (ctx) => {
+            const hints = [];
+            if (!ctx.hasPreconnect && ctx.externalOrigins && ctx.externalOrigins > 2) {
+                hints.push('preconnect for critical third-party origins');
+            }
+            if (!ctx.hasDnsPrefetch && ctx.externalOrigins && ctx.externalOrigins > 3) {
+                hints.push('dns-prefetch for secondary origins');
+            }
+            if (!ctx.hasPreload && ctx.hasCriticalResources) {
+                hints.push('preload for critical CSS/fonts/images');
+            }
+            if (hints.length > 0) {
+                return createResult({ id: 'cwv-resource-hints', name: 'Resource Hints', category: 'performance', severity: 'info' }, 'info', `Consider adding: ${hints.join(', ')}`, {
+                    recommendation: 'Add resource hints in <head> for faster loading',
+                    evidence: {
+                        expected: hints,
+                        example: `<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="dns-prefetch" href="https://analytics.example.com">
+<link rel="preload" as="font" href="/fonts/main.woff2" crossorigin>`,
+                        learnMore: 'https://web.dev/preconnect-and-dns-prefetch/',
+                    },
+                });
+            }
+            return createResult({ id: 'cwv-resource-hints', name: 'Resource Hints', category: 'performance', severity: 'info' }, 'pass', 'Resource hints configured');
+        },
+    },
+    {
+        id: 'cwv-critical-css',
+        name: 'Critical CSS',
+        category: 'performance',
+        severity: 'info',
+        description: 'Inline critical CSS for above-the-fold content',
+        check: (ctx) => {
+            if (ctx.hasInlineCriticalCss) {
+                return createResult({ id: 'cwv-critical-css', name: 'Critical CSS', category: 'performance', severity: 'info' }, 'pass', 'Inline critical CSS detected');
+            }
+            if (ctx.renderBlockingStylesheets && ctx.renderBlockingStylesheets > 0) {
+                return createResult({ id: 'cwv-critical-css', name: 'Critical CSS', category: 'performance', severity: 'info' }, 'info', 'Consider inlining critical CSS', {
+                    recommendation: 'Inline critical CSS in <head> and defer non-critical styles',
+                    evidence: {
+                        example: `<style>
+  /* Critical above-the-fold styles */
+  body { margin: 0; font-family: system-ui; }
+</style>
+<link rel="stylesheet" href="main.css" media="print" onload="this.media='all'">`,
+                        impact: 'Critical CSS eliminates render-blocking stylesheets',
+                        learnMore: 'https://web.dev/extract-critical-css/',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+];

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

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

package/dist/seo/rules/ecommerce.js

@@ -0,0 +1,252 @@
+import { createResult } from './types.js';
+export const ecommerceRules = [
+    {
+        id: 'ecommerce-product-schema',
+        name: 'Product Schema',
+        category: 'structured-data',
+        severity: 'warning',
+        description: 'Product pages should have Product schema for rich snippets',
+        check: (ctx) => {
+            if (!ctx.jsonLdTypes)
+                return null;
+            if (!ctx.isProductPage)
+                return null;
+            const hasProduct = ctx.jsonLdTypes.includes('Product');
+            if (!hasProduct) {
+                return createResult({ id: 'ecommerce-product-schema', name: 'Product Schema', category: 'structured-data', severity: 'warning' }, 'warn', 'Product page missing Product schema', {
+                    recommendation: 'Add Product structured data for rich snippets in search results',
+                    evidence: {
+                        expected: 'Product schema with name, image, price, availability',
+                        example: `{
+  "@type": "Product",
+  "name": "Product Name",
+  "image": "https://example.com/image.jpg",
+  "offers": {
+    "@type": "Offer",
+    "price": "99.99",
+    "priceCurrency": "USD",
+    "availability": "https://schema.org/InStock"
+  }
+}`,
+                        learnMore: 'https://developers.google.com/search/docs/appearance/structured-data/product',
+                    },
+                });
+            }
+            return createResult({ id: 'ecommerce-product-schema', name: 'Product Schema', category: 'structured-data', severity: 'warning' }, 'pass', 'Product schema found');
+        },
+    },
+    {
+        id: 'ecommerce-product-price',
+        name: 'Product Price',
+        category: 'structured-data',
+        severity: 'warning',
+        description: 'Product schema should include price information',
+        check: (ctx) => {
+            if (!ctx.productSchema)
+                return null;
+            const hasPrice = ctx.productSchema.offers?.price !== undefined ||
+                ctx.productSchema.offers?.lowPrice !== undefined;
+            const hasCurrency = ctx.productSchema.offers?.priceCurrency !== undefined;
+            if (!hasPrice) {
+                return createResult({ id: 'ecommerce-product-price', name: 'Product Price', category: 'structured-data', severity: 'warning' }, 'warn', 'Product schema missing price', {
+                    recommendation: 'Add price to Product offers for price display in search results',
+                    evidence: {
+                        expected: 'offers.price or offers.lowPrice with priceCurrency',
+                        impact: 'Products without price may not show in Google Shopping results',
+                    },
+                });
+            }
+            if (!hasCurrency) {
+                return createResult({ id: 'ecommerce-product-price', name: 'Product Price', category: 'structured-data', severity: 'warning' }, 'warn', 'Product schema missing currency', {
+                    recommendation: 'Add priceCurrency (e.g., USD, EUR, BRL) to offers',
+                    evidence: {
+                        found: `price: ${ctx.productSchema.offers?.price}`,
+                        expected: 'priceCurrency: "USD" or similar ISO 4217 code',
+                    },
+                });
+            }
+            return createResult({ id: 'ecommerce-product-price', name: 'Product Price', category: 'structured-data', severity: 'warning' }, 'pass', `Price: ${ctx.productSchema.offers?.priceCurrency} ${ctx.productSchema.offers?.price || ctx.productSchema.offers?.lowPrice}`);
+        },
+    },
+    {
+        id: 'ecommerce-product-availability',
+        name: 'Product Availability',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Product schema should include availability status',
+        check: (ctx) => {
+            if (!ctx.productSchema?.offers)
+                return null;
+            const availability = ctx.productSchema.offers.availability;
+            if (!availability) {
+                return createResult({ id: 'ecommerce-product-availability', name: 'Product Availability', category: 'structured-data', severity: 'info' }, 'info', 'Product schema missing availability', {
+                    recommendation: 'Add availability to help users know if product is in stock',
+                    evidence: {
+                        expected: 'availability: "https://schema.org/InStock" or similar',
+                        example: 'InStock, OutOfStock, PreOrder, BackOrder, Discontinued',
+                        learnMore: 'https://schema.org/ItemAvailability',
+                    },
+                });
+            }
+            const availType = availability.replace('https://schema.org/', '').replace('http://schema.org/', '');
+            return createResult({ id: 'ecommerce-product-availability', name: 'Product Availability', category: 'structured-data', severity: 'info' }, 'pass', `Availability: ${availType}`);
+        },
+    },
+    {
+        id: 'ecommerce-product-image',
+        name: 'Product Image',
+        category: 'structured-data',
+        severity: 'warning',
+        description: 'Product schema should include high-quality images',
+        check: (ctx) => {
+            if (!ctx.productSchema)
+                return null;
+            const hasImage = ctx.productSchema.image !== undefined;
+            if (!hasImage) {
+                return createResult({ id: 'ecommerce-product-image', name: 'Product Image', category: 'structured-data', severity: 'warning' }, 'warn', 'Product schema missing image', {
+                    recommendation: 'Add product images for visual search results',
+                    evidence: {
+                        expected: 'At least one high-quality product image',
+                        impact: 'Products without images are less likely to appear in image search and shopping results',
+                    },
+                });
+            }
+            const imageCount = Array.isArray(ctx.productSchema.image)
+                ? ctx.productSchema.image.length
+                : 1;
+            return createResult({ id: 'ecommerce-product-image', name: 'Product Image', category: 'structured-data', severity: 'warning' }, 'pass', `${imageCount} product image(s) in schema`);
+        },
+    },
+    {
+        id: 'ecommerce-product-reviews',
+        name: 'Product Reviews',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Product schema can include aggregate ratings for star snippets',
+        check: (ctx) => {
+            if (!ctx.productSchema)
+                return null;
+            const hasRating = ctx.productSchema.aggregateRating !== undefined;
+            const hasReviews = ctx.productSchema.review !== undefined;
+            if (!hasRating && !hasReviews) {
+                return createResult({ id: 'ecommerce-product-reviews', name: 'Product Reviews', category: 'structured-data', severity: 'info' }, 'info', 'Product schema has no reviews or ratings', {
+                    recommendation: 'Add aggregateRating for star ratings in search results',
+                    evidence: {
+                        example: `"aggregateRating": {
+  "@type": "AggregateRating",
+  "ratingValue": "4.5",
+  "reviewCount": "42"
+}`,
+                        impact: 'Star ratings in search results can improve click-through rate by 20-30%',
+                    },
+                });
+            }
+            if (hasRating && ctx.productSchema.aggregateRating) {
+                const rating = ctx.productSchema.aggregateRating;
+                return createResult({ id: 'ecommerce-product-reviews', name: 'Product Reviews', category: 'structured-data', severity: 'info' }, 'pass', `Rating: ${rating.ratingValue ?? '?'}/5 (${rating.reviewCount ?? rating.ratingCount ?? '?'} reviews)`);
+            }
+            return createResult({ id: 'ecommerce-product-reviews', name: 'Product Reviews', category: 'structured-data', severity: 'info' }, 'pass', 'Product has review data');
+        },
+    },
+    {
+        id: 'ecommerce-product-brand',
+        name: 'Product Brand',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Product schema should include brand information',
+        check: (ctx) => {
+            if (!ctx.productSchema)
+                return null;
+            const hasBrand = ctx.productSchema.brand !== undefined;
+            if (!hasBrand) {
+                return createResult({ id: 'ecommerce-product-brand', name: 'Product Brand', category: 'structured-data', severity: 'info' }, 'info', 'Product schema missing brand', {
+                    recommendation: 'Add brand for better product identification',
+                    evidence: {
+                        example: `"brand": { "@type": "Brand", "name": "Brand Name" }`,
+                        impact: 'Brand helps Google understand product context for shopping queries',
+                    },
+                });
+            }
+            const brandName = typeof ctx.productSchema.brand === 'string'
+                ? ctx.productSchema.brand
+                : ctx.productSchema.brand?.name;
+            return createResult({ id: 'ecommerce-product-brand', name: 'Product Brand', category: 'structured-data', severity: 'info' }, 'pass', `Brand: ${brandName || 'specified'}`);
+        },
+    },
+    {
+        id: 'ecommerce-product-sku',
+        name: 'Product Identifiers',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Product schema should include unique identifiers (SKU, GTIN, MPN)',
+        check: (ctx) => {
+            if (!ctx.productSchema)
+                return null;
+            const hasSku = ctx.productSchema.sku !== undefined;
+            const hasGtin = ctx.productSchema.gtin !== undefined ||
+                ctx.productSchema.gtin13 !== undefined ||
+                ctx.productSchema.gtin14 !== undefined ||
+                ctx.productSchema.gtin8 !== undefined;
+            const hasMpn = ctx.productSchema.mpn !== undefined;
+            const identifiers = [];
+            if (hasSku)
+                identifiers.push('SKU');
+            if (hasGtin)
+                identifiers.push('GTIN');
+            if (hasMpn)
+                identifiers.push('MPN');
+            if (identifiers.length === 0) {
+                return createResult({ id: 'ecommerce-product-sku', name: 'Product Identifiers', category: 'structured-data', severity: 'info' }, 'info', 'Product schema missing identifiers', {
+                    recommendation: 'Add SKU, GTIN, or MPN for better product matching',
+                    evidence: {
+                        expected: 'At least one of: sku, gtin, gtin13, gtin14, gtin8, mpn',
+                        impact: 'Product identifiers help Google match products across retailers',
+                        learnMore: 'https://support.google.com/merchants/answer/6324461',
+                    },
+                });
+            }
+            return createResult({ id: 'ecommerce-product-sku', name: 'Product Identifiers', category: 'structured-data', severity: 'info' }, 'pass', `Identifiers: ${identifiers.join(', ')}`);
+        },
+    },
+    {
+        id: 'ecommerce-offer-valid-dates',
+        name: 'Offer Valid Dates',
+        category: 'structured-data',
+        severity: 'info',
+        description: 'Time-sensitive offers should have valid date ranges',
+        check: (ctx) => {
+            if (!ctx.productSchema?.offers)
+                return null;
+            const offers = ctx.productSchema.offers;
+            const priceValidUntil = offers.priceValidUntil;
+            const validFrom = offers.validFrom;
+            const validThrough = offers.validThrough;
+            if (priceValidUntil) {
+                const endDate = new Date(priceValidUntil);
+                const now = new Date();
+                if (endDate < now) {
+                    return createResult({ id: 'ecommerce-offer-valid-dates', name: 'Offer Valid Dates', category: 'structured-data', severity: 'info' }, 'warn', 'Offer priceValidUntil date has passed', {
+                        evidence: {
+                            found: priceValidUntil,
+                            issue: 'Expired offer dates should be updated or removed',
+                            impact: 'Expired dates may cause Google to distrust your pricing data',
+                        },
+                    });
+                }
+            }
+            if (validThrough) {
+                const endDate = new Date(validThrough);
+                const now = new Date();
+                if (endDate < now) {
+                    return createResult({ id: 'ecommerce-offer-valid-dates', name: 'Offer Valid Dates', category: 'structured-data', severity: 'info' }, 'warn', 'Offer validThrough date has passed', {
+                        evidence: {
+                            found: validThrough,
+                            issue: 'Expired validity dates should be updated',
+                        },
+                    });
+                }
+            }
+            return null;
+        },
+    },
+];

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

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