@ucptools/validator 1.0.1 → 1.2.0

package/dist/services/validation.js

@@ -0,0 +1,1185 @@
+"use strict";
+/**
+ * Validation Service
+ *
+ * Validates UCP Profile + AI Readiness for a domain
+ * Refactored from api/validate.js serverless function
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDomainReadiness = validateDomainReadiness;
+const index_js_1 = require("../db/index.js");
+const schema_js_1 = require("../db/schema.js");
+const drizzle_orm_1 = require("drizzle-orm");
+const structural_validator_js_1 = require("../validator/structural-validator.js");
+const rules_validator_js_1 = require("../validator/rules-validator.js");
+const latency_js_1 = require("./latency.js");
+const index_js_2 = require("../validator/acp/index.js");
+// Constants
+const VERSION_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+const PRODUCT_FIELDS = {
+    required: ['name', 'offers'],
+    recommended: ['description', 'image', 'brand', 'sku', 'aggregateRating'],
+    optional: ['gtin', 'mpn', 'review', 'category', 'color', 'material', 'weight']
+};
+const OFFER_FIELDS = {
+    required: ['price', 'priceCurrency'],
+    recommended: ['availability', 'hasMerchantReturnPolicy', 'shippingDetails'],
+    optional: ['priceValidUntil', 'itemCondition', 'seller']
+};
+/**
+ * Ensure benchmark tables are initialized with required rows
+ */
+async function ensureBenchmarkTablesInitialized(db) {
+    // Ensure all score buckets exist (0, 10, 20, ..., 100)
+    const existingBuckets = await db.select({ scoreBucket: schema_js_1.benchmarkStats.scoreBucket }).from(schema_js_1.benchmarkStats);
+    const existingBucketSet = new Set(existingBuckets.map(r => r.scoreBucket));
+    const missingBuckets = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100].filter(b => !existingBucketSet.has(b));
+    if (missingBuckets.length > 0) {
+        // Use raw SQL for INSERT with ON CONFLICT since Drizzle may not support it directly
+        for (const bucket of missingBuckets) {
+            await db.insert(schema_js_1.benchmarkStats).values({ scoreBucket: bucket, count: 0 }).onConflictDoNothing();
+        }
+    }
+    // Ensure summary row exists
+    const [summary] = await db.select().from(schema_js_1.benchmarkSummary).where((0, drizzle_orm_1.eq)(schema_js_1.benchmarkSummary.id, 1));
+    if (!summary) {
+        await db.insert(schema_js_1.benchmarkSummary).values({
+            id: 1,
+            totalValidations: 0,
+            avgScore: '50',
+            updatedAt: new Date(),
+        }).onConflictDoNothing();
+    }
+}
+/**
+ * Record score and calculate percentile using Drizzle
+ */
+async function recordAndGetBenchmark(score) {
+    try {
+        const db = (0, index_js_1.getDb)();
+        const bucket = Math.floor(score / 10) * 10;
+        // Ensure tables are initialized
+        await ensureBenchmarkTablesInitialized(db);
+        // Record the score - use upsert pattern
+        const [existingBucket] = await db
+            .select()
+            .from(schema_js_1.benchmarkStats)
+            .where((0, drizzle_orm_1.eq)(schema_js_1.benchmarkStats.scoreBucket, bucket));
+        if (existingBucket) {
+            await db
+                .update(schema_js_1.benchmarkStats)
+                .set({ count: (0, drizzle_orm_1.sql) `${schema_js_1.benchmarkStats.count} + 1` })
+                .where((0, drizzle_orm_1.eq)(schema_js_1.benchmarkStats.scoreBucket, bucket));
+        }
+        else {
+            await db.insert(schema_js_1.benchmarkStats).values({ scoreBucket: bucket, count: 1 });
+        }
+        // Update summary
+        const [summary] = await db.select().from(schema_js_1.benchmarkSummary).where((0, drizzle_orm_1.eq)(schema_js_1.benchmarkSummary.id, 1));
+        if (summary) {
+            const newTotal = summary.totalValidations + 1;
+            const currentAvg = parseFloat(summary.avgScore || '50');
+            const newAvg = (currentAvg * summary.totalValidations + score) / newTotal;
+            await db
+                .update(schema_js_1.benchmarkSummary)
+                .set({
+                totalValidations: newTotal,
+                avgScore: String(newAvg),
+                updatedAt: new Date(),
+            })
+                .where((0, drizzle_orm_1.eq)(schema_js_1.benchmarkSummary.id, 1));
+        }
+        else {
+            // Insert if not exists
+            await db.insert(schema_js_1.benchmarkSummary).values({
+                id: 1,
+                totalValidations: 1,
+                avgScore: String(score),
+                updatedAt: new Date(),
+            });
+        }
+        // Calculate percentile
+        const distribution = await db
+            .select({
+            scoreBucket: schema_js_1.benchmarkStats.scoreBucket,
+            count: schema_js_1.benchmarkStats.count,
+        })
+            .from(schema_js_1.benchmarkStats)
+            .orderBy(schema_js_1.benchmarkStats.scoreBucket);
+        const [updatedSummary] = await db.select().from(schema_js_1.benchmarkSummary).where((0, drizzle_orm_1.eq)(schema_js_1.benchmarkSummary.id, 1));
+        const total = updatedSummary?.totalValidations || 1;
+        const avgScore = Math.round(parseFloat(updatedSummary?.avgScore || '50') * 10) / 10;
+        let cumulative = 0;
+        let belowCount = 0;
+        for (const row of distribution) {
+            cumulative += row.count;
+            if (row.scoreBucket < bucket) {
+                belowCount = cumulative;
+            }
+            else if (row.scoreBucket === bucket) {
+                belowCount = cumulative - Math.floor(row.count / 2);
+                break;
+            }
+        }
+        const percentile = Math.round((belowCount / total) * 100);
+        return {
+            percentile,
+            total_validations: total,
+            avg_score: avgScore,
+        };
+    }
+    catch (error) {
+        console.error('Benchmark error:', error);
+        return null;
+    }
+}
+/**
+ * Fetch UCP profile from domain
+ */
+async function fetchProfile(domain) {
+    const urls = [
+        `https://${domain}/.well-known/ucp`,
+        `https://${domain}/.well-known/ucp.json`,
+    ];
+    for (const url of urls) {
+        try {
+            const res = await fetch(url, {
+                headers: {
+                    'Accept': 'application/json',
+                    'User-Agent': 'UCP-Validator/1.0 (https://ucptools.dev)'
+                },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok)
+                continue;
+            const text = await res.text();
+            if (text.trim().startsWith('<'))
+                continue;
+            const profile = JSON.parse(text);
+            return { profile, profileUrl: url };
+        }
+        catch {
+            continue;
+        }
+    }
+    return { profile: null, error: 'No UCP profile found at /.well-known/ucp or /.well-known/ucp.json' };
+}
+/**
+ * Fetch homepage HTML
+ */
+async function fetchHomepage(domain) {
+    const url = `https://${domain}`;
+    try {
+        const res = await fetch(url, {
+            headers: {
+                'Accept': 'text/html',
+                'User-Agent': 'UCP-Validator/1.0 (https://ucptools.dev)'
+            },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok) {
+            return { html: null, error: `HTTP ${res.status}` };
+        }
+        const html = await res.text();
+        return { html };
+    }
+    catch (e) {
+        return { html: null, error: e.message };
+    }
+}
+/**
+ * Extract JSON-LD from HTML
+ */
+function extractJsonLd(html) {
+    const schemas = [];
+    const regex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+    let match;
+    while ((match = regex.exec(html)) !== null) {
+        try {
+            const parsed = JSON.parse(match[1]);
+            if (Array.isArray(parsed)) {
+                schemas.push(...parsed);
+            }
+            else {
+                schemas.push(parsed);
+            }
+        }
+        catch {
+            // Invalid JSON-LD, skip
+        }
+    }
+    return schemas;
+}
+/**
+ * Find schemas by type
+ */
+function findInSchema(schemas, type) {
+    const results = [];
+    function search(obj) {
+        if (!obj || typeof obj !== 'object')
+            return;
+        if (Array.isArray(obj)) {
+            obj.forEach(search);
+            return;
+        }
+        if (obj['@type'] === type || (Array.isArray(obj['@type']) && obj['@type'].includes(type))) {
+            results.push(obj);
+        }
+        Object.values(obj).forEach(search);
+    }
+    schemas.forEach(search);
+    return results;
+}
+/**
+ * Get string length helper
+ */
+function getStringLength(val) {
+    if (typeof val === 'string')
+        return val.length;
+    if (typeof val === 'object' && val !== null) {
+        if (val['@value'])
+            return String(val['@value']).length;
+        if (val.name)
+            return String(val.name).length;
+    }
+    return 0;
+}
+/**
+ * Check if value exists
+ */
+function hasValue(val) {
+    if (val === null || val === undefined)
+        return false;
+    if (typeof val === 'string')
+        return val.trim().length > 0;
+    if (Array.isArray(val))
+        return val.length > 0;
+    if (typeof val === 'object')
+        return Object.keys(val).length > 0;
+    return true;
+}
+/**
+ * Validate product quality
+ */
+function validateProductQuality(products) {
+    const issues = [];
+    const recommendations = [];
+    let totalCompleteness = 0;
+    products.forEach((product, idx) => {
+        let productScore = 0;
+        let maxScore = 0;
+        const productName = product.name || `Product ${idx + 1}`;
+        // Required fields (30 points each)
+        PRODUCT_FIELDS.required.forEach(field => {
+            maxScore += 30;
+            if (hasValue(product[field])) {
+                productScore += 30;
+            }
+            else {
+                issues.push({
+                    severity: 'error',
+                    code: `PRODUCT_MISSING_${field.toUpperCase()}`,
+                    category: 'product_quality',
+                    message: `Product "${productName}" missing required field: ${field}`,
+                });
+            }
+        });
+        // Recommended fields (15 points each)
+        PRODUCT_FIELDS.recommended.forEach(field => {
+            maxScore += 15;
+            if (hasValue(product[field])) {
+                productScore += 15;
+            }
+            else {
+                recommendations.push({
+                    field,
+                    message: `Add ${field} to improve AI product matching`,
+                    priority: 'high'
+                });
+            }
+        });
+        // Optional fields (5 points each)
+        PRODUCT_FIELDS.optional.forEach(field => {
+            maxScore += 5;
+            if (hasValue(product[field])) {
+                productScore += 5;
+            }
+        });
+        // Description quality check
+        if (product.description) {
+            const descLength = getStringLength(product.description);
+            if (descLength < 50) {
+                issues.push({
+                    severity: 'warn',
+                    code: 'PRODUCT_SHORT_DESCRIPTION',
+                    category: 'content_quality',
+                    message: `Product "${productName}" has very short description (${descLength} chars)`,
+                    hint: 'Descriptions under 50 chars may cause AI hallucinations. Aim for 150-300 chars.'
+                });
+            }
+        }
+        else {
+            issues.push({
+                severity: 'warn',
+                code: 'PRODUCT_NO_DESCRIPTION',
+                category: 'content_quality',
+                message: `Product "${productName}" has no description`,
+                hint: 'Missing descriptions increase risk of AI hallucinations'
+            });
+        }
+        // Image check
+        if (!product.image) {
+            issues.push({
+                severity: 'warn',
+                code: 'PRODUCT_NO_IMAGE',
+                category: 'content_quality',
+                message: `Product "${productName}" has no image`,
+                hint: 'Products without images may be deprioritized by AI agents'
+            });
+        }
+        // Validate offers
+        const offers = Array.isArray(product.offers) ? product.offers : (product.offers ? [product.offers] : []);
+        if (offers.length === 0) {
+            issues.push({
+                severity: 'error',
+                code: 'PRODUCT_NO_OFFERS',
+                category: 'product_quality',
+                message: `Product "${productName}" has no offers/pricing`,
+            });
+        }
+        else {
+            offers.forEach((offer) => {
+                if (!hasValue(offer.price)) {
+                    issues.push({
+                        severity: 'error',
+                        code: 'OFFER_NO_PRICE',
+                        category: 'product_quality',
+                        message: `Product "${productName}" offer missing price`,
+                    });
+                }
+                if (!hasValue(offer.priceCurrency)) {
+                    issues.push({
+                        severity: 'warn',
+                        code: 'OFFER_NO_CURRENCY',
+                        category: 'product_quality',
+                        message: `Product "${productName}" offer missing priceCurrency`,
+                        hint: 'Add ISO 4217 currency code (e.g., "USD", "EUR")'
+                    });
+                }
+                // Shipping details validation
+                if (offer.shippingDetails) {
+                    const shipping = Array.isArray(offer.shippingDetails) ? offer.shippingDetails[0] : offer.shippingDetails;
+                    if (!shipping.shippingRate && !shipping.freeShippingThreshold) {
+                        issues.push({
+                            severity: 'warn',
+                            code: 'SHIPPING_NO_RATE',
+                            category: 'shipping_quality',
+                            message: `Product "${productName}" shippingDetails missing shippingRate`,
+                            hint: 'AI agents need shipping costs to complete purchases'
+                        });
+                    }
+                    if (!shipping.deliveryTime) {
+                        issues.push({
+                            severity: 'warn',
+                            code: 'SHIPPING_NO_DELIVERY_TIME',
+                            category: 'shipping_quality',
+                            message: `Product "${productName}" shippingDetails missing deliveryTime`,
+                            hint: 'Delivery estimates help AI agents make purchase decisions'
+                        });
+                    }
+                }
+                // Return policy validation
+                if (offer.hasMerchantReturnPolicy) {
+                    const policy = offer.hasMerchantReturnPolicy;
+                    if (!policy.returnPolicyCategory) {
+                        issues.push({
+                            severity: 'warn',
+                            code: 'RETURN_NO_CATEGORY',
+                            category: 'return_policy',
+                            message: `Return policy missing returnPolicyCategory`,
+                            hint: 'Use MerchantReturnFiniteReturnWindow, MerchantReturnNotPermitted, etc.'
+                        });
+                    }
+                }
+            });
+        }
+        totalCompleteness += (productScore / maxScore) * 100;
+    });
+    const avgCompleteness = products.length > 0 ? Math.round(totalCompleteness / products.length) : 0;
+    // Dedupe recommendations
+    const uniqueRecs = [...new Map(recommendations.map(r => [r.field, r])).values()];
+    return {
+        issues,
+        recommendations: uniqueRecs,
+        completeness: avgCompleteness
+    };
+}
+/**
+ * Validate Schema.org markup
+ */
+function validateSchema(schemas) {
+    const issues = [];
+    const recommendations = [];
+    const orgs = findInSchema(schemas, 'Organization');
+    const products = findInSchema(schemas, 'Product');
+    const returnPolicies = findInSchema(schemas, 'MerchantReturnPolicy');
+    // Check for Organization
+    if (orgs.length === 0) {
+        issues.push({
+            severity: 'warn',
+            code: 'SCHEMA_NO_ORG',
+            category: 'schema',
+            message: 'No Organization schema found',
+            hint: 'Add Organization schema for better AI recognition'
+        });
+    }
+    else {
+        const org = orgs[0];
+        if (!org.logo) {
+            recommendations.push({
+                field: 'logo',
+                message: 'Add logo to Organization schema',
+                priority: 'medium'
+            });
+        }
+        if (!org.contactPoint && !org.email && !org.telephone) {
+            recommendations.push({
+                field: 'contactPoint',
+                message: 'Add contact information to Organization',
+                priority: 'low'
+            });
+        }
+    }
+    // Check for MerchantReturnPolicy
+    const hasReturnPolicyInOffer = products.some((p) => p.offers?.hasMerchantReturnPolicy ||
+        (Array.isArray(p.offers) && p.offers.some((o) => o.hasMerchantReturnPolicy)));
+    if (returnPolicies.length === 0 && !hasReturnPolicyInOffer) {
+        issues.push({
+            severity: 'error',
+            code: 'SCHEMA_NO_RETURN_POLICY',
+            category: 'schema',
+            message: 'Missing MerchantReturnPolicy schema (required Jan 2026)',
+            hint: 'Add hasMerchantReturnPolicy to Product offers for AI commerce eligibility'
+        });
+    }
+    // Check for shippingDetails
+    const hasShippingInOffer = products.some((p) => p.offers?.shippingDetails ||
+        (Array.isArray(p.offers) && p.offers.some((o) => o.shippingDetails)));
+    if (!hasShippingInOffer && products.length > 0) {
+        issues.push({
+            severity: 'error',
+            code: 'SCHEMA_NO_SHIPPING',
+            category: 'schema',
+            message: 'Missing shippingDetails schema (required Jan 2026)',
+            hint: 'Add shippingDetails to Product offers for AI commerce eligibility'
+        });
+    }
+    // Validate product quality
+    const productQuality = products.length > 0 ? validateProductQuality(products) : { issues: [], recommendations: [], completeness: 0 };
+    issues.push(...productQuality.issues);
+    recommendations.push(...productQuality.recommendations);
+    return {
+        issues,
+        recommendations: [...new Map(recommendations.map(r => [r.field, r])).values()],
+        stats: {
+            orgs: orgs.length,
+            products: products.length,
+            returnPolicies: returnPolicies.length + (hasReturnPolicyInOffer ? 1 : 0),
+            productCompleteness: productQuality.completeness
+        }
+    };
+}
+/**
+ * Validate UCP profile structure
+ */
+function validateUcpProfile(profile) {
+    const issues = [];
+    let version = null;
+    if (!profile) {
+        issues.push({
+            severity: 'error',
+            code: 'UCP_FETCH_FAILED',
+            category: 'ucp',
+            message: 'No UCP profile found at /.well-known/ucp or /.well-known/ucp.json',
+            hint: 'Create a UCP profile at /.well-known/ucp'
+        });
+        return { issues, version };
+    }
+    // Use proper validators from src/validator/ (updated per UCP Spec 2026-01-11)
+    const structuralIssues = (0, structural_validator_js_1.validateStructure)(profile);
+    const rulesIssues = (0, rules_validator_js_1.validateRules)(profile);
+    // Convert validator issues to service format (add category field)
+    const allValidatorIssues = [...structuralIssues, ...rulesIssues].map(issue => ({
+        severity: issue.severity,
+        code: issue.code,
+        category: 'ucp',
+        message: issue.message,
+        hint: issue.hint,
+        path: issue.path
+    }));
+    issues.push(...allValidatorIssues);
+    // Extract version if available
+    if (profile.ucp?.version) {
+        version = profile.ucp.version;
+    }
+    return { issues, version };
+}
+/**
+ * Calculate AI Readiness Score (0-100) - ADDITIVE MODEL
+ *
+ * Scale: 0 = Invisible to AI agents, 100 = Perfect AI commerce readiness
+ *
+ * NO UCP = 0 points (invisible to AI shopping agents)
+ * WITH UCP = earn points for each achievement:
+ *   - UCP Profile: 50 points max (earn points for having UCP + valid structure)
+ *   - Schema.org: 35 points max (earn points for required markup)
+ *   - Performance: 15 points max (earn points for fast responses)
+ *
+ * Note: Products/catalog are NOT part of UCP spec. Product feeds are managed
+ * separately via Google Merchant Center. Use the Feed Analyzer for product validation.
+ */
+function calculateReadinessScore(ucpIssues, schemaIssues, hasUcp, performanceScore = 100) {
+    if (!hasUcp) {
+        // NO UCP = 0 points - you're invisible to AI agents
+        return {
+            score: 0,
+            breakdown: {
+                ucp: { score: 0, maxScore: 50, status: 'Not found - install UCP to get discovered' },
+                schema: { score: 0, maxScore: 35, status: 'Requires UCP first' },
+                performance: { score: 0, maxScore: 15, status: 'Requires UCP first' },
+                total: 0,
+                maxTotal: 100
+            }
+        };
+    }
+    // ============ ADDITIVE SCORING ============
+    // UCP Profile: 50 points max
+    // +30 pts: UCP profile exists and is parseable (you're discoverable!)
+    // +7 pts: Has signing keys
+    // +7 pts: Valid capability structure
+    // +6 pts: No errors
+    let ucpScore = 30; // Base: UCP exists and is parseable
+    const ucpDetails = ['Discoverable (+30)'];
+    const hasSigningKeys = !ucpIssues.some(i => i.code === 'UCP_MISSING_SIGNING_KEYS');
+    if (hasSigningKeys) {
+        ucpScore += 7;
+        ucpDetails.push('Signing keys (+7)');
+    }
+    const hasValidCapabilities = !ucpIssues.some(i => i.code === 'UCP_INVALID_CAPABILITY');
+    if (hasValidCapabilities) {
+        ucpScore += 7;
+        ucpDetails.push('Valid capabilities (+7)');
+    }
+    const ucpErrors = ucpIssues.filter(i => i.severity === 'error').length;
+    if (ucpErrors === 0) {
+        ucpScore += 6;
+        ucpDetails.push('No errors (+6)');
+    }
+    const ucpStatus = ucpScore === 50 ? 'Perfect' : ucpDetails.join(', ');
+    // Schema.org: 35 points max
+    // +17 pts: Has MerchantReturnPolicy
+    // +18 pts: Has shippingDetails
+    let schemaScore = 0;
+    const schemaDetails = [];
+    const hasReturnPolicy = !schemaIssues.some(i => i.code === 'SCHEMA_NO_RETURN_POLICY');
+    if (hasReturnPolicy) {
+        schemaScore += 17;
+        schemaDetails.push('Return policy (+17)');
+    }
+    const hasShipping = !schemaIssues.some(i => i.code === 'SCHEMA_NO_SHIPPING');
+    if (hasShipping) {
+        schemaScore += 18;
+        schemaDetails.push('Shipping info (+18)');
+    }
+    const schemaStatus = schemaScore === 35 ? 'Complete' :
+        schemaScore === 0 ? 'Missing required markup' : schemaDetails.join(', ');
+    // Performance: 15 points max
+    // Points based on response time
+    let performancePoints = 0;
+    let perfStatus = 'Very slow';
+    if (performanceScore >= 90) {
+        performancePoints = 15;
+        perfStatus = 'Excellent (+15)';
+    }
+    else if (performanceScore >= 70) {
+        performancePoints = 12;
+        perfStatus = 'Good (+12)';
+    }
+    else if (performanceScore >= 50) {
+        performancePoints = 8;
+        perfStatus = 'Acceptable (+8)';
+    }
+    else if (performanceScore >= 30) {
+        performancePoints = 4;
+        perfStatus = 'Slow (+4)';
+    }
+    const totalScore = ucpScore + schemaScore + performancePoints;
+    return {
+        score: totalScore,
+        breakdown: {
+            ucp: { score: ucpScore, maxScore: 50, status: ucpStatus },
+            schema: { score: schemaScore, maxScore: 35, status: schemaStatus },
+            performance: { score: performancePoints, maxScore: 15, status: perfStatus },
+            total: totalScore,
+            maxTotal: 100
+        }
+    };
+}
+/**
+ * Get grade from score (0-100)
+ */
+function getGrade(score) {
+    if (score >= 90)
+        return 'A';
+    if (score >= 75)
+        return 'B';
+    if (score >= 60)
+        return 'C';
+    if (score >= 40)
+        return 'D';
+    return 'F';
+}
+/**
+ * Get readiness level based on score and UCP presence
+ */
+function getReadinessLevel(score, hasUcp, schemaIssues) {
+    if (!hasUcp) {
+        return { level: 'invisible', label: 'Invisible to AI Agents' };
+    }
+    const hasCriticalSchema = schemaIssues.some(i => i.code === 'SCHEMA_NO_RETURN_POLICY' || i.code === 'SCHEMA_NO_SHIPPING');
+    if (score >= 90 && !hasCriticalSchema) {
+        return { level: 'ready', label: 'AI Commerce Ready' };
+    }
+    if (score >= 75) {
+        return { level: 'good', label: 'Good - Minor Improvements Needed' };
+    }
+    if (score >= 60) {
+        return { level: 'partial', label: 'Partially Ready' };
+    }
+    if (score >= 40) {
+        return { level: 'limited', label: 'Limited Readiness' };
+    }
+    return { level: 'not_ready', label: 'Needs Work' };
+}
+/**
+ * Generate lint suggestions
+ */
+function generateLintSuggestions(ucpIssues, schemaIssues, hasUcp, profile, schemaStats) {
+    const suggestions = [];
+    // UCP not found - critical
+    if (!hasUcp) {
+        suggestions.push({
+            severity: 'critical',
+            title: 'Create a UCP Profile',
+            code: 'UCP_FETCH_FAILED',
+            path: '$.well-known/ucp',
+            impact: 'AI shopping agents cannot discover your store without a UCP profile',
+            fix: 'Create a file at /.well-known/ucp with your store configuration',
+            codeSnippet: `{
+  "ucp": {
+    "version": "2026-05-01",
+    "services": {
+      "dev.ucp.shopping": {
+        "version": "1.0.0",
+        "spec": "https://ucp.dev/specs/shopping/1.0",
+        "rest": {
+          "schema": "https://yourstore.com/api/openapi.json",
+          "endpoint": "https://yourstore.com/api/v1"
+        }
+      }
+    },
+    "capabilities": [
+      {
+        "name": "dev.ucp.shopping.catalog",
+        "version": "1.0.0",
+        "spec": "https://ucp.dev/caps/catalog/1.0",
+        "schema": "https://ucp.dev/caps/catalog/1.0/schema.json"
+      }
+    ]
+  }
+}`,
+            docLink: 'https://ucp.dev/docs/getting-started',
+            generatorLink: '/generate'
+        });
+    }
+    // Missing signing keys
+    if (ucpIssues.some(i => i.code === 'UCP_MISSING_SIGNING_KEYS')) {
+        suggestions.push({
+            severity: 'critical',
+            title: 'Add Signing Keys for Webhook Verification',
+            code: 'UCP_MISSING_SIGNING_KEYS',
+            path: '$.signing_keys',
+            impact: 'Required for secure webhook verification - AI agents cannot verify your responses',
+            fix: 'Add a signing_keys array with at least one JWK public key',
+            codeSnippet: `{
+  "signing_keys": [
+    {
+      "kid": "key-2026-01",
+      "kty": "EC",
+      "crv": "P-256",
+      "x": "YOUR_X_COORDINATE_BASE64URL",
+      "y": "YOUR_Y_COORDINATE_BASE64URL",
+      "use": "sig",
+      "alg": "ES256"
+    }
+  ]
+}`,
+            docLink: 'https://ucp.dev/latest/specification/overview/',
+            generatorLink: '/generate?tab=keys'
+        });
+    }
+    // HTTP endpoint instead of HTTPS
+    if (ucpIssues.some(i => i.code === 'UCP_ENDPOINT_NOT_HTTPS')) {
+        const httpIssue = ucpIssues.find(i => i.code === 'UCP_ENDPOINT_NOT_HTTPS');
+        suggestions.push({
+            severity: 'critical',
+            title: 'Use HTTPS for All Endpoints',
+            code: 'UCP_ENDPOINT_NOT_HTTPS',
+            path: httpIssue?.path || '$.ucp.services',
+            impact: 'UCP requires all endpoints use HTTPS - AI agents will reject insecure connections',
+            fix: 'Change all endpoint URLs from http:// to https://',
+            codeSnippet: `// Change this:
+"endpoint": "http://example.com/api/ucp"
+
+// To this:
+"endpoint": "https://example.com/api/ucp"`,
+            docLink: 'https://ucp.dev/latest/specification/overview/',
+            generatorLink: '/generate'
+        });
+    }
+    // Missing return policy
+    if (schemaIssues.some(i => i.code === 'SCHEMA_NO_RETURN_POLICY')) {
+        suggestions.push({
+            severity: 'critical',
+            title: 'Add MerchantReturnPolicy Schema',
+            code: 'SCHEMA_NO_RETURN_POLICY',
+            impact: 'Required for AI commerce eligibility (Jan 2026 deadline)',
+            fix: 'Add MerchantReturnPolicy to your product offers',
+            codeSnippet: `{
+  "@type": "Product",
+  "offers": {
+    "@type": "Offer",
+    "hasMerchantReturnPolicy": {
+      "@type": "MerchantReturnPolicy",
+      "applicableCountry": "US",
+      "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
+      "merchantReturnDays": 30,
+      "returnFees": "https://schema.org/FreeReturn"
+    }
+  }
+}`,
+            docLink: 'https://schema.org/MerchantReturnPolicy',
+            generatorLink: '/generate?tab=schema'
+        });
+    }
+    // Missing shipping
+    if (schemaIssues.some(i => i.code === 'SCHEMA_NO_SHIPPING')) {
+        suggestions.push({
+            severity: 'critical',
+            title: 'Add OfferShippingDetails Schema',
+            code: 'SCHEMA_NO_SHIPPING',
+            impact: 'Required for AI commerce eligibility (Jan 2026 deadline)',
+            fix: 'Add shippingDetails to your product offers',
+            codeSnippet: `{
+  "@type": "Product",
+  "offers": {
+    "@type": "Offer",
+    "shippingDetails": {
+      "@type": "OfferShippingDetails",
+      "shippingRate": {
+        "@type": "MonetaryAmount",
+        "value": "5.99",
+        "currency": "USD"
+      },
+      "deliveryTime": {
+        "@type": "ShippingDeliveryTime",
+        "handlingTime": {
+          "@type": "QuantitativeValue",
+          "minValue": 1,
+          "maxValue": 2,
+          "unitCode": "d"
+        },
+        "transitTime": {
+          "@type": "QuantitativeValue",
+          "minValue": 3,
+          "maxValue": 5,
+          "unitCode": "d"
+        }
+      },
+      "shippingDestination": {
+        "@type": "DefinedRegion",
+        "addressCountry": "US"
+      }
+    }
+  }
+}`,
+            docLink: 'https://schema.org/OfferShippingDetails',
+            generatorLink: '/generate?tab=schema'
+        });
+    }
+    // Missing payment handlers
+    if (ucpIssues.some(i => i.code === 'UCP_MISSING_PAYMENT_HANDLERS')) {
+        suggestions.push({
+            severity: 'critical',
+            title: 'Add Payment Handlers Configuration',
+            code: 'UCP_MISSING_PAYMENT_HANDLERS',
+            path: '$.payment',
+            impact: 'AI agents cannot complete purchases without payment configuration',
+            fix: 'Add payment handlers to specify supported payment methods',
+            codeSnippet: `{
+  "payment": {
+    "handlers": [
+      {
+        "id": "google_pay",
+        "name": "Google Pay",
+        "version": "2026-01-11",
+        "spec": "https://ucp.dev/handlers/google-pay/"
+      },
+      {
+        "id": "shop_pay",
+        "name": "Shop Pay",
+        "version": "2026-01-11",
+        "spec": "https://ucp.dev/handlers/shop-pay/"
+      }
+    ]
+  }
+}`,
+            docLink: 'https://ucp.dev/latest/specification/overview/',
+            generatorLink: '/generate?tab=payment'
+        });
+    }
+    // Missing services
+    if (ucpIssues.some(i => i.code === 'UCP_MISSING_SERVICES')) {
+        suggestions.push({
+            severity: 'critical',
+            title: 'Add Services Configuration',
+            code: 'UCP_MISSING_SERVICES',
+            path: '$.ucp.services',
+            impact: 'No API endpoints defined - AI agents cannot interact with your store',
+            fix: 'Add at least one service with transport binding',
+            codeSnippet: `{
+  "ucp": {
+    "services": {
+      "dev.ucp.shopping": {
+        "version": "2026-01-11",
+        "spec": "https://ucp.dev/specification/shopping/",
+        "rest": {
+          "schema": "https://yourstore.com/api/openapi.json",
+          "endpoint": "https://yourstore.com/api/ucp"
+        }
+      }
+    }
+  }
+}`,
+            docLink: 'https://ucp.dev/latest/specification/overview/',
+            generatorLink: '/generate'
+        });
+    }
+    // Missing capabilities
+    if (ucpIssues.some(i => i.code === 'UCP_MISSING_CAPABILITIES')) {
+        suggestions.push({
+            severity: 'critical',
+            title: 'Add Capabilities Array',
+            code: 'UCP_MISSING_CAPABILITIES',
+            path: '$.ucp.capabilities',
+            impact: 'AI agents cannot determine what actions are supported',
+            fix: 'Add capabilities to define supported checkout, order, and other features',
+            codeSnippet: `{
+  "ucp": {
+    "capabilities": [
+      {
+        "name": "dev.ucp.shopping.checkout",
+        "version": "2026-01-11",
+        "spec": "https://ucp.dev/specification/checkout/",
+        "schema": "https://ucp.dev/schemas/shopping/checkout.json"
+      },
+      {
+        "name": "dev.ucp.shopping.order",
+        "version": "2026-01-11",
+        "spec": "https://ucp.dev/specification/order/",
+        "schema": "https://ucp.dev/schemas/shopping/order.json"
+      }
+    ]
+  }
+}`,
+            docLink: 'https://ucp.dev/latest/specification/overview/',
+            generatorLink: '/generate'
+        });
+    }
+    // REST transport missing schema or endpoint
+    if (ucpIssues.some(i => i.code === 'UCP_REST_MISSING_SCHEMA' || i.code === 'UCP_REST_MISSING_ENDPOINT')) {
+        suggestions.push({
+            severity: 'critical',
+            title: 'Complete REST Transport Configuration',
+            code: 'UCP_REST_MISSING_SCHEMA',
+            path: '$.ucp.services[].rest',
+            impact: 'REST API integration incomplete - AI agents cannot call your endpoints',
+            fix: 'Add both schema (OpenAPI) and endpoint URL to REST transport',
+            codeSnippet: `{
+  "rest": {
+    "schema": "https://yourstore.com/api/openapi.json",
+    "endpoint": "https://yourstore.com/api/v1"
+  }
+}`,
+            docLink: 'https://ucp.dev/latest/specification/overview/',
+            generatorLink: '/generate'
+        });
+    }
+    // MCP transport missing schema or endpoint
+    if (ucpIssues.some(i => i.code === 'UCP_MCP_MISSING_SCHEMA' || i.code === 'UCP_MCP_MISSING_ENDPOINT')) {
+        suggestions.push({
+            severity: 'critical',
+            title: 'Complete MCP Transport Configuration',
+            code: 'UCP_MCP_MISSING_SCHEMA',
+            path: '$.ucp.services[].mcp',
+            impact: 'MCP integration incomplete - LLM tools cannot connect to your store',
+            fix: 'Add both schema (OpenRPC) and endpoint URL to MCP transport',
+            codeSnippet: `{
+  "mcp": {
+    "schema": "https://yourstore.com/api/openrpc.json",
+    "endpoint": "https://yourstore.com/api/mcp"
+  }
+}`,
+            docLink: 'https://ucp.dev/latest/specification/overview/',
+            generatorLink: '/generate'
+        });
+    }
+    // Namespace origin mismatch
+    if (ucpIssues.some(i => i.code === 'UCP_NS_ORIGIN_MISMATCH')) {
+        const mismatchIssue = ucpIssues.find(i => i.code === 'UCP_NS_ORIGIN_MISMATCH');
+        suggestions.push({
+            severity: 'critical',
+            title: 'Fix Namespace Origin Mismatch',
+            code: 'UCP_NS_ORIGIN_MISMATCH',
+            path: mismatchIssue?.path || '$.ucp.capabilities',
+            impact: 'Security violation - spec/schema URLs must match capability namespace authority',
+            fix: 'Ensure spec and schema URLs come from the same domain as the capability namespace',
+            codeSnippet: `// For official UCP capabilities (dev.ucp.*):
+{
+  "name": "dev.ucp.shopping.checkout",
+  "spec": "https://ucp.dev/specification/checkout/",  // Must be ucp.dev
+  "schema": "https://ucp.dev/schemas/checkout.json"   // Must be ucp.dev
+}
+
+// For custom capabilities (com.yourcompany.*):
+{
+  "name": "com.yourcompany.custom",
+  "spec": "https://yourcompany.com/specs/custom/",    // Must match namespace
+  "schema": "https://yourcompany.com/schemas/custom.json"
+}`,
+            docLink: 'https://ucp.dev/latest/specification/overview/',
+            generatorLink: '/generate'
+        });
+    }
+    // Orphaned extension
+    if (ucpIssues.some(i => i.code === 'UCP_ORPHANED_EXTENSION')) {
+        const orphanIssue = ucpIssues.find(i => i.code === 'UCP_ORPHANED_EXTENSION');
+        suggestions.push({
+            severity: 'critical',
+            title: 'Fix Orphaned Extension',
+            code: 'UCP_ORPHANED_EXTENSION',
+            path: orphanIssue?.path || '$.ucp.capabilities',
+            impact: 'Extension references a parent capability that does not exist in your profile',
+            fix: 'Either add the parent capability or remove the extends field',
+            codeSnippet: `// If using an extension, parent must exist:
+{
+  "capabilities": [
+    // Parent capability (REQUIRED)
+    {
+      "name": "dev.ucp.shopping.checkout",
+      "version": "2026-01-11",
+      "spec": "https://ucp.dev/specification/checkout/",
+      "schema": "https://ucp.dev/schemas/checkout.json"
+    },
+    // Extension (references parent via extends)
+    {
+      "name": "dev.ucp.shopping.fulfillment",
+      "version": "2026-01-11",
+      "spec": "https://ucp.dev/specification/fulfillment/",
+      "schema": "https://ucp.dev/schemas/fulfillment.json",
+      "extends": "dev.ucp.shopping.checkout"  // Parent must be in capabilities
+    }
+  ]
+}`,
+            docLink: 'https://ucp.dev/latest/specification/overview/',
+            generatorLink: '/generate'
+        });
+    }
+    // Trailing slash in endpoint
+    if (ucpIssues.some(i => i.code === 'UCP_ENDPOINT_TRAILING_SLASH')) {
+        const slashIssue = ucpIssues.find(i => i.code === 'UCP_ENDPOINT_TRAILING_SLASH');
+        suggestions.push({
+            severity: 'warning',
+            title: 'Remove Trailing Slash from Endpoint',
+            code: 'UCP_ENDPOINT_TRAILING_SLASH',
+            path: slashIssue?.path || '$.ucp.services',
+            impact: 'Trailing slashes can cause URL concatenation issues with AI agents',
+            fix: 'Remove the trailing slash from endpoint URLs',
+            codeSnippet: `// Change this:
+"endpoint": "https://example.com/api/"
+
+// To this:
+"endpoint": "https://example.com/api"`,
+            docLink: 'https://ucp.dev/latest/specification/overview/'
+        });
+    }
+    return suggestions;
+}
+/**
+ * Main validation function
+ */
+async function validateDomainReadiness(domain) {
+    const cleanDomain = domain.replace(/^https?:\/\//, '').replace(/\/$/, '').split('/')[0];
+    // Fetch UCP profile, homepage, measure latency, and check ACP readiness in parallel
+    const [ucpResult, homepageResult, latencyResult, acpResult] = await Promise.all([
+        fetchProfile(cleanDomain),
+        fetchHomepage(cleanDomain),
+        (0, latency_js_1.quickLatencyCheck)(cleanDomain),
+        (0, index_js_2.checkAcpReadiness)(cleanDomain, { timeoutMs: 15000 }).catch(() => null),
+    ]);
+    const { profile, profileUrl, error: ucpError } = ucpResult;
+    const { html } = homepageResult;
+    // Validate UCP
+    const hasUcp = !!profile;
+    const ucpValidation = validateUcpProfile(profile);
+    const ucpIssues = ucpValidation.issues;
+    const ucpVersion = ucpValidation.version;
+    // Validate Schema.org
+    let schemaIssues = [];
+    let schemaRecommendations = [];
+    let schemaStats = { orgs: 0, products: 0, returnPolicies: 0, productCompleteness: 0 };
+    if (html) {
+        const schemas = extractJsonLd(html);
+        const schemaResult = validateSchema(schemas);
+        schemaIssues = schemaResult.issues;
+        schemaRecommendations = schemaResult.recommendations;
+        schemaStats = schemaResult.stats;
+    }
+    else {
+        schemaIssues.push({
+            severity: 'warn',
+            code: 'SCHEMA_FETCH_FAILED',
+            category: 'schema',
+            message: 'Could not fetch homepage to check schema',
+        });
+    }
+    // Add performance warning for slow sites
+    if (latencyResult.performanceScore < 60) {
+        schemaIssues.push({
+            severity: 'warn',
+            code: 'PERFORMANCE_SLOW',
+            category: 'performance',
+            message: `Slow response time detected (${latencyResult.ucpLatencyMs || latencyResult.homepageLatencyMs}ms)`,
+            hint: 'AI agents may timeout or deprioritize slow endpoints. Aim for <500ms response time.',
+        });
+    }
+    // Calculate scores (including performance)
+    // Note: Products removed from scoring - not part of UCP spec (use Feed Analyzer instead)
+    const { score: readinessScore, breakdown: scoreBreakdown } = calculateReadinessScore(ucpIssues, schemaIssues, hasUcp, latencyResult.performanceScore);
+    const grade = getGrade(readinessScore);
+    const readiness = getReadinessLevel(readinessScore, hasUcp, schemaIssues);
+    // Record to benchmark
+    const benchmark = await recordAndGetBenchmark(readinessScore);
+    // Generate lint suggestions
+    const lintSuggestions = generateLintSuggestions(ucpIssues, schemaIssues, hasUcp, profile, schemaStats);
+    // Calculate UCP score for backwards compatibility
+    const ucpErrors = ucpIssues.filter(i => i.severity === 'error').length;
+    const ucpScore = hasUcp ? Math.max(0, 100 - ucpErrors * 20 - ucpIssues.filter(i => i.severity === 'warn').length * 5) : 0;
+    // Combine all issues
+    const allIssues = [...ucpIssues, ...schemaIssues];
+    return {
+        ok: ucpErrors === 0 && hasUcp,
+        domain: cleanDomain,
+        profile_url: profileUrl || `https://${cleanDomain}/.well-known/ucp`,
+        ucp_version: ucpVersion,
+        ai_readiness: {
+            score: readinessScore,
+            grade: grade,
+            level: readiness.level,
+            label: readiness.label,
+        },
+        score_breakdown: scoreBreakdown,
+        benchmark: benchmark ? {
+            percentile: benchmark.percentile,
+            comparison: `Your site scores better than ${benchmark.percentile}% of sites analyzed`,
+            total_sites_analyzed: benchmark.total_validations,
+            average_score: benchmark.avg_score,
+        } : null,
+        sdk_validation: {
+            validated: true,
+            sdk_version: '0.1.0',
+            compliant: hasUcp && ucpErrors === 0,
+            badge: hasUcp && ucpErrors === 0
+                ? 'Validated using Official UCP SDK v0.1.0'
+                : null,
+        },
+        ucp: {
+            found: hasUcp,
+            score: ucpScore,
+            issues: ucpIssues.map(i => ({
+                severity: i.severity,
+                code: i.code,
+                message: i.message,
+                path: i.path,
+                hint: i.hint,
+            })),
+        },
+        schema: {
+            checked: !!html,
+            stats: schemaStats,
+            issues: schemaIssues.filter(i => i.category === 'schema').map(i => ({
+                severity: i.severity,
+                code: i.code,
+                message: i.message,
+                path: i.path,
+                hint: i.hint,
+            })),
+        },
+        product_quality: {
+            completeness: schemaStats.productCompleteness,
+            issues: schemaIssues.filter(i => i.category === 'product_quality' || i.category === 'content_quality').map(i => ({
+                severity: i.severity,
+                code: i.code,
+                message: i.message,
+                hint: i.hint,
+            })),
+            recommendations: schemaRecommendations.slice(0, 10),
+        },
+        shipping: {
+            issues: schemaIssues.filter(i => i.category === 'shipping_quality').map(i => ({
+                severity: i.severity,
+                code: i.code,
+                message: i.message,
+                hint: i.hint,
+            })),
+        },
+        performance: {
+            ucpLatencyMs: latencyResult.ucpLatencyMs,
+            homepageLatencyMs: latencyResult.homepageLatencyMs,
+            apiLatencyMs: null, // Only measured in detailed mode
+            overallAvgMs: latencyResult.ucpLatencyMs || latencyResult.homepageLatencyMs || 0,
+            performanceScore: latencyResult.performanceScore,
+            performanceGrade: latencyResult.performanceGrade,
+        },
+        issues: allIssues.map(i => ({
+            severity: i.severity,
+            code: i.code,
+            message: i.message,
+            hint: i.hint,
+            category: i.category,
+        })),
+        lint_suggestions: lintSuggestions.map(s => ({
+            severity: s.severity,
+            title: s.title,
+            code: s.code,
+            path: s.path,
+            impact: s.impact,
+            fix: s.fix,
+            codeSnippet: s.codeSnippet,
+            docLink: s.docLink,
+            generatorLink: s.generatorLink,
+        })),
+        acp: acpResult || null,
+    };
+}
+//# sourceMappingURL=validation.js.map