bulltrackers-module 1.0.577 → 1.0.578

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

@@ -2,6 +2,7 @@
  * @fileoverview Factory for creating the Computation Context.
  * UPDATED: Injects verification and rankings data into context globally and locally.
  * UPDATED: Added support for historical ranking data in both Standard and Meta contexts.
+ * UPDATED: Added support for 'series' data (historical root data or computation results) in Global Data.
  */
 const mathLayer          = require('../layers/index');
 const { LEGACY_MAPPING } = require('../topology/HashManager');
@@ -28,7 +29,9 @@ class ContextFactory {
             allVerifications,
             // [NEW] New Root Data Types for Profile Metrics
             ratings, pageViews, watchlistMembership, alertHistory,
-            piMasterList, // [NEW]
+            piMasterList,
+            // [NEW] Series Data (Lookback for Root Data or Computation Results)
+            seriesData
         } = options;
         
         return {
@@ -58,7 +61,10 @@ class ContextFactory {
                 pageViews: pageViews || {},
                 watchlistMembership: watchlistMembership || {},
                 alertHistory: alertHistory || {},
-                piMasterList: piMasterList || {}, // [NEW]
+                piMasterList: piMasterList || {},
+                // [NEW] Expose Series Data
+                // Structure: { root: { [type]: { [date]: data } }, results: { [date]: { [calcName]: data } } }
+                series: seriesData || {} 
             }
         };
     }
@@ -67,10 +73,12 @@ class ContextFactory {
         const { 
             dateStr, metadata, mappings, insights, socialData, prices, 
             computedDependencies, previousComputedDependencies, config, deps,
-            allRankings, allRankingsYesterday, // [UPDATED] Accepted here
+            allRankings, allRankingsYesterday,
             allVerifications,
-            // [NEW] New Root Data Types for Profile Metrics
-            ratings, pageViews, watchlistMembership, alertHistory
+            // [NEW] New Root Data Types
+            ratings, pageViews, watchlistMembership, alertHistory,
+            // [NEW] Series Data
+            seriesData
         } = options;
         
         return {
@@ -85,13 +93,14 @@ class ContextFactory {
             meta: metadata, config, deps,
             globalData: {
                 rankings: allRankings || [],
-                rankingsYesterday: allRankingsYesterday || [], // [UPDATED] Injected here
+                rankingsYesterday: allRankingsYesterday || [], 
                 verifications: allVerifications || {},
-                // [NEW] New Root Data Types for Profile Metrics
                 ratings: ratings || {},
                 pageViews: pageViews || {},
                 watchlistMembership: watchlistMembership || {},
-                alertHistory: alertHistory || {}
+                alertHistory: alertHistory || {},
+                // [NEW] Expose Series Data
+                series: seriesData || {}
             }
         };
     }

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

@@ -7,6 +7,7 @@
 /**
  * @fileoverview Dynamic Manifest Builder - Handles Topological Sort and Auto-Discovery.
  * UPDATED: Removed Automatic Infra Hashing. Now relies strictly on SYSTEM_EPOCH.
+ * UPDATED: Whitelisted 'rootDataSeries' and 'dependencySeries' metadata fields.
  */
 const { generateCodeHash, LEGACY_MAPPING } = require('../topology/HashManager.js');
 const { normalizeName } = require('../utils/utils');
@@ -253,6 +254,10 @@ function buildManifest(productLinesToRun = [], calculations) {
             isPage: metadata.isPage === true,
             isHistorical: metadata.isHistorical !== undefined ? metadata.isHistorical : false, 
             rootDataDependencies: metadata.rootDataDependencies || [],
+            // [NEW] Pass Series Configuration
+            rootDataSeries: metadata.rootDataSeries || null,
+            dependencySeries: metadata.dependencySeries || null,
+            
             canHaveMissingRoots: metadata.canHaveMissingRoots || false,
             userType: metadata.userType,
             dependencies: dependencies,

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

@@ -1,7 +1,7 @@
 /**
  * {
  * type: uploaded file
- * fileName: bulltrackers-module/functions/computation-system/data/CachedDataLoader.js
+ * fileName: computation-system/data/CachedDataLoader.js
  * }
  */
 const { 
@@ -9,14 +9,14 @@ const {
     loadDailySocialPostInsights, 
     getRelevantShardRefs, 
     getPriceShardRefs,
-    loadVerificationProfiles,     // [NEW]
-    loadPopularInvestorRankings,  // [NEW]
-    loadPIRatings,                // [NEW]
-    loadPIPageViews,              // [NEW]
-    loadWatchlistMembership: loadWatchlistMembershipData, // [NEW] Renamed to avoid conflict
-    loadPIAlertHistory,            // [NEW]
-    loadPIWatchlistData,           // [NEW] PI-centric watchlist data
-    loadPopularInvestorMasterList // [NEW]
+    loadVerificationProfiles,
+    loadPopularInvestorRankings,
+    loadPIRatings,
+    loadPIPageViews,
+    loadWatchlistMembership: loadWatchlistMembershipData,
+    loadPIAlertHistory,
+    loadPIWatchlistData,
+    loadPopularInvestorMasterList
 } = require('../utils/data_loader');
 const zlib = require('zlib'); 
 
@@ -28,14 +28,14 @@ class CachedDataLoader {
             mappings: null, 
             insights: new Map(), 
             social:   new Map(),
-            verifications: null, // [NEW]
-            rankings: new Map(),  // [NEW]
-            ratings: new Map(),   // [NEW]
-            pageViews: new Map(), // [NEW]
-            watchlistMembership: new Map(), // [NEW]
-            alertHistory: new Map(),// [NEW]
-            piWatchlistData: new Map(), // [NEW] PI-centric watchlist data cache (keyed by piCid)
-            piMasterList: null // [NEW] Singleton cache (not date dependent)
+            verifications: null,
+            rankings: new Map(),
+            ratings: new Map(),
+            pageViews: new Map(),
+            watchlistMembership: new Map(),
+            alertHistory: new Map(),
+            piWatchlistData: new Map(),
+            piMasterList: null
         }; 
     }
 
@@ -51,6 +51,7 @@ class CachedDataLoader {
         return data;
     }
 
+    // ... [Existing load methods: loadMappings, loadInsights, etc. unchanged] ...
     async loadMappings() { 
         if (this.cache.mappings) return this.cache.mappings; 
         const { calculationUtils } = this.deps; 
@@ -58,7 +59,6 @@ class CachedDataLoader {
         return this.cache.mappings; 
     }
 
-    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadInsights(dateStr) { 
         if (this.cache.insights.has(dateStr)) return this.cache.insights.get(dateStr); 
         const promise = loadDailyInsights(this.config, this.deps, dateStr); 
@@ -66,7 +66,6 @@ class CachedDataLoader {
         return promise; 
     }
 
-    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadSocial(dateStr) { 
         if (this.cache.social.has(dateStr)) return this.cache.social.get(dateStr); 
         const promise = loadDailySocialPostInsights(this.config, this.deps, dateStr); 
@@ -74,7 +73,6 @@ class CachedDataLoader {
         return promise; 
     }
 
-    // [NEW]
     async loadVerifications() {
         if (this.cache.verifications) return this.cache.verifications;
         const verifications = await loadVerificationProfiles(this.config, this.deps);
@@ -82,8 +80,6 @@ class CachedDataLoader {
         return verifications;
     }
 
-    // [NEW]
-    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadRankings(dateStr) {
         if (this.cache.rankings.has(dateStr)) return this.cache.rankings.get(dateStr);
         const promise = loadPopularInvestorRankings(this.config, this.deps, dateStr);
@@ -91,8 +87,6 @@ class CachedDataLoader {
         return promise;
     }
 
-    // [NEW] Load PI Ratings Data
-    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadRatings(dateStr) {
         if (this.cache.ratings.has(dateStr)) return this.cache.ratings.get(dateStr);
         const promise = loadPIRatings(this.config, this.deps, dateStr);
@@ -100,8 +94,6 @@ class CachedDataLoader {
         return promise;
     }
 
-    // [NEW] Load PI Page Views Data
-    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadPageViews(dateStr) {
         if (this.cache.pageViews.has(dateStr)) return this.cache.pageViews.get(dateStr);
         const promise = loadPIPageViews(this.config, this.deps, dateStr);
@@ -109,8 +101,6 @@ class CachedDataLoader {
         return promise;
     }
 
-    // [NEW] Load Watchlist Membership Data
-    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadWatchlistMembership(dateStr) {
         if (this.cache.watchlistMembership.has(dateStr)) return this.cache.watchlistMembership.get(dateStr);
         const promise = loadWatchlistMembershipData(this.config, this.deps, dateStr);
@@ -118,8 +108,6 @@ class CachedDataLoader {
         return promise;
     }
 
-    // [NEW] Load PI Alert History Data
-    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadAlertHistory(dateStr) {
         if (this.cache.alertHistory.has(dateStr)) return this.cache.alertHistory.get(dateStr);
         const promise = loadPIAlertHistory(this.config, this.deps, dateStr);
@@ -127,9 +115,6 @@ class CachedDataLoader {
         return promise;
     }
 
-    // [NEW] Load PI-Centric Watchlist Data
-    // Loads watchlist data from PopularInvestors/{piCid}/watchlistData/current
-    // [FIX] Cache promises to prevent race conditions when multiple users request same data
     async loadPIWatchlistData(piCid) {
         const piCidStr = String(piCid);
         if (this.cache.piWatchlistData.has(piCidStr)) return this.cache.piWatchlistData.get(piCidStr);
@@ -156,13 +141,63 @@ class CachedDataLoader {
             return {}; 
         } 
     }
-    // [NEW] Load PI Master List (Global, Cached)
+
     async loadPIMasterList() {
         if (this.cache.piMasterList) return this.cache.piMasterList;
         const data = await loadPopularInvestorMasterList(this.config, this.deps);
         this.cache.piMasterList = data;
         return data;
     }
+
+    // --- [NEW] Series Loading Logic ---
+    /**
+     * Optimistically loads a series of root data over a lookback period.
+     * @param {string} loaderMethod - The method name to call (e.g., 'loadAlertHistory')
+     * @param {string} dateStr - The end date (exclusive or inclusive depending on data availability)
+     * @param {number} lookbackDays - Number of days to look back
+     */
+    async loadSeries(loaderMethod, dateStr, lookbackDays) {
+        if (!this[loaderMethod]) throw new Error(`[CachedDataLoader] Unknown method ${loaderMethod}`);
+        
+        const results = {};
+        const endDate = new Date(dateStr);
+        const promises = [];
+
+        // Fetch N days back (including dateStr if relevant, usually handled by caller logic)
+        // Here we fetch [dateStr, dateStr-1, ... dateStr-(N-1)]
+        for (let i = 0; i < lookbackDays; i++) {
+            const d = new Date(endDate);
+            d.setUTCDate(d.getUTCDate() - i);
+            const dString = d.toISOString().slice(0, 10);
+            
+            promises.push(
+                this[loaderMethod](dString)
+                    .then(data => ({ date: dString, data }))
+                    .catch(err => {
+                        // Optimistic: Log warning but continue
+                        console.warn(`[CachedDataLoader] Failed to load series item ${loaderMethod} for ${dString}: ${err.message}`);
+                        return { date: dString, data: null };
+                    })
+            );
+        }
+
+        const loaded = await Promise.all(promises);
+        
+        let foundCount = 0;
+        loaded.forEach(({ date, data }) => {
+            if (data) {
+                results[date] = data;
+                foundCount++;
+            }
+        });
+
+        return {
+            dates: Object.keys(results).sort(),
+            data: results,
+            found: foundCount,
+            requested: lookbackDays
+        };
+    }
 }
 
 module.exports = { CachedDataLoader };

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

@@ -2,9 +2,10 @@
  * @fileoverview Fetches results from previous computations, handling auto-sharding and decompression.
  */
 const { normalizeName } = require('../utils/utils');
-const zlib = require('zlib'); // [NEW]
+const zlib = require('zlib'); 
 
 async function fetchExistingResults(dateStr, calcsInPass, fullManifest, config, { db }, includeSelf = false) {
+    // ... [Existing implementation unchanged] ...
     const manifestMap = new Map(fullManifest.map(c => [normalizeName(c.name), c]));
     const calcsToFetch = new Set();
     
@@ -41,10 +42,8 @@ async function fetchExistingResults(dateStr, calcsInPass, fullManifest, config,
             if (!doc.exists) return; 
             const data = doc.data(); 
 
-            // --- [NEW] DECOMPRESSION LOGIC ---
             if (data._compressed === true && data.payload) {
                 try {
-                    // Firestore returns Buffers automatically
                     const unzipped = zlib.gunzipSync(data.payload);
                     fetched[name] = JSON.parse(unzipped.toString());
                 } catch (e) {
@@ -52,7 +51,6 @@ async function fetchExistingResults(dateStr, calcsInPass, fullManifest, config,
                     fetched[name] = {};
                 }
             }
-            // --- END NEW LOGIC ---
             else if (data._sharded === true) { 
                 hydrationPromises.push(hydrateAutoShardedResult(doc.ref, name)); 
             } else if (data._completed) { 
@@ -81,4 +79,39 @@ async function hydrateAutoShardedResult(docRef, resultName) {
     return { name: resultName, data: assembledData };
 }
 
-module.exports = { fetchExistingResults };
+// [NEW] Fetch Result Series
+async function fetchResultSeries(dateStr, calcsToFetchNames, fullManifest, config, deps, lookbackDays) {
+    const results = {}; // Structure: { [date]: { [calcName]: data } }
+    const endDate = new Date(dateStr);
+    const promises = [];
+
+    // Create a dummy "calcsInPass" object to satisfy fetchExistingResults signature
+    // We just need objects that have .dependencies matching what we want to fetch
+    const dummyCalc = { dependencies: calcsToFetchNames, isHistorical: false };
+
+    for (let i = 0; i < lookbackDays; i++) {
+        const d = new Date(endDate);
+        d.setUTCDate(d.getUTCDate() - i);
+        const dString = d.toISOString().slice(0, 10);
+
+        promises.push(
+            fetchExistingResults(dString, [dummyCalc], fullManifest, config, deps, false)
+                .then(res => ({ date: dString, data: res }))
+                .catch(e => {
+                    console.warn(`[DependencyFetcher] Failed to fetch series for ${dString}: ${e.message}`);
+                    return { date: dString, data: {} };
+                })
+        );
+    }
+
+    const series = await Promise.all(promises);
+    series.forEach(({ date, data }) => {
+        if (data && Object.keys(data).length > 0) {
+            results[date] = data;
+        }
+    });
+
+    return results;
+}
+
+module.exports = { fetchExistingResults, fetchResultSeries };

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

@@ -4,11 +4,13 @@
  * UPDATED: Tracks processed shard/item counts.
  * UPDATED: Sends 'isInitialWrite: true' for robust cleanup.
  * UPDATED: Support for historical rankings in Meta Context.
+ * UPDATED: Added support for loading Series Data (Root & Results) for lookbacks.
  */
-const { normalizeName }    = require('../utils/utils');
-const { CachedDataLoader } = require('../data/CachedDataLoader');
-const { ContextFactory }   = require('../context/ContextFactory');
-const { commitResults }    = require('../persistence/ResultCommitter');
+const { normalizeName }     = require('../utils/utils');
+const { CachedDataLoader }  = require('../data/CachedDataLoader');
+const { ContextFactory }    = require('../context/ContextFactory');
+const { commitResults }     = require('../persistence/ResultCommitter');
+const { fetchResultSeries } = require('../data/DependencyFetcher'); // [NEW] Import series fetcher
 
 class MetaExecutor {
     static async run(date, calcs, passName, config, deps, rootData, fetchedDeps, previousFetchedDeps) {
@@ -125,6 +127,64 @@ class MetaExecutor {
             }
         }
 
+        // --- [NEW] Series / Lookback Loading Logic ---
+        const rootSeriesRequests = {};
+        const dependencySeriesRequests = {};
+
+        // 1. Identify requirements from manifests
+        calcs.forEach(c => {
+            // Check for Root Data Series
+            if (c.rootDataSeries) {
+                Object.entries(c.rootDataSeries).forEach(([type, conf]) => {
+                    const days = typeof conf === 'object' ? conf.lookback : conf;
+                    if (!rootSeriesRequests[type] || days > rootSeriesRequests[type]) {
+                        rootSeriesRequests[type] = days;
+                    }
+                });
+            }
+            // Check for Computation Result Series
+            if (c.dependencySeries) {
+                Object.entries(c.dependencySeries).forEach(([depName, conf]) => {
+                    const days = typeof conf === 'object' ? conf.lookback : conf;
+                    const normalized = normalizeName(depName);
+                    if (!dependencySeriesRequests[normalized] || days > dependencySeriesRequests[normalized]) {
+                        dependencySeriesRequests[normalized] = days;
+                    }
+                });
+            }
+        });
+
+        const seriesData = { root: {}, results: {} };
+
+        // 2. Load Root Series
+        for (const [type, days] of Object.entries(rootSeriesRequests)) {
+            let loaderMethod = null;
+            if (type === 'alerts') loaderMethod = 'loadAlertHistory';
+            else if (type === 'insights') loaderMethod = 'loadInsights';
+            else if (type === 'ratings') loaderMethod = 'loadRatings';
+            else if (type === 'watchlist') loaderMethod = 'loadWatchlistMembership';
+            // Add other root types if needed
+
+            if (loaderMethod) {
+                logger.log('INFO', `[MetaExecutor] Loading ${days}-day series for Root Data '${type}'...`);
+                // Assume CachedDataLoader has loadSeries method (added in previous step)
+                const series = await loader.loadSeries(loaderMethod, dStr, days);
+                seriesData.root[type] = series.data; // map of date -> data
+            }
+        }
+
+        // 3. Load Computation Result Series
+        const calcNamesToFetch = Object.keys(dependencySeriesRequests);
+        if (calcNamesToFetch.length > 0) {
+            const maxDays = Math.max(...Object.values(dependencySeriesRequests));
+            logger.log('INFO', `[MetaExecutor] Loading up to ${maxDays}-day series for Dependencies: ${calcNamesToFetch.join(', ')}`);
+            
+            // We pass the list of manifests (calcs) so the fetcher knows details if needed
+            const resultsSeries = await fetchResultSeries(dStr, calcNamesToFetch, calcs, config, deps, maxDays);
+            seriesData.results = resultsSeries; // map of date -> { calcName: data }
+        }
+        // ---------------------------------------------
+
         const state = {};
         for (const c of calcs) {
             const inst = new c.class();
@@ -146,7 +206,9 @@ class MetaExecutor {
                 ratings: ratings || {},
                 pageViews: pageViews || {},
                 watchlistMembership: watchlistMembership || {},
-                alertHistory: alertHistory || {}
+                alertHistory: alertHistory || {},
+                // [NEW] Pass Series Data
+                seriesData
             });
 
             try {
@@ -239,6 +301,10 @@ class MetaExecutor {
             }
         }
 
+        // [NOTE] "executeOncePerDay" is typically for sharded price/batch jobs. 
+        // We initialize empty series data to maintain compatibility.
+        const seriesData = { root: {}, results: {} }; 
+
         if (metadata.rootDataDependencies?.includes('price')) {
             logger.log('INFO', `[Executor] Running Batched/Sharded Execution for ${metadata.name}`);
             const shardRefs = await loader.getPriceShardReferences();
@@ -257,7 +323,9 @@ class MetaExecutor {
                     ratings: ratings || {},
                     pageViews: pageViews || {},
                     watchlistMembership: watchlistMembership || {},
-                    alertHistory: alertHistory || {}
+                    alertHistory: alertHistory || {},
+                    // [NEW] Pass Series Data
+                    seriesData
                 });
                 
                 await calcInstance.process(partialContext);
@@ -282,7 +350,9 @@ class MetaExecutor {
                 ratings: ratings || {},
                 pageViews: pageViews || {},
                 watchlistMembership: watchlistMembership || {},
-                alertHistory: alertHistory || {}
+                alertHistory: alertHistory || {},
+                // [NEW] Pass Series Data
+                seriesData
             });
             const res = await calcInstance.process(context);
             

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

@@ -9,6 +9,8 @@ const { streamPortfolioData, streamHistoryData, getPortfolioPartRefs, getHistory
 const { CachedDataLoader }                                             = require('../data/CachedDataLoader');
 const { ContextFactory }                                               = require('../context/ContextFactory');
 const { commitResults }                                                = require('../persistence/ResultCommitter');
+// [NEW] Import series fetcher for computation results
+const { fetchResultSeries }                                            = require('../data/DependencyFetcher');
 const mathLayer                                                        = require('../layers/index');
 const { performance }                                                  = require('perf_hooks');
 const v8                                                               = require('v8'); 
@@ -124,6 +126,66 @@ class StandardExecutor {
         const setupDuration = performance.now() - startSetup;
         Object.keys(executionStats).forEach(name => executionStats[name].timings.setup += setupDuration);
 
+        // --- [NEW] Series / Lookback Loading Logic ---
+        const rootSeriesRequests = {};
+        const dependencySeriesRequests = {};
+        
+        // 1. Identify requirements from manifests
+        streamingCalcs.forEach(c => {
+            // Check for Root Data Series (e.g., { insights: 7, alerts: 30 })
+            if (c.manifest.rootDataSeries) {
+                Object.entries(c.manifest.rootDataSeries).forEach(([type, conf]) => {
+                    const days = typeof conf === 'object' ? conf.lookback : conf;
+                    if (!rootSeriesRequests[type] || days > rootSeriesRequests[type]) {
+                        rootSeriesRequests[type] = days;
+                    }
+                });
+            }
+            // Check for Computation Result Series (e.g., { 'RiskScore': 7 })
+            if (c.manifest.dependencySeries) {
+                Object.entries(c.manifest.dependencySeries).forEach(([depName, conf]) => {
+                    const days = typeof conf === 'object' ? conf.lookback : conf;
+                    const normalized = normalizeName(depName);
+                    if (!dependencySeriesRequests[normalized] || days > dependencySeriesRequests[normalized]) {
+                        dependencySeriesRequests[normalized] = days;
+                    }
+                });
+            }
+        });
+
+        const seriesData = { root: {}, results: {} };
+
+        // 2. Load Root Series
+        for (const [type, days] of Object.entries(rootSeriesRequests)) {
+            let loaderMethod = null;
+            if (type === 'alerts') loaderMethod = 'loadAlertHistory';
+            else if (type === 'insights') loaderMethod = 'loadInsights';
+            else if (type === 'ratings') loaderMethod = 'loadRatings';
+            else if (type === 'watchlist') loaderMethod = 'loadWatchlistMembership';
+            // Add other root types as needed...
+
+            if (loaderMethod) {
+                logger.log('INFO', `[StandardExecutor] Loading ${days}-day series for Root Data '${type}'...`);
+                // Assume CachedDataLoader has loadSeries method (added in previous step)
+                const series = await cachedLoader.loadSeries(loaderMethod, dateStr, days);
+                seriesData.root[type] = series.data; // map of date -> data
+            }
+        }
+
+        // 3. Load Computation Result Series
+        const calcNamesToFetch = Object.keys(dependencySeriesRequests);
+        if (calcNamesToFetch.length > 0) {
+            const maxDays = Math.max(...Object.values(dependencySeriesRequests));
+            logger.log('INFO', `[StandardExecutor] Loading up to ${maxDays}-day series for Dependencies: ${calcNamesToFetch.join(', ')}`);
+            
+            // We pass the full list of manifests so the fetcher knows where to look
+            const allManifests = streamingCalcs.map(c => c.manifest); 
+            const resultsSeries = await fetchResultSeries(dateStr, calcNamesToFetch, allManifests, config, deps, maxDays);
+            
+            seriesData.results = resultsSeries; // map of date -> { calcName: data }
+        }
+        // ---------------------------------------------
+
         const prevDate    = new Date(dateStr + 'T00:00:00Z'); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
         const prevDateStr = prevDate.toISOString().slice(0, 10);
         
@@ -158,7 +220,9 @@ class StandardExecutor {
                         calc, calc.manifest, dateStr, tP_chunk, yP_chunk, tH_chunk, 
                         fetchedDeps, previousFetchedDeps, config, deps, cachedLoader,
                         executionStats[normalizeName(calc.manifest.name)],
-                        earliestDates 
+                        earliestDates,
+                        // [NEW] Pass loaded series data
+                        seriesData 
                     ) 
                 ));
                 
@@ -261,7 +325,7 @@ class StandardExecutor {
         if (newResult.failureReport) failureAcc.push(...newResult.failureReport);
     }
     
-   static async executePerUser(calcInstance, metadata, dateStr, portfolioData, yesterdayPortfolioData, historyData, computedDeps, prevDeps, config, deps, loader, stats, earliestDates) {
+   static async executePerUser(calcInstance, metadata, dateStr, portfolioData, yesterdayPortfolioData, historyData, computedDeps, prevDeps, config, deps, loader, stats, earliestDates, seriesData = {}) {
         const { logger } = deps;
         const targetUserType = metadata.userType; 
         // [FIX] Always load Global Helpers
@@ -426,6 +490,8 @@ class StandardExecutor {
                 alertHistory: alertHistory || {},
 
                 piMasterList,
+                // [NEW] Pass Series Data
+                seriesData
             });
 
             if (metadata.requiresEarliestDataDate && earliestDates) {

package/package.json

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