bulltrackers-module 1.0.519 → 1.0.521

package/functions/alert-system/helpers/alert_helpers.js

@@ -127,6 +127,11 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     // 6. Commit batch
     await batch.commit();
     
+    // 7. Update global rootdata collection for computation system
+    const { updateAlertHistoryRootData } = require('../../generic-api/user-api/helpers/rootdata/rootdata_aggregation_helpers');
+    const triggeredUserCids = subscriptions.map(s => s.userCid);
+    await updateAlertHistoryRootData(db, logger, piCid, alertType, computationMetadata, computationDate, triggeredUserCids);
+    
     logger.log('SUCCESS', `[processAlertForPI] Created ${notificationRefs.length} notifications for PI ${piCid}, alert type ${alertType.id}`);
     
   } catch (error) {

package/functions/computation-system/context/ContextFactory.js

@@ -25,7 +25,9 @@ class ContextFactory {
             verification, 
             rankings, yesterdayRankings,         // User-specific rank entries
             allRankings, allRankingsYesterday,   // Global rank lists
-            allVerifications 
+            allVerifications,
+            // [NEW] New Root Data Types for Profile Metrics
+            ratings, pageViews, watchlistMembership, alertHistory
         } = options;
         
         return {
@@ -49,7 +51,12 @@ class ContextFactory {
             globalData: {
                 rankings: allRankings || [],
                 rankingsYesterday: allRankingsYesterday || [],
-                verifications: allVerifications || {}
+                verifications: allVerifications || {},
+                // [NEW] New Root Data Types for Profile Metrics
+                ratings: ratings || {},
+                pageViews: pageViews || {},
+                watchlistMembership: watchlistMembership || {},
+                alertHistory: alertHistory || {}
             }
         };
     }
@@ -59,7 +66,9 @@ class ContextFactory {
             dateStr, metadata, mappings, insights, socialData, prices, 
             computedDependencies, previousComputedDependencies, config, deps,
             allRankings, allRankingsYesterday, // [UPDATED] Accepted here
-            allVerifications 
+            allVerifications,
+            // [NEW] New Root Data Types for Profile Metrics
+            ratings, pageViews, watchlistMembership, alertHistory
         } = options;
         
         return {
@@ -75,7 +84,12 @@ class ContextFactory {
             globalData: {
                 rankings: allRankings || [],
                 rankingsYesterday: allRankingsYesterday || [], // [UPDATED] Injected here
-                verifications: allVerifications || {}
+                verifications: allVerifications || {},
+                // [NEW] New Root Data Types for Profile Metrics
+                ratings: ratings || {},
+                pageViews: pageViews || {},
+                watchlistMembership: watchlistMembership || {},
+                alertHistory: alertHistory || {}
             }
         };
     }

package/functions/computation-system/data/AvailabilityChecker.js

@@ -10,65 +10,150 @@ const INDEX_COLLECTION = process.env.ROOT_DATA_AVAILABILITY_COLLECTION || 'syste
 
 function checkRootDependencies(calcManifest, rootDataStatus) {
     const missing = [];
-    if (!calcManifest.rootDataDependencies) return { canRun: true, missing };
+    const available = [];
+    
+    if (!calcManifest.rootDataDependencies) return { canRun: true, missing, available };
+
+    // Check if computation can run with missing rootdata
+    const canHaveMissingRoots = calcManifest.canHaveMissingRoots === true;
 
     // Normalize userType to lowercase for comparison (computations use uppercase)
     const userType = (calcManifest.userType || 'all').toLowerCase();
 
     for (const dep of calcManifest.rootDataDependencies) {
+        let isAvailable = false;
+        
         if (dep === 'portfolio') {
-            if (userType === 'speculator' && !rootDataStatus.speculatorPortfolio) missing.push('speculatorPortfolio');
-            else if (userType === 'normal' && !rootDataStatus.normalPortfolio) missing.push('normalPortfolio');
-            else if (userType === 'popular_investor') {
-                // [FIX] Must have PI-specific portfolio data, not just any portfolio
-                if (!rootDataStatus.piPortfolios) missing.push('piPortfolios');
-                // Note: piDeepPortfolios is optional, so we don't require it
-            } 
-            else if (userType === 'signed_in_user') {
-                // [FIX] Must have signed-in user portfolio data, not just any portfolio
-                if (!rootDataStatus.signedInUserPortfolio) missing.push('signedInUserPortfolio');
-            }
-            else if (userType === 'all' && !rootDataStatus.hasPortfolio) missing.push('portfolio');
-            else {
-                // [FIX] Safety Block: If userType doesn't match known types (e.g. typo in metadata), 
-                // enforce the global 'hasPortfolio' check instead of silently allowing it.
-                if (!rootDataStatus.hasPortfolio) missing.push('portfolio (fallback)');
+            if (userType === 'speculator' && rootDataStatus.speculatorPortfolio) isAvailable = true;
+            else if (userType === 'normal' && rootDataStatus.normalPortfolio) isAvailable = true;
+            else if (userType === 'popular_investor' && rootDataStatus.piPortfolios) isAvailable = true;
+            else if (userType === 'signed_in_user' && rootDataStatus.signedInUserPortfolio) isAvailable = true;
+            else if (userType === 'all' && rootDataStatus.hasPortfolio) isAvailable = true;
+            else if (rootDataStatus.hasPortfolio) isAvailable = true; // Fallback
+            
+            if (!isAvailable) {
+                if (userType === 'speculator') missing.push('speculatorPortfolio');
+                else if (userType === 'normal') missing.push('normalPortfolio');
+                else if (userType === 'popular_investor') missing.push('piPortfolios');
+                else if (userType === 'signed_in_user') missing.push('signedInUserPortfolio');
+                else missing.push('portfolio');
+            } else {
+                available.push('portfolio');
             }
         }
         else if (dep === 'history') {
-            if (userType === 'speculator' && !rootDataStatus.speculatorHistory) missing.push('speculatorHistory');
-            else if (userType === 'normal' && !rootDataStatus.normalHistory) missing.push('normalHistory');
-            else if (userType === 'popular_investor' && !rootDataStatus.piHistory) missing.push('piHistory');
-            else if (userType === 'signed_in_user' && !rootDataStatus.signedInUserHistory) missing.push('signedInUserHistory');
-            else if (userType === 'all' && !rootDataStatus.hasHistory) missing.push('history');
-            else {
-                 // [FIX] Safety Block for History
-                 if (!rootDataStatus.hasHistory) missing.push('history (fallback)');
+            if (userType === 'speculator' && rootDataStatus.speculatorHistory) isAvailable = true;
+            else if (userType === 'normal' && rootDataStatus.normalHistory) isAvailable = true;
+            else if (userType === 'popular_investor' && rootDataStatus.piHistory) isAvailable = true;
+            else if (userType === 'signed_in_user' && rootDataStatus.signedInUserHistory) isAvailable = true;
+            else if (userType === 'all' && rootDataStatus.hasHistory) isAvailable = true;
+            else if (rootDataStatus.hasHistory) isAvailable = true; // Fallback
+            
+            if (!isAvailable) {
+                if (userType === 'speculator') missing.push('speculatorHistory');
+                else if (userType === 'normal') missing.push('normalHistory');
+                else if (userType === 'popular_investor') missing.push('piHistory');
+                else if (userType === 'signed_in_user') missing.push('signedInUserHistory');
+                else missing.push('history');
+            } else {
+                available.push('history');
+            }
+        }
+        else if (dep === 'rankings') {
+            if (rootDataStatus.piRankings) {
+                isAvailable = true;
+                available.push('rankings');
+            } else {
+                missing.push('piRankings');
+            }
+        }
+        else if (dep === 'verification') {
+            if (rootDataStatus.signedInUserVerification) {
+                isAvailable = true;
+                available.push('verification');
+            } else {
+                missing.push('signedInUserVerification');
+            }
+        }
+        else if (dep === 'insights') {
+            if (rootDataStatus.hasInsights) {
+                isAvailable = true;
+                available.push('insights');
+            } else {
+                missing.push('insights');
             }
         }
-        else if (dep === 'rankings' && !rootDataStatus.piRankings) missing.push('piRankings');
-        else if (dep === 'verification' && !rootDataStatus.signedInUserVerification) missing.push('signedInUserVerification');
-        else if (dep === 'insights' && !rootDataStatus.hasInsights) missing.push('insights');
-        
         // [UPDATED] Strict Social Data Checking
         else if (dep === 'social') {
-            if (userType === 'popular_investor') {
-                // Strict check: Must have PI-specific social data
-                if (!rootDataStatus.hasPISocial) missing.push('piSocial');
+            if (userType === 'popular_investor' && rootDataStatus.hasPISocial) {
+                isAvailable = true;
+                available.push('social');
+            } else if (userType === 'signed_in_user' && rootDataStatus.hasSignedInSocial) {
+                isAvailable = true;
+                available.push('social');
+            } else if (rootDataStatus.hasSocial) {
+                isAvailable = true;
+                available.push('social');
+            } else {
+                if (userType === 'popular_investor') missing.push('piSocial');
+                else if (userType === 'signed_in_user') missing.push('signedInSocial');
+                else missing.push('social');
+            }
+        }
+        else if (dep === 'price') {
+            if (rootDataStatus.hasPrices) {
+                isAvailable = true;
+                available.push('price');
+            } else {
+                missing.push('price');
+            }
+        }
+        // [NEW] New Root Data Types for Profile Metrics
+        else if (dep === 'ratings') {
+            if (rootDataStatus.piRatings) {
+                isAvailable = true;
+                available.push('ratings');
+            } else {
+                missing.push('piRatings');
             }
-            else if (userType === 'signed_in_user') {
-                // Strict check: Must have Signed-In User specific social data
-                if (!rootDataStatus.hasSignedInSocial) missing.push('signedInSocial');
+        }
+        else if (dep === 'pageViews') {
+            if (rootDataStatus.piPageViews) {
+                isAvailable = true;
+                available.push('pageViews');
+            } else {
+                missing.push('piPageViews');
             }
-            else {
-                // Default behavior: Check for generic asset/market social data
-                if (!rootDataStatus.hasSocial) missing.push('social');
+        }
+        else if (dep === 'watchlist') {
+            if (rootDataStatus.watchlistMembership) {
+                isAvailable = true;
+                available.push('watchlist');
+            } else {
+                missing.push('watchlistMembership');
             }
         }
-
-        else if (dep === 'price' && !rootDataStatus.hasPrices) missing.push('price');
+        else if (dep === 'alerts') {
+            if (rootDataStatus.piAlertHistory) {
+                isAvailable = true;
+                available.push('alerts');
+            } else {
+                missing.push('piAlertHistory');
+            }
+        }
+    }
+    
+    // [FIX] Enforce canHaveMissingRoots logic:
+    // - If canHaveMissingRoots: false, ALL required rootdata must be available
+    // - If canHaveMissingRoots: true, AT LEAST ONE required rootdata must be available (not zero)
+    if (canHaveMissingRoots) {
+        // Must have at least one available rootdata type
+        const canRun = available.length > 0;
+        return { canRun, missing, available };
     }
-    return { canRun: missing.length === 0, missing };
+    
+    // Strict mode: all required rootdata must be available
+    return { canRun: missing.length === 0, missing, available };
 }
 
 function getViableCalculations(candidates, fullManifest, rootDataStatus, dailyStatus) {
@@ -138,7 +223,13 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
                     
                     // [UPDATED] Granular Social Flags
                     hasPISocial:       !!details.hasPISocial || !!data.hasPISocial,
-                    hasSignedInSocial: !!details.hasSignedInSocial || !!data.hasSignedInSocial
+                    hasSignedInSocial: !!details.hasSignedInSocial || !!data.hasSignedInSocial,
+                    
+                    // [NEW] New Root Data Types for Profile Metrics
+                    piRatings:          !!details.piRatings,
+                    piPageViews:        !!details.piPageViews,
+                    watchlistMembership: !!details.watchlistMembership,
+                    piAlertHistory:     !!details.piAlertHistory
                 },
                 portfolioRefs: null, 
                 historyRefs: null,
@@ -154,7 +245,9 @@ async function checkRootDataAvailability(dateStr, config, dependencies, earliest
                     speculatorPortfolio: false, normalPortfolio: false, speculatorHistory: false, normalHistory: false,
                     piRankings: false, piPortfolios: false, piDeepPortfolios: false, piHistory: false,
                     signedInUserPortfolio: false, signedInUserHistory: false, signedInUserVerification: false,
-                    hasPISocial: false, hasSignedInSocial: false
+                    hasPISocial: false, hasSignedInSocial: false,
+                    // New Root Data Types
+                    piRatings: false, piPageViews: false, watchlistMembership: false, piAlertHistory: false
                 }
             };
         }

package/functions/computation-system/data/CachedDataLoader.js

@@ -10,7 +10,11 @@ const {
     getRelevantShardRefs, 
     getPriceShardRefs,
     loadVerificationProfiles,     // [NEW]
-    loadPopularInvestorRankings   // [NEW]
+    loadPopularInvestorRankings,  // [NEW]
+    loadPIRatings,                // [NEW]
+    loadPIPageViews,              // [NEW]
+    loadWatchlistMembership: loadWatchlistMembershipData, // [NEW] Renamed to avoid conflict
+    loadPIAlertHistory            // [NEW]
 } = require('../utils/data_loader');
 const zlib = require('zlib'); 
 
@@ -23,7 +27,11 @@ class CachedDataLoader {
             insights: new Map(), 
             social:   new Map(),
             verifications: null, // [NEW]
-            rankings: new Map()  // [NEW]
+            rankings: new Map(),  // [NEW]
+            ratings: new Map(),   // [NEW]
+            pageViews: new Map(), // [NEW]
+            watchlistMembership: new Map(), // [NEW]
+            alertHistory: new Map() // [NEW]
         }; 
     }
 
@@ -46,18 +54,20 @@ class CachedDataLoader {
         return this.cache.mappings; 
     }
 
+    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadInsights(dateStr) { 
         if (this.cache.insights.has(dateStr)) return this.cache.insights.get(dateStr); 
-        const insights = await loadDailyInsights(this.config, this.deps, dateStr); 
-        this.cache.insights.set(dateStr, insights); 
-        return insights; 
+        const promise = loadDailyInsights(this.config, this.deps, dateStr); 
+        this.cache.insights.set(dateStr, promise); 
+        return promise; 
     }
 
+    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadSocial(dateStr) { 
         if (this.cache.social.has(dateStr)) return this.cache.social.get(dateStr); 
-        const social = await loadDailySocialPostInsights(this.config, this.deps, dateStr); 
-        this.cache.social.set(dateStr, social); 
-        return social; 
+        const promise = loadDailySocialPostInsights(this.config, this.deps, dateStr); 
+        this.cache.social.set(dateStr, promise); 
+        return promise; 
     }
 
     // [NEW]
@@ -69,11 +79,48 @@ class CachedDataLoader {
     }
 
     // [NEW]
+    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadRankings(dateStr) {
         if (this.cache.rankings.has(dateStr)) return this.cache.rankings.get(dateStr);
-        const rankings = await loadPopularInvestorRankings(this.config, this.deps, dateStr);
-        this.cache.rankings.set(dateStr, rankings);
-        return rankings;
+        const promise = loadPopularInvestorRankings(this.config, this.deps, dateStr);
+        this.cache.rankings.set(dateStr, promise);
+        return promise;
+    }
+
+    // [NEW] Load PI Ratings Data
+    // [FIX] Cache promises to prevent race conditions when multiple users request same data
+    async loadRatings(dateStr) {
+        if (this.cache.ratings.has(dateStr)) return this.cache.ratings.get(dateStr);
+        const promise = loadPIRatings(this.config, this.deps, dateStr);
+        this.cache.ratings.set(dateStr, promise);
+        return promise;
+    }
+
+    // [NEW] Load PI Page Views Data
+    // [FIX] Cache promises to prevent race conditions when multiple users request same data
+    async loadPageViews(dateStr) {
+        if (this.cache.pageViews.has(dateStr)) return this.cache.pageViews.get(dateStr);
+        const promise = loadPIPageViews(this.config, this.deps, dateStr);
+        this.cache.pageViews.set(dateStr, promise);
+        return promise;
+    }
+
+    // [NEW] Load Watchlist Membership Data
+    // [FIX] Cache promises to prevent race conditions when multiple users request same data
+    async loadWatchlistMembership(dateStr) {
+        if (this.cache.watchlistMembership.has(dateStr)) return this.cache.watchlistMembership.get(dateStr);
+        const promise = loadWatchlistMembershipData(this.config, this.deps, dateStr);
+        this.cache.watchlistMembership.set(dateStr, promise);
+        return promise;
+    }
+
+    // [NEW] Load PI Alert History Data
+    // [FIX] Cache promises to prevent race conditions when multiple users request same data
+    async loadAlertHistory(dateStr) {
+        if (this.cache.alertHistory.has(dateStr)) return this.cache.alertHistory.get(dateStr);
+        const promise = loadPIAlertHistory(this.config, this.deps, dateStr);
+        this.cache.alertHistory.set(dateStr, promise);
+        return promise;
     }
 
     async getPriceShardReferences() { 

package/functions/computation-system/executors/MetaExecutor.js

@@ -34,6 +34,96 @@ class MetaExecutor {
             loader.loadRankings(dStr),
             loader.loadVerifications()
         ]);
+        
+        // [NEW] Load New Root Data Types for Profile Metrics (if any calc needs them)
+        const needsNewRootData = calcs.some(c => {
+            const deps = c.rootDataDependencies || [];
+            return deps.includes('ratings') || deps.includes('pageViews') || 
+                   deps.includes('watchlist') || deps.includes('alerts');
+        });
+        
+        let ratings = null, pageViews = null, watchlistMembership = null, alertHistory = null;
+        if (needsNewRootData) {
+            const loadPromises = [];
+            if (calcs.some(c => c.rootDataDependencies?.includes('ratings'))) {
+                loadPromises.push(loader.loadRatings(dStr).then(r => { ratings = r; }).catch(e => {
+                    // Only catch if ALL calcs allow missing roots
+                    const allAllowMissing = calcs.every(c => {
+                        const needsRatings = c.rootDataDependencies?.includes('ratings');
+                        return !needsRatings || c.canHaveMissingRoots === true;
+                    });
+                    if (allAllowMissing) {
+                        ratings = null;
+                    } else {
+                        throw e; // Re-throw if any calc requires this data
+                    }
+                }));
+            }
+            if (calcs.some(c => c.rootDataDependencies?.includes('pageViews'))) {
+                loadPromises.push(loader.loadPageViews(dStr).then(pv => { pageViews = pv; }).catch(e => {
+                    const allAllowMissing = calcs.every(c => {
+                        const needsPageViews = c.rootDataDependencies?.includes('pageViews');
+                        return !needsPageViews || c.canHaveMissingRoots === true;
+                    });
+                    if (allAllowMissing) {
+                        pageViews = null;
+                    } else {
+                        throw e;
+                    }
+                }));
+            }
+            if (calcs.some(c => c.rootDataDependencies?.includes('watchlist'))) {
+                loadPromises.push(loader.loadWatchlistMembership(dStr).then(w => { watchlistMembership = w; }).catch(e => {
+                    const allAllowMissing = calcs.every(c => {
+                        const needsWatchlist = c.rootDataDependencies?.includes('watchlist');
+                        return !needsWatchlist || c.canHaveMissingRoots === true;
+                    });
+                    if (allAllowMissing) {
+                        watchlistMembership = null;
+                    } else {
+                        throw e;
+                    }
+                }));
+            }
+            if (calcs.some(c => c.rootDataDependencies?.includes('alerts'))) {
+                loadPromises.push(loader.loadAlertHistory(dStr).then(a => { alertHistory = a; }).catch(e => {
+                    const allAllowMissing = calcs.every(c => {
+                        const needsAlerts = c.rootDataDependencies?.includes('alerts');
+                        return !needsAlerts || c.canHaveMissingRoots === true;
+                    });
+                    if (allAllowMissing) {
+                        alertHistory = null;
+                    } else {
+                        throw e;
+                    }
+                }));
+            }
+            await Promise.all(loadPromises);
+            
+            // [FIX] Enforce canHaveMissingRoots - validate after loading
+            for (const c of calcs) {
+                const deps = c.rootDataDependencies || [];
+                const canSkip = c.canHaveMissingRoots === true;
+                
+                // Helper to check if a specific root is missing
+                const isMissing = (key, val) => deps.includes(key) && (val === null || val === undefined);
+                
+                if (!canSkip) {
+                    if (isMissing('ratings', ratings)) {
+                        throw new Error(`[MetaExecutor] Missing required root 'ratings' for ${c.name}`);
+                    }
+                    if (isMissing('pageViews', pageViews)) {
+                        throw new Error(`[MetaExecutor] Missing required root 'pageViews' for ${c.name}`);
+                    }
+                    if (isMissing('watchlist', watchlistMembership)) {
+                        throw new Error(`[MetaExecutor] Missing required root 'watchlist' for ${c.name}`);
+                    }
+                    if (isMissing('alerts', alertHistory)) {
+                        throw new Error(`[MetaExecutor] Missing required root 'alerts' for ${c.name}`);
+                    }
+                }
+            }
+        }
 
         const state = {};
         for (const c of calcs) {
@@ -51,7 +141,12 @@ class MetaExecutor {
                 config, deps,
                 allRankings: rankings,
                 allRankingsYesterday: rankingsYesterday, // [FIX] Injected
-                allVerifications: verifications
+                allVerifications: verifications,
+                // [NEW] Pass New Root Data Types for Profile Metrics
+                ratings: ratings || {},
+                pageViews: pageViews || {},
+                watchlistMembership: watchlistMembership || {},
+                alertHistory: alertHistory || {}
             });
 
             try {
@@ -87,6 +182,62 @@ class MetaExecutor {
 
         // Load current rankings (often needed for ContextFactory.buildMetaContext)
         const rankings = await loader.loadRankings(dateStr);
+        
+        // [NEW] Load New Root Data Types for Profile Metrics
+        // [FIX] Enforce canHaveMissingRoots
+        const allowMissing = metadata.canHaveMissingRoots === true;
+        
+        let ratings = null;
+        if (metadata.rootDataDependencies?.includes('ratings')) {
+            try {
+                ratings = await loader.loadRatings(dateStr);
+            } catch (e) {
+                if (!allowMissing) throw new Error(`[MetaExecutor.executeOncePerDay] Required root 'ratings' failed to load for ${metadata.name}: ${e.message}`);
+                ratings = null;
+            }
+            if (!ratings && !allowMissing) {
+                throw new Error(`[MetaExecutor.executeOncePerDay] Required root 'ratings' is missing for ${metadata.name}`);
+            }
+        }
+        
+        let pageViews = null;
+        if (metadata.rootDataDependencies?.includes('pageViews')) {
+            try {
+                pageViews = await loader.loadPageViews(dateStr);
+            } catch (e) {
+                if (!allowMissing) throw new Error(`[MetaExecutor.executeOncePerDay] Required root 'pageViews' failed to load for ${metadata.name}: ${e.message}`);
+                pageViews = null;
+            }
+            if (!pageViews && !allowMissing) {
+                throw new Error(`[MetaExecutor.executeOncePerDay] Required root 'pageViews' is missing for ${metadata.name}`);
+            }
+        }
+        
+        let watchlistMembership = null;
+        if (metadata.rootDataDependencies?.includes('watchlist')) {
+            try {
+                watchlistMembership = await loader.loadWatchlistMembership(dateStr);
+            } catch (e) {
+                if (!allowMissing) throw new Error(`[MetaExecutor.executeOncePerDay] Required root 'watchlist' failed to load for ${metadata.name}: ${e.message}`);
+                watchlistMembership = null;
+            }
+            if (!watchlistMembership && !allowMissing) {
+                throw new Error(`[MetaExecutor.executeOncePerDay] Required root 'watchlist' is missing for ${metadata.name}`);
+            }
+        }
+        
+        let alertHistory = null;
+        if (metadata.rootDataDependencies?.includes('alerts')) {
+            try {
+                alertHistory = await loader.loadAlertHistory(dateStr);
+            } catch (e) {
+                if (!allowMissing) throw new Error(`[MetaExecutor.executeOncePerDay] Required root 'alerts' failed to load for ${metadata.name}: ${e.message}`);
+                alertHistory = null;
+            }
+            if (!alertHistory && !allowMissing) {
+                throw new Error(`[MetaExecutor.executeOncePerDay] Required root 'alerts' is missing for ${metadata.name}`);
+            }
+        }
 
         if (metadata.rootDataDependencies?.includes('price')) {
             logger.log('INFO', `[Executor] Running Batched/Sharded Execution for ${metadata.name}`);
@@ -101,7 +252,12 @@ class MetaExecutor {
                     prices: { history: shardData }, computedDependencies: computedDeps, 
                     previousComputedDependencies: prevDeps, config, deps,
                     allRankings: rankings,
-                    allRankingsYesterday: rankingsYesterday
+                    allRankingsYesterday: rankingsYesterday,
+                    // [NEW] Pass New Root Data Types for Profile Metrics
+                    ratings: ratings || {},
+                    pageViews: pageViews || {},
+                    watchlistMembership: watchlistMembership || {},
+                    alertHistory: alertHistory || {}
                 });
                 
                 await calcInstance.process(partialContext);
@@ -121,7 +277,12 @@ class MetaExecutor {
                 prices: {}, computedDependencies: computedDeps, 
                 previousComputedDependencies: prevDeps, config, deps,
                 allRankings: rankings,
-                allRankingsYesterday: rankingsYesterday
+                allRankingsYesterday: rankingsYesterday,
+                // [NEW] Pass New Root Data Types for Profile Metrics
+                ratings: ratings || {},
+                pageViews: pageViews || {},
+                watchlistMembership: watchlistMembership || {},
+                alertHistory: alertHistory || {}
             });
             const res = await calcInstance.process(context);