Best Google Analytics 4 Phone Validation API & Email Verification Integration 2025

// Enhanced GA4 integration with 1lookup validation
// Initialize Google Analytics 4
gtag('config', 'GA_MEASUREMENT_ID', {
  custom_map: {
    'custom_parameter_1': 'phone_validation_status',
    'custom_parameter_2': 'email_validation_status',
    'custom_parameter_3': 'user_quality_score',
    'custom_parameter_4': 'contact_quality_tier'
  }
});

// Enhanced event tracking with contact validation
async function trackGA4EventWithValidation(eventName, eventParameters) {
  try {
    // Validate contact information if present in parameters
    if (eventParameters.user_email || eventParameters.user_phone) {
      const validationData = await validateContactForGA4({
        phone: eventParameters.user_phone,
        email: eventParameters.user_email
      });
      
      // Enhance event parameters with validation results
      const enhancedParameters = {
        ...eventParameters,
        // Phone validation parameters
        phone_validation_status: validationData.phone?.is_valid ? 'valid' : 'invalid',
        phone_carrier: validationData.phone?.carrier_details?.name || '',
        phone_line_type: validationData.phone?.carrier_details?.type || '',
        phone_country: validationData.phone?.location_details?.country || '',
        phone_region: validationData.phone?.location_details?.region || '',
        phone_risk_level: validationData.phone?.risk_assessment?.risk_level || '',
        // Email validation parameters
        email_validation_status: validationData.email?.is_valid ? 'valid' : 'invalid',
        email_deliverability: validationData.email?.deliverability?.status || '',
        email_domain_type: validationData.email?.domain_details?.type || '',
        email_risk_level: validationData.email?.risk_assessment?.risk_level || '',
        // Marketing-specific enhancements
        user_quality_score: calculateMarketingUserQuality(validationData),
        contact_quality_tier: determineMarketingTier(validationData),
        is_verified_user: isVerifiedMarketingUser(validationData),
        marketing_segment: determineMarketingSegment(validationData),
        attribution_weight: calculateAttributionWeight(validationData),
        // GA4-specific parameters
        validation_timestamp: Math.floor(Date.now() / 1000),
        ga4_validation_version: '2025.1'
      };
      
      // Track enhanced event with validation data
      gtag('event', eventName, enhancedParameters);
      
      // Track validation insights for marketing analytics
      gtag('event', 'contact_validation_insight', {
        validation_type: 'marketing_enhancement',
        event_type: eventName,
        phone_valid: validationData.phone?.is_valid,
        email_valid: validationData.email?.is_valid,
        quality_score: enhancedParameters.user_quality_score,
        marketing_segment: enhancedParameters.marketing_segment
      });
      
      // Set user properties for audience segmentation
      gtag('set', 'user_properties', {
        contact_quality_tier: enhancedParameters.contact_quality_tier,
        user_verification_status: enhancedParameters.is_verified_user ? 'verified' : 'unverified',
        marketing_segment: enhancedParameters.marketing_segment,
        last_validation_date: enhancedParameters.validation_timestamp
      });
      
    } else {
      // Track normal event without validation
      gtag('event', eventName, eventParameters);
    }
  } catch (error) {
    console.error('GA4 validation error:', error);
    // Fallback to normal tracking with error parameter
    gtag('event', eventName, {
      ...eventParameters,
      validation_error: true,
      validation_error_type: error.message
    });
  }
}

// Contact validation function optimized for marketing analytics
async function validateContactForGA4(contactData) {
  const response = await fetch('https://app.1lookup.io/api/v1/validate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_1LOOKUP_API_KEY',
      'Content-Type': 'application/json',
      'X-Integration': 'ga4-marketing'
    },
    body: JSON.stringify({
      ...contactData,
      include_carrier_details: true,
      include_location_details: true,
      include_risk_assessment: true,
      marketing_context: true
    })
  });
  
  if (!response.ok) {
    throw new Error(`Marketing validation failed: ${response.status}`);
  }
  
  return await response.json();
}

// Calculate marketing-specific user quality score
function calculateMarketingUserQuality(validationData) {
  let score = 0;
  
  // Email scoring for marketing
  if (validationData.email?.is_valid) score += 40;
  if (validationData.email?.deliverability?.status === 'deliverable') score += 15;
  
  // Phone scoring for marketing
  if (validationData.phone?.is_valid) score += 35;
  if (validationData.phone?.risk_assessment?.risk_level === 'low') score += 10;
  
  return Math.min(100, score);
}

// Determine marketing user tier
function determineMarketingTier(validationData) {
  const qualityScore = calculateMarketingUserQuality(validationData);
  
  if (qualityScore >= 80) return 'premium_marketing_user';
  if (qualityScore >= 60) return 'high_value_marketing_user';
  if (qualityScore >= 40) return 'standard_marketing_user';
  return 'basic_marketing_user';
}

// Calculate attribution weight based on user quality
function calculateAttributionWeight(validationData) {
  const baseWeight = 1.0;
  let weight = baseWeight;
  
  if (validationData.phone?.is_valid) weight += 0.2;
  if (validationData.email?.is_valid) weight += 0.2;
  if (validationData.phone?.risk_assessment?.risk_level === 'low') weight += 0.1;
  if (validationData.email?.risk_assessment?.risk_level === 'low') weight += 0.1;
  
  return Math.min(2.0, weight);
}

// Enhanced GA4 Measurement Protocol integration with contact validation
const { GoogleAnalyticsData } = require('@google-analytics/data');
const fetch = require('node-fetch');

class GA4ValidationEnhancer {
  constructor(measurementId, apiSecret, lookupApiKey) {
    this.measurementId = measurementId;
    this.apiSecret = apiSecret;
    this.lookupApiKey = lookupApiKey;
    this.analyticsData = new GoogleAnalyticsData();
  }
  
  async trackEnhancedConversion(clientId, userId, conversionData) {
    try {
      // Validate user contact information
      const validation = await this.validateUserContactForGA4(conversionData);
      
      // Calculate conversion quality metrics
      const conversionQuality = this.calculateConversionQuality(validation, conversionData);
      
      // Prepare enhanced conversion payload
      const conversionPayload = {
        client_id: clientId,
        user_id: userId,
        events: [{
          name: conversionData.event_name || 'purchase',
          params: {
            // Original conversion data
            ...conversionData.parameters,
            // Contact validation enhancements
            phone_validation_status: validation.phone?.is_valid ? 'valid' : 'invalid',
            phone_carrier: validation.phone?.carrier_details?.name || '',
            phone_country: validation.phone?.location_details?.country || '',
            email_validation_status: validation.email?.is_valid ? 'valid' : 'invalid',
            email_deliverability: validation.email?.deliverability?.status || '',
            // Marketing quality metrics
            user_quality_score: conversionQuality.user_score,
            conversion_quality_score: conversionQuality.conversion_score,
            conversion_confidence: conversionQuality.confidence,
            is_high_quality_conversion: conversionQuality.is_high_quality,
            marketing_attribution_weight: conversionQuality.attribution_weight,
            // Fraud and risk indicators
            conversion_risk_level: conversionQuality.risk_level,
            fraud_indicators: conversionQuality.fraud_indicators.join(','),
            // Geographic and demographic data
            user_country: validation.phone?.location_details?.country || '',
            user_region: validation.phone?.location_details?.region || '',
            carrier_type: validation.phone?.carrier_details?.type || '',
            // Timestamp and versioning
            validation_timestamp: Math.floor(Date.now() / 1000),
            validation_version: '2025.1'
          }
        }]
      };
      
      // Send enhanced conversion to GA4
      await this.sendToGA4MeasurementProtocol(conversionPayload);
      
      // Track validation analytics separately
      await this.trackValidationAnalytics(userId, validation, conversionQuality);
      
      return {
        success: true,
        conversionQuality,
        validation
      };
      
    } catch (error) {
      console.error('GA4 conversion validation error:', error);
      
      // Send fallback conversion without validation
      await this.sendToGA4MeasurementProtocol({
        client_id: clientId,
        user_id: userId,
        events: [{
          name: conversionData.event_name || 'purchase',
          params: {
            ...conversionData.parameters,
            validation_error: true,
            validation_error_message: error.message
          }
        }]
      });
      
      return { success: false, error: error.message };
    }
  }
  
