aiden-shared-calculations-unified 1.0.91 → 1.0.93

package/calculations/capitulation/asset-volatility-estimator.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview CORE Product Line (Pass 1 - Meta)
  * Calculates annualized volatility using the new priceExtractor.
+ * FIXED: Supports Sharded/Batched Execution (Accumulates results).
  */
 class AssetVolatilityEstimator {
     constructor() {
@@ -33,21 +34,20 @@ class AssetVolatilityEstimator {
     }
 
     process(context) {
-        // FIXED: Destructure 'mappings' to resolve real tickers
         const { math, prices, mappings } = context; 
-        
-        // FIXED: Destructure 'priceExtractor' directly (matches worker.js injection)
         const { compute, priceExtractor } = math; 
+        
+        if (!prices || !prices.history) return;
 
-        // 1. Get ALL histories properly sorted and parsed
+        // 1. Get THIS SHARD'S histories
         const allHistories = priceExtractor.getAllHistories(prices);
 
+        const batchResult = {};
+
         for (const [key, candles] of allHistories.entries()) {
-            // RESOLUTION FIX: 
-            // 'key' is likely an index string ("0") because mock data is an array.
-            // We must resolve this to the real Ticker Symbol for the result map.
             let ticker = key;
 
+            // Resolve ticker (logic maintained from original)
             if (prices.history && prices.history[key] && prices.history[key].instrumentId) {
                 const instId = prices.history[key].instrumentId;
                 if (mappings && mappings.instrumentToTicker && mappings.instrumentToTicker[instId]) {
@@ -57,7 +57,6 @@ class AssetVolatilityEstimator {
 
             if (candles.length < 10) continue;
 
-            // 2. Calculate Log Returns
             const logReturns = [];
             let lastPrice = 0;
 
@@ -71,22 +70,23 @@ class AssetVolatilityEstimator {
                 }
             }
 
-            // 3. Filter 30-Day Lookback
             const LOOKBACK = 30;
             const relevantReturns = logReturns.slice(-LOOKBACK);
 
             if (relevantReturns.length < 5) continue;
 
-            // 4. Calculate Stats
             const stdDev = compute.standardDeviation(relevantReturns);
             const annualizedVol = stdDev * Math.sqrt(365);
 
-            this.result[ticker] = {
+            batchResult[ticker] = {
                 volatility_30d: annualizedVol,
                 last_price: lastPrice,
                 data_points: relevantReturns.length
             };
         }
+        
+        // Accumulate
+        Object.assign(this.result, batchResult);
     }
 
     async getResult() { return this.result; }

package/calculations/core/instrument-price-change-1d.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for 1-day price change.
- * REFACTORED: Uses process(context) solely.
+ * FIXED: Supports Sharded/Batched Execution (Accumulates results).
  */
 class InstrumentPriceChange1D {
     constructor() {
@@ -29,54 +29,54 @@ class InstrumentPriceChange1D {
         };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
-
-    _getPrices(priceData) {
-        if (!priceData || !priceData.prices) return [];
-        return Object.entries(priceData.prices)
-            .map(([date, price]) => ({ date, price }))
-            .sort((a, b) => new Date(a.date) - new Date(b.date));
-    }
     
     process(context) {
-        const { mappings, prices } = context;
+        const { mappings, prices, date, math } = context;
         const { instrumentToTicker } = mappings;
+        const { priceExtractor } = math;
         
-        // Expecting context.prices to be populated by the controller for 'meta' + 'price' dependency
-        const todayPrices = prices?.today || [];
-        const yesterdayPrices = prices?.yesterday || [];
-
-        const results = {};
+        if (!prices || !prices.history) {
+            // Do NOT reset result here, just return if this shard is empty
+            return;
+        }
 
-        const todayPriceMap = new Map(todayPrices.map(p => {
-            const pList = this._getPrices(p);
-            const lastPrice = pList.length > 0 ? pList[pList.length - 1].price : 0;
-            return [p.instrumentId, lastPrice];
-        }));
+        const todayStr = date.today;
+        const todayDate = new Date(todayStr + 'T00:00:00Z');
+        const yesterdayDate = new Date(todayDate);
+        yesterdayDate.setUTCDate(yesterdayDate.getUTCDate() - 1);
+        const yesterdayStr = yesterdayDate.toISOString().slice(0, 10);
 
-        const yesterdayPriceMap = new Map(yesterdayPrices.map(p => {
-            const pList = this._getPrices(p);
-            const lastPrice = pList.length > 0 ? pList[pList.length - 1].price : 0;
-            return [p.instrumentId, lastPrice];
-        }));
+        const batchResults = {};
 
-        for (const [instrumentId, todayPrice] of todayPriceMap) {
-            const yesterdayPrice = yesterdayPriceMap.get(instrumentId);
+        // Iterate over THIS SHARD'S instruments
+        for (const [instrumentId, priceData] of Object.entries(prices.history)) {
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
 
+            // Note: getHistory works on the partial 'prices' object just fine
+            const history = priceExtractor.getHistory(prices, instrumentId);
+            if (history.length === 0) continue;
+
+            const todayPrice = priceData.prices?.[todayStr];
+            const yesterdayPrice = priceData.prices?.[yesterdayStr];
+
             if (todayPrice && yesterdayPrice && yesterdayPrice > 0) {
                 const changePct = ((todayPrice - yesterdayPrice) / yesterdayPrice) * 100;
-                results[ticker] = {
+                batchResults[ticker] = {
                     change_1d_pct: isFinite(changePct) ? changePct : 0
                 };
             } else {
-                results[ticker] = { change_1d_pct: 0 };
+                batchResults[ticker] = { change_1d_pct: 0 };
             }
         }
-        this.result = results;
+        
+        // Merge batch results into main result
+        Object.assign(this.result, batchResults);
     }
 
     async getResult() { return this.result; }
+    
+    // Explicit reset only called by system between full runs
     reset() { this.result = {}; }
 }
 module.exports = InstrumentPriceChange1D;

package/calculations/core/instrument-price-momentum-20d.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for 20-day momentum.
- * REFACTORED: Uses process(context) solely.
+ * FIXED: Supports Sharded/Batched Execution (Accumulates results).
  */
 class InstrumentPriceMomentum20D {
     constructor() {
@@ -30,13 +30,14 @@ class InstrumentPriceMomentum20D {
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    _findPriceOnOrBefore(priceHistoryObj, targetDateStr) {
-        if (!priceHistoryObj || !priceHistoryObj.prices) return null;
+    _findPriceOnOrBefore(prices, instrumentId, targetDateStr) {
+        const priceData = prices.history[instrumentId];
+        if (!priceData || !priceData.prices) return null;
         
         let checkDate = new Date(targetDateStr + 'T00:00:00Z');
         for (let i = 0; i < 5; i++) { 
             const str = checkDate.toISOString().slice(0, 10);
-            const price = priceHistoryObj.prices[str];
+            const price = priceData.prices[str];
             if (price !== undefined && price !== null && price > 0) return price;
             checkDate.setUTCDate(checkDate.getUTCDate() - 1);
         }
@@ -47,8 +48,9 @@ class InstrumentPriceMomentum20D {
         const { mappings, prices, date } = context;
         const { instrumentToTicker } = mappings;
         
-        // Use historical price data available in context
-        const priceData = prices?.history || []; 
+        if (!prices || !prices.history) {
+            return;
+        }
         
         const todayStr = date.today;
         const todayDate = new Date(todayStr + 'T00:00:00Z');
@@ -56,26 +58,28 @@ class InstrumentPriceMomentum20D {
         twentyDaysAgo.setUTCDate(todayDate.getUTCDate() - 20);
         const oldStr = twentyDaysAgo.toISOString().slice(0, 10);
 
-        const results = {};
+        const batchResults = {};
 
-        for (const p of priceData) {
-            const instrumentId = p.instrumentId;
+        // Iterate over THIS SHARD'S instruments
+        for (const [instrumentId, priceData] of Object.entries(prices.history)) {
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
 
-            const currentPrice = this._findPriceOnOrBefore(p, todayStr);
-            const oldPrice = this._findPriceOnOrBefore(p, oldStr);
+            const currentPrice = this._findPriceOnOrBefore(prices, instrumentId, todayStr);
+            const oldPrice = this._findPriceOnOrBefore(prices, instrumentId, oldStr);
 
             if (currentPrice && oldPrice && oldPrice > 0) {
                 const momPct = ((currentPrice - oldPrice) / oldPrice) * 100;
-                results[ticker] = {
+                batchResults[ticker] = {
                     momentum_20d_pct: isFinite(momPct) ? momPct : 0
                 };
             } else {
-                results[ticker] = { momentum_20d_pct: 0 };
+                batchResults[ticker] = { momentum_20d_pct: 0 };
             }
         }
-        this.result = results;
+        
+        // Merge
+        Object.assign(this.result, batchResults);
     }
 
     async getResult() { return this.result; }

package/calculations/core/price-metrics.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for historical price metrics.
- * REFACTORED: Uses process(context) solely.
+ * FIXED: Supports Sharded/Batched Execution.
+ * MOVED: Sector aggregation logic moved to getResult() to handle sharding correctly.
  */
 const RANGES = [7, 30, 90, 365];
 const TRADING_DAYS_PER_YEAR = 252;
@@ -8,6 +9,8 @@ const TRADING_DAYS_PER_YEAR = 252;
 class CorePriceMetrics {
     constructor() {
         this.result = { by_instrument: {}, by_sector: {} };
+        // We persist mappings here because we process shard-by-shard
+        this.mappings = null; 
     }
 
     static getMetadata() {
@@ -87,25 +90,22 @@ class CorePriceMetrics {
 
     process(context) {
         const { mappings, prices, date } = context;
-        // FIX 1: Use the correct property name 'instrumentToSector'
-        const { instrumentToTicker, instrumentToSector } = mappings; 
+        const { instrumentToTicker } = mappings;
+        
+        // Save mappings for the final aggregation step
+        if (!this.mappings) this.mappings = mappings;
         
         const priceData = prices?.history;
         const todayDateStr = date.today;
 
         if (!priceData || !todayDateStr) {
-            this.result = { by_instrument: {}, by_sector: {} };
             return;
         }
 
-        const by_instrument = {};
-        const tickerToInstrument = {};
-
-        // FIX 2: Iterate over Object.values() since priceData is a map, not an array
+        // Iterate over THIS SHARD'S data
         for (const p of Object.values(priceData)) {
             const ticker = instrumentToTicker[p.instrumentId];
             if (!ticker) continue;
-            tickerToInstrument[ticker] = p.instrumentId;
 
             const metrics = {};
             for (const range of RANGES) {
@@ -119,14 +119,26 @@ class CorePriceMetrics {
                     ? (stats.mean / stats.stdDev) * Math.sqrt(TRADING_DAYS_PER_YEAR) 
                     : 0;
             }
-            by_instrument[ticker] = metrics;
+            // Accumulate into by_instrument
+            this.result.by_instrument[ticker] = metrics;
+        }
+    }
+
+    async getResult() { 
+        // Perform Sector Aggregation HERE (after all shards are processed)
+        const by_instrument = this.result.by_instrument;
+        const instrumentToSector = this.mappings?.instrumentToSector || {};
+        const instrumentToTicker = this.mappings?.instrumentToTicker || {};
+        
+        // Reverse map ticker -> instrumentId
+        const tickerToInstrument = {};
+        for(const [id, tick] of Object.entries(instrumentToTicker)) {
+            tickerToInstrument[tick] = id;
         }
 
-        // Sector Aggregation
         const sectorAggs = {};
         for (const ticker in by_instrument) {
             const instId = tickerToInstrument[ticker];
-            // FIX 1 (Usage): Use the corrected variable name
             const sector = instrumentToSector[instId] || "Unknown"; 
             
             if (!sectorAggs[sector]) sectorAggs[sector] = { metrics: {}, counts: {} };
@@ -152,11 +164,14 @@ class CorePriceMetrics {
                 by_sector[sector][`average_${key}`] = count > 0 ? sectorAggs[sector].metrics[key] / count : null;
             }
         }
-
-        this.result = { by_instrument, by_sector };
+        
+        this.result.by_sector = by_sector;
+        return this.result; 
     }
 
-    async getResult() { return this.result; }
-    reset() { this.result = { by_instrument: {}, by_sector: {} }; }
+    reset() { 
+        this.result = { by_instrument: {}, by_sector: {} }; 
+        this.mappings = null;
+    }
 }
 module.exports = CorePriceMetrics;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.91",
+  "version": "1.0.93",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [

package/utils/firestore_utils.js

@@ -41,7 +41,6 @@ async function withRetry(asyncOperation, operationName = 'Firestore operation')
             const code = error.code || error.details;
 
             if (RETRYABLE_ERROR_CODES.has(code)) {
-                // Assuming logger is available globally or passed in somehow in the package context
                 if (typeof logger !== 'undefined' && logger.log) {
                     logger.log('WARN', `[Retry ${attempt}/${MAX_RETRIES}] Retrying ${operationName} due to ${code}. Waiting ${backoff}ms...`);
                 } else {