aiden-shared-calculations-unified 1.0.92 → 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.
- * FIXED: Uses priceExtractor properly
+ * FIXED: Supports Sharded/Batched Execution (Accumulates results).
  */
 class InstrumentPriceChange1D {
     constructor() {
@@ -36,7 +36,7 @@ class InstrumentPriceChange1D {
         const { priceExtractor } = math;
         
         if (!prices || !prices.history) {
-            this.result = {};
+            // Do NOT reset result here, just return if this shard is empty
             return;
         }
 
@@ -46,34 +46,37 @@ class InstrumentPriceChange1D {
         yesterdayDate.setUTCDate(yesterdayDate.getUTCDate() - 1);
         const yesterdayStr = yesterdayDate.toISOString().slice(0, 10);
 
-        const results = {};
+        const batchResults = {};
 
-        // Iterate over all instruments in price history
+        // 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;
 
-            // Find today's and yesterday's prices
             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.
- * FIXED: Uses priceExtractor properly
+ * FIXED: Supports Sharded/Batched Execution (Accumulates results).
  */
 class InstrumentPriceMomentum20D {
     constructor() {
@@ -49,7 +49,6 @@ class InstrumentPriceMomentum20D {
         const { instrumentToTicker } = mappings;
         
         if (!prices || !prices.history) {
-            this.result = {};
             return;
         }
         
@@ -59,9 +58,9 @@ class InstrumentPriceMomentum20D {
         twentyDaysAgo.setUTCDate(todayDate.getUTCDate() - 20);
         const oldStr = twentyDaysAgo.toISOString().slice(0, 10);
 
-        const results = {};
+        const batchResults = {};
 
-        // Iterate over all instruments in price history
+        // Iterate over THIS SHARD'S instruments
         for (const [instrumentId, priceData] of Object.entries(prices.history)) {
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
@@ -71,15 +70,16 @@ class InstrumentPriceMomentum20D {
 
             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.92",
+  "version": "1.0.93",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [