bulltrackers-module 1.0.589 → 1.0.591

package/functions/computation-system/persistence/ResultCommitter.js

@@ -3,6 +3,7 @@
  * UPDATED: Fixed bug where Alert Computations failed to trigger Pub/Sub on empty FINAL flush.
  * UPDATED: Added support for 'isPage' mode to store per-user data in subcollections.
  * UPDATED: Implemented TTL retention policy. Defaults to 90 days from the computation date.
+ * UPDATED: Fixed issue where switching to 'isPage' mode didn't clean up old sharded/raw data.
  */
 const { commitBatchInChunks, generateDataHash } = require('../utils/utils');
 const { updateComputationStatus }          = require('./StatusRepository');
@@ -26,7 +27,9 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     const schemas        = [];
     const cleanupTasks   = []; 
     const alertTriggers  = []; 
-    const { logger, db } = deps;
+    const { logger, db, calculationUtils } = deps; // Extract calculationUtils if available
+    const withRetry = calculationUtils?.withRetry || (fn => fn());
+
     const pid            = generateProcessId(PROCESS_TYPES.STORAGE, passName, dStr);
     
     const flushMode        = options.flushMode || 'STANDARD';
@@ -141,6 +144,30 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                     .collection(config.resultsSubcollection).doc(calc.manifest.category)
                     .collection(config.computationsSubcollection).doc(name);
 
+                // --- CLEANUP START: Remove old storage formats (Sharded/Compressed) ---
+                // If the computation previously ran in Standard mode, we must remove shards
+                // and clear the main document data to avoid conflicting flags.
+                try {
+                    const docSnap = await mainDocRef.get();
+                    if (docSnap.exists) {
+                        const dData = docSnap.data();
+                        if (dData._sharded) {
+                            const shardCol = mainDocRef.collection('_shards');
+                            const shardDocs = await withRetry(() => shardCol.listDocuments());
+                            
+                            if (shardDocs.length > 0) {
+                                const cleanupOps = shardDocs.map(d => ({ type: 'DELETE', ref: d }));
+                                await commitBatchInChunks(config, deps, cleanupOps, `${name}::PageModeCleanup`);
+                                runMetrics.io.deletes += cleanupOps.length;
+                                logger.log('INFO', `[PageMode] ${name}: Cleaned up ${cleanupOps.length} old shard documents.`);
+                            }
+                        }
+                    }
+                } catch (cleanupErr) {
+                    logger.log('WARN', `[PageMode] ${name}: Cleanup warning: ${cleanupErr.message}`);
+                }
+                // --- CLEANUP END ---
+
                 // Calculate expiration based on computation date
                 const expireAt = calculateExpirationDate(dStr, ttlDays);
 
@@ -181,7 +208,9 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                         _expireAt: expireAt // Ensure the header also gets deleted
                     };
                     
-                    await mainDocRef.set(headerData, { merge: true });
+                    // CHANGED: Use merge: false to FORCE overwrite. 
+                    // This clears old "payload" (compressed), raw data keys, and old flags like "_sharded".
+                    await mainDocRef.set(headerData, { merge: false });
                     runMetrics.io.writes += 1;
                     
                     if (calc.manifest.hash) { 

package/functions/generic-api/user-api/helpers/data/computation_helpers.js

@@ -26,7 +26,9 @@ const { getEffectiveCid, getDevOverride } = require('../dev/dev_helpers');
 async function checkPiInComputationDate(db, insightsCollection, resultsSub, compsSub, category, computationName, dateStr, cidStr, logger) {
     try {
         // Check if this computation uses the pages subcollection structure
-        const usesPagesStructure = computationName === 'PopularInvestorProfileMetrics' || computationName === 'SignedInUserProfileMetrics';
+        const usesPagesStructure = computationName === 'PopularInvestorProfileMetrics' || 
+                                   computationName === 'SignedInUserProfileMetrics' || 
+                                   computationName === 'SignedInUserPIPersonalizedMetrics';
         
         if (usesPagesStructure) {
             // New path format: /unified_insights/YYYY-MM-DD/results/popular-investor/computations/{computationName}/pages/{cid}
@@ -335,8 +337,10 @@ async function getUserComputations(req, res, dependencies, config) {
                     let userResult = null;
                     
                     // Special handling for computations that use pages subcollection structure
-                    // Both PopularInvestorProfileMetrics and SignedInUserProfileMetrics use pages subcollection
-                    if (compName === 'PopularInvestorProfileMetrics' || compName === 'SignedInUserProfileMetrics') {
+                    // PopularInvestorProfileMetrics, SignedInUserProfileMetrics, and SignedInUserPIPersonalizedMetrics use pages subcollection
+                    if (compName === 'PopularInvestorProfileMetrics' || 
+                        compName === 'SignedInUserProfileMetrics' || 
+                        compName === 'SignedInUserPIPersonalizedMetrics') {
                         const pageRef = db.collection(insightsCollection)
                             .doc(date)
                             .collection(resultsSub)

package/functions/generic-api/user-api/helpers/metrics/personalized_metrics_helpers.js

@@ -8,84 +8,10 @@ const { tryDecompress } = require('../core/compression_helpers');
 const { checkIfUserIsPI } = require('../core/user_status_helpers');
 const { getEffectiveCid, getDevOverride } = require('../dev/dev_helpers');
 
-/**
- * Generate sample PI personalized metrics data for dev testing
- * Creates realistic sample data that matches the computation structure 1:1
- */
-function generateSamplePIPersonalizedMetrics(userCid, rankEntry) {
-    const today = new Date().toISOString().split('T')[0];
-    const yesterday = new Date();
-    yesterday.setDate(yesterday.getDate() - 1);
-    const yesterdayStr = yesterday.toISOString().split('T')[0];
-    
-    // Generate sample base metrics (from PopularInvestorProfileMetrics)
-    const baseMetrics = {
-        socialEngagement: {
-            chartType: 'line',
-            data: Array.from({ length: 30 }, (_, i) => {
-                const date = new Date();
-                date.setDate(date.getDate() - (29 - i));
-                return {
-                    date: date.toISOString().split('T')[0],
-                    likes: Math.floor(Math.random() * 50) + 10,
-                    comments: Math.floor(Math.random() * 20) + 5
-                };
-            })
-        },
-        profitablePositions: {
-            chartType: 'bar',
-            data: Array.from({ length: 30 }, (_, i) => {
-                const date = new Date();
-                date.setDate(date.getDate() - (29 - i));
-                return {
-                    date: date.toISOString().split('T')[0],
-                    profitableCount: Math.floor(Math.random() * 10) + 5,
-                    totalCount: Math.floor(Math.random() * 15) + 10
-                };
-            })
-        },
-        topWinningPositions: {
-            chartType: 'table',
-            data: Array.from({ length: 5 }, (_, i) => ({
-                instrumentId: 1000 + i,
-                instrumentName: `Stock ${i + 1}`,
-                netProfit: Math.floor(Math.random() * 1000) + 100,
-                invested: Math.floor(Math.random() * 500) + 50
-            }))
-        }
-    };
-    
-    return {
-        baseMetrics,
-        reviewMetrics: {
-            overTime: [],
-            currentStats: {
-                averageRating: 4.5,
-                totalReviews: 10,
-                distribution: { 1: 0, 2: 0, 3: 1, 4: 3, 5: 6 }
-            }
-        },
-        profileViews: {
-            overTime: [],
-            totalViews: 150,
-            totalUniqueViews: 50,
-            averageDailyViews: 5
-        },
-        engagementScore: {
-            current: 75.5,
-            components: {
-                reviewScore: 90,
-                viewScore: 50,
-                copierScore: 80,
-                socialScore: 60
-            }
-        }
-    };
-}
-
 /**
  * GET /user/me/pi-personalized-metrics
  * Fetches personalized metrics for a signed-in user who is also a Popular Investor
+ * Reads from pages subcollection: /unified_insights/YYYY-MM-DD/results/popular-investor/computations/SignedInUserPIPersonalizedMetrics/pages/{cid}
  */
 async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, config) {
     const { db, logger } = dependencies;
@@ -165,36 +91,19 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
             });
         }
         
-        const isDevOverride = devOverride && devOverride.enabled && devOverride.pretendToBePI;
-        
-        // If dev override, generate sample data
-        if (isDevOverride) {
-            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] DEV OVERRIDE: Generating sample PI metrics for effective CID ${effectiveCid}`);
-            const sampleData = generateSamplePIPersonalizedMetrics(effectiveCid, rankEntry);
-            const today = new Date().toISOString().split('T')[0];
-            
-            return res.status(200).json({
-                status: 'success',
-                userCid: String(effectiveCid),
-                data: sampleData,
-                dataDate: today,
-                requestedDate: today,
-                isFallback: false,
-                isDevOverride: true,
-                isImpersonating: isImpersonating || false,
-                actualCid: Number(userCid)
-            });
-        }
-        
         const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
         const resultsSub = config.resultsSubcollection || 'results';
         const compsSub = config.computationsSubcollection || 'computations';
         const category = 'popular-investor';
         const computationName = 'SignedInUserPIPersonalizedMetrics';
         const today = new Date().toISOString().split('T')[0];
+        const cidStr = String(effectiveCid);
+        const maxDaysBack = 30;
+        
+        logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Starting search for PI CID: ${effectiveCid}`);
         
-        // Find latest computation date
-        const latestComputationDate = await findLatestComputationDate(
+        // Find latest available computation date
+        const latestDate = await findLatestComputationDate(
             db,
             insightsCollection,
             resultsSub,
@@ -205,189 +114,97 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
             30
         );
         
-        if (!latestComputationDate) {
+        logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Latest computation date found: ${latestDate || 'NONE'}`);
+        
+        if (!latestDate) {
+            logger.log('WARN', `[getSignedInUserPIPersonalizedMetrics] No computation document found for ${computationName} in last 30 days`);
             return res.status(200).json({
-                status: 'fallback',
-                message: 'Computation not available, use frontend fallback',
+                status: 'not_found',
+                message: 'No computation data available. Please sync your account to generate personalized metrics.',
                 data: null,
-                useFrontendFallback: true,
+                dataDate: null,
+                requestedDate: today,
+                fallbackWindowExhausted: true,
                 effectiveCid: effectiveCid,
-                isImpersonating: isImpersonating || false
+                isImpersonating: isImpersonating || false,
+                actualCid: Number(userCid)
             });
         }
         
-        // Check if user exists in computation (look back 7 days from latest)
+        // Try to find the user's page starting from the latest date, then going back up to 30 days
         let foundDate = null;
         let metricsData = null;
         let checkedDates = [];
         
-        const latestDateObj = new Date(latestComputationDate + 'T00:00:00Z');
+        const latestDateObj = new Date(latestDate + 'T00:00:00Z');
         
-        for (let daysBack = 0; daysBack <= 7; daysBack++) {
+        for (let daysBack = 0; daysBack <= maxDaysBack; daysBack++) {
             const checkDate = new Date(latestDateObj);
             checkDate.setUTCDate(latestDateObj.getUTCDate() - daysBack);
             const dateStr = checkDate.toISOString().split('T')[0];
             checkedDates.push(dateStr);
             
-            const computationRef = db.collection(insightsCollection)
+            logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Checking date ${dateStr} for CID ${effectiveCid} (${daysBack} days back from latest)`);
+            
+            // Read from pages subcollection: /unified_insights/YYYY-MM-DD/results/popular-investor/computations/SignedInUserPIPersonalizedMetrics/pages/{cid}
+            const pageRef = db.collection(insightsCollection)
                 .doc(dateStr)
                 .collection(resultsSub)
                 .doc(category)
                 .collection(compsSub)
-                .doc(computationName);
+                .doc(computationName)
+                .collection('pages')
+                .doc(cidStr);
             
-            const computationDoc = await computationRef.get();
+            const pageDoc = await pageRef.get();
             
-            if (computationDoc.exists) {
-                const rawData = computationDoc.data();
-                let computationData = tryDecompress(rawData);
+            if (pageDoc.exists) {
+                const rawData = pageDoc.data();
+                let data = tryDecompress(rawData);
                 
-                if (typeof computationData === 'string') {
+                // Handle string decompression result
+                if (typeof data === 'string') {
                     try {
-                        computationData = JSON.parse(computationData);
+                        data = JSON.parse(data);
                     } catch (e) {
+                        logger.log('WARN', `[getSignedInUserPIPersonalizedMetrics] Failed to parse decompressed string for CID ${effectiveCid} on date ${dateStr}:`, e.message);
                         continue;
                     }
                 }
                 
-                if (computationData && typeof computationData === 'object' && !Array.isArray(computationData)) {
-                    const userData = computationData[String(effectiveCid)];
-                    if (userData) {
-                        foundDate = dateStr;
-                        metricsData = userData;
-                        logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Found effective CID ${effectiveCid} in computation date ${dateStr}`);
-                        break;
-                    }
+                if (data && typeof data === 'object') {
+                    foundDate = dateStr;
+                    metricsData = data;
+                    logger.log('SUCCESS', `[getSignedInUserPIPersonalizedMetrics] Found personalized metrics for CID ${effectiveCid} in date ${dateStr} (${daysBack} days back from latest)`);
+                    break;
+                } else {
+                    logger.log('WARN', `[getSignedInUserPIPersonalizedMetrics] Page data is not an object for CID ${effectiveCid} on date ${dateStr}`);
                 }
+            } else {
+                logger.log('INFO', `[getSignedInUserPIPersonalizedMetrics] Page document not found for CID ${effectiveCid} in date ${dateStr}`);
             }
         }
         
+        // If not found in any checked date, return response indicating sync is needed
         if (!foundDate || !metricsData) {
+            logger.log('WARN', `[getSignedInUserPIPersonalizedMetrics] CID ${effectiveCid} not found in any checked dates: ${checkedDates.join(', ')}`);
+            
             return res.status(200).json({
-                status: 'fallback',
-                message: 'User not found in computation, use frontend fallback',
+                status: 'not_found',
+                message: 'No personalized metrics found for this user. Please sync your account to generate personalized metrics.',
                 data: null,
-                useFrontendFallback: true,
+                dataDate: null,
+                requestedDate: today,
+                latestComputationDate: latestDate,
                 checkedDates: checkedDates,
+                fallbackWindowExhausted: true,
                 effectiveCid: effectiveCid,
-                isImpersonating: isImpersonating || false
-            });
-        }
-        
-        // Enhance with review metrics and profile views
-        const reviewsCollection = config.reviewsCollection || 'pi_reviews';
-        const reviewsSnapshot = await db.collection(reviewsCollection)
-            .where('piCid', '==', Number(effectiveCid))
-            .orderBy('createdAt', 'desc')
-            .limit(1000)
-            .get();
-        
-        const reviewTimeMap = new Map();
-        let totalReviews = 0;
-        let totalRating = 0;
-        const ratingDistribution = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
-        
-        reviewsSnapshot.forEach(doc => {
-            const review = doc.data();
-            const rating = review.rating || 0;
-            totalReviews++;
-            totalRating += rating;
-            ratingDistribution[rating] = (ratingDistribution[rating] || 0) + 1;
-            
-            if (review.createdAt) {
-                const reviewDate = review.createdAt.toDate ? review.createdAt.toDate().toISOString().split('T')[0] : review.createdAt;
-                const existing = reviewTimeMap.get(reviewDate) || { date: reviewDate, count: 0, totalRating: 0 };
-                existing.count++;
-                existing.totalRating += rating;
-                reviewTimeMap.set(reviewDate, existing);
-            }
-        });
-        
-        const reviewMetricsOverTime = Array.from(reviewTimeMap.values())
-            .map(entry => ({
-                date: entry.date,
-                averageRating: entry.count > 0 ? Number((entry.totalRating / entry.count).toFixed(2)) : 0,
-                count: entry.count
-            }))
-            .sort((a, b) => a.date.localeCompare(b.date));
-        
-        metricsData.reviewMetrics = {
-            overTime: reviewMetricsOverTime,
-            currentStats: {
-                averageRating: totalReviews > 0 ? Number((totalRating / totalReviews).toFixed(2)) : 0,
-                totalReviews: totalReviews,
-                distribution: ratingDistribution
-            },
-            sentimentTrend: []
-        };
-        
-        // Fetch profile views
-        const profileViewsCollection = config.profileViewsCollection || 'profile_views';
-        const viewsSnapshot = await db.collection(profileViewsCollection)
-            .where('piCid', '==', Number(effectiveCid))
-            .limit(90)
-            .get();
-        
-        const viewsOverTime = [];
-        let totalViews = 0;
-        let totalUniqueViews = 0;
-        const uniqueViewersSet = new Set();
-        const viewsByDate = new Map();
-        
-        viewsSnapshot.forEach(doc => {
-            const viewData = doc.data();
-            const date = viewData.date;
-            if (!date) return;
-            
-            const views = typeof viewData.totalViews === 'number' ? viewData.totalViews : 0;
-            const uniqueViewers = Array.isArray(viewData.uniqueViewers) ? viewData.uniqueViewers : [];
-            
-            const existing = viewsByDate.get(date) || { date, views: 0, uniqueViewers: [] };
-            existing.views += views;
-            existing.uniqueViewers = [...new Set([...existing.uniqueViewers, ...uniqueViewers])];
-            viewsByDate.set(date, existing);
-        });
-        
-        for (const [date, data] of viewsByDate.entries()) {
-            totalViews += data.views;
-            data.uniqueViewers.forEach(v => uniqueViewersSet.add(v));
-            
-            viewsOverTime.push({
-                date: date,
-                views: data.views,
-                uniqueViews: data.uniqueViewers.length
+                isImpersonating: isImpersonating || false,
+                actualCid: Number(userCid)
             });
         }
         
-        totalUniqueViews = uniqueViewersSet.size;
-        const averageDailyViews = viewsOverTime.length > 0 ? Number((totalViews / viewsOverTime.length).toFixed(2)) : 0;
-        
-        metricsData.profileViews = {
-            overTime: viewsOverTime.sort((a, b) => a.date.localeCompare(b.date)),
-            totalViews: totalViews,
-            totalUniqueViews: totalUniqueViews,
-            averageDailyViews: averageDailyViews
-        };
-        
-        // Calculate engagement score
-        const reviewScore = metricsData.reviewMetrics.currentStats.averageRating * 20;
-        const viewScore = Math.min(100, (averageDailyViews / 10) * 100);
-        const copierScore = rankEntry.Copiers ? Math.min(100, (rankEntry.Copiers / 1000) * 100) : 0;
-        const socialScore = metricsData.baseMetrics?.socialEngagement?.data?.length > 0 ? Math.min(100, (metricsData.baseMetrics.socialEngagement.data.length / 10) * 100) : 0;
-        
-        const engagementScore = (reviewScore * 0.3 + viewScore * 0.2 + copierScore * 0.3 + socialScore * 0.2);
-        
-        metricsData.engagementScore = {
-            current: Number(engagementScore.toFixed(2)),
-            components: {
-                reviewScore: Number(reviewScore.toFixed(2)),
-                viewScore: Number(viewScore.toFixed(2)),
-                copierScore: Number(copierScore.toFixed(2)),
-                socialScore: Number(socialScore.toFixed(2))
-            }
-        };
-        
-        logger.log('SUCCESS', `[getSignedInUserPIPersonalizedMetrics] Returning personalized metrics for effective CID ${effectiveCid} from date ${foundDate}`);
+        logger.log('SUCCESS', `[getSignedInUserPIPersonalizedMetrics] Returning personalized metrics for CID ${effectiveCid} from date ${foundDate} (requested: ${today}, latest available: ${latestDate})`);
         
         return res.status(200).json({
             status: 'success',
@@ -395,7 +212,8 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
             data: metricsData,
             dataDate: foundDate,
             requestedDate: today,
-            isFallback: foundDate !== today,
+            latestComputationDate: latestDate,
+            isFallback: foundDate !== latestDate || foundDate !== today,
             daysBackFromLatest: checkedDates.indexOf(foundDate),
             isImpersonating: isImpersonating || false,
             actualCid: Number(userCid),
@@ -409,7 +227,5 @@ async function getSignedInUserPIPersonalizedMetrics(req, res, dependencies, conf
 }
 
 module.exports = {
-    getSignedInUserPIPersonalizedMetrics,
-    generateSamplePIPersonalizedMetrics
+    getSignedInUserPIPersonalizedMetrics
 };
-

package/functions/task-engine/helpers/popular_investor_helpers.js

@@ -405,32 +405,52 @@ async function finalizeOnDemandRequest(deps, config, taskData, isPI, success, to
     // 2. Trigger Computations (only if root data indexer completed successfully)
     if (indexerCompleted && pubsub && config.computationSystem) {
         const { triggerComputationWithDependencies } = require('../../computation-system/helpers/on_demand_helpers');
+        const { checkIfUserIsPI } = require('../../generic-api/user-api/helpers/core/user_status_helpers');
         
         // Use userType from metadata if available, otherwise fall back to isPI
         const userType = metadata?.userType || (isPI ? 'POPULAR_INVESTOR' : 'SIGNED_IN_USER');
         
         // Determine which computations to run based on userType
-        const comps = [];
+        // Use a Set to avoid duplicate computation names
+        const compsSet = new Set();
         if (userType === 'POPULAR_INVESTOR') {
-            comps.push('PopularInvestorProfileMetrics');
+            compsSet.add('PopularInvestorProfileMetrics');
             // PIs might also be signed-in users
             const userDoc = await db.collection('signed_in_users').doc(String(cid)).get();
             if (userDoc.exists) {
-                comps.push('SignedInUserPIPersonalizedMetrics');
+                compsSet.add('SignedInUserPIPersonalizedMetrics');
             }
         } else if (userType === 'SIGNED_IN_USER') {
-            comps.push('SignedInUserProfileMetrics', 'SignedInUserCopiedList', 'SignedInUserCopiedPIs', 'SignedInUserPastCopies');
+            // Signed-in users get standard signed-in user computations
+            compsSet.add('SignedInUserProfileMetrics');
+            compsSet.add('SignedInUserCopiedList');
+            compsSet.add('SignedInUserCopiedPIs');
+            compsSet.add('SignedInUserPastCopies');
+            
+            // IMPORTANT: Check if this signed-in user is also a Popular Investor
+            // If they are, we need to run PI computations as well
+            const rankEntry = await checkIfUserIsPI(db, cid, config, logger);
+            if (rankEntry) {
+                logger.log('INFO', `[On-Demand] Signed-in user ${cid} is also a Popular Investor. Adding PI computations.`);
+                compsSet.add('PopularInvestorProfileMetrics');
+                compsSet.add('SignedInUserPIPersonalizedMetrics');
+            }
         } else {
             // Fallback to isPI-based logic for backward compatibility
             if (isPI) {
-                comps.push('PopularInvestorProfileMetrics');
+                compsSet.add('PopularInvestorProfileMetrics');
                 const userDoc = await db.collection('signed_in_users').doc(String(cid)).get();
-                if (userDoc.exists) comps.push('SignedInUserPIPersonalizedMetrics');
+                if (userDoc.exists) compsSet.add('SignedInUserPIPersonalizedMetrics');
             } else {
-                comps.push('SignedInUserProfileMetrics', 'SignedInUserCopiedList', 'SignedInUserCopiedPIs', 'SignedInUserPastCopies');
+                compsSet.add('SignedInUserProfileMetrics');
+                compsSet.add('SignedInUserCopiedList');
+                compsSet.add('SignedInUserCopiedPIs');
+                compsSet.add('SignedInUserPastCopies');
             }
         }
 
+        // Convert Set to Array for logging and iteration
+        const comps = Array.from(compsSet);
         logger.log('INFO', `[On-Demand] Triggering ${comps.length} computations for ${userType} (${username}): ${comps.join(', ')}`);
 
         for (const comp of comps) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.589",
+  "version": "1.0.591",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [