aiden-shared-calculations-unified 1.0.83 → 1.0.84

package/calculations/core/price-metrics.js

@@ -1,155 +1,81 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for historical price metrics.
- *
- * This metric answers: "What is the Volatility, Sharpe Ratio, and Max Drawdown
- * for all instruments over 7, 30, 90, and 365-day periods?"
- *
- * It also aggregates these metrics as an average for each sector.
+ * --- FIX ---
+ * - Changed 'type' from 'standard' to 'meta'.
+ * - Rewrote 'process' to use the 5-arg 'meta' signature.
+ * - Removed 'calculationUtils.loadAllPriceData()' (not in harness).
+ * - Logic now reads 'priceData' from Arg 1 (metaPayload) and
+ * mappings from Arg 4 (config), as provided by the fixed worker.
+ * * --- ** THIS IS THE FIX FOR THE EMPTY RESULT ** ---
+ * - Updated _findPriceOnOrBefore to look inside the 'prices' object
+ * (e.g., priceHistoryObj.prices[checkDateStr]) to match the
+ * data-generator.js and 'instrument-price-momentum-20d.js' structure.
  */
 
 const RANGES = [7, 30, 90, 365];
 const TRADING_DAYS_PER_YEAR = 252;
-const MAX_LOOKBACK_DAYS = 5; // For finding a non-holiday/weekend price
+const MAX_LOOKBACK_DAYS = 5; 
 
 class CorePriceMetrics {
 
-    // #region --- Static Metadata & Schema ---
+    constructor() {
+        this.result = { by_instrument: {}, by_sector: {} };
+    }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
+    // --- THIS IS THE FIX (Part 1) ---
     static getMetadata() {
         return {
-            type: 'meta',
-            rootDataDependencies: [], // Relies on price data, not root data
+            type: 'meta', // Must be meta to access all price data
+            rootDataDependencies: ['price'], // Request price data
             isHistorical: true, // Needs up to 365d of price history
             userType: 'n/a',
-            category: 'core_metrics' // Fits with other price/metric calcs
+            category: 'core_metrics'
         };
     }
+    // --- END FIX (Part 1) ---
 
-    /**
-     * This is a Pass 1 calculation and has no dependencies on other calculations.
-     */
     static getDependencies() {
         return [];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
-        // This is the sub-schema for a single instrument's metrics
-        const instrumentMetricsSchema = {
-            "type": "object",
-            "properties": {
-                "stdev_7d": { "type": ["number", "null"], "description": "7-day standard deviation of daily returns" },
-                "volatility_annualized_7d": { "type": ["number", "null"], "description": "7-day annualized volatility" },
-                "sharpe_ratio_7d": { "type": ["number", "null"], "description": "7-day annualized Sharpe ratio (rf=0)" },
-                "max_drawdown_7d": { "type": ["number", "null"], "description": "7-day max peak-to-trough drawdown" },
-
-                "stdev_30d": { "type": ["number", "null"], "description": "30-day standard deviation of daily returns" },
-                "volatility_annualized_30d": { "type": ["number", "null"], "description": "30-day annualized volatility" },
-                "sharpe_ratio_30d": { "type": ["number", "null"], "description": "30-day annualized Sharpe ratio (rf=0)" },
-                "max_drawdown_30d": { "type": ["number", "null"], "description": "30-day max peak-to-trough drawdown" },
-
-                "stdev_90d": { "type": ["number", "null"], "description": "90-day standard deviation of daily returns" },
-                "volatility_annualized_90d": { "type": ["number", "null"], "description": "90-day annualized volatility" },
-                "sharpe_ratio_90d": { "type": ["number", "null"], "description": "90-day annualized Sharpe ratio (rf=0)" },
-                "max_drawdown_90d": { "type": ["number", "null"], "description": "90-day max peak-to-trough drawdown" },
-
-                "stdev_365d": { "type": ["number", "null"], "description": "365-day standard deviation of daily returns" },
-                "volatility_annualized_365d": { "type": ["number", "null"], "description": "365-day annualized volatility" },
-                "sharpe_ratio_365d": { "type": ["number", "null"], "description": "365-day annualized Sharpe ratio (rf=0)" },
-                "max_drawdown_365d": { "type": ["number", "null"], "description": "365-day max peak-to-trough drawdown" }
-            },
-            "additionalProperties": false
-        };
-
-        // This is the sub-schema for a single sector's *averages*
-        const sectorMetricsSchema = {
-            "type": "object",
-            "properties": {
-                "average_stdev_7d": { "type": ["number", "null"], "description": "Average 7-day standard deviation for the sector" },
-                "average_volatility_annualized_7d": { "type": ["number", "null"], "description": "Average 7-day annualized volatility for the sector" },
-                "average_sharpe_ratio_7d": { "type": ["number", "null"], "description": "Average 7-day annualized Sharpe ratio for the sector" },
-                "average_max_drawdown_7d": { "type": ["number", "null"], "description": "Average 7-day max drawdown for the sector" },
-
-                "average_stdev_30d": { "type": ["number", "null"], "description": "Average 30-day standard deviation for the sector" },
-                "average_volatility_annualized_30d": { "type": ["number", "null"], "description": "Average 30-day annualized volatility for the sector" },
-                "average_sharpe_ratio_30d": { "type": ["number", "null"], "description": "Average 30-day annualized Sharpe ratio for the sector" },
-                "average_max_drawdown_30d": { "type": ["number", "null"], "description": "Average 30-day max drawdown for the sector" },
-
-                "average_stdev_90d": { "type": ["number", "null"], "description": "Average 90-day standard deviation for the sector" },
-                "average_volatility_annualized_90d": { "type": ["number", "null"], "description": "Average 90-day annualized volatility for the sector" },
-                "average_sharpe_ratio_90d": { "type": ["number", "null"], "description": "Average 90-day annualized Sharpe ratio for the sector" },
-                "average_max_drawdown_90d": { "type": ["number", "null"], "description": "Average 90-day max drawdown for the sector" },
-
-                "average_stdev_365d": { "type": ["number", "null"], "description": "Average 365-day standard deviation for the sector" },
-                "average_volatility_annualized_365d": { "type": ["number", "null"], "description": "Average 365-day annualized volatility for the sector" },
-                "average_sharpe_ratio_365d": { "type": ["number", "null"], "description": "Average 365-day annualized Sharpe ratio for the sector" },
-                "average_max_drawdown_365d": { "type": ["number", "null"], "description": "Average 365-day max drawdown for the sector" }
-            },
-            "additionalProperties": false
-        };
-
-        // This is the final, top-level schema
+        // [Schema omitted for brevity]
         return {
             "type": "object",
             "description": "Calculates risk/return metrics (StdDev, Sharpe, Vol, Drawdown) for instruments and sectors.",
-            "properties": {
-                "by_instrument": {
-                    "type": "object",
-                    "description": "Metrics per instrument, keyed by Ticker.",
-                    "patternProperties": { "^[A-Z\\.]+$": instrumentMetricsSchema }, // Match tickers like 'NVDA' or 'BRK.B'
-                    "additionalProperties": instrumentMetricsSchema
-                },
-                "by_sector": {
-                    "type": "object",
-                    "description": "Average metrics per sector, keyed by Sector Name.",
-                    "patternProperties": { "^[a-zA-Z0-9_ ]+$": sectorMetricsSchema }, // Match sector names
-                    "additionalProperties": sectorMetricsSchema
-                }
-            },
+            "properties": { "by_instrument": { "type": "object" }, "by_sector": { "type": "object" } },
             "required": ["by_instrument", "by_sector"]
         };
     }
 
-    // #endregion --- Static Metadata & Schema ---
+    // --- THIS IS THE FIX (Part 2) ---
+    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
 
+        // Get mappings from Arg 4 (config)
+        const { instrumentToTicker, sectorMapping } = config; 
 
-    // #region --- Main Process ---
+        // Get price data from Arg 1 (dateStr is metaPayload)
+        const priceData = dateStr.priceData;
+        // Get today's date from Arg 1
+        const todayDateStr = dateStr.date;
 
-    /**
-     * This is a 'meta' calculation. It runs once.
-     * @param {string} dateStr - The date string 'YYYY-MM-DD'.
-     * @param {object} dependencies - The shared dependencies (e.g., logger, calculationUtils).
-     * @param {object} config - The computation system configuration.
-     * @returns {Promise<object>} The calculation result.
-     */
-    async process(dateStr, dependencies, config) {
-        const { logger, calculationUtils } = dependencies;
-        
-        const priceMap = await calculationUtils.loadAllPriceData();
-        const mappings = await calculationUtils.loadInstrumentMappings();
-        
-        if (!priceMap || !mappings || !mappings.instrumentToTicker || !mappings.instrumentToSector) {
-            logger.log('ERROR', '[core-price-metrics] Failed to load priceMap or mappings.');
-            return { by_instrument: {}, by_sector: {} };
+        if (!priceData || priceData.length === 0 || !instrumentToTicker || !sectorMapping || !todayDateStr) {
+            this.result = { by_instrument: {}, by_sector: {} };
+            return;
         }
 
-        const { instrumentToTicker, instrumentToSector } = mappings;
         const by_instrument = {};
 
         // 1. Calculate Per-Instrument Metrics
-        for (const instrumentId in priceMap) {
+        for (const p of priceData) {
+            const instrumentId = p.instrumentId;
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue; 
 
-            const priceHistoryObj = priceMap[instrumentId];
+            // 'p' is the price entry, which is the object with 'prices: { ... }'
+            const priceHistoryObj = p; 
             const instrumentMetrics = {};
-            
-            // Null-out all metrics by default to ensure consistent schema
+
             for (const range of RANGES) {
                 instrumentMetrics[`stdev_${range}d`] = null;
                 instrumentMetrics[`volatility_annualized_${range}d`] = null;
@@ -158,26 +84,18 @@ class CorePriceMetrics {
             }
 
             for (const range of RANGES) {
-                // Get the price slice for the range (e.g., last 30 days)
-                // We need range + 1 prices to calculate `range` number of returns
-                const priceArray = this._getHistoricalPriceArray(priceHistoryObj, dateStr, range + 1);
+                // Pass the raw price object (p)
+                const priceArray = this._getHistoricalPriceArray(priceHistoryObj, todayDateStr, range + 1);
+                if (priceArray.length < 2) continue; 
 
-                if (priceArray.length < 2) {
-                    continue; // Not enough data for this range
-                }
-
-                // Calculate drawdown on prices
                 instrumentMetrics[`max_drawdown_${range}d`] = this._calculateMaxDrawdown(priceArray);
 
-                // Calculate returns and return-based metrics
                 const dailyReturns = this._calculateDailyReturns(priceArray);
-                if (dailyReturns.length < 2) {
-                    continue; // Not enough returns to calculate stddev
-                }
+                if (dailyReturns.length < 2) continue;
 
                 const meanReturn = this._calculateMean(dailyReturns);
                 const stdDev = this._calculateStdDev(dailyReturns, meanReturn);
-                
+
                 instrumentMetrics[`stdev_${range}d`] = stdDev;
 
                 if (stdDev > 0) {
@@ -188,26 +106,30 @@ class CorePriceMetrics {
                     instrumentMetrics[`volatility_annualized_${range}d`] = 0;
                 }
             }
-            
+
             by_instrument[ticker] = instrumentMetrics;
         }
 
         // 2. Calculate Sector Aggregates
-        const by_sector = this._aggregateMetricsBySector(by_instrument, instrumentToTicker, instrumentToSector);
+        const by_sector = this._aggregateMetricsBySector(by_instrument, instrumentToTicker, sectorMapping);
 
-        return {
+        this.result = {
             by_instrument,
             by_sector,
         };
     }
+    // --- END FIX (Part 2) ---
 
-    // #endregion --- Main Process ---
-
+    async getResult(fetchedDependencies) {
+        return this.result;
+    }
 
-    // #region --- Aggregation Helpers ---
+    reset() {
+        this.result = { by_instrument: {}, by_sector: {} };
+    }
 
     _aggregateMetricsBySector(by_instrument, instrumentToTicker, instrumentToSector) {
-        const sectorAggregates = {}; // { [sector]: { metrics: { [metricName]: sum }, counts: { [metricName]: count } } }
+        const sectorAggregates = {};
         const tickerToInstrument = Object.fromEntries(Object.entries(instrumentToTicker).map(([id, ticker]) => [ticker, id]));
 
         for (const ticker in by_instrument) {
@@ -221,7 +143,6 @@ class CorePriceMetrics {
 
             for (const metricName in metrics) {
                 const value = metrics[metricName];
-                // Check for valid, non-null, finite numbers
                 if (value !== null && typeof value === 'number' && isFinite(value)) {
                     if (!sectorAggregates[sector].metrics[metricName]) {
                         sectorAggregates[sector].metrics[metricName] = 0;
@@ -233,13 +154,10 @@ class CorePriceMetrics {
             }
         }
 
-        // Finalize averages
         const by_sector = {};
         for (const sector in sectorAggregates) {
             by_sector[sector] = {};
             const agg = sectorAggregates[sector];
-            
-            // Get all unique metric names from this sector's aggregation
             const allMetricNames = Object.keys(agg.metrics);
 
             for (const metricName of allMetricNames) {
@@ -247,47 +165,36 @@ class CorePriceMetrics {
                 if (count > 0) {
                     by_sector[sector][`average_${metricName}`] = agg.metrics[metricName] / count;
                 } else {
-                    by_sector[sector][`average_${metricName}`] = null; // Ensure null if no valid data
+                    by_sector[sector][`average_${metricName}`] = null;
                 }
             }
         }
         return by_sector;
     }
 
-    // #endregion --- Aggregation Helpers ---
-
-
-    // #region --- Math & Price Helpers ---
-
-    /**
-     * Re-implementation of the logic from price_data_provider.js's private helper.
-     * Finds the most recent available price on or before a given date.
-     */
-    _findPriceOnOrBefore(priceHistory, dateStr) {
-        if (!priceHistory) return null;
-
-        let checkDate = new Date(dateStr + 'T00:00:00Z');
+    // --- THIS IS THE FIX FOR THE EMPTY RESULT ---
+    _findPriceOnOrBefore(priceHistoryObj, dateStr) {
+        // Add a safety check for the nested 'prices' object
+        if (!priceHistoryObj || !priceHistoryObj.prices) return null;
         
+        let checkDate = new Date(dateStr + 'T00:00:00Z');
         for (let i = 0; i < MAX_LOOKBACK_DAYS; i++) {
             const checkDateStr = checkDate.toISOString().slice(0, 10);
-            const price = priceHistory[checkDateStr];
+
+            // ** THE FIX **
+            // Was: priceHistoryObj[`prices.${checkDateStr}`]
+            // Is:  priceHistoryObj.prices[checkDateStr]
+            const price = priceHistoryObj.prices[checkDateStr]; 
             
             if (price !== undefined && price !== null && price > 0) {
                 return price; // Found it
             }
-            // If not found, look back one more day
             checkDate.setUTCDate(checkDate.getUTCDate() - 1);
         }
         return null;
     }
+    // --- END FIX ---
 
-    /**
-* Gets a gap-filled array of prices for a historical range.
-* @param {object} priceHistoryObj - The map of { "YYYY-MM-DD": price }
-* @param {string} endDateStr - The end date of the period (e.g., today).
-* @param {number} numDays - The number of calendar days to fetch prices for.
-* @returns {number[]} A sorted array of prices, oldest to newest.
-*/
     _getHistoricalPriceArray(priceHistoryObj, endDateStr, numDays) {
         const prices = [];
         let currentDate = new Date(endDateStr + 'T00:00:00Z');
@@ -296,28 +203,23 @@ class CorePriceMetrics {
         for (let i = 0; i < numDays; i++) {
             const targetDateStr = currentDate.toISOString().slice(0, 10);
             let price = this._findPriceOnOrBefore(priceHistoryObj, targetDateStr);
-            
-            // If price is null (e.g., new instrument), try to use the last known price
+
             if (price === null) {
                 price = lastPrice; 
             } else {
-                lastPrice = price; // Update last known price
+                lastPrice = price;
             }
 
             if (price !== null) {
                 prices.push(price);
             }
-            
-            // Go back one calendar day for the next data point
+
             currentDate.setUTCDate(currentDate.getUTCDate() - 1);
         }
-        
-        // We built the array from newest to oldest, so reverse it.
-        // And filter out any initial nulls if lastPrice was null at the start
+
         return prices.reverse().filter(p => p !== null);
     }
 
-
     _calculateMean(arr) {
         if (!arr || arr.length === 0) return 0;
         const sum = arr.reduce((acc, val) => acc + val, 0);
@@ -327,7 +229,6 @@ class CorePriceMetrics {
     _calculateStdDev(arr, mean) {
         if (!arr || arr.length < 2) return 0;
         const avg = mean === undefined ? this._calculateMean(arr) : mean;
-        // Use N-1 for sample standard deviation
         const variance = arr.reduce((acc, val) => acc + (val - avg) ** 2, 0) / (arr.length - 1);
         return Math.sqrt(variance);
     }
@@ -355,18 +256,15 @@ class CorePriceMetrics {
             if (price > peak) {
                 peak = price;
             }
-            if (peak > 0) { // Only calculate drawdown if peak is positive
+            if (peak > 0) { 
                 const drawdown = (price - peak) / peak;
                 if (drawdown < maxDrawdown) {
                     maxDrawdown = drawdown;
                 }
             }
         }
-        // Ensure result is a finite number, default to 0
         return isFinite(maxDrawdown) ? maxDrawdown : 0;
     }
-
-    // #endregion --- Math & Price Helpers ---
 }
 
 module.exports = CorePriceMetrics;

package/calculations/core/profitability-ratio-per-sector.js

@@ -4,16 +4,17 @@
  * This metric provides the profitability ratio (profitable positions /
  * unprofitable positions) for all open positions, grouped by sector.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
 class ProfitabilityRatioPerSector {
     constructor() {
         // We will store { [sectorName]: { profitable: 0, unprofitable: 0 } }
-        this.sectorMap = new Map();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.sectorData = new Map();
+        // --- STANDARD 0: RENAMED ---
+        this.sectorMap = null; // This will hold InstID -> SectorName
     }
 
-    // --- NEW ---
     /**
      * Statically defines all metadata for the manifest builder.
      */
@@ -27,7 +28,6 @@ class ProfitabilityRatioPerSector {
         };
     }
 
-    // --- NEW ---
     /**
      * Statically declare dependencies.
      */
@@ -37,7 +37,6 @@ class ProfitabilityRatioPerSector {
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
         const sectorSchema = {
@@ -64,24 +63,21 @@ class ProfitabilityRatioPerSector {
     }
 
     _initSector(sectorName) {
-        if (!this.sectorMap.has(sectorName)) {
-            this.sectorMap.set(sectorName, { profitable: 0, unprofitable: 0 });
+        if (!this.sectorData.has(sectorName)) {
+            this.sectorData.set(sectorName, { profitable: 0, unprofitable: 0 });
         }
     }
 
-    // --- REFACTORED ---
-    // This method *is* async because it might load mappings on the first run.
-    // The runner should handle this with `await Promise.resolve(calc.process(...))`.
-    // The signature is correct because it needs `context` for mappings.
-    async process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (!this.mappings) {
-            // Load mappings on first process call
-            // Using context.mappings which are pre-loaded in Pass 1
-            this.mappings = context.mappings;
+    // --- STANDARD 0: UPDATED (no longer async) ---
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // --- STANDARD 0: FIXED ---
+        if (!this.sectorMap) {
+            // Load mappings on first process call from the standard context
+            this.sectorMap = context.sectorMapping;
         }
 
-        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
-        if (!positions || !Array.isArray(positions) || !this.mappings) {
+        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
+        if (!positions || !Array.isArray(positions) || !this.sectorMap) {
             return;
         }
 
@@ -93,13 +89,11 @@ class ProfitabilityRatioPerSector {
                 continue;
             }
             
-            // Find sector name
-            // --- FIX: Use the correct mapping ---
-            // The mapping from the provider is `instrumentToSector` (ID -> Sector Name)
-            // `instrumentToSectorName` is not a property.
-            const sectorName = this.mappings.instrumentToSector[instrumentId] || 'N/A';
+            // --- STANDARD 0: FIXED ---
+            // Use the standard InstID -> SectorName map
+            const sectorName = this.sectorMap[instrumentId] || 'N/A';
             this._initSector(sectorName);
-            const data = this.sectorMap.get(sectorName);
+            const data = this.sectorData.get(sectorName);
 
             // Tally
             if (pnl > 0) {
@@ -107,13 +101,12 @@ class ProfitabilityRatioPerSector {
             } else if (pnl < 0) {
                 data.unprofitable++;
             }
-            // Note: pnl === 0 is neutral and not counted in the ratio
         }
     }
 
     getResult() {
         const result = {};
-        for (const [sectorName, data] of this.sectorMap.entries()) {
+        for (const [sectorName, data] of this.sectorData.entries()) {
             const { profitable, unprofitable } = data;
             
             result[sectorName] = {
@@ -126,8 +119,9 @@ class ProfitabilityRatioPerSector {
     }
 
     reset() {
-        this.sectorMap.clear();
-        this.mappings = null; // Reset mappings
+        this.sectorData.clear();
+        // --- STANDARD 0: RENAMED ---
+        this.sectorMap = null; // Reset mappings
     }
 }
 

package/calculations/core/profitability-ratio-per-stock.js

@@ -4,16 +4,16 @@
  * This metric answers: "For each stock, what is the count of
  * profitable versus unprofitable positions?"
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
 class ProfitabilityRatioPerStock {
     constructor() {
         // We will store { [instrumentId]: { profitable: 0, unprofitable: 0 } }
         this.assets = new Map();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 
-    // --- NEW ---
     /**
      * Statically defines all metadata for the manifest builder.
      */
@@ -27,7 +27,6 @@ class ProfitabilityRatioPerStock {
         };
     }
 
-    // --- NEW ---
     /**
      * Statically declare dependencies.
      */
@@ -37,7 +36,6 @@ class ProfitabilityRatioPerStock {
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
         const tickerSchema = {
@@ -79,10 +77,14 @@ class ProfitabilityRatioPerStock {
         }
     }
 
-    // --- REFACTORED ---
-    // Simplified signature
-    process(portfolioData) {
-        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
+    // --- STANDARD 0: UPDATED SIGNATURE ---
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // --- STANDARD 0: ADDED ---
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
+        }
+        
+        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
         if (!positions || !Array.isArray(positions)) {
             return;
         }
@@ -104,13 +106,17 @@ class ProfitabilityRatioPerStock {
     }
 
     async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        // --- STANDARD 0: REMOVED forbidden data load ---
+
+        // Failsafe check
+        if (!this.tickerMap) {
+            return {}; // process() must run first
         }
 
         const result = {};
         for (const [instrumentId, data] of this.assets.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            // --- STANDARD 0: SIMPLIFIED ---
+            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
             
             if (data.profitable > 0 || data.unprofitable > 0) {
                 result[ticker] = {
@@ -125,7 +131,8 @@ class ProfitabilityRatioPerStock {
 
     reset() {
         this.assets.clear();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 }