  async validateUserContactForGA4(conversionData) {
    const contactInfo = {
      phone: conversionData.phone || conversionData.parameters?.phone,
      email: conversionData.email || conversionData.parameters?.email
    };
    
    if (!contactInfo.phone && !contactInfo.email) {
      return { quality_score: 0 };
    }
    
    const response = await fetch('https://app.1lookup.io/api/v1/validate', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.lookupApiKey}`,
        'Content-Type': 'application/json',
        'X-Integration': 'ga4-measurement-protocol'
      },
      body: JSON.stringify({
        ...contactInfo,
        include_marketing_data: true,
        include_risk_assessment: true
      })
    });
    
    return await response.json();
  }
  
  calculateConversionQuality(validation, conversionData) {
    let userScore = 0;
    let conversionScore = 0;
    let confidence = 0;
    
    // Calculate user quality score
    if (validation.phone?.is_valid) userScore += 40;
    if (validation.email?.is_valid) userScore += 40;
    if (validation.phone?.risk_assessment?.risk_level === 'low') userScore += 10;
    if (validation.email?.risk_assessment?.risk_level === 'low') userScore += 10;
    
    // Calculate conversion-specific score
    const conversionValue = parseFloat(conversionData.parameters?.value || 0);
    if (conversionValue > 0) {
      conversionScore = Math.min(50, conversionValue / 10); // Scale conversion value
    }
    
    const totalScore = userScore + conversionScore;
    
    // Calculate confidence based on validation completeness
    if (validation.phone?.is_valid && validation.email?.is_valid) confidence = 95;
    else if (validation.phone?.is_valid || validation.email?.is_valid) confidence = 75;
    else confidence = 25;
    
    return {
      user_score: Math.min(100, userScore),
      conversion_score: Math.min(100, conversionScore),
      total_score: Math.min(100, totalScore),
      confidence: confidence,
      is_high_quality: totalScore >= 70 && confidence >= 75,
      attribution_weight: this.calculateAttributionWeight(validation),
      risk_level: this.calculateConversionRisk(validation),
      fraud_indicators: this.detectFraudIndicators(validation, conversionData)
    };
  }
  
  async sendToGA4MeasurementProtocol(payload) {
    const url = `https://www.google-analytics.com/mp/collect?measurement_id=${this.measurementId}&api_secret=${this.apiSecret}`;
    
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
    });
    
    if (!response.ok) {
      throw new Error(`GA4 Measurement Protocol error: ${response.status}`);
    }
  }
}

// Advanced GA4 event tracking with marketing validation enhancement
class GA4MarketingEventTracker {
  constructor(measurementId, lookupApiKey) {
    this.measurementId = measurementId;
    this.lookupApiKey = lookupApiKey;
    this.userValidationCache = new Map();
  }
  
  async trackMarketingEventWithValidation(eventName, eventParams, userContext) {
    try {
      // Get or validate user contact data
      let userValidation = this.userValidationCache.get(userContext.user_id);
      if (!userValidation) {
        userValidation = await this.validateUserForMarketing(userContext);
        this.userValidationCache.set(userContext.user_id, userValidation);
      }
      
      // Calculate marketing event quality
      const eventQuality = this.calculateMarketingEventQuality(
        eventName,
        eventParams,
        userValidation
      );
      
      // Enhanced marketing event parameters
      const enhancedEventParams = {
        ...eventParams,
        // User validation context
        user_quality_score: userValidation.quality_score,
        user_quality_tier: userValidation.tier,
        user_verification_status: userValidation.verification_status,
        // Marketing event quality
        event_quality_score: eventQuality.score,
        event_reliability: eventQuality.reliability,
        marketing_value_tier: eventQuality.value_tier,
        is_high_value_event: eventQuality.is_high_value,
        // Attribution and segmentation
        attribution_weight: eventQuality.attribution_weight,
        marketing_segment: userValidation.marketing_segment,
        audience_tier: userValidation.audience_tier,
        // Geographic and demographic context
        user_country: userValidation.country,
        user_region: userValidation.region,
        carrier_type: userValidation.carrier_type,
        device_trust_score: eventQuality.device_trust,
        // Fraud and quality indicators
        fraud_risk_indicators: eventQuality.fraud_indicators.join(','),
        conversion_likelihood: eventQuality.conversion_likelihood,
        customer_lifetime_value_tier: userValidation.ltv_tier
      };
      
      // Track enhanced marketing event
      gtag('event', eventName, enhancedEventParams);
      
      // Track marketing quality analytics
      gtag('event', 'marketing_quality_analytics', {
        original_event: eventName,
        quality_score: eventQuality.score,
        user_tier: userValidation.tier,
        marketing_value: eventQuality.marketing_value
      });
      
      // Update user properties for audience building
      gtag('set', 'user_properties', {
        marketing_segment: userValidation.marketing_segment,
        quality_tier: userValidation.tier,
        ltv_prediction: userValidation.ltv_tier,
        last_quality_update: Math.floor(Date.now() / 1000)
      });
      
      return { success: true, eventQuality, userValidation };
      
    } catch (error) {
      console.error('Marketing event validation error:', error);
      
      // Fallback tracking
      gtag('event', eventName, {
        ...eventParams,
        validation_error: true,
        error_type: 'marketing_validation_failed'
      });
      
      return { success: false, error: error.message };
    }
  }
  
  calculateMarketingEventQuality(eventName, eventParams, userValidation) {
    let score = 0;
    let reliability = 0;
    let attributionWeight = 1.0;
    let marketingValue = 0;
    
    // Base score from user validation
    const userQuality = userValidation.quality_score || 0;
    score = userQuality * 0.6; // 60% weight from user quality
    
    // Event-specific scoring
    const eventMultipliers = {
      'page_view': 1.0,
      'scroll': 0.8,
      'click': 1.1,
      'form_start': 1.3,
      'form_submit': 1.5,
      'sign_up': 1.7,
      'purchase': 2.0,
      'subscription': 2.2,
      'add_to_cart': 1.4,
      'begin_checkout': 1.6
    };
    
    score *= (eventMultipliers[eventName] || 1.0);
    
    // Marketing value calculation
    marketingValue = this.calculateMarketingValue(eventName, eventParams, userValidation);
    
    // Reliability scoring
    reliability = this.calculateEventReliability(userValidation, eventParams);
    
    // Attribution weight based on user verification
    if (userValidation.phone_verified) attributionWeight += 0.3;
    if (userValidation.email_verified) attributionWeight += 0.3;
    if (userValidation.fraud_risk_level === 'low') attributionWeight += 0.4;
    
    return {
      score: Math.min(100, score),
      reliability: Math.min(100, reliability),
      value_tier: this.determineMarketingValueTier(marketingValue),
      is_high_value: score >= 70 && reliability >= 80,
      attribution_weight: Math.min(2.0, attributionWeight),
      marketing_value: marketingValue,
      conversion_likelihood: this.calculateConversionLikelihood(userValidation, eventName),
      device_trust: this.calculateDeviceTrust(eventParams, userValidation),
      fraud_indicators: this.detectEventFraudIndicators(eventParams, userValidation)
    };
  }
  
  async validateUserForMarketing(userContext) {
    try {
      const contactData = {
        phone: userContext.phone,
        email: userContext.email
      };
      
      if (!contactData.phone && !contactData.email) {
        return this.getDefaultUserValidation();
      }
      
      const validation = await this.performContactValidation(contactData);
      
      return {
        quality_score: this.calculateUserMarketingScore(validation),
        tier: this.determineUserMarketingTier(validation),
        verification_status: this.getUserVerificationStatus(validation),
        phone_verified: validation.phone?.is_valid,
        email_verified: validation.email?.is_valid,
        fraud_risk_level: this.getFraudRiskLevel(validation),
        country: validation.phone?.location_details?.country,
        region: validation.phone?.location_details?.region,
        carrier_type: validation.phone?.carrier_details?.type,
        marketing_segment: this.determineMarketingSegment(validation),
        audience_tier: this.determineAudienceTier(validation),
        ltv_tier: this.predictLTVTier(validation)
      };
      
    } catch (error) {
      console.error('User validation for marketing error:', error);
      return this.getDefaultUserValidation();
    }
  }
  
  determineMarketingSegment(validation) {
    const qualityScore = this.calculateUserMarketingScore(validation);
    const hasPhone = validation.phone?.is_valid;
    const hasEmail = validation.email?.is_valid;
    
    if (qualityScore >= 80 && hasPhone && hasEmail) {
      return 'premium_multi_channel';
    } else if (qualityScore >= 70) {
      return 'high_value_verified';
    } else if (qualityScore >= 50) {
      return 'standard_marketing';
    } else {
      return 'basic_prospect';
    }
  }
}

// Advanced e-commerce tracking with contact validation for GA4
class GA4EcommerceTracker {
  constructor(measurementId, lookupApiKey) {
    this.measurementId = measurementId;
    this.lookupApiKey = lookupApiKey;
    this.conversionCache = new Map();
  }
  
  async trackEnhancedPurchase(transactionId, purchaseData, customerData) {
    try {
      // Validate customer contact information
      const customerValidation = await this.validateCustomerForEcommerce(customerData);
      
      // Calculate purchase quality metrics
      const purchaseQuality = this.calculatePurchaseQuality(
        purchaseData,
        customerValidation
      );
      
      // Enhanced purchase event
      const enhancedPurchaseEvent = {
        transaction_id: transactionId,
        value: purchaseData.value,
        currency: purchaseData.currency,
        items: purchaseData.items,
        // Customer validation enhancements
        customer_quality_score: customerValidation.quality_score,
        customer_tier: customerValidation.tier,
        customer_verification_status: customerValidation.verification_status,
        // Purchase quality metrics
        purchase_quality_score: purchaseQuality.overall_score,
        purchase_reliability: purchaseQuality.reliability,
        purchase_authenticity: purchaseQuality.authenticity,
        is_high_quality_purchase: purchaseQuality.is_high_quality,
        // Fraud and risk assessment
        fraud_risk_level: purchaseQuality.fraud_risk_level,
        fraud_indicators: purchaseQuality.fraud_indicators.join(','),
        risk_score: purchaseQuality.risk_score,
        // Attribution and marketing metrics
        attribution_confidence: purchaseQuality.attribution_confidence,
        marketing_attribution_weight: purchaseQuality.attribution_weight,
        customer_acquisition_quality: purchaseQuality.acquisition_quality,
        predicted_ltv_tier: purchaseQuality.ltv_tier,
        // Geographic and demographic data
        customer_country: customerValidation.country,
        customer_region: customerValidation.region,
        payment_method_country: customerData.payment_country,
        // Validation metadata
        validation_timestamp: Math.floor(Date.now() / 1000),
        validation_confidence: customerValidation.confidence_score
      };
      
      // Track enhanced purchase event in GA4
      gtag('event', 'purchase', enhancedPurchaseEvent);
      
      // Track purchase quality analytics
      gtag('event', 'purchase_quality_analytics', {
        transaction_id: transactionId,
        quality_score: purchaseQuality.overall_score,
        customer_tier: customerValidation.tier,
        purchase_value_tier: purchaseQuality.value_tier,
        is_trusted_purchase: purchaseQuality.is_trusted
      });
      
      // Update customer lifetime value prediction
      gtag('set', 'user_properties', {
        predicted_ltv_tier: purchaseQuality.ltv_tier,
        purchase_quality_history: this.updatePurchaseHistory(
          customerData.customer_id,
          purchaseQuality
        ),
        last_high_quality_purchase: purchaseQuality.is_high_quality ? 
          Math.floor(Date.now() / 1000) : undefined
      });
      
      // Track conversion path quality if available
      if (customerData.conversion_path) {
        await this.analyzeConversionPathQuality(
          customerData.conversion_path,
          customerValidation,
          purchaseQuality
        );
      }
      
      return {
        success: true,
        purchaseQuality,
        customerValidation,
        enhancedEvent: enhancedPurchaseEvent
      };
      
    } catch (error) {
      console.error('Enhanced purchase tracking error:', error);
      
      // Fallback to standard purchase tracking
      gtag('event', 'purchase', {
        transaction_id: transactionId,
        value: purchaseData.value,
        currency: purchaseData.currency,
        items: purchaseData.items,
        validation_error: true,
        validation_error_type: error.message
      });
      
      return { success: false, error: error.message };
    }
  }
  
  calculatePurchaseQuality(purchaseData, customerValidation) {
    let overallScore = 0;
    let reliability = 0;
    let authenticity = 0;
    
    // Customer quality contribution (60%)
    const customerQuality = customerValidation.quality_score || 0;
    overallScore = customerQuality * 0.6;
    
    // Purchase value contribution (20%)
    const purchaseValue = parseFloat(purchaseData.value) || 0;
    const valueScore = Math.min(40, purchaseValue / 25); // Scale purchase value
    overallScore += valueScore * 0.2;
    
    // Purchase context contribution (20%)
    const contextScore = this.calculatePurchaseContextScore(purchaseData);
    overallScore += contextScore * 0.2;
    
    // Calculate reliability
    reliability = this.calculatePurchaseReliability(customerValidation, purchaseData);
    
    // Calculate authenticity
    authenticity = this.calculatePurchaseAuthenticity(customerValidation, purchaseData);
    
    // Determine value tier
    const valueTier = this.determinePurchaseValueTier(overallScore, purchaseValue);
    
    // Calculate attribution metrics
    const attributionWeight = this.calculatePurchaseAttributionWeight(customerValidation);
    const attributionConfidence = this.calculateAttributionConfidence(
      customerValidation,
      purchaseData
    );
    
    return {
      overall_score: Math.min(100, overallScore),
      reliability: Math.min(100, reliability),
      authenticity: Math.min(100, authenticity),
      is_high_quality: overallScore >= 75 && reliability >= 80,
      is_trusted: authenticity >= 85 && reliability >= 90,
      value_tier: valueTier,
      attribution_weight: attributionWeight,
      attribution_confidence: attributionConfidence,
      fraud_risk_level: this.calculatePurchaseFraudRisk(customerValidation, purchaseData),
      fraud_indicators: this.detectPurchaseFraudIndicators(customerValidation, purchaseData),
      risk_score: this.calculatePurchaseRiskScore(customerValidation, purchaseData),
      ltv_tier: this.predictCustomerLTVTier(customerValidation, purchaseData),
      acquisition_quality: this.calculateAcquisitionQuality(customerValidation)
    };
  }
  
  async validateCustomerForEcommerce(customerData) {
    const contactInfo = {
      phone: customerData.phone,
      email: customerData.email
    };
    
    if (!contactInfo.phone && !contactInfo.email) {
      return this.getDefaultCustomerValidation();
    }
    
    try {
      const response = await fetch('https://app.1lookup.io/api/v1/validate', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json',
          'X-Integration': 'ga4-ecommerce'
        },
        body: JSON.stringify({
          ...contactInfo,
          include_fraud_indicators: true,
          include_location_details: true,
          ecommerce_context: true
        })
      });
      
      const validation = await response.json();
      
      return {
        quality_score: this.calculateCustomerEcommerceScore(validation),
        tier: this.determineCustomerTier(validation),
        verification_status: this.getCustomerVerificationStatus(validation),
        phone_verified: validation.phone?.is_valid,
        email_verified: validation.email?.is_valid,
        fraud_risk_level: validation.fraud_risk_level,
        country: validation.phone?.location_details?.country,
        region: validation.phone?.location_details?.region,
        confidence_score: this.calculateValidationConfidence(validation)
      };
      
    } catch (error) {
      console.error('Customer validation error:', error);
      return this.getDefaultCustomerValidation();
    }
  }
  
  async analyzeConversionPathQuality(conversionPath, customerValidation, purchaseQuality) {
    try {
      // Analyze each touchpoint in the conversion path
      const pathQuality = conversionPath.map(touchpoint => ({
        ...touchpoint,
        touchpoint_quality: this.calculateTouchpointQuality(
          touchpoint,
          customerValidation
        ),
        attribution_weight: this.calculateTouchpointWeight(
          touchpoint,
          customerValidation,
          purchaseQuality
        )
      }));
      
      // Calculate overall path quality
      const pathQualityScore = this.calculateConversionPathScore(pathQuality);
      
      // Track conversion path analytics
      gtag('event', 'conversion_path_quality', {
        path_length: conversionPath.length,
        path_quality_score: pathQualityScore,
        customer_tier: customerValidation.tier,
        final_conversion_quality: purchaseQuality.overall_score,
        path_attribution_confidence: this.calculatePathAttributionConfidence(pathQuality)
      });
      
    } catch (error) {
      console.error('Conversion path analysis error:', error);
    }
  }
}