aiden-shared-calculations-unified 1.0.90 → 1.0.91

package/calculations/core/asset-pnl-status.js

@@ -1,11 +1,13 @@
 /**
  * @fileoverview Core Metric (Pass 2)
- * REFACTORED: Buckets users by P&L status (Win/Loss).
+ * REFACTORED: Buckets P&L status by User Profile.
+ * - Pivots data to be User-Centric (User -> Winners/Losers).
+ * - Removes sharding complexity (fits within 1MB via structure optimization).
  */
 class AssetPnlStatus {
     constructor() {
-        this.tickerBuckets = new Map();
-        this.sectorBuckets = new Map();
+        // Map<UserId, { winners: Set<String>, losers: Set<String> }>
+        this.userStats = new Map();
     }
 
     static getMetadata() {
@@ -21,80 +23,92 @@ class AssetPnlStatus {
     static getDependencies() { return []; }
 
     static getSchema() {
-        const cohortSchema = {
-            "type": "object",
-            "properties": {
-                "winners": { "type": "array", "items": { "type": "string" } },
-                "losers": { "type": "array", "items": { "type": "string" } }
-            },
-            "required": ["winners", "losers"]
-        };
         return {
             "type": "object",
             "properties": {
-                "by_ticker": { "type": "object", "patternProperties": { "^.*$": cohortSchema } },
-                "by_sector": { "type": "object", "patternProperties": { "^.*$": cohortSchema } }
+                "by_user": {
+                    "type": "object",
+                    "description": "Map of User IDs to their winning/losing assets and sectors.",
+                    "patternProperties": {
+                        "^[0-9]+$": { // Matches User IDs (CIDs)
+                            "type": "object",
+                            "properties": {
+                                "winners": { "type": "array", "items": { "type": "string" } },
+                                "losers": { "type": "array", "items": { "type": "string" } }
+                            },
+                            "required": ["winners", "losers"]
+                        }
+                    }
+                }
             }
         };
     }
     
-    _init(map, key) {
-        if (!map.has(key)) map.set(key, { winners: new Set(), losers: new Set() });
+    _initUser(userId) {
+        if (!this.userStats.has(userId)) {
+            this.userStats.set(userId, { winners: new Set(), losers: new Set() });
+        }
+        return this.userStats.get(userId);
     }
 
     process(context) {
         const { extract } = context.math;
         const { mappings, user } = context;
+        const userId = user.id;
 
+        // 1. Get Positions using the standard extractor
         const positions = extract.getPositions(user.portfolio.today, user.type);
+        if (!positions || positions.length === 0) return;
+
+        // 2. Lazy init stats only if needed
+        let stats = null;
 
         for (const pos of positions) {
             const instId = extract.getInstrumentId(pos);
             if (!instId) continue;
             
             const pnl = extract.getNetProfit(pos);
-            if (pnl === 0) continue;
+            if (pnl === 0) continue; // Ignore flat positions
             
             const ticker = mappings.instrumentToTicker[instId];
             const sector = mappings.instrumentToSector[instId];
             const isWinner = pnl > 0;
 
-            if (ticker) {
-                this._init(this.tickerBuckets, ticker);
-                const asset = this.tickerBuckets.get(ticker);
-                if (isWinner) asset.winners.add(user.id);
-                else asset.losers.add(user.id);
-            }
-            
-            if (sector) {
-                this._init(this.sectorBuckets, sector);
-                const sec = this.sectorBuckets.get(sector);
-                if (isWinner) sec.winners.add(user.id);
-                else sec.losers.add(user.id);
+            if (ticker || sector) {
+                if (!stats) stats = this._initUser(userId);
+
+                if (ticker) {
+                    if (isWinner) stats.winners.add(ticker);
+                    else stats.losers.add(ticker);
+                }
+                
+                if (sector) {
+                    if (isWinner) stats.winners.add(sector);
+                    else stats.losers.add(sector);
+                }
             }
         }
     }
 
     async getResult() {
-        const result = { by_ticker: {}, by_sector: {} };
-        
-        const buildResult = (map, out) => {
-            for (const [key, data] of map.entries()) {
-                out[key] = {
-                    winners: Array.from(data.winners),
-                    losers: Array.from(data.losers)
+        const byUser = {};
+
+        for (const [userId, stats] of this.userStats) {
+            // Only include users who actually have relevant P&L data
+            if (stats.winners.size > 0 || stats.losers.size > 0) {
+                byUser[userId] = {
+                    winners: Array.from(stats.winners),
+                    losers: Array.from(stats.losers)
                 };
             }
-        };
+        }
 
-        buildResult(this.tickerBuckets, result.by_ticker);
-        buildResult(this.sectorBuckets, result.by_sector);
-        return result;
+        return { by_user: byUser };
     }
     
     reset() {
-        this.tickerBuckets.clear();
-        this.sectorBuckets.clear();
+        this.userStats.clear();
     }
 }
+
 module.exports = AssetPnlStatus;

package/package.json

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