aiden-shared-calculations-unified 1.0.109 → 1.0.110

package/calculations/gem/unskilled-cohort-flow.js

@@ -1,142 +1,66 @@
-/**
- * @fileoverview GEM Product Line (Pass 2)
- * REFACTORED: Uses context.computed and context.math.extract.
- */
 class UnskilledCohortFlow {
-    constructor() {
-        this.assetFlows = new Map();
-        this.cohortMap = new Map();
-        this.dependenciesLoaded = false;
-        this.tickerMap = null;
-    }
-
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio'],
-            isHistorical: true, 
-            userType: 'all',
-            category: 'gem'
-        };
-    }
-
-    static getDependencies() {
-        return ['cohort-skill-definition', 'instrument-price-change-1d'];
-    }
+    constructor() { this.assetFlows = new Map(); this.cohortMap = new Map(); this.dependenciesLoaded = false; this.tickerMap = null; }
+    static getMetadata() { return { type: 'standard', rootDataDependencies: ['portfolio'], isHistorical: true, userType: 'all', category: 'gem' }; }
+    static getDependencies() { return ['cohort-skill-definition', 'instrument-price-change-1d']; }
 
     static getSchema() {
-        const tickerSchema = {
-            "type": "object",
-            "properties": {
-                "net_flow_pct": { "type": "number" },
-                "net_flow_contribution": { "type": "number" },
-                "avg_position_change_pct": { "type": "number" },
-                "user_count": { "type": "number" }
-            },
-            "required": ["net_flow_pct", "net_flow_contribution", "avg_position_change_pct", "user_count"]
-        };
-        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
-    }
-
-    _initFlowData(instrumentId) {
-        if (!this.assetFlows.has(instrumentId)) {
-            this.assetFlows.set(instrumentId, {
-                total_invested_yesterday: 0, total_invested_today: 0, price_change_yesterday: 0,
-                total_pos_size_yesterday: 0, total_pos_size_today: 0, user_count_yesterday: 0, user_count_today: 0
-            });
-        }
+        const s = { "type": "object", "properties": { "net_flow_pct": { "type": ["number", "null"] }, "net_flow_contribution": { "type": ["number", "null"] }, "avg_position_change_pct": { "type": ["number", "null"] }, "user_count": { "type": "number" }, "total_invested_today": { "type": "number" } }, "required": ["net_flow_pct", "net_flow_contribution", "avg_position_change_pct", "user_count", "total_invested_today"] };
+        return { "type": "object", "patternProperties": { "^.*$": s } };
     }
 
     _loadDependencies(computed) {
         if (this.dependenciesLoaded) return;
-        const cohortData = computed['cohort-skill-definition'];
-        if (cohortData) {
-            (cohortData.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled'));
-        }
+        const d = computed['cohort-skill-definition'];
+        if (d) (d.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled'));
         this.dependenciesLoaded = true;
     }
 
     process(context) {
         const { user, computed, mappings, math } = context;
         const { extract } = math;
-        
         this._loadDependencies(computed);
-        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
-
         if (this.cohortMap.get(user.id) !== 'unskilled') return;
-        
-        const priceChangeMap = computed['instrument-price-change-1d'];
-        if (!priceChangeMap) return;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
+        const priceMap = computed['instrument-price-change-1d'];
 
-        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
         const tPos = extract.getPositions(user.portfolio.today, user.type);
-
+        const yPos = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
         const yPosMap = new Map(yPos.map(p => [extract.getInstrumentId(p), p]));
         const tPosMap = new Map(tPos.map(p => [extract.getInstrumentId(p), p]));
-        const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
-
-        for (const instId of allInstrumentIds) {
-            if (!instId) continue;
-            this._initFlowData(instId);
-            const asset = this.assetFlows.get(instId);
-
-            const yWeight = extract.getPositionWeight(yPosMap.get(instId), user.type);
-            const tWeight = extract.getPositionWeight(tPosMap.get(instId), user.type);
+        const ids = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
 
-            if (yWeight > 0) {
-                asset.total_invested_yesterday += yWeight;
-                const ticker = mappings.instrumentToTicker[instId];
-                const priceChange = (ticker && priceChangeMap[ticker]) ? priceChangeMap[ticker].change_1d_pct : 0;
-                asset.price_change_yesterday += (priceChange / 100.0) * yWeight;
-                asset.total_pos_size_yesterday += yWeight;
-                asset.user_count_yesterday++;
-            }
-            if (tWeight > 0) {
-                asset.total_invested_today += tWeight;
-                asset.user_count_today++;
-                asset.total_pos_size_today += tWeight;
+        for (const id of ids) {
+            if (!this.assetFlows.has(id)) this.assetFlows.set(id, { yInv: 0, tInv: 0, pChg: 0, ySize: 0, tSize: 0, yCount: 0, tCount: 0, hasY: false });
+            const asset = this.assetFlows.get(id);
+            const tW = extract.getPositionWeight(tPosMap.get(id), user.type);
+            if (tW > 0) { asset.tInv += tW; asset.tCount++; asset.tSize += tW; }
+            if (user.portfolio.yesterday) {
+                asset.hasY = true;
+                const yW = extract.getPositionWeight(yPosMap.get(id), user.type);
+                if (yW > 0) {
+                    asset.yInv += yW; asset.yCount++; asset.ySize += yW;
+                    const tick = mappings.instrumentToTicker[id];
+                    const chg = (tick && priceMap?.[tick]) ? priceMap[tick].change_1d_pct : 0;
+                    asset.pChg += ((chg || 0) / 100.0) * yW;
+                }
             }
         }
     }
 
     async getResult() {
-        if (!this.tickerMap) return {};
-        const finalResult = {};
-        for (const [instId, data] of this.assetFlows.entries()) {
-            const ticker = this.tickerMap[instId];
-            if (!ticker) continue;
-            let net_flow = 0, flow_contrib = 0;
-            if (data.total_invested_yesterday > 0) {
-                const avg_change = data.price_change_yesterday / data.total_invested_yesterday;
-                const adjusted_y = data.total_invested_yesterday * (1 + avg_change);
-                flow_contrib = data.total_invested_today - adjusted_y;
-                net_flow = (flow_contrib / data.total_invested_yesterday) * 100;
-            } else if (data.total_invested_today > 0) {
-                flow_contrib = data.total_invested_today;
-                net_flow = Infinity;
+        if (!this.tickerMap) return {}; const res = {};
+        for (const [id, d] of this.assetFlows.entries()) {
+            const tick = this.tickerMap[id]; if (!tick) continue;
+            let net = null, contrib = null, avgPos = null;
+            if (d.hasY) {
+                const adjY = d.yInv + d.pChg; contrib = d.tInv - adjY;
+                net = d.yInv > 0 ? (contrib / d.yInv) * 100 : (d.tInv > 0 ? Infinity : 0);
+                if (d.yCount > 0 && d.tCount > 0) avgPos = (((d.tSize / d.tCount) - (d.ySize / d.yCount)) / (d.ySize / d.yCount)) * 100;
             }
-            let avg_pos_change = 0;
-            if (data.user_count_yesterday > 0 && data.user_count_today > 0) {
-                const avg_y = data.total_pos_size_yesterday / data.user_count_yesterday;
-                const avg_t = data.total_pos_size_today / data.user_count_today;
-                if (avg_y > 0) avg_pos_change = ((avg_t - avg_y) / avg_y) * 100;
-            } else if (data.user_count_today > 0) avg_pos_change = Infinity;
-
-            finalResult[ticker] = {
-                net_flow_pct: isFinite(net_flow) ? net_flow : 0,
-                net_flow_contribution: isFinite(flow_contrib) ? flow_contrib : 0,
-                avg_position_change_pct: isFinite(avg_pos_change) ? avg_pos_change : 0,
-                user_count: data.user_count_today
-            };
+            res[tick] = { net_flow_pct: isFinite(net) ? net : null, net_flow_contribution: isFinite(contrib) ? contrib : null, avg_position_change_pct: isFinite(avgPos) ? avgPos : null, user_count: d.tCount, total_invested_today: d.tInv };
         }
-        return finalResult;
-    }
-
-    reset() {
-        this.assetFlows.clear();
-        this.cohortMap.clear();
-        this.dependenciesLoaded = false;
-        this.tickerMap = null;
+        return res;
     }
+    reset() { this.assetFlows.clear(); this.cohortMap.clear(); this.dependenciesLoaded = false; this.tickerMap = null; }
 }
 module.exports = UnskilledCohortFlow;

package/calculations/ghost-book/retail-gamma-exposure.js

@@ -1,80 +1,33 @@
-/**
- * @fileoverview Ghost Book: Retail Gamma Exposure
- * Measures the "Elasticity of Intent" (Beta) between Price Change and Net Flow.
- */
 class RetailGammaExposure {
     constructor() { this.gammaResults = {}; }
-
-    static getMetadata() {
-        return {
-            type: 'meta',
-            dependencies: ['skilled-cohort-flow', 'instrument-price-change-1d'],
-            isHistorical: true, // Requires t-1, t-2... for rolling regression
-            userType: 'n/a',    // FIXED: Added missing field
-            category: 'ghost_book'
-        };
-    }
-
+    static getMetadata() { return { type: 'meta', dependencies: ['skilled-cohort-flow', 'instrument-price-change-1d'], isHistorical: true, userType: 'n/a', category: 'ghost_book' }; }
     static getDependencies() { return ['skilled-cohort-flow', 'instrument-price-change-1d']; }
 
     static getSchema() {
-        return {
-            "type": "object",
-            "patternProperties": {
-                "^.*$": {
-                    "type": "object",
-                    "properties": {
-                        "gamma_beta": { "type": "number" },
-                        "regime": { "type": "string", "enum": ["ACCELERANT", "STABILIZER", "NEUTRAL"] },
-                        "_state": { "type": "object" } // Rolling buffer
-                    }
-                }
-            }
-        };
+        return { "type": "object", "patternProperties": { "^.*$": { "type": "object", "properties": { "gamma_beta": { "type": ["number", "null"] }, "regime": { "type": "string" }, "_state": { "type": "object" } } } } };
     }
 
     process(context) {
         const { computed, previousComputed, math } = context;
         const { signals, distribution } = math;
-
         const tickers = signals.getUnionKeys(computed, ['skilled-cohort-flow']);
-
         for (const ticker of tickers) {
             const flow = signals.getMetric(computed, 'skilled-cohort-flow', ticker, 'net_flow_pct', 0);
-            const priceChange = signals.getMetric(computed, 'instrument-price-change-1d', ticker, 'change_1d_pct', 0);
-
-            const prevResult = signals.getPreviousState(previousComputed, 'retail-gamma-exposure', ticker);
-            const bufferSize = 14; 
-            
-            let flowBuffer = prevResult?._state?.flow_buffer || [];
-            let priceBuffer = prevResult?._state?.price_buffer || [];
-
-            flowBuffer.push(flow);
-            priceBuffer.push(priceChange);
-
-            if (flowBuffer.length > bufferSize) {
-                flowBuffer.shift();
-                priceBuffer.shift();
+            const price = signals.getMetric(computed, 'instrument-price-change-1d', ticker, 'change_1d_pct', 0);
+            const prev = signals.getPreviousState(previousComputed, 'retail-gamma-exposure', ticker);
+            let fBuf = [...(prev?._state?.flow_buffer || [])], pBuf = [...(prev?._state?.price_buffer || [])];
+            fBuf.push(flow); pBuf.push(price);
+            if (fBuf.length > 14) { fBuf.shift(); pBuf.shift(); }
+
+            let beta = null, regime = "WARM_UP";
+            if (fBuf.length >= 7) {
+                const reg = distribution.linearRegression(pBuf, fBuf);
+                beta = reg.slope;
+                regime = beta > 0.5 ? "ACCELERANT" : (beta < -0.5 ? "STABILIZER" : "NEUTRAL");
             }
-
-            const regression = distribution.linearRegression(priceBuffer, flowBuffer);
-            const beta = regression.slope;
-
-            let regime = "NEUTRAL";
-            if (beta > 0.5) regime = "ACCELERANT"; 
-            else if (beta < -0.5) regime = "STABILIZER"; 
-
-            this.gammaResults[ticker] = {
-                gamma_beta: Number(beta.toFixed(4)),
-                regime: regime,
-                _state: {
-                    flow_buffer: flowBuffer,
-                    price_buffer: priceBuffer
-                }
-            };
+            this.gammaResults[ticker] = { gamma_beta: (beta !== null && isFinite(beta)) ? Number(beta.toFixed(4)) : null, regime, _state: { flow_buffer: fBuf, price_buffer: pBuf } };
         }
     }
-
     getResult() { return this.gammaResults; }
     reset() { this.gammaResults = {}; }
 }

package/calculations/helix/herd-consensus-score.js

@@ -1,108 +1,45 @@
-/**
- * @fileoverview HELIX Product Line (Pass 2)
- * REFACTORED: Uses context.math.extract.
- */
 class HerdConsensusScore {
-    constructor() {
-        this.assetConviction = new Map();
-        this.tickerMap = null;
-    }
+    constructor() { this.assetConviction = new Map(); this.tickerMap = null; }
+    static getMetadata() { return { type: 'standard', rootDataDependencies: ['portfolio'], isHistorical: true, userType: 'all', category: 'helix' }; }
+    static getDependencies() { return []; }
 
     static getSchema() {
-        const tickerSchema = {
-            "type": "object",
-            "properties": {
-                "herd_conviction_score": { "type": "number" },
-                "user_count": { "type": "number" }
-            },
-            "required": ["herd_conviction_score", "user_count"]
-        };
-        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
+        const s = { "type": "object", "properties": { "herd_conviction_score": { "type": ["number", "null"] }, "user_count": { "type": "number" }, "total_abs_size_today": { "type": "number" } }, "required": ["herd_conviction_score", "user_count", "total_abs_size_today"] };
+        return { "type": "object", "patternProperties": { "^.*$": s } };
     }
 
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio'],
-            isHistorical: true, 
-            userType: 'all',
-            category: 'helix'
-        };
-    }
-
-    static getDependencies() { return []; }
-
-    _initAsset(instrumentId) {
-        if (!this.assetConviction.has(instrumentId)) {
-            this.assetConviction.set(instrumentId, {
-                total_pos_size_yesterday: 0, total_pos_size_today: 0,
-                user_count_yesterday: 0, user_count_today: 0
-            });
-        }
-    }
+    _init(id) { if (!this.assetConviction.has(id)) this.assetConviction.set(id, { ySize: 0, tSize: 0, yCount: 0, tCount: 0, hasY: false }); }
 
     process(context) {
-        const { user, mappings, math } = context;
-        const { extract } = math;
+        const { user, mappings, math } = context; const { extract } = math;
         if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
-
-        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
         const tPos = extract.getPositions(user.portfolio.today, user.type);
-
-        const yPosMap = new Map(yPos.map(p => [extract.getInstrumentId(p), p]));
-        const tPosMap = new Map(tPos.map(p => [extract.getInstrumentId(p), p]));
-        
-        const allIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
-
-        for (const instId of allIds) {
-            const tP = tPosMap.get(instId);
-            const yP = yPosMap.get(instId);
-            
-            if (extract.getNetProfit(tP) >= 0) continue; // Only Losers (Herd)
-            
-            this._initAsset(instId);
-            const asset = this.assetConviction.get(instId);
-            const yWeight = extract.getPositionWeight(yP, user.type);
-            const tWeight = extract.getPositionWeight(tP, user.type);
-
-            if (yWeight > 0) {
-                asset.total_pos_size_yesterday += yWeight;
-                asset.user_count_yesterday++;
-            }
-            if (tWeight > 0) {
-                asset.total_pos_size_today += tWeight;
-                asset.user_count_today++;
+        const yPos = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
+        const yMap = new Map(yPos.map(p => [extract.getInstrumentId(p), p]));
+        const tMap = new Map(tPos.map(p => [extract.getInstrumentId(p), p]));
+        const ids = new Set([...yMap.keys(), ...tMap.keys()]);
+        for (const id of ids) {
+            const tP = tMap.get(id), yP = yMap.get(id);
+            if (extract.getNetProfit(tP) >= 0) continue;
+            this._init(id); const a = this.assetConviction.get(id);
+            const tW = extract.getPositionWeight(tP, user.type);
+            if (tW > 0) { a.tSize += tW; a.tCount++; }
+            if (user.portfolio.yesterday) {
+                a.hasY = true; const yW = extract.getPositionWeight(yP, user.type);
+                if (yW > 0) { a.ySize += yW; a.yCount++; }
             }
         }
     }
 
     async getResult() {
-        if (!this.tickerMap) return {};
-        const result = {};
-        for (const [instId, data] of this.assetConviction.entries()) {
-            const ticker = this.tickerMap[instId];
-            if (!ticker) continue;
-
-            let avg_pos_change = 0;
-            if (data.user_count_yesterday > 0 && data.user_count_today > 0) {
-                const avg_y = data.total_pos_size_yesterday / data.user_count_yesterday;
-                const avg_t = data.total_pos_size_today / data.user_count_today;
-                if (avg_y > 0) avg_pos_change = ((avg_t - avg_y) / avg_y) * 100;
-            } else if (data.user_count_today > 0) avg_pos_change = Infinity;
-
-            if (isFinite(avg_pos_change) && data.user_count_today > 0) {
-                result[ticker] = {
-                    herd_conviction_score: avg_pos_change,
-                    user_count: data.user_count_today
-                };
-            }
+        if (!this.tickerMap) return {}; const res = {};
+        for (const [id, d] of this.assetConviction.entries()) {
+            const tick = this.tickerMap[id]; if (!tick) continue;
+            let score = null; if (d.hasY && d.yCount > 0 && d.tCount > 0) score = (((d.tSize / d.tCount) - (d.ySize / d.yCount)) / (d.ySize / d.yCount)) * 100;
+            res[tick] = { herd_conviction_score: isFinite(score) ? score : null, user_count: d.tCount, total_abs_size_today: d.tSize };
         }
-        return result;
-    }
-
-    reset() {
-        this.assetConviction.clear();
-        this.tickerMap = null;
+        return res;
     }
+    reset() { this.assetConviction.clear(); this.tickerMap = null; }
 }
 module.exports = HerdConsensusScore;

package/calculations/helix/winner-loser-flow.js

@@ -1,108 +1,39 @@
-/**
- * @fileoverview HELIX Product Line (Pass 2)
- * REFACTORED: Uses context.math.extract.
- */
 class WinnerLoserFlow {
-    constructor() {
-        this.assetFlows = new Map();
-        this.tickerMap = null;
-    }
-
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio'],
-            isHistorical: true,
-            userType: 'all',
-            category: 'helix'
-        };
-    }s
-
+    constructor() { this.assetFlows = new Map(); this.tickerMap = null; }
+    static getMetadata() { return { type: 'standard', rootDataDependencies: ['portfolio'], isHistorical: true, userType: 'all', category: 'helix' }; }
     static getDependencies() { return []; }
 
     static getSchema() {
-        const tickerSchema = {
-            "type": "object",
-            "properties": {
-                "net_winner_flow": { "type": "number" },
-                "net_loser_flow": { "type": "number" },
-                "raw_counts": { "type": "object" }
-            },
-            "required": ["net_winner_flow", "net_loser_flow", "raw_counts"]
-        };
-        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
-    }
-
-    _getHoldings(positions, extract) {
-        const map = new Map();
-        for (const pos of positions) {
-            const id = extract.getInstrumentId(pos);
-            if (id) map.set(id, { pnl: extract.getNetProfit(pos) });
-        }
-        return map;
-    }
-    
-    _initAsset(ticker) {
-        if (!this.assetFlows.has(ticker)) {
-            this.assetFlows.set(ticker, { winners_joined: 0, winners_left: 0, losers_joined: 0, losers_left: 0 });
-        }
+        const s = { "type": "object", "properties": { "net_winner_flow": { "type": ["number", "null"] }, "net_loser_flow": { "type": ["number", "null"] }, "total_winners_today": { "type": "number" }, "total_losers_today": { "type": "number" } }, "required": ["net_winner_flow", "net_loser_flow", "total_winners_today", "total_losers_today"] };
+        return { "type": "object", "patternProperties": { "^.*$": s } };
     }
 
     process(context) {
-        const { user, mappings, math } = context;
-        const { extract } = math;
+        const { user, mappings, math } = context; const { extract } = math;
         if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
-
-        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
         const tPos = extract.getPositions(user.portfolio.today, user.type);
-        
-        const yHoldings = this._getHoldings(yPos, extract);
-        const tHoldings = this._getHoldings(tPos, extract);
-
-        const allIds = new Set([...yHoldings.keys(), ...tHoldings.keys()]);
-
-        for (const instId of allIds) {
-            const ticker = this.tickerMap[instId];
-            if (!ticker) continue;
-            
-            const tPnl = tHoldings.get(instId)?.pnl || 0;
-            const isWinner = tPnl > 0;
-            const isLoser = tPnl < 0;
-            if (!isWinner && !isLoser) continue;
-
-            const heldYesterday = yHoldings.has(instId);
-            const holdsToday = tHoldings.has(instId);
-            if (heldYesterday === holdsToday) continue;
-
-            this._initAsset(ticker);
-            const stats = this.assetFlows.get(ticker);
-
-            if (isWinner) {
-                if (holdsToday && !heldYesterday) stats.winners_joined++;
-                if (!holdsToday && heldYesterday) stats.winners_left++;
-            }
-            if (isLoser) {
-                if (holdsToday && !heldYesterday) stats.losers_joined++;
-                if (!holdsToday && heldYesterday) stats.losers_left++;
+        const yPos = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
+        const yH = new Map(yPos.map(p => [extract.getInstrumentId(p), extract.getNetProfit(p)]));
+        const tH = new Map(tPos.map(p => [extract.getInstrumentId(p), extract.getNetProfit(p)]));
+        const ids = new Set([...yH.keys(), ...tH.keys()]);
+        for (const id of ids) {
+            const tick = this.tickerMap[id]; if (!tick) continue;
+            if (!this.assetFlows.has(tick)) this.assetFlows.set(tick, { wJ: 0, wL: 0, lJ: 0, lL: 0, wT: 0, lT: 0, hasY: !!user.portfolio.yesterday });
+            const s = this.assetFlows.get(tick), tPnl = tH.get(id), yPnl = yH.get(id);
+            if (tH.has(id)) { if (tPnl > 0) s.wT++; if (tPnl < 0) s.lT++; }
+            if (user.portfolio.yesterday) {
+                if (tH.has(id) && !yH.has(id)) { if (tPnl > 0) s.wJ++; if (tPnl < 0) s.lJ++; }
+                if (!tH.has(id) && yH.has(id)) { if (yPnl > 0) s.wL++; if (yPnl < 0) s.lL++; }
             }
         }
     }
 
     async getResult() {
-        const result = {};
-        for (const [ticker, data] of this.assetFlows.entries()) {
-            result[ticker] = {
-                net_winner_flow: data.winners_joined - data.winners_left,
-                net_loser_flow: data.losers_joined - data.losers_left,
-                raw_counts: data
-            };
+        const res = {}; for (const [tick, d] of this.assetFlows.entries()) {
+            res[tick] = { net_winner_flow: d.hasY ? d.wJ - d.wL : null, net_loser_flow: d.hasY ? d.lJ - d.lL : null, total_winners_today: d.wT, total_losers_today: d.lT };
         }
-        return result;
-    }
-
-    reset() {
-        this.assetFlows.clear();
-        this.tickerMap = null;
+        return res;
     }
+    reset() { this.assetFlows.clear(); this.tickerMap = null; }
 }
 module.exports = WinnerLoserFlow;