bulltrackers-module 1.0.778 → 1.0.779

package/functions/api-v2/helpers/data-fetchers/firestore.js

@@ -83,36 +83,88 @@ const latestUserCentricSnapshot = async (firestore, userId, collectionName, data
 // Currently all of the isPage computations are stored under the same popular-investor location, so computation path isn't really needed, can hardcode for now.
 // A lookback period to return the latest data we have for a given userID within a given lookback range, otherwise returning an identifiable error
 
+// V2 profile metrics paths (one doc per entity per date)
+const PROFILE_COMPUTATION_PATHS = {
+    SignedInUserProfileMetrics: 'SignedInUserProfiles/{entityId}/metrics/{date}',
+    SignedInUserPIProfileMetrics: 'users/{entityId}/signed_in_user_pi_profile_metrics/{date}',
+    PopularInvestorProfileMetrics: 'PiProfiles/{entityId}/metrics/{date}'
+};
+
+/**
+ * Fetch profile metrics from V2 Firestore path (one doc per date).
+ * @param {Object} firestore - Firestore instance
+ * @param {string} pathTemplate - e.g. 'PiProfiles/{entityId}/metrics/{date}'
+ * @param {string} entityId - User or PI ID
+ * @param {string} dateStr - Target date (YYYY-MM-DD)
+ * @param {number} lookbackDays - Days to look back
+ * @returns {Promise<Array<{date: string, data: object}>>} Sorted by date desc (newest first)
+ */
+const getProfileMetricsFromPath = async (firestore, pathTemplate, entityId, dateStr, lookbackDays = 7) => {
+    const sanitizedEntityId = sanitizeCid(entityId);
+    const endDate = new Date(dateStr);
+    const startDate = new Date(endDate);
+    startDate.setDate(endDate.getDate() - lookbackDays);
+    const results = [];
+    for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
+        const dateKey = d.toISOString().split('T')[0];
+        const path = pathTemplate.replace(/{entityId}/g, sanitizedEntityId).replace(/{date}/g, dateKey);
+        const docRef = firestore.doc(path);
+        const docSnapshot = await docRef.get();
+        if (docSnapshot.exists) {
+            results.push({ date: dateKey, data: docSnapshot.data() });
+        }
+    }
+    if (results.length === 0) {
+        throw new Error(`No profile data found for entity ${sanitizedEntityId} within the last ${lookbackDays} days`);
+    }
+    results.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+    return results;
+};
+
+/**
+ * Fetch profile metrics for a computation that writes to V2 path.
+ * @param {Object} db - Firestore instance
+ * @param {string} computationName - SignedInUserProfileMetrics | SignedInUserPIProfileMetrics | PopularInvestorProfileMetrics
+ * @param {string} entityId - User or PI ID
+ * @param {string} dateStr - Target date
+ * @param {number} lookbackDays - Lookback days
+ * @returns {Promise<Array<{date: string, data: object}>>}
+ */
+const fetchProfileMetrics = async (db, computationName, entityId, dateStr, lookbackDays = 7) => {
+    const pathTemplate = PROFILE_COMPUTATION_PATHS[computationName];
+    if (!pathTemplate) {
+        throw new Error(`Unknown profile computation: ${computationName}`);
+    }
+    return getProfileMetricsFromPath(db, pathTemplate, entityId, dateStr, lookbackDays);
+};
+
+/** @deprecated Use fetchProfileMetrics for V2 profile computations (SignedInUserProfileMetrics, SignedInUserPIProfileMetrics, PopularInvestorProfileMetrics). */
 const pageCollection = async (firestore, dateStr, computationName, userId, lookbackDays = 7) => {
+    if (PROFILE_COMPUTATION_PATHS[computationName]) {
+        return fetchProfileMetrics(firestore, computationName, userId, dateStr, lookbackDays);
+    }
     try {
-        // Sanitize user inputs
         const sanitizedUserId = sanitizeCid(userId);
         const sanitizedComputationName = sanitizeDocId(computationName);
-        
         const endDate = new Date(dateStr);
         const startDate = new Date(endDate);
         startDate.setDate(endDate.getDate() - lookbackDays);
         const results = [];
         for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
             const dateKey = d.toISOString().split('T')[0];
-            const docRef = firestore.collection('unified_insights').doc(dateKey)    
+            const docRef = firestore.collection('unified_insights').doc(dateKey)
                 .collection('results').doc('popular-investor')
                 .collection('computations').doc(sanitizedComputationName)
                 .collection('pages').doc(sanitizedUserId);
             const docSnapshot = await docRef.get();
             if (docSnapshot.exists) {
                 results.push({ date: dateKey, data: docSnapshot.data() });
-            }   
+            }
         }
         if (results.length === 0) {
             throw new Error(`No page data found for User ID ${sanitizedUserId} in computation ${sanitizedComputationName} within the last ${lookbackDays} days`);
         }
-        // Sort results by date descending (newest first) so the latest data is always first
-        results.sort((a, b) => {
-            const dateA = new Date(a.date);
-            const dateB = new Date(b.date);
-            return dateB.getTime() - dateA.getTime(); // Descending order (newest first)
-        });
+        results.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
         return results;
     } catch (error) {
         console.error(`Error fetching page collection data: ${error}`);
@@ -169,18 +221,18 @@ const fetchPopularInvestorMasterList = async (firestore, userId = null) => {
         const data = docSnapshot.data().investors;
         if (userId) {
             if (data[userId]) {
-                return data[userId];    
+                return data[userId];
             } else {
                 throw new Error(`User ID ${userId} not found in popular investor master list`);
             }
         } else {
             return data;
-        }   
+        }
     } catch (error) {
         console.error(`Error fetching popular investor master list: ${error}`);
         throw error;
     }
-};  
+};
 
 // 4. Fetch developer overrides data
 // GOAL : Used for allowing a given userID to have special abilities
@@ -191,12 +243,12 @@ const isDeveloper = async (firestore, userId) => {
     try {
         const docRef = firestore.collection('dev_overrides').doc(userId);
         const docSnapshot = await docRef.get();
-        
+
         // Check both that document exists AND enabled === true
         if (!docSnapshot.exists) {
             return false;
         }
-        
+
         const data = docSnapshot.data();
         return data?.enabled === true;
     }
@@ -388,15 +440,15 @@ const isDeveloper = async (firestore, userId) => {
 const manageUserWatchlist = async (db, userId, instruction, payload = {}) => {
     const todayStr = new Date().toISOString().split('T')[0]; // "2026-01-09"
     const batch = db.batch();
-    
+
     // Sanitize user inputs
     const sanitizedUserId = sanitizeCid(userId);
-    
+
     // 1. Determine Watchlist ID and Reference
     // Handle both 'id' (from frontend) and 'watchlistId' (legacy)
-    const watchlistId = payload.id ? sanitizeDocId(payload.id) 
-                      : payload.watchlistId ? sanitizeDocId(payload.watchlistId)
-                      : `watchlist_${Date.now()}_${Math.random().toString(16).substr(2, 8)}`;
+    const watchlistId = payload.id ? sanitizeDocId(payload.id)
+        : payload.watchlistId ? sanitizeDocId(payload.watchlistId)
+            : `watchlist_${Date.now()}_${Math.random().toString(16).substr(2, 8)}`;
     const userDocRef = db.collection('SignedInUsers').doc(sanitizedUserId).collection('watchlists').doc(watchlistId);
 
     try {
@@ -406,12 +458,14 @@ const manageUserWatchlist = async (db, userId, instruction, payload = {}) => {
 
         // 2. Fetch Old State (necessary for Update and Delete)
         let oldItems = [];
+        let oldDocData = null;
         if (instruction === 'update' || instruction === 'delete') {
             const currentSnap = await userDocRef.get();
             if (currentSnap.exists) {
-                oldItems = currentSnap.data().items || [];
+                oldDocData = currentSnap.data();
+                oldItems = oldDocData.items || [];
             } else if (instruction === 'update') {
-                 // Fail safe: If updating a non-existent doc, treat as create
+                // Fail safe: If updating a non-existent doc, treat as create
             }
         }
 
@@ -429,33 +483,33 @@ const manageUserWatchlist = async (db, userId, instruction, payload = {}) => {
                 isAutoGenerated: false
             };
             batch.set(userDocRef, newDocData);
-        } 
-        
+        }
+
         else if (instruction === 'delete') {
             removedItems = oldItems; // All items are being removed
             // Delete the User Document
             batch.delete(userDocRef);
-        } 
-        
+        }
+
         else if (instruction === 'update') {
             const newItems = payload.items || [];
-            
+
             // Map IDs for comparison
             const oldCids = new Set(oldItems.map(i => Number(i.cid)));
             const newCids = new Set(newItems.map(i => Number(i.cid)));
 
             // Calculate Added (In New, not in Old)
             addedItems = newItems.filter(i => !oldCids.has(Number(i.cid)));
-            
+
             // Calculate Removed (In Old, not in New)
             removedItems = oldItems.filter(i => !newCids.has(Number(i.cid)));
 
             if (payload.visibility) isPrivate = payload.visibility === 'private';
 
             // Update the User Document
-            batch.set(userDocRef, { 
-                ...payload, 
-                updatedAt: FieldValue.serverTimestamp() 
+            batch.set(userDocRef, {
+                ...payload,
+                updatedAt: FieldValue.serverTimestamp()
             }, { merge: true });
         }
 
@@ -480,7 +534,7 @@ const manageUserWatchlist = async (db, userId, instruction, payload = {}) => {
                 .doc(piId).collection('watchlistData').doc('current');
 
             const dailyField = `dailyAdditions.${todayStr}`;
-            
+
             batch.set(piCounterRef, {
                 lastUpdated: FieldValue.serverTimestamp(),
                 totalUsers: FieldValue.increment(1),
@@ -494,88 +548,125 @@ const manageUserWatchlist = async (db, userId, instruction, payload = {}) => {
             }, { merge: true });
         });
 
-        // 5. Handle REMOVALS (Current Counter Decrement ONLY)
+        // 5. Handle REMOVALS (Current Counter Decrement only; BQ uses in-memory delta for removed PIs)
         removedItems.forEach(item => {
             const piId = String(item.cid);
-
-            // Update PI Real-time Counter (Decrement)
             const piCounterRef = db.collection('PopularInvestors')
                 .doc(piId).collection('watchlistData').doc('current');
-
-            // We do NOT touch dailyAdditions here, only global totals
             batch.set(piCounterRef, {
                 lastUpdated: FieldValue.serverTimestamp(),
                 totalUsers: FieldValue.increment(-1),
-                userCids: FieldValue.arrayRemove(userId)
+                userCids: FieldValue.arrayRemove(sanitizedUserId)
             }, { merge: true });
         });
 
         // 6. Commit Batch
         await batch.commit();
-        
+
         // 7. Write to BigQuery (after Firestore commit to get final values)
         if (process.env.BIGQUERY_ENABLED !== 'false' && (addedItems.length > 0 || removedItems.length > 0)) {
             try {
-                const { ensureWatchlistMembershipTable, insertRowsWithMerge } = require('../../../core/utils/bigquery_utils');
+                const { ensureWatchlistMembershipTable, ensureUserAlertSettingsTable, insertRowsWithMerge } = require('../../../core/utils/bigquery_utils');
                 await ensureWatchlistMembershipTable();
-                
+
                 const datasetId = process.env.BIGQUERY_DATASET_ID || 'bulltrackers_data';
                 const bigqueryRows = [];
-                
-                // Process all affected PIs (both added and removed)
+
                 const affectedPIs = new Set([
                     ...addedItems.map(item => String(item.cid)),
                     ...removedItems.map(item => String(item.cid))
                 ]);
-                
-                // Read updated documents from subcollection for each affected PI
+                const removedPIIds = new Set(removedItems.map(item => String(item.cid)));
+
                 for (const piId of affectedPIs) {
                     const masterRef = db.collection('WatchlistMembershipData')
                         .doc(todayStr).collection('popular_investors').doc(piId);
-                    
                     const piDoc = await masterRef.get();
+
+                    let totalUsers = 0;
+                    let publicWatchlistCount = 0;
+                    let privateWatchlistCount = 0;
+                    let users = [];
+                    let lastUpdated = new Date().toISOString();
+
                     if (piDoc.exists) {
                         const piData = piDoc.data();
-                        
-                        // Transform to BigQuery format
-                        const lastUpdated = piData.lastUpdated 
-                            ? (piData.lastUpdated.toDate ? piData.lastUpdated.toDate().toISOString() : piData.lastUpdated)
-                            : new Date().toISOString();
-                        
-                        bigqueryRows.push({
-                            date: todayStr,
-                            pi_id: parseInt(piId, 10),
-                            total_users: piData.totalUsers || 0,
-                            public_watchlist_count: piData.publicWatchlistCount || 0,
-                            private_watchlist_count: piData.privateWatchlistCount || 0,
-                            users: Array.isArray(piData.users) ? piData.users : [],
-                            last_updated: lastUpdated
-                        });
+                        totalUsers = piData.totalUsers || 0;
+                        publicWatchlistCount = piData.publicWatchlistCount || 0;
+                        privateWatchlistCount = piData.privateWatchlistCount || 0;
+                        users = Array.isArray(piData.users) ? piData.users : [];
+                        lastUpdated = piData.lastUpdated
+                            ? (piData.lastUpdated.toDate ? piData.lastUpdated.toDate().toISOString() : String(piData.lastUpdated))
+                            : lastUpdated;
+
+                        if (removedPIIds.has(piId)) {
+                            totalUsers = Math.max(0, totalUsers - 1);
+                            users = users.filter((u) => u !== sanitizedUserId);
+                            if (isPrivate) {
+                                privateWatchlistCount = Math.max(0, privateWatchlistCount - 1);
+                            } else {
+                                publicWatchlistCount = Math.max(0, publicWatchlistCount - 1);
+                            }
+                        }
+                    } else if (removedPIIds.has(piId)) {
+                        totalUsers = 0;
+                        users = [];
                     }
+
+                    bigqueryRows.push({
+                        date: todayStr,
+                        pi_id: parseInt(piId, 10),
+                        total_users: totalUsers,
+                        public_watchlist_count: publicWatchlistCount,
+                        private_watchlist_count: privateWatchlistCount,
+                        users,
+                        last_updated: lastUpdated
+                    });
                 }
-                
+
                 if (bigqueryRows.length > 0) {
-                    // Use MERGE to update existing rows or insert new
                     await insertRowsWithMerge(
                         datasetId,
                         'watchlist_membership',
                         bigqueryRows,
-                        ['date', 'pi_id'], // Key fields for MERGE
-                        console // Simple logger
+                        ['date', 'pi_id'],
+                        console
                     );
                 }
+
+                // 8. Write to user_alert_settings (one row per watchlist create/update/delete)
+                await ensureUserAlertSettingsTable();
+                const watchlistName = payload.name ?? oldDocData?.name ?? null;
+                const watchlistVisibility = payload.visibility ?? oldDocData?.visibility ?? null;
+                const finalItems = instruction === 'delete' ? [] : (payload.items || []);
+                const userAlertRow = {
+                    date: todayStr,
+                    user_id: sanitizedUserId,
+                    watchlist_id: watchlistId,
+                    watchlist_name: watchlistName,
+                    visibility: watchlistVisibility,
+                    items: finalItems,
+                    updated_at: new Date().toISOString()
+                };
+                await insertRowsWithMerge(
+                    datasetId,
+                    'user_alert_settings',
+                    [userAlertRow],
+                    ['date', 'user_id', 'watchlist_id'],
+                    console
+                );
             } catch (bqError) {
                 console.error(`[manageUserWatchlist] BigQuery write failed: ${bqError.message}`);
                 // Don't throw - Firestore write succeeded, BigQuery is secondary
             }
         }
-        
-        return { 
-            success: true, 
-            id: watchlistId, 
-            action: instruction, 
-            added: addedItems.length, 
-            removed: removedItems.length 
+
+        return {
+            success: true,
+            id: watchlistId,
+            action: instruction,
+            added: addedItems.length,
+            removed: removedItems.length
         };
 
     } catch (error) {
@@ -619,7 +710,7 @@ const fetchUserVerificationData = async (firestore, userId) => {
         const docSnapshot = await docRef.get();
         if (!docSnapshot.exists) {
             throw new Error(`Verification data for User ID ${userId} not found`);
-        }  
+        }
         return { id: docSnapshot.id, ...docSnapshot.data() };
     } catch (error) {
         console.error(`Error fetching user verification data: ${error}`);
@@ -644,14 +735,14 @@ const createEmailLookup = async (firestore, email, cid) => {
     try {
         const hashedEmail = hashEmail(email);
         const lookupRef = firestore.collection('sys_user_lookup').doc(hashedEmail);
-        
+
         await lookupRef.set({
             cid: Number(cid),
             emailHash: hashedEmail,
             createdAt: FieldValue.serverTimestamp(),
             updatedAt: FieldValue.serverTimestamp(),
         }, { merge: true });
-        
+
         console.log(`[createEmailLookup] Created lookup document for email hash ${hashedEmail} -> CID ${cid}`);
     } catch (error) {
         console.error(`[createEmailLookup] Error creating lookup for ${email}:`, error);
@@ -672,33 +763,33 @@ const lookupCidByEmail = async (firestore, userEmail, firebaseUid = null) => {
     if (!userEmail) {
         throw new Error('Email is required for lookup');
     }
-    
+
     try {
         // Normalize email for comparison
         const normalizedEmail = String(userEmail).toLowerCase().trim();
         const hashedEmail = hashEmail(normalizedEmail);
-        
+
         // STEP 1: Try O(1) lookup from denormalized collection
         const lookupRef = firestore.collection('sys_user_lookup').doc(hashedEmail);
         const lookupDoc = await lookupRef.get();
-        
+
         if (lookupDoc.exists) {
             const lookupData = lookupDoc.data();
             const cid = lookupData.cid;
-            
+
             // Fetch verification data to return full user info
             const verificationRef = firestore.collection('SignedInUsers').doc(String(cid)).collection('verification').doc('data');
             const verificationDoc = await verificationRef.get();
-            
+
             if (verificationDoc.exists) {
                 const verificationData = verificationDoc.data();
-                
+
                 // Verify email is still in the verification document (safety check)
-                const emails = Array.isArray(verificationData.email) 
-                    ? verificationData.email 
+                const emails = Array.isArray(verificationData.email)
+                    ? verificationData.email
                     : (verificationData.email ? [verificationData.email] : []);
                 const normalizedEmails = emails.map(e => String(e).toLowerCase().trim());
-                
+
                 if (normalizedEmails.includes(normalizedEmail)) {
                     // Validate and enforce Firebase UID if provided
                     if (firebaseUid) {
@@ -716,7 +807,7 @@ const lookupCidByEmail = async (firestore, userEmail, firebaseUid = null) => {
                             console.log(`[Migration] Added Firebase UID ${firebaseUid} to CID ${cid}`);
                         }
                     }
-                    
+
                     // Return result from O(1) lookup
                     return {
                         cid: verificationData.etoroCID || Number(cid),
@@ -733,31 +824,31 @@ const lookupCidByEmail = async (firestore, userEmail, firebaseUid = null) => {
                 }
             }
         }
-        
+
         // STEP 2: Fallback to O(N) search (migration path)
         // This happens when:
         // 1. Lookup document doesn't exist yet (new user or not migrated)
         // 2. Lookup document exists but email not in verification (stale data)
         console.log(`[lookupCidByEmail] Lookup document not found for ${normalizedEmail}, performing O(N) search (migration)`);
-        
+
         const signedInUsersSnapshot = await firestore.collection('SignedInUsers').get();
-        
+
         // Search through each CID's verification document
         for (const userDoc of signedInUsersSnapshot.docs) {
             const verificationRef = userDoc.ref.collection('verification').doc('data');
             const verificationDoc = await verificationRef.get();
-            
+
             if (verificationDoc.exists) {
                 const verificationData = verificationDoc.data();
-                const emails = Array.isArray(verificationData.email) 
-                    ? verificationData.email 
+                const emails = Array.isArray(verificationData.email)
+                    ? verificationData.email
                     : (verificationData.email ? [verificationData.email] : []);
-                
+
                 // Case-insensitive email comparison
                 const normalizedEmails = emails.map(e => String(e).toLowerCase().trim());
                 if (normalizedEmails.includes(normalizedEmail)) {
                     const cid = verificationData.etoroCID || Number(userDoc.id);
-                    
+
                     // Validate and enforce Firebase UID if provided
                     if (firebaseUid) {
                         if (verificationData.firebaseUids && Array.isArray(verificationData.firebaseUids)) {
@@ -774,13 +865,13 @@ const lookupCidByEmail = async (firestore, userEmail, firebaseUid = null) => {
                             console.log(`[Migration] Added Firebase UID ${firebaseUid} to CID ${cid}`);
                         }
                     }
-                    
+
                     // STEP 3: Create lookup document for future O(1) access (migration)
                     // Create lookup for all emails in the verification document to handle multiple accounts
                     for (const email of normalizedEmails) {
                         await createEmailLookup(firestore, email, cid);
                     }
-                    
+
                     // Return result
                     return {
                         cid: cid,
@@ -794,7 +885,7 @@ const lookupCidByEmail = async (firestore, userEmail, firebaseUid = null) => {
                 }
             }
         }
-        
+
         // No match found
         return null;
     } catch (error) {
@@ -828,7 +919,7 @@ const requestPopularInvestorAddition = async (firestore, userId, piId, piUsernam
             if (masterData[piId]) {
                 throw new Error(`Popular Investor ID ${piId} is already in the master list`);
             }
-        }   
+        }
         const ttlDate = new Date();
         ttlDate.setDate(ttlDate.getDate() + 7);
         await userRequestRef.set({
@@ -848,7 +939,7 @@ const requestPopularInvestorAddition = async (firestore, userId, piId, piUsernam
     } catch (error) {
         console.error(`Error requesting popular investor addition: ${error}`);
         throw error;
-    }           
+    }
 };
 
 // 8. Verification process to check if a given userID has copied a given popular investor
@@ -1038,10 +1129,10 @@ const manageReviews = async (db, userId, action, params = {}) => {
     const sanitizedUserId = sanitizeCid(userId);
     const { piId } = params;
     const sanitizedPiId = sanitizeCid(piId);
-    
+
     const batch = db.batch();
     const todayStr = new Date().toISOString().split('T')[0];
-    
+
     // Paths - all user inputs sanitized
     const newReviewPath = db.collection('SignedInUsers').doc(sanitizedUserId).collection('reviews').doc(sanitizedPiId);
     const piReviewPath = db.collection('PopularInvestors').doc(sanitizedPiId).collection('reviews').doc(`${sanitizedUserId}_${sanitizedPiId}`);
@@ -1089,7 +1180,7 @@ const manageReviews = async (db, userId, action, params = {}) => {
             // 1. Verify User Copies PI (Internal Logic)
             const portfolioRef = db.collection('SignedInUsers').doc(userId).collection('portfolio').doc('latest');
             const portfolioSnap = await portfolioRef.get();
-            
+
             const hasCopy = portfolioSnap.exists && (portfolioSnap.data().AggregatedMirrors || [])
                 .some(m => String(m.ParentCID) === String(piId));
 
@@ -1098,14 +1189,14 @@ const manageReviews = async (db, userId, action, params = {}) => {
             // 2. Validation
             const rating = Number(params.rating);
             if (!Number.isInteger(rating) || rating < 1 || rating > 5) throw new Error("Rating must be 1-5");
-            
+
             const comment = (params.comment || "").trim();
             if (comment.length > 1000) throw new Error("Comment too long");
 
             // 3. Check for existing data
             const existingNew = await newReviewPath.get();
             const existingLegacy = !existingNew.exists ? await legacyReviewPath.get() : null;
-            
+
             const now = FieldValue.serverTimestamp();
             let finalCreatedAt = now;
             let isEdit = false;
@@ -1135,7 +1226,7 @@ const manageReviews = async (db, userId, action, params = {}) => {
 
             batch.set(newReviewPath, reviewPayload);
             batch.set(piReviewPath, reviewPayload);
-            
+
             batch.set(globalLogPath, {
                 [`reviews.${userId}_${piId}`]: {
                     ...reviewPayload,
@@ -1146,15 +1237,15 @@ const manageReviews = async (db, userId, action, params = {}) => {
 
             if (!isEdit) {
                 const piRef = db.collection('PopularInvestors').doc(piId.toString());
-                batch.set(piRef, { 
-                    reviewStats: { totalReviews: FieldValue.increment(1) } 
+                batch.set(piRef, {
+                    reviewStats: { totalReviews: FieldValue.increment(1) }
                 }, { merge: true });
             }
 
             await batch.commit();
             return { success: true, action: isEdit ? 'updated' : 'created' };
         }
-        
+
         throw new Error("Invalid Action");
 
     } catch (error) {
@@ -1287,12 +1378,12 @@ const getComputationResults = async (db, computationName, dateStr, userId = null
             try {
                 const bucketName = pointerData.gcsBucket || pointerData.gcsUri.split('/')[2];
                 const fileName = pointerData.gcsPath || pointerData.gcsUri.split('/').slice(3).join('/');
-                
+
                 console.log(`[Computation] Reading from GCS: ${fileName} for ${computationName}`);
-                
+
                 // Stream download is memory efficient for large files
                 const [fileContent] = await storage.bucket(bucketName).file(fileName).download();
-                
+
                 // Assume Gzip (as writer does it), if fails try plain
                 try {
                     return JSON.parse(zlib.gunzipSync(fileContent).toString('utf8'));
@@ -1318,7 +1409,7 @@ const getComputationResults = async (db, computationName, dateStr, userId = null
         if (pointerData._sharded === true) {
             const shardCount = pointerData._shardCount || 0;
             console.log(`[Computation] Reassembling ${shardCount} shards for ${computationName}`);
-            
+
             if (shardCount === 0) return {}; // Return empty object for object-based results
 
             // Create an array of promises to fetch all shards in parallel
@@ -1329,17 +1420,17 @@ const getComputationResults = async (db, computationName, dateStr, userId = null
             }
 
             const shardSnaps = await Promise.all(shardPromises);
-            
+
             // Reassemble data by merging objects (for object-based results like GlobalAumPerAsset30D)
             // Shards contain partial objects that need to be merged together
             let reassembledData = {};
-            
+
             shardSnaps.forEach((snap, index) => {
                 if (snap.exists) {
                     const data = snap.data();
                     // If the shard itself is compressed (common in big data), decompress it
                     const content = (data._compressed) ? tryDecompress(data) : data;
-                    
+
                     // Merge shard contents, ignoring internal metadata fields
                     if (content && typeof content === 'object') {
                         Object.entries(content).forEach(([k, v]) => {
@@ -1375,35 +1466,91 @@ const getComputationResults = async (db, computationName, dateStr, userId = null
     }
 };
 
-// 10.4. Find most recent available GlobalAumPerAsset30D data
-// Looks back up to 7 days to find the most recent available data
+// Normalize computation name for BigQuery (matches ManifestBuilder: lowercase alphanumeric)
+const normalizeComputationName = (name) => (name || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+
+const COMPUTATION_RESULTS_TABLE = 'computation_results_v3';
+
+/**
+ * Fetch computation result from BigQuery (computation_results_v3).
+ * @param {string} computationName - Config name (e.g. GlobalAumPerAsset)
+ * @param {string} dateStr - Date YYYY-MM-DD
+ * @param {string} [entityId] - Optional entity_id (e.g. _global for global computations)
+ * @param {object} [logger] - Logger
+ * @returns {Promise<object|null>} Parsed result_data or null
+ */
+const getComputationResultFromBigQuery = async (computationName, dateStr, entityId = '_global', logger = null) => {
+    if (process.env.BIGQUERY_ENABLED === 'false') return null;
+    const datasetId = process.env.BIGQUERY_DATASET_ID || 'bulltrackers_data';
+    const normalizedName = normalizeComputationName(computationName);
+    try {
+        const rows = await bigqueryQuery(
+            `SELECT result_data FROM \`${datasetId}.${COMPUTATION_RESULTS_TABLE}\`
+             WHERE date = @date AND computation_name = @name AND entity_id = @entityId
+             ORDER BY updated_at DESC LIMIT 1`,
+            { params: { date: dateStr, name: normalizedName, entityId } },
+            logger
+        );
+        if (!rows || rows.length === 0) return null;
+        const raw = rows[0].result_data;
+        if (typeof raw === 'string') {
+            try { return JSON.parse(raw); } catch (e) { return null; }
+        }
+        return raw;
+    } catch (error) {
+        if (logger) logger.log('WARN', `[BigQuery] getComputationResultFromBigQuery failed: ${error.message}`);
+        return null;
+    }
+};
+
+/**
+ * Fetch all entity results for a computation/date from BigQuery (e.g. PIDailyAssetAUM per PI).
+ * @param {string} computationName - Config name (e.g. PIDailyAssetAUM)
+ * @param {string} dateStr - Date YYYY-MM-DD
+ * @param {object} [logger] - Logger
+ * @returns {Promise<object>} Map of entity_id -> parsed result_data
+ */
+const getComputationResultsFromBigQueryForDate = async (computationName, dateStr, logger = null) => {
+    if (process.env.BIGQUERY_ENABLED === 'false') return {};
+    const datasetId = process.env.BIGQUERY_DATASET_ID || 'bulltrackers_data';
+    const normalizedName = normalizeComputationName(computationName);
+    try {
+        const rows = await bigqueryQuery(
+            `SELECT entity_id, result_data FROM \`${datasetId}.${COMPUTATION_RESULTS_TABLE}\`
+             WHERE date = @date AND computation_name = @name`,
+            { params: { date: dateStr, name: normalizedName } },
+            logger
+        );
+        const out = {};
+        if (rows) {
+            for (const row of rows) {
+                let data = row.result_data;
+                if (typeof data === 'string') {
+                    try { data = JSON.parse(data); } catch (e) { continue; }
+                }
+                if (row.entity_id != null) out[String(row.entity_id)] = data || {};
+            }
+        }
+        return out;
+    } catch (error) {
+        if (logger) logger.log('WARN', `[BigQuery] getComputationResultsFromBigQueryForDate failed: ${error.message}`);
+        return {};
+    }
+};
+
+// 10.4. Find most recent available GlobalAumPerAsset data (from BigQuery)
 const findMostRecentGlobalAumData = async (db, startDateStr, maxLookbackDays = 7) => {
     try {
         const startDate = new Date(startDateStr);
-        
-        // Look back through dates to find the most recent available data
         for (let i = 0; i < maxLookbackDays; i++) {
             const checkDate = new Date(startDate);
             checkDate.setDate(startDate.getDate() - i);
             const dateKey = checkDate.toISOString().split('T')[0];
-            
-            try {
-                const computationData = await getComputationResults(db, 'GlobalAumPerAsset30D', dateKey);
-                
-                // If we got valid data (not null/empty), return it
-                if (computationData && typeof computationData === 'object' && Object.keys(computationData).length > 0) {
-                    return {
-                        date: dateKey,
-                        data: computationData
-                    };
-                }
-            } catch (error) {
-                // Missing data for this date - continue looking back
-                console.log(`[GlobalAum] No data found for ${dateKey}, checking previous date...`);
+            const computationData = await getComputationResultFromBigQuery('GlobalAumPerAsset', dateKey, '_global');
+            if (computationData && typeof computationData === 'object' && Object.keys(computationData).length > 0) {
+                return { date: dateKey, data: computationData };
             }
         }
-        
-        // No data found in the lookback period
         return null;
     } catch (error) {
         console.error(`[GlobalAum] Error finding most recent data:`, error);
@@ -1411,55 +1558,28 @@ const findMostRecentGlobalAumData = async (db, startDateStr, maxLookbackDays = 7
     }
 };
 
-// 10.5. Fetch GlobalAumPerAsset30D with 7-day lookback
-// Returns the last 7 days of successfully stored data for a specific ticker or all assets
+// 10.5. Fetch GlobalAumPerAsset with lookback (from BigQuery)
 const fetchGlobalAumPerAssetWithLookback = async (db, dateStr, ticker = null, lookbackDays = 7) => {
     try {
         const endDate = new Date(dateStr);
         const results = [];
-        
-        // Fetch data for the last 7 days, handling missing data gracefully
         for (let i = 0; i < lookbackDays; i++) {
             const checkDate = new Date(endDate);
             checkDate.setDate(endDate.getDate() - i);
             const dateKey = checkDate.toISOString().split('T')[0];
-            
-            try {
-                const computationData = await getComputationResults(db, 'GlobalAumPerAsset30D', dateKey);
-                
-                // If we got valid data (not null/empty), add it to results
-                if (computationData && typeof computationData === 'object' && Object.keys(computationData).length > 0) {
-                    if (ticker) {
-                        // If searching for a specific ticker, only include if it exists
-                        const tickerUpper = ticker.toUpperCase();
-                        if (computationData[tickerUpper] !== undefined) {
-                            results.push({
-                                date: dateKey,
-                                aum: computationData[tickerUpper],
-                                ticker: tickerUpper
-                            });
-                        }
-                    } else {
-                        // Return all assets for this date
-                        results.push({
-                            date: dateKey,
-                            data: computationData
-                        });
+            const computationData = await getComputationResultFromBigQuery('GlobalAumPerAsset', dateKey, '_global');
+            if (computationData && typeof computationData === 'object' && Object.keys(computationData).length > 0) {
+                if (ticker) {
+                    const tickerUpper = ticker.toUpperCase();
+                    if (computationData[tickerUpper] !== undefined) {
+                        results.push({ date: dateKey, aum: computationData[tickerUpper], ticker: tickerUpper });
                     }
+                } else {
+                    results.push({ date: dateKey, data: computationData });
                 }
-            } catch (error) {
-                // Missing data for this date - skip it (graceful handling)
-                console.log(`[GlobalAum] No data found for ${dateKey}, skipping`);
             }
         }
-        
-        // Sort by date descending (newest first)
-        results.sort((a, b) => {
-            const dateA = new Date(a.date);
-            const dateB = new Date(b.date);
-            return dateB.getTime() - dateA.getTime();
-        });
-        
+        results.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
         return results;
     } catch (error) {
         console.error(`[GlobalAum] Error fetching with lookback:`, error);
@@ -1473,12 +1593,12 @@ const fetchNotifications = async (firestore, userId, options = {}) => {
     try {
         let query = firestore.collection('SignedInUsers').doc(userId).collection('notifications');
         if (unreadOnly) query = query.where('read', '==', false);
-        
+
         const snapshot = await query.orderBy('createdAt', 'desc').limit(limit * 2).get(); // Fetch more to filter
-        
+
         // Filter out excluded types (like watchlistAlerts which go to alerts bell)
         let notifications = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
-        
+
         if (excludeTypes && excludeTypes.length > 0) {
             notifications = notifications.filter(notif => {
                 // Exclude by type field or metadata.notificationType
@@ -1486,7 +1606,7 @@ const fetchNotifications = async (firestore, userId, options = {}) => {
                 return !excludeTypes.includes(notifType);
             });
         }
-        
+
         // Limit after filtering
         return notifications.slice(0, limit);
     } catch (error) {
@@ -1509,16 +1629,16 @@ const markNotificationRead = async (firestore, userId, notificationIds, markAll
         const MAX_NOTIFICATIONS_TO_PROCESS = 1000; // Limit to prevent timeouts
         const snapshot = await collectionRef.where('read', '==', false).limit(MAX_NOTIFICATIONS_TO_PROCESS).get();
         console.log(`[markNotificationRead] Marking ${snapshot.size} notifications as read for user ${userId} (limited to ${MAX_NOTIFICATIONS_TO_PROCESS})`);
-        
+
         if (snapshot.size === 0) {
             console.log(`[markNotificationRead] No unread notifications found for user ${userId}`);
             return;
         }
-        
+
         snapshot.docs.forEach(doc => {
             currentBatch.update(doc.ref, { read: true, readAt: new Date() });
             batchCount++;
-            
+
             // If batch is full, commit it and start a new one
             if (batchCount >= MAX_BATCH_SIZE) {
                 batches.push(currentBatch);
@@ -1526,7 +1646,7 @@ const markNotificationRead = async (firestore, userId, notificationIds, markAll
                 batchCount = 0;
             }
         });
-        
+
         // Add the last batch if it has operations
         if (batchCount > 0) {
             batches.push(currentBatch);
@@ -1537,7 +1657,7 @@ const markNotificationRead = async (firestore, userId, notificationIds, markAll
             const ref = collectionRef.doc(id);
             currentBatch.update(ref, { read: true, readAt: new Date() });
             batchCount++;
-            
+
             // If batch is full, commit it and start a new one
             if (batchCount >= MAX_BATCH_SIZE) {
                 batches.push(currentBatch);
@@ -1545,7 +1665,7 @@ const markNotificationRead = async (firestore, userId, notificationIds, markAll
                 batchCount = 0;
             }
         });
-        
+
         // Add the last batch if it has operations
         if (batchCount > 0) {
             batches.push(currentBatch);
@@ -1575,16 +1695,16 @@ const trackPopularInvestorView = async (db, piId, viewerId = null, viewerType =
     // References
     // A. Global Day Aggregation
     const globalDayRef = db.collection('PIPageViewsData').doc(todayStr);
-    
+
     // B. Per PI Daily Stats
     const piDailyRef = db.collection('PopularInvestors').doc(piId).collection('profileViews').doc(todayStr);
-    
+
     // 1. Determine Uniqueness (Read PI Daily)
     // We read the PI Daily stats to check the 'uniqueViewers' array
     const piDailySnap = await piDailyRef.get();
     let isUnique = true;
     let currentUniqueViewers = [];
-    
+
     if (piDailySnap.exists) {
         const data = piDailySnap.data();
         currentUniqueViewers = data.uniqueViewers || [];
@@ -1600,19 +1720,19 @@ const trackPopularInvestorView = async (db, piId, viewerId = null, viewerType =
         piCid: Number(piId),
         totalViews: FieldValue.increment(1)
     };
-    
+
     // Add to uniqueViewers array if unique
     if (viewerId && isUnique) {
         piDailyUpdate.uniqueViewers = FieldValue.arrayUnion(String(viewerId));
     }
-    
+
     batch.set(piDailyRef, piDailyUpdate, { merge: true });
 
     // 3. PI Individual View Update (PopularInvestors/{piId}/views/{viewId})
     if (viewerId) {
         const viewId = `${piId}_${viewerId}_${timestamp}`;
         const individualRef = db.collection('PopularInvestors').doc(piId).collection('views').doc(viewId);
-        
+
         batch.set(individualRef, {
             date: todayStr,
             piCid: Number(piId),
@@ -1635,39 +1755,49 @@ const trackPopularInvestorView = async (db, piId, viewerId = null, viewerType =
         globalUpdate[`${piId}.viewsByUser.${viewerId}.lastViewed`] = FieldValue.serverTimestamp();
         globalUpdate[`${piId}.viewsByUser.${viewerId}.viewCount`] = FieldValue.increment(1);
     }
-    
+
     // Use set with merge to create the global document if it doesn't exist for the day
     batch.set(globalDayRef, globalUpdate, { merge: true });
 
     await batch.commit();
-    
+
     // 5. Write to BigQuery (after Firestore commit to get final values)
     if (process.env.BIGQUERY_ENABLED !== 'false') {
         try {
             const { ensurePIPageViewsTable, insertRowsWithMerge } = require('../../../core/utils/bigquery_utils');
             await ensurePIPageViewsTable();
-            
+
             // Read the updated document to get final values (after increments)
             const updatedDoc = await globalDayRef.get();
             if (updatedDoc.exists) {
                 const data = updatedDoc.data();
                 const piData = data[piId];
-                
+
                 if (piData) {
-                    // Transform to BigQuery format
-                    const lastUpdated = piData.lastUpdated 
-                        ? (piData.lastUpdated.toDate ? piData.lastUpdated.toDate().toISOString() : piData.lastUpdated)
+                    // Transform to BigQuery format (views_by_user: JSON-serializable; lastViewed as ISO string)
+                    const lastUpdated = piData.lastUpdated
+                        ? (piData.lastUpdated.toDate ? piData.lastUpdated.toDate().toISOString() : String(piData.lastUpdated))
                         : new Date().toISOString();
-                    
+
+                    const viewsByUser = piData.viewsByUser || {};
+                    const viewsByUserForBq = {};
+                    for (const [uid, rec] of Object.entries(viewsByUser)) {
+                        if (!rec || typeof rec !== 'object') continue;
+                        const lastViewed = rec.lastViewed
+                            ? (rec.lastViewed.toDate ? rec.lastViewed.toDate().toISOString() : String(rec.lastViewed))
+                            : null;
+                        viewsByUserForBq[uid] = { lastViewed, viewCount: rec.viewCount ?? 0 };
+                    }
+
                     const bigqueryRow = {
                         date: todayStr,
                         pi_id: parseInt(piId, 10),
                         total_views: piData.totalViews || 0,
-                        unique_viewers: piData.uniqueViewers || 0,
-                        views_by_user: piData.viewsByUser || {},
+                        unique_viewers: piData.uniqueViewers ?? 0,
+                        views_by_user: viewsByUserForBq,
                         last_updated: lastUpdated
                     };
-                    
+
                     // Use MERGE to update existing row or insert new
                     const datasetId = process.env.BIGQUERY_DATASET_ID || 'bulltrackers_data';
                     await insertRowsWithMerge(
@@ -1684,7 +1814,7 @@ const trackPopularInvestorView = async (db, piId, viewerId = null, viewerType =
             // Don't throw - Firestore write succeeded, BigQuery is secondary
         }
     }
-    
+
     return { success: true };
 };
 // ==========================================
@@ -1706,12 +1836,12 @@ const fetchUserAlerts = async (db, userId, options = {}) => {
         const data = doc.data();
         // Convert Firestore timestamps to ISO strings
         if (data.createdAt) {
-            data.createdAt = data.createdAt.toDate ? data.createdAt.toDate().toISOString() : 
-                           (data.createdAt.toISOString ? data.createdAt.toISOString() : data.createdAt);
+            data.createdAt = data.createdAt.toDate ? data.createdAt.toDate().toISOString() :
+                (data.createdAt.toISOString ? data.createdAt.toISOString() : data.createdAt);
         }
         if (data.readAt) {
-            data.readAt = data.readAt.toDate ? data.readAt.toDate().toISOString() : 
-                         (data.readAt.toISOString ? data.readAt.toISOString() : data.readAt);
+            data.readAt = data.readAt.toDate ? data.readAt.toDate().toISOString() :
+                (data.readAt.toISOString ? data.readAt.toISOString() : data.readAt);
         }
         return { id: doc.id, ...data };
     });
@@ -1721,7 +1851,7 @@ const subscribeToWatchlistAlerts = async (db, userId, watchlistId, piId, alertCo
     // Path: watchlist_subscriptions/{userId}/alerts/{piId}
     // This allows quick lookup of "Does User X subscribe to PI Y?"
     const subRef = db.collection('watchlist_subscriptions').doc(userId).collection('alerts').doc(piId);
-    
+
     await subRef.set({
         userCid: Number(userId),
         piCid: Number(piId),
@@ -1729,7 +1859,7 @@ const subscribeToWatchlistAlerts = async (db, userId, watchlistId, piId, alertCo
         alertTypes: alertConfig || { all: true }, // Default config
         subscribedAt: FieldValue.serverTimestamp()
     }, { merge: true });
-    
+
     return { success: true };
 };
 
@@ -1761,14 +1891,14 @@ const fetchPublicWatchlists = async (db, limit = 50, offset = 0) => {
  */
 const publishWatchlistVersion = async (db, userId, watchlistId) => {
     const batch = db.batch();
-    
+
     // 1. Fetch Source Watchlist
     const userRef = db.collection('SignedInUsers').doc(userId).collection('watchlists').doc(watchlistId);
     const userSnap = await userRef.get();
-    
+
     if (!userSnap.exists) throw new Error("Watchlist not found");
     const data = userSnap.data();
-    
+
     if (data.createdBy !== userId) throw new Error("Ownership required to publish");
 
     // 2. Get/Inc Version Number from Public Meta Doc
@@ -1779,18 +1909,18 @@ const publishWatchlistVersion = async (db, userId, watchlistId) => {
     // 3. Create Immutable Snapshot
     const versionId = `${watchlistId}_v${nextVersion}`;
     const versionRef = db.collection('public_watchlists').doc(watchlistId).collection('versions').doc(String(nextVersion));
-    
+
     const snapshotData = {
         ...data,
         watchlistId,
         version: nextVersion,
         isImmutable: true, // Lock this version
         snapshotAt: new Date(),
-        copyCount: 0 
+        copyCount: 0
     };
-    
+
     // Cleanup internal fields before publishing
-    delete snapshotData.isAutoGenerated; 
+    delete snapshotData.isAutoGenerated;
 
     batch.set(versionRef, snapshotData);
 
@@ -1831,7 +1961,7 @@ const copyWatchlist = async (db, userId, sourceWatchlistId, version = null) => {
                 .collection('versions').doc(String(latest)).get();
             sourceData = vSnap.data();
         } else {
-             throw new Error("Public watchlist not found");
+            throw new Error("Public watchlist not found");
         }
     }
 
@@ -1859,17 +1989,17 @@ const copyWatchlist = async (db, userId, sourceWatchlistId, version = null) => {
     // 3. Execute Copy & Increment Global Counter
     const batch = db.batch();
     batch.set(newRef, newPayload);
-    
+
     // Increment copy count on the public reference
     const publicRef = db.collection('public_watchlists').doc(sourceWatchlistId);
     batch.update(publicRef, { copyCount: FieldValue.increment(1) });
 
     await batch.commit();
-    
+
     // Note: We should technically call 'manageUserWatchlist' here to sync the PIs to the global 
     // root data, but for brevity, assuming the UI will trigger a 'save' or we implement the 
     // root data sync logic here similar to manageUserWatchlist.
-    
+
     return { success: true, id: newWatchlistId };
 };
 
@@ -1896,31 +2026,31 @@ const fetchAllReviewsForPI = async (db, piId, limit = 100) => {
         const data = doc.data();
         // Convert Firestore timestamps to ISO strings
         if (data.createdAt) {
-            data.createdAt = data.createdAt.toDate ? data.createdAt.toDate().toISOString() : 
-                           (data.createdAt.toISOString ? data.createdAt.toISOString() : 
-                           (data.createdAt._seconds ? new Date(data.createdAt._seconds * 1000).toISOString() : data.createdAt));
+            data.createdAt = data.createdAt.toDate ? data.createdAt.toDate().toISOString() :
+                (data.createdAt.toISOString ? data.createdAt.toISOString() :
+                    (data.createdAt._seconds ? new Date(data.createdAt._seconds * 1000).toISOString() : data.createdAt));
         }
         if (data.updatedAt) {
-            data.updatedAt = data.updatedAt.toDate ? data.updatedAt.toDate().toISOString() : 
-                           (data.updatedAt.toISOString ? data.updatedAt.toISOString() : 
-                           (data.updatedAt._seconds ? new Date(data.updatedAt._seconds * 1000).toISOString() : data.updatedAt));
+            data.updatedAt = data.updatedAt.toDate ? data.updatedAt.toDate().toISOString() :
+                (data.updatedAt.toISOString ? data.updatedAt.toISOString() :
+                    (data.updatedAt._seconds ? new Date(data.updatedAt._seconds * 1000).toISOString() : data.updatedAt));
         }
         return data;
     });
-    
+
     // 2. Calculate Stats
     let total = 0;
     const counts = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
-    
+
     reviews.forEach(r => {
         const rating = r.rating || 0;
         total += rating;
-        if(counts[rating] !== undefined) counts[rating]++;
+        if (counts[rating] !== undefined) counts[rating]++;
     });
-    
+
     const count = reviews.length;
     const avg = count > 0 ? Number((total / count).toFixed(2)) : 0;
-    
+
     // Calculate percentages
     const percentages = {
         1: count > 0 ? Number((counts[1] / count * 100).toFixed(1)) : 0,
@@ -1930,14 +2060,14 @@ const fetchAllReviewsForPI = async (db, piId, limit = 100) => {
         5: count > 0 ? Number((counts[5] / count * 100).toFixed(1)) : 0
     };
 
-    return { 
-        count, 
-        averageRating: avg, 
+    return {
+        count,
+        averageRating: avg,
         ratingDistribution: {
             counts,
             percentages
         },
-        reviews 
+        reviews
     };
 };
 
@@ -1949,15 +2079,15 @@ const checkReviewEligibility = async (db, userId, piId) => {
     try {
         await fetchPopularInvestorMasterList(db, userId);
         // If this succeeds, user is a PI
-        const targetIsPI = await fetchPopularInvestorMasterList(db, piId).then(()=>true).catch(()=>false);
-        if(targetIsPI) return { eligible: false, reason: "PI cannot review PI" };
-    } catch(e) { /* User is not PI, continue */ }
+        const targetIsPI = await fetchPopularInvestorMasterList(db, piId).then(() => true).catch(() => false);
+        if (targetIsPI) return { eligible: false, reason: "PI cannot review PI" };
+    } catch (e) { /* User is not PI, continue */ }
 
     // 3. Copier Check
     const hasCopied = await hasUserCopiedPopularInvestor(db, userId, piId);
-    return { 
-        eligible: hasCopied, 
-        reason: hasCopied ? "Eligible" : "Must copy PI to review" 
+    return {
+        eligible: hasCopied,
+        reason: hasCopied ? "Eligible" : "Must copy PI to review"
     };
 };
 
@@ -1987,16 +2117,16 @@ const initiateVerification = async (db, username) => {
         expiresAt: new Date(Date.now() + 3600000) // 1 hour expiry
     });
 
-    return { 
-        success: true, 
+    return {
+        success: true,
         message: "Please place this code in your eToro Bio or Short Bio.",
-        otp 
+        otp
     };
 };
 
 const finalizeVerification = async (db, pubsub, userId, username) => {
     if (!username) throw new Error("Missing username.");
-    
+
     const verificationsCollection = 'verifications';
     const signedInUsersCollection = 'SignedInUsers';
 
@@ -2027,7 +2157,7 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
     try {
         // Using native fetch (Node 18+)
         const response = await fetch(targetUrl, { method: 'GET', headers: requestHeaders });
-        
+
         if (response.ok) {
             profileData = await response.json();
         } else {
@@ -2045,7 +2175,7 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
     // C. Validate OTP in Bio
     const bio = profileData.userBio?.aboutMe || profileData.aboutMe || "";
     const bioShort = profileData.userBio?.aboutMeShort || profileData.aboutMeShort || "";
-    
+
     if (!bio.includes(otp) && !bioShort.includes(otp)) {
         throw new Error("OTP not found in Bio. Ensure the code is saved in your 'About Me' section.");
     }
@@ -2055,8 +2185,8 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
     const isOptOut = profileData.optOut === true;
 
     // 1. Mark Request Verified
-    await docRef.update({ 
-        status: 'VERIFIED', 
+    await docRef.update({
+        status: 'VERIFIED',
         verifiedAt: FieldValue.serverTimestamp(),
         cid: realCID,
         isOptOut
@@ -2065,7 +2195,7 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
     // 2. Create/Update verification data in new format location: /SignedInUsers/{cid}/verification/data
     const verificationDataRef = db.collection('SignedInUsers').doc(String(realCID)).collection('verification').doc('data');
     const existingVerificationDoc = await verificationDataRef.get();
-    
+
     let emails = [];
     if (existingVerificationDoc.exists()) {
         const existingData = existingVerificationDoc.data();
@@ -2073,7 +2203,7 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
         emails = Array.isArray(existingData.email) ? existingData.email : (existingData.email ? [existingData.email] : []);
     }
     // Note: Email will be added by frontend completeAccountSetup when Firebase Auth email is available
-    
+
     await verificationDataRef.set({
         etoroUsername: profileData.username,
         etoroCID: realCID,
@@ -2084,7 +2214,7 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
         accountSetupComplete: false, // Will be set to true by frontend completeAccountSetup
         createdAt: FieldValue.serverTimestamp(),
     }, { merge: true });
-    
+
     // 3. Create lookup documents for all emails (O(1) lookup optimization)
     // This ensures future lookups are fast even if emails are added later
     for (const email of emails) {
@@ -2098,7 +2228,7 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
         try {
             // Replicating the 'unifiedTask' payload from generic-api
             const requestId = `signup-${realCID}-${Date.now()}`;
-            
+
             // Create request tracking doc
             await db.collection('user_sync_requests').doc(String(realCID))
                 .collection('requests').doc(requestId).set({
@@ -2127,15 +2257,15 @@ const finalizeVerification = async (db, pubsub, userId, username) => {
                     requestingUserCid: realCID
                 }
             });
-            
+
             console.log(`[Verification] Triggered unified data fetch for ${username} (${realCID})`);
         } catch (e) {
             console.error(`[Verification] Failed to trigger sync: ${e.message}`);
         }
     }
 
-    return { 
-        success: true, 
+    return {
+        success: true,
         message: "Account verified successfully. Data ingestion started.",
         cid: realCID
     };
@@ -2232,62 +2362,62 @@ const fetchPopularInvestorCategories = async (db) => {
 // ==========================================
 
 const ALERT_TYPES = {
-  increasedRisk: {
-    id: 'increasedRisk',
-    name: 'Increased Risk',
-    description: 'Alert when a Popular Investor\'s risk score increases',
-    computationName: 'RiskScoreIncrease',
-    severity: 'high',
-    enabled: true
-  },
-  volatilityChanges: {
-    id: 'volatilityChanges',
-    name: 'Significant Volatility',
-    description: 'Alert when a Popular Investor\'s portfolio volatility exceeds 50%',
-    computationName: 'SignificantVolatility',
-    severity: 'medium',
-    enabled: true
-  },
-  newSector: {
-    id: 'newSector',
-    name: 'New Sector Entry',
-    description: 'Alert when a Popular Investor enters a new sector',
-    computationName: 'NewSectorExposure',
-    severity: 'low',
-    enabled: true
-  },
-  increasedPositionSize: {
-    id: 'increasedPositionSize',
-    name: 'Increased Position Size',
-    description: 'Alert when a Popular Investor significantly increases a position size (>5%)',
-    computationName: 'PositionInvestedIncrease',
-    severity: 'medium',
-    enabled: true
-  },
-  newSocialPost: {
-    id: 'newSocialPost',
-    name: 'New Social Post',
-    description: 'Alert when a Popular Investor makes a new social post',
-    computationName: 'NewSocialPost',
-    severity: 'low',
-    enabled: true
-  },
-  behavioralAnomaly: {
-    id: 'behavioralAnomaly',
-    name: 'Behavioral Anomaly',
-    description: 'Alert when a Popular Investor deviates significantly from their baseline behavior',
-    computationName: 'BehavioralAnomaly',
-    severity: 'high',
-    enabled: true
-  },
-  testSystemProbe: {
-    id: 'testSystemProbe',
-    name: 'Test System Probe',
-    description: 'Always-on debug alert',
-    computationName: 'TestSystemProbe',
-    severity: 'info',
-    enabled: true
-  }
+    increasedRisk: {
+        id: 'increasedRisk',
+        name: 'Increased Risk',
+        description: 'Alert when a Popular Investor\'s risk score increases',
+        computationName: 'RiskScoreIncrease',
+        severity: 'high',
+        enabled: true
+    },
+    volatilityChanges: {
+        id: 'volatilityChanges',
+        name: 'Significant Volatility',
+        description: 'Alert when a Popular Investor\'s portfolio volatility exceeds 50%',
+        computationName: 'SignificantVolatility',
+        severity: 'medium',
+        enabled: true
+    },
+    newSector: {
+        id: 'newSector',
+        name: 'New Sector Entry',
+        description: 'Alert when a Popular Investor enters a new sector',
+        computationName: 'NewSectorExposure',
+        severity: 'low',
+        enabled: true
+    },
+    increasedPositionSize: {
+        id: 'increasedPositionSize',
+        name: 'Increased Position Size',
+        description: 'Alert when a Popular Investor significantly increases a position size (>5%)',
+        computationName: 'PositionInvestedIncrease',
+        severity: 'medium',
+        enabled: true
+    },
+    newSocialPost: {
+        id: 'newSocialPost',
+        name: 'New Social Post',
+        description: 'Alert when a Popular Investor makes a new social post',
+        computationName: 'NewSocialPost',
+        severity: 'low',
+        enabled: true
+    },
+    behavioralAnomaly: {
+        id: 'behavioralAnomaly',
+        name: 'Behavioral Anomaly',
+        description: 'Alert when a Popular Investor deviates significantly from their baseline behavior',
+        computationName: 'BehavioralAnomaly',
+        severity: 'high',
+        enabled: true
+    },
+    testSystemProbe: {
+        id: 'testSystemProbe',
+        name: 'Test System Probe',
+        description: 'Always-on debug alert',
+        computationName: 'TestSystemProbe',
+        severity: 'info',
+        enabled: true
+    }
 };
 
 const manageNotificationPreferences = async (db, userId, action, payload = {}) => {
@@ -2297,7 +2427,7 @@ const manageNotificationPreferences = async (db, userId, action, payload = {}) =
     if (action === 'get') {
         const snap = await docRef.get();
         let prefs = {};
-        
+
         if (snap.exists) {
             prefs = snap.data();
         } else {
@@ -2317,7 +2447,7 @@ const manageNotificationPreferences = async (db, userId, action, payload = {}) =
             ...prefs
         };
     }
-    
+
     if (action === 'update') {
         await docRef.set(payload, { merge: true });
         return { success: true };
@@ -2335,11 +2465,11 @@ const fetchAlertTypes = async () => {
 const searchPopularInvestors = async (db, queryStr) => {
     // 1. Get Master List (Cached/Fast)
     const allPis = await fetchPopularInvestorMasterList(db);
-    
+
     // 2. Filter In-Memory (Server-side)
     const term = queryStr.toLowerCase();
     const results = [];
-    
+
     Object.values(allPis).forEach(pi => {
         if (pi.username && pi.username.toLowerCase().includes(term)) {
             results.push({
@@ -2351,10 +2481,10 @@ const searchPopularInvestors = async (db, queryStr) => {
             });
         }
     });
-    
+
     // 3. Sort Results (Shortest match first usually implies closer match)
     results.sort((a, b) => a.username.length - b.username.length);
-    
+
     return results.slice(0, 20);
 };
 
@@ -2373,45 +2503,45 @@ const checkSyncRateLimits = async (db, targetId, requesterId, isDev, maxRequests
         const DEV_PER_TARGET_LIMIT_MS = 60 * 60 * 1000; // 1 hour
         const DEV_PER_TARGET_MAX_REQUESTS = 10; // Requests per target per hour
         const now = Date.now();
-        
+
         // Check global developer limit (total requests across all targets)
         const globalDevRef = db.collection('developer_rate_limits').doc(String(requesterId)).collection('global').doc('latest');
         const globalDevSnap = await globalDevRef.get();
-        
+
         let globalRequestCount = 0;
         let globalWindowStart = now;
-        
+
         if (globalDevSnap.exists) {
             const globalData = globalDevSnap.data();
             globalRequestCount = globalData.requestCount || 0;
             globalWindowStart = globalData.windowStart?.toMillis() || now;
-            
+
             // Reset window if expired
             if (now - globalWindowStart >= DEV_GLOBAL_LIMIT_MS) {
                 globalRequestCount = 0;
                 globalWindowStart = now;
             }
         }
-        
+
         // Check per-target limit (prevent spamming specific users)
         const sanitizedTargetId = sanitizeCid(targetId);
         const perTargetRef = db.collection('user_sync_requests').doc(sanitizedTargetId).collection('developer_limits').doc(String(requesterId));
         const perTargetSnap = await perTargetRef.get();
-        
+
         let perTargetCount = 0;
         let perTargetWindowStart = now;
-        
+
         if (perTargetSnap.exists) {
             const perTargetData = perTargetSnap.data();
             perTargetCount = perTargetData.requestCount || 0;
             perTargetWindowStart = perTargetData.windowStart?.toMillis() || now;
-            
+
             // Reset window if expired
             if (now - perTargetWindowStart >= DEV_PER_TARGET_LIMIT_MS) {
                 perTargetCount = 0;
                 perTargetWindowStart = now;
             }
-            
+
             // Check per-target limit
             if (perTargetCount >= DEV_PER_TARGET_MAX_REQUESTS) {
                 const waitMinutes = Math.ceil((perTargetWindowStart + DEV_PER_TARGET_LIMIT_MS - now) / 60000);
@@ -2421,7 +2551,7 @@ const checkSyncRateLimits = async (db, targetId, requesterId, isDev, maxRequests
                 };
             }
         }
-        
+
         // Check global limit
         if (globalRequestCount >= DEV_GLOBAL_MAX_REQUESTS) {
             const waitMinutes = Math.ceil((globalWindowStart + DEV_GLOBAL_LIMIT_MS - now) / 60000);
@@ -2430,36 +2560,36 @@ const checkSyncRateLimits = async (db, targetId, requesterId, isDev, maxRequests
                 message: `Developer global rate limit exceeded. Try again in ${waitMinutes} minutes.`
             };
         }
-        
+
         // Update both counters
         await globalDevRef.set({
             requestCount: globalRequestCount + 1,
             windowStart: Timestamp.fromMillis(globalWindowStart)
         }, { merge: true });
-        
+
         await perTargetRef.set({
             requestCount: perTargetCount + 1,
             windowStart: Timestamp.fromMillis(perTargetWindowStart)
         }, { merge: true });
-        
+
         return { allowed: true };
     }
 
     // Regular users: 1 request per 6 hours
     const RATE_LIMIT_MS = 6 * 60 * 60 * 1000; // 6 hours
     const now = Date.now();
-    
+
     // Check global limit for target (prevent spamming one user/PI)
     const globalRef = db.collection('user_sync_requests').doc(String(targetId)).collection('global').doc('latest');
     const globalSnap = await globalRef.get();
-    
+
     if (globalSnap.exists) {
         const last = globalSnap.data().lastRequestedAt?.toMillis() || 0;
         if (now - last < RATE_LIMIT_MS) {
             const waitHours = Math.ceil((last + RATE_LIMIT_MS - now) / 36e5);
-            return { 
-                allowed: false, 
-                message: `Recently synced. Try again in ${waitHours} hours.` 
+            return {
+                allowed: false,
+                message: `Recently synced. Try again in ${waitHours} hours.`
             };
         }
     }
@@ -2471,19 +2601,19 @@ const getSyncStatus = async (db, targetId) => {
     const reqRef = db.collection('user_sync_requests').doc(String(targetId))
         .collection('requests').orderBy('createdAt', 'desc').limit(1);
     const snap = await reqRef.get();
-    
+
     if (snap.empty) return { status: 'never_requested' };
-    
+
     const doc = snap.docs[0];
     const data = doc.data();
     const requestId = data.requestId;
     const currentStatus = data.status;
-    
+
     // Server-side timeout: Check if request is stale (older than 2 minutes and still processing)
     const STALE_THRESHOLD_MS = 2 * 60 * 1000; // 2 minutes
     const processingStates = ['queued', 'dispatched', 'processing', 'indexing', 'computing'];
     const isProcessingState = processingStates.includes(currentStatus);
-    
+
     if (isProcessingState) {
         // First, check if computation results exist (computation may have completed but status wasn't updated)
         // This is especially important for "computing" status
@@ -2491,7 +2621,7 @@ const getSyncStatus = async (db, targetId) => {
             try {
                 const today = new Date().toISOString().split('T')[0];
                 const userType = data.userType || 'SIGNED_IN_USER';
-                
+
                 // Determine which computation to check based on user type
                 let computationNames = [];
                 if (userType === 'POPULAR_INVESTOR') {
@@ -2513,7 +2643,7 @@ const getSyncStatus = async (db, targetId) => {
                         // Not a PI
                     }
                 }
-                
+
                 // Check if any computation results exist for today
                 let computationFound = false;
                 for (const compName of computationNames) {
@@ -2526,7 +2656,7 @@ const getSyncStatus = async (db, targetId) => {
                             .doc(compName)
                             .collection('pages')
                             .doc(String(targetId));
-                        
+
                         const pageSnap = await pageRef.get();
                         if (pageSnap.exists) {
                             computationFound = true;
@@ -2537,7 +2667,7 @@ const getSyncStatus = async (db, targetId) => {
                         console.error(`Error checking computation ${compName} for ${today}:`, error);
                     }
                 }
-                
+
                 // If computation results exist, mark as completed
                 if (computationFound) {
                     await doc.ref.update({
@@ -2545,7 +2675,7 @@ const getSyncStatus = async (db, targetId) => {
                         completedAt: new Date(),
                         updatedAt: new Date()
                     });
-                    
+
                     return {
                         requestId: requestId,
                         status: 'completed',
@@ -2561,17 +2691,17 @@ const getSyncStatus = async (db, targetId) => {
                 console.error(`[getSyncStatus] Error checking computation results:`, error);
             }
         }
-        
+
         // Check age of request for timeout
         const createdAt = data.createdAt;
         const updatedAt = data.updatedAt;
-        
+
         // Use updatedAt if available, otherwise createdAt
         const checkTime = updatedAt || createdAt;
         if (checkTime) {
             const checkTimestamp = checkTime.toMillis ? checkTime.toMillis() : (checkTime.getTime ? checkTime.getTime() : new Date(checkTime).getTime());
             const age = Date.now() - checkTimestamp;
-            
+
             if (age > STALE_THRESHOLD_MS) {
                 // Mark as failed due to timeout
                 const errorMessage = `Sync request timed out after ${Math.round(age / 1000 / 60)} minutes. The task may have failed.`;
@@ -2581,7 +2711,7 @@ const getSyncStatus = async (db, targetId) => {
                     failedAt: new Date(),
                     updatedAt: new Date()
                 });
-                
+
                 return {
                     requestId: requestId,
                     status: 'failed',
@@ -2594,14 +2724,14 @@ const getSyncStatus = async (db, targetId) => {
             }
         }
     }
-    
+
     // Return current status with timestamps
     const result = {
         requestId: requestId,
         status: currentStatus,
         type: data.userType
     };
-    
+
     // Add timestamps if available
     if (data.createdAt) {
         result.createdAt = data.createdAt.toDate ? data.createdAt.toDate().toISOString() : (data.createdAt.toISOString ? data.createdAt.toISOString() : data.createdAt);
@@ -2621,10 +2751,10 @@ const getSyncStatus = async (db, targetId) => {
     if (data.error) {
         result.error = data.error;
     }
-    
+
     // Add canRequest flag (true if not in processing state or failed)
     result.canRequest = !isProcessingState && currentStatus !== 'failed';
-    
+
     return result;
 };
 
@@ -2636,7 +2766,7 @@ const autoGenerateWatchlist = async (db, userId) => {
     // 1. Fetch Copied PIs (Try Computation First, Fallback to Portfolio)
     let copiedPIs = [];
     const today = new Date().toISOString().split('T')[0];
-    
+
     try {
         // Try Computation
         const compData = await getComputationResults(db, 'SignedInUserCopiedPIs', today, userId);
@@ -2654,7 +2784,7 @@ const autoGenerateWatchlist = async (db, userId) => {
     }
 
     const totalCopied = copiedPIs.length;
-    
+
     // If no copied PIs, send notification and return early
     if (totalCopied === 0) {
         const notificationId = `watchlist_auto_gen_${Date.now()}_${userId}`;
@@ -2696,7 +2826,7 @@ const autoGenerateWatchlist = async (db, userId) => {
     // Check for existing auto-generated list
     const listsRef = db.collection('SignedInUsers').doc(userId).collection('watchlists');
     const autoSnap = await listsRef.where('isAutoGenerated', '==', true).limit(1).get();
-    
+
     let instruction = 'create';
     let payload = {
         name: "My Copy Watchlist",
@@ -2705,7 +2835,7 @@ const autoGenerateWatchlist = async (db, userId) => {
         items,
         isAutoGenerated: true
     };
-    
+
     let wasUpdate = false;
     if (!autoSnap.empty) {
         instruction = 'update';
@@ -2715,7 +2845,7 @@ const autoGenerateWatchlist = async (db, userId) => {
 
     const result = await manageUserWatchlist(db, userId, instruction, payload);
     const generated = items.length;
-    
+
     // 4. Send notification with proper text
     const notificationId = `watchlist_auto_gen_${Date.now()}_${userId}`;
     let notificationMessage;
@@ -2724,7 +2854,7 @@ const autoGenerateWatchlist = async (db, userId) => {
     } else {
         notificationMessage = `Successfully generated watchlist with ${generated} Popular Investor${generated !== 1 ? 's' : ''} from ${totalCopied} copied PI${totalCopied !== 1 ? 's' : ''}.`;
     }
-    
+
     await db.collection('SignedInUsers').doc(userId).collection('notifications').doc(notificationId).set({
         id: notificationId,
         type: 'watchlist_auto_generate',
@@ -2741,7 +2871,7 @@ const autoGenerateWatchlist = async (db, userId) => {
             wasUpdate: wasUpdate
         }
     });
-    
+
     return { success: true, generated: generated, totalCopied: totalCopied, message: notificationMessage };
 };
 
@@ -2753,7 +2883,7 @@ const checkDataStatus = async (db, userId) => {
     // Check freshness of key data types
     const types = ['portfolio', 'tradeHistory', 'posts'];
     const status = {};
-    
+
     for (const type of types) {
         const snap = await db.collection('SignedInUsers').doc(userId).collection(type).doc('latest').get();
         status[type] = {
@@ -2764,13 +2894,13 @@ const checkDataStatus = async (db, userId) => {
             lastUpdated: snap.exists ? snap.updateTime.toDate().toISOString() : null
         };
     }
-    
+
     // Find the latest computation date for profile metrics (7-day lookback)
     const lookbackDays = 7;
     const today = new Date();
     let computationDate = null;
     let fallbackWindowExhausted = false;
-    
+
     // Determine which computations to check based on user type
     // Signed-in users always have SignedInUserProfileMetrics
     // If they're also a PI, they may have SignedInUserPIPersonalizedMetrics
@@ -2782,14 +2912,14 @@ const checkDataStatus = async (db, userId) => {
     } catch (e) {
         // User is not a PI, only check SignedInUserProfileMetrics
     }
-    
+
     // Check for computation results in the last 7 days
     // Check all relevant computation names for this user
     for (let i = 0; i < lookbackDays; i++) {
         const checkDate = new Date(today);
         checkDate.setDate(checkDate.getDate() - i);
         const dateStr = checkDate.toISOString().split('T')[0];
-        
+
         // Check each computation name
         for (const compName of computationNames) {
             try {
@@ -2801,7 +2931,7 @@ const checkDataStatus = async (db, userId) => {
                     .doc(compName)
                     .collection('pages')
                     .doc(String(userId));
-                
+
                 const pageSnap = await pageRef.get();
                 if (pageSnap.exists) {
                     computationDate = dateStr;
@@ -2812,18 +2942,18 @@ const checkDataStatus = async (db, userId) => {
                 console.error(`Error checking computation ${compName} for ${dateStr}:`, error);
             }
         }
-        
+
         // If we found a computation date, stop checking
         if (computationDate) {
             break;
         }
     }
-    
+
     // If no computation found in 7 days, mark fallback window as exhausted
     if (!computationDate) {
         fallbackWindowExhausted = true;
     }
-    
+
     // Return frontend-compatible format
     return {
         portfolio: {
@@ -2856,15 +2986,15 @@ const checkPopularInvestorDataStatus = async (db, piId) => {
     const lookbackDays = 7;
     const today = new Date();
     let computationDate = null;
-    
+
     const computationName = 'PopularInvestorProfileMetrics';
-    
+
     // Check for computation results in the last 7 days
     for (let i = 0; i < lookbackDays; i++) {
         const checkDate = new Date(today);
         checkDate.setDate(checkDate.getDate() - i);
         const dateStr = checkDate.toISOString().split('T')[0];
-        
+
         try {
             const pageRef = db.collection('unified_insights')
                 .doc(dateStr)
@@ -2874,7 +3004,7 @@ const checkPopularInvestorDataStatus = async (db, piId) => {
                 .doc(computationName)
                 .collection('pages')
                 .doc(String(piId));
-            
+
             const pageSnap = await pageRef.get();
             if (pageSnap.exists) {
                 computationDate = dateStr;
@@ -2885,7 +3015,7 @@ const checkPopularInvestorDataStatus = async (db, piId) => {
             console.error(`Error checking computation ${computationName} for ${dateStr}:`, error);
         }
     }
-    
+
     return {
         computationDate: computationDate,
         available: computationDate !== null
@@ -2933,7 +3063,7 @@ const getUserUsername = async (db, cid) => {
             const data = signedInDoc.data();
             return data.username || null;
         }
-        
+
         // Try PI master list
         try {
             const piData = await fetchPopularInvestorMasterList(db, String(cid));
@@ -2959,17 +3089,17 @@ const getUserSubscriptions = async (db, userId) => {
         const subscriptionsRef = db.collection('watchlist_subscriptions')
             .doc(String(userId))
             .collection('alerts');
-        
+
         const snapshot = await subscriptionsRef.get();
         const subscriptions = [];
-        
+
         snapshot.forEach(doc => {
             subscriptions.push({
                 piCid: Number(doc.id),
                 ...doc.data()
             });
         });
-        
+
         return subscriptions;
     } catch (error) {
         console.error(`Error fetching subscriptions: ${error}`);
@@ -2986,20 +3116,20 @@ const updateSubscription = async (db, userId, piCid, updates) => {
             .doc(String(userId))
             .collection('alerts')
             .doc(String(piCid));
-        
+
         const subscriptionDoc = await subscriptionRef.get();
-        
+
         if (!subscriptionDoc.exists) {
             throw new Error("Subscription not found");
         }
-        
+
         const updateData = {
             ...updates,
             updatedAt: FieldValue.serverTimestamp()
         };
-        
+
         await subscriptionRef.update(updateData);
-        
+
         const updatedDoc = await subscriptionRef.get();
         return {
             id: updatedDoc.id,
@@ -3020,13 +3150,13 @@ const unsubscribeFromAlerts = async (db, userId, piCid) => {
             .doc(String(userId))
             .collection('alerts')
             .doc(String(piCid));
-        
+
         const subscriptionDoc = await subscriptionRef.get();
-        
+
         if (!subscriptionDoc.exists) {
             throw new Error("Subscription not found");
         }
-        
+
         await subscriptionRef.delete();
         return { success: true };
     } catch (error) {
@@ -3046,22 +3176,22 @@ const getWatchlistTriggerCounts = async (db, userId, watchlistId) => {
     try {
         // Fetch watchlist
         const watchlist = await latestUserCentricSnapshot(
-            db, 
-            userId, 
-            'watchlists', 
-            'watchlist', 
-            'SignedInUsers', 
+            db,
+            userId,
+            'watchlists',
+            'watchlist',
+            'SignedInUsers',
             watchlistId
         );
-        
+
         if (!watchlist || !watchlist.items) {
             throw new Error("Watchlist not found");
         }
-        
+
         const items = watchlist.items || [];
         const triggerCounts = {};
         const userCidStr = String(userId);
-        
+
         // Calculate date 7 days ago
         const today = new Date();
         const dates = [];
@@ -3070,15 +3200,15 @@ const getWatchlistTriggerCounts = async (db, userId, watchlistId) => {
             date.setDate(today.getDate() - i);
             dates.push(date.toISOString().split('T')[0]);
         }
-        
+
         // For each PI in the watchlist
         for (const item of items) {
             const piCid = String(item.cid);
             let totalCount = 0;
-            
+
             // Check each of the last 7 days - PARALLELIZED to fix N+1 query problem
             const dayDocs = await Promise.all(
-                dates.map(dateStr => 
+                dates.map(dateStr =>
                     db.collection('PIAlertHistoryData')
                         .doc(dateStr)
                         .get()
@@ -3088,20 +3218,20 @@ const getWatchlistTriggerCounts = async (db, userId, watchlistId) => {
                         })
                 )
             );
-            
+
             // Process all day documents
             for (const dayDoc of dayDocs) {
                 if (!dayDoc || !dayDoc.exists) continue;
-                
+
                 try {
                     const dayData = dayDoc.data();
                     const piData = dayData[piCid];
-                    
+
                     if (piData) {
                         // Check all alert types for this PI
                         for (const [alertType, alertData] of Object.entries(piData)) {
                             if (alertType === 'lastUpdated' || typeof alertData !== 'object') continue;
-                            
+
                             // Check if triggeredFor array contains this user
                             const triggeredFor = alertData.triggeredFor || [];
                             if (Array.isArray(triggeredFor) && triggeredFor.includes(userCidStr)) {
@@ -3114,10 +3244,10 @@ const getWatchlistTriggerCounts = async (db, userId, watchlistId) => {
                     console.warn(`Error processing day data for PI ${piCid}: ${e.message}`);
                 }
             }
-            
+
             triggerCounts[piCid] = totalCount;
         }
-        
+
         return {
             triggerCounts,
             watchlistId,
@@ -3145,11 +3275,11 @@ const getWatchlistTriggerCounts = async (db, userId, watchlistId) => {
 const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}, timeRange = 'last_7_days', limit = 100) => {
     try {
         console.log(`[queryDynamicWatchlistMatches] Aggregating ${computationName} over ${timeRange}`);
-        
+
         // 1. Determine Date Range
         const endDate = new Date();
         const startDate = new Date();
-        
+
         switch (timeRange) {
             case 'today':
                 // Just today
@@ -3161,10 +3291,10 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
             default:
                 startDate.setDate(startDate.getDate() - 7);
         }
-        
+
         const startDateStr = startDate.toISOString().split('T')[0];
         const endDateStr = endDate.toISOString().split('T')[0];
-        
+
         // 2. Try BigQuery first (if enabled)
         if (process.env.BIGQUERY_ENABLED !== 'false') {
             try {
@@ -3185,14 +3315,14 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
                 // Fall through to Firestore logic
             }
         }
-        
+
         // 3. Fallback to Firestore (original logic)
         // Build list of dates to check (Newest -> Oldest)
         const dates = [];
         for (let d = new Date(endDate); d >= startDate; d.setDate(d.getDate() - 1)) {
             dates.push(d.toISOString().split('T')[0]);
         }
-        
+
         // 4. Fetch Data for ALL Dates in Parallel
         const datePromises = dates.map(async (dateStr) => {
             try {
@@ -3203,9 +3333,9 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
                     .doc('alerts')
                     .collection('computations')
                     .doc(computationName);
-                
+
                 let docSnapshot = await docRef.get();
-                
+
                 // Fallback to popular-investor path
                 if (!docSnapshot.exists) {
                     docRef = db.collection('unified_insights')
@@ -3241,7 +3371,7 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
                         }
                     });
                 }
-                
+
                 return { date: dateStr, data: dayData };
 
             } catch (err) {
@@ -3253,28 +3383,28 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
         // Wait for all days to load
         // rawResults is sorted Newest -> Oldest (matches 'dates' order)
         const rawResults = (await Promise.all(datePromises)).filter(r => r !== null);
-        
+
         // 5. Aggregate Matches Per User
         // Map: piCid -> { firstMatchedAt, lastMatchedAt, history: [], ... }
         const piAggregates = new Map();
-        
+
         // Process dates from Oldest -> Newest to build timeline correctly
         // Note: .reverse() mutates the array in place, so rawResults becomes Oldest->Newest
         const timeline = rawResults.reverse();
-        
+
         for (const dayEntry of timeline) {
             const { date, data } = dayEntry;
             const seenCidsThisDay = new Set();
-            
+
             // A. Process Users Present in the Daily File
             for (const [piCidStr, piData] of Object.entries(data)) {
                 if (piData.error) continue;
-                
+
                 const piCid = Number(piCidStr);
                 seenCidsThisDay.add(piCid);
-                
+
                 const filterResult = checkPIMatchesCriteria(computationName, piData, parameters);
-                
+
                 if (filterResult.passes) {
                     // Initialize if new
                     if (!piAggregates.has(piCid)) {
@@ -3287,12 +3417,12 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
                             latestData: null
                         });
                     }
-                    
+
                     const agg = piAggregates.get(piCid);
                     agg.lastMatchedAt = date;
                     agg.matchCount++;
                     agg.latestData = piData;
-                    
+
                     agg.history.push({
                         date: date,
                         matched: true,
@@ -3305,7 +3435,7 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
                         const agg = piAggregates.get(piCid);
                         // Update metadata to show why they failed (current value)
                         agg.latestData = piData;
-                        
+
                         agg.history.push({
                             date: date,
                             matched: false,
@@ -3315,7 +3445,7 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
                     }
                 }
             }
-            
+
             // B. Process Missing Users (Implicit Drop-off)
             // If a user was tracked previously but is missing today, record as non-match
             for (const [cid, agg] of piAggregates) {
@@ -3329,21 +3459,21 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
                 }
             }
         }
-        
+
         // 6. Calculate Status (Dropped Off, Current) & Fetch Usernames
         const results = [];
         const todayStr = new Date().toISOString().split('T')[0];
         // Since rawResults was reversed, the last element is the Newest date
         const lastDataDate = timeline.length > 0 ? timeline[timeline.length - 1].date : todayStr;
-        
+
         for (const [cid, agg] of piAggregates) {
             const history = agg.history;
             const lastEntry = history[history.length - 1];
-            
+
             // Is Currently Matching?
             // Must be matched=true AND on the most recent data date available
             const isCurrent = lastEntry.matched && lastEntry.date === lastDataDate;
-            
+
             // Calculate Drop Off Dates
             // Find all transitions from True -> False
             const droppedOffAt = [];
@@ -3354,41 +3484,41 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
                     droppedOffAt.push(curr.date);
                 }
             }
-            
+
             // Fetch Username (Optimistic)
             let username = `PI-${cid}`;
             if (db) {
                 try {
                     const piProfile = await fetchPopularInvestorMasterList(db, String(cid)).catch(() => null);
                     if (piProfile) username = piProfile.username;
-                } catch (e) {}
+                } catch (e) { }
             }
-            
+
             results.push({
                 cid: cid,
                 username: username,
-                
+
                 // Aggregated Stats
                 firstMatchedAt: agg.firstMatchedAt,
                 lastMatchedAt: agg.lastMatchedAt,
-                
+
                 // [UPDATED] Array of dates where they stopped matching
                 droppedOffAt: droppedOffAt,
-                
+
                 isCurrentlyMatching: isCurrent,
                 matchCount: agg.matchCount,
-                
+
                 // Visualization Data
                 history: agg.history,
-                
+
                 // Latest Snapshot Values
                 latestValue: history[history.length - 1]?.value,
-                
+
                 // Metadata
                 metadata: agg.latestData
             });
         }
-        
+
         // 7. Sort Results
         // Priority: Currently Matching > Recently Dropped Off
         // Secondary: Match Value magnitude
@@ -3399,11 +3529,11 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
             // If both same status, sort by magnitude of value (risk, change, etc)
             return Math.abs(b.latestValue || 0) - Math.abs(a.latestValue || 0);
         });
-        
+
         const limitedResults = results.slice(0, limit);
-        
+
         console.log(`[queryDynamicWatchlistMatches] Found ${results.length} unique PIs matching at least once.`);
-        
+
         return {
             success: true,
             matches: limitedResults,
@@ -3429,7 +3559,7 @@ const queryDynamicWatchlistMatches = async (db, computationName, parameters = {}
  */
 function checkPIMatchesCriteria(computationName, piData, parameters) {
     const result = { passes: false, matchValue: 0, currentValue: null, previousValue: null, change: null };
-    
+
     switch (computationName) {
         case 'RiskScoreIncrease': {
             // Data format: { change, currentRisk, previousRisk, isBaselineReset }
@@ -3438,97 +3568,97 @@ function checkPIMatchesCriteria(computationName, piData, parameters) {
             const previousRisk = piData.previousRisk;
             const minChange = parameters.minChange ?? 0;
             const minRiskLevel = parameters.minRiskLevel ?? 0;
-            
+
             result.currentValue = currentRisk;
             result.previousValue = previousRisk;
             result.change = change;
             result.matchValue = currentRisk; // Sort by current risk level
-            
+
             // Pass if change >= minChange AND currentRisk >= minRiskLevel
             if (change >= minChange && currentRisk >= minRiskLevel) {
                 result.passes = true;
             }
             break;
         }
-        
+
         case 'SignificantVolatility': {
             // Data format: { volatility, threshold, samples }
             const volatility = piData.volatility || 0;
             const minVolatility = parameters.volatilityThreshold ?? 50;
-            
+
             result.currentValue = volatility;
             result.matchValue = volatility;
-            
+
             if (volatility >= minVolatility) {
                 result.passes = true;
             }
             break;
         }
-        
+
         case 'PositionInvestedIncrease': {
             // Data format: { moveCount, moves: [{symbol, prev, curr, diff}], isBaselineReset }
             const moveCount = piData.moveCount || 0;
             const moves = piData.moves || [];
             const minIncrease = parameters.minIncrease ?? 5;
-            
+
             // Find the largest position increase
             const maxMove = moves.reduce((max, m) => m.diff > max ? m.diff : max, 0);
-            
+
             result.currentValue = moveCount;
             result.matchValue = maxMove;
-            
+
             if (maxMove >= minIncrease) {
                 result.passes = true;
             }
             break;
         }
-        
+
         case 'NewSectorExposure': {
             // Data format: { currentSectors, previousSectors, newExposures, isBaselineReset }
             const newExposures = piData.newExposures || [];
-            
+
             result.currentValue = newExposures.length;
             result.matchValue = newExposures.length;
-            
+
             if (newExposures.length > 0) {
                 result.passes = true;
             }
             break;
         }
-        
+
         case 'NewSocialPost': {
             // Data format: { hasNewPost, latestPostDate, postCount, title }
             const hasNewPost = piData.hasNewPost || false;
-            
+
             result.currentValue = hasNewPost ? 1 : 0;
             result.matchValue = hasNewPost ? 1 : 0;
-            
+
             if (hasNewPost) {
                 result.passes = true;
             }
             break;
         }
-        
+
         case 'BehavioralAnomaly': {
             // Data format: { anomalyScore, primaryDriver, driverSignificance }
             const anomalyScore = piData.anomalyScore || 0;
             const minScore = parameters.minAnomalyScore ?? 0;
-            
+
             result.currentValue = anomalyScore;
             result.matchValue = anomalyScore;
-            
+
             if (anomalyScore >= minScore) {
                 result.passes = true;
             }
             break;
         }
-        
+
         default:
             // Generic fallback - pass if there's any data
             result.passes = true;
             result.matchValue = 0;
     }
-    
+
     return result;
 }
 
@@ -3539,23 +3669,23 @@ const subscribeToAllWatchlistPIs = async (db, userId, watchlistId, alertTypes =
     try {
         // Fetch watchlist
         const watchlist = await latestUserCentricSnapshot(
-            db, 
-            userId, 
-            'watchlists', 
-            'watchlist', 
-            'SignedInUsers', 
+            db,
+            userId,
+            'watchlists',
+            'watchlist',
+            'SignedInUsers',
             watchlistId
         );
-        
+
         if (!watchlist) {
             throw new Error("Watchlist not found");
         }
-        
+
         const items = watchlist.items || [];
         const subscriptionsRef = db.collection('watchlist_subscriptions')
             .doc(String(userId))
             .collection('alerts');
-        
+
         // Default alert types
         const defaultAlertTypes = alertTypes || {
             newPositions: true,
@@ -3565,9 +3695,9 @@ const subscribeToAllWatchlistPIs = async (db, userId, watchlistId, alertTypes =
             increasedPositionSize: true,
             newSocialPost: true
         };
-        
+
         let subscribedCount = 0;
-        
+
         // Subscribe to each PI in the watchlist
         for (const item of items) {
             const subscriptionData = {
@@ -3579,11 +3709,11 @@ const subscribeToAllWatchlistPIs = async (db, userId, watchlistId, alertTypes =
                 subscribedAt: FieldValue.serverTimestamp(),
                 lastAlertAt: null
             };
-            
+
             await subscriptionsRef.doc(String(item.cid)).set(subscriptionData, { merge: true });
             subscribedCount++;
         }
-        
+
         return {
             success: true,
             subscribed: subscribedCount,
@@ -3611,22 +3741,22 @@ const subscribeToAllWatchlistPIs = async (db, userId, watchlistId, alertTypes =
 async function fetchWithBigQueryCache(firestore, cacheCollection, dateStr, bigqueryFetcher, dataType = 'data') {
     const CACHE_TTL_MINUTES = 10;
     const CACHE_TTL_MS = CACHE_TTL_MINUTES * 60 * 1000;
-    
+
     try {
         // 1. Check Firestore cache
         const cacheDocRef = firestore.collection(cacheCollection).doc(dateStr);
         const cacheDoc = await cacheDocRef.get();
-        
+
         if (cacheDoc.exists) {
             const cacheData = cacheDoc.data();
             const cachedAt = cacheData.cachedAt;
-            
+
             // Check if cache is still valid
             if (cachedAt) {
                 const cachedTimestamp = cachedAt.toMillis ? cachedAt.toMillis() : (cachedAt._seconds * 1000);
                 const now = Date.now();
                 const age = now - cachedTimestamp;
-                
+
                 if (age < CACHE_TTL_MS) {
                     // Cache is valid, return cached data
                     const { cachedAt, ...data } = cacheData;
@@ -3634,19 +3764,19 @@ async function fetchWithBigQueryCache(firestore, cacheCollection, dateStr, bigqu
                 }
             }
         }
-        
+
         // 2. Cache missing or expired, fetch from BigQuery
         if (process.env.BIGQUERY_ENABLED !== 'false') {
             try {
                 const bigqueryData = await bigqueryFetcher();
-                
+
                 if (bigqueryData) {
                     // 3. Cache the result in Firestore with TTL
                     await cacheDocRef.set({
                         ...bigqueryData,
                         cachedAt: FieldValue.serverTimestamp()
                     }, { merge: true });
-                    
+
                     return bigqueryData;
                 }
             } catch (error) {
@@ -3659,14 +3789,14 @@ async function fetchWithBigQueryCache(firestore, cacheCollection, dateStr, bigqu
                 }
             }
         }
-        
+
         // 4. Fallback: return cached data even if expired, or null
         if (cacheDoc.exists) {
             const cacheData = cacheDoc.data();
             const { cachedAt, ...data } = cacheData;
             return data;
         }
-        
+
         return null;
     } catch (error) {
         console.error(`[API] Error in fetchWithBigQueryCache for ${dataType} (${dateStr}): ${error.message}`);
@@ -3745,8 +3875,13 @@ async function fetchPIAlertHistory(firestore, dateStr) {
 module.exports = {
     latestUserCentricSnapshot,
     pageCollection,
+    fetchProfileMetrics,
+    getProfileMetricsFromPath,
+    PROFILE_COMPUTATION_PATHS,
     findMostRecentGlobalAumData,
     fetchGlobalAumPerAssetWithLookback,
+    getComputationResultFromBigQuery,
+    getComputationResultsFromBigQueryForDate,
     getComputationResults,
     fetchPopularInvestorMasterList,
     isDeveloper,