bulltrackers-module 1.0.285 → 1.0.287

package/functions/computation-system/context/ManifestBuilder.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Dynamic Manifest Builder - Handles Topological Sort and Auto-Discovery.
  * UPDATED: Generates Granular Hash Composition for Audit Trails.
+ * UPGRADE: Implements Tarjan's Algorithm for Precise Cycle Detection.
  */
 const { generateCodeHash, LEGACY_MAPPING } = require('../topology/HashManager.js');
 const { normalizeName }                    = require('../utils/utils');
@@ -82,6 +83,68 @@ function getDependencySet(endpoints, adjacencyList) {
     return required;
 }
 
+/**
+ * Helper: Detects cycles using Tarjan's SCC Algorithm.
+ * Returns a string description of the first cycle found.
+ */
+function detectCircularDependencies(manifestMap) {
+    let index = 0;
+    const stack = [];
+    const indices = new Map();
+    const lowLinks = new Map();
+    const onStack = new Set();
+    const cycles = [];
+
+    function strongconnect(v) {
+        indices.set(v, index);
+        lowLinks.set(v, index);
+        index++;
+        stack.push(v);
+        onStack.add(v);
+
+        const entry = manifestMap.get(v);
+        if (entry && entry.dependencies) {
+            for (const w of entry.dependencies) {
+                if (!manifestMap.has(w)) continue; // Skip external/missing deps (handled elsewhere)
+                
+                if (!indices.has(w)) {
+                    strongconnect(w);
+                    lowLinks.set(v, Math.min(lowLinks.get(v), lowLinks.get(w)));
+                } else if (onStack.has(w)) {
+                    lowLinks.set(v, Math.min(lowLinks.get(v), indices.get(w)));
+                }
+            }
+        }
+
+        if (lowLinks.get(v) === indices.get(v)) {
+            const scc = [];
+            let w;
+            do {
+                w = stack.pop();
+                onStack.delete(w);
+                scc.push(w);
+            } while (w !== v);
+
+            if (scc.length > 1) {
+                cycles.push(scc);
+            }
+        }
+    }
+
+    for (const name of manifestMap.keys()) {
+        if (!indices.has(name)) {
+            strongconnect(name);
+        }
+    }
+
+    if (cycles.length > 0) {
+        // Format the first cycle for display
+        const cycle = cycles[0];
+        return cycle.join(' -> ') + ' -> ' + cycle[0];
+    }
+    return null;
+}
+
 function buildManifest(productLinesToRun = [], calculations) {
     log.divider('Building Dynamic Manifest');
     
@@ -111,7 +174,6 @@ function buildManifest(productLinesToRun = [], calculations) {
         let compositeHashString = selfCodeHash + `|EPOCH:${SYSTEM_EPOCH}`; 
         
         const usedDeps = [];
-        // Track layer hashes for composition analysis
         const usedLayerHashes = {}; 
 
         for (const [layerName, exportsMap] of Object.entries(LAYER_TRIGGERS)) {
@@ -123,7 +185,6 @@ function buildManifest(productLinesToRun = [], calculations) {
                         compositeHashString += exportHash;
                         usedDeps.push(`${layerName}.${exportName}`);
                         
-                        // Group hashes by layer for the composition report
                         if (!usedLayerHashes[layerName]) usedLayerHashes[layerName] = '';
                         usedLayerHashes[layerName] += exportHash;
                     }
@@ -131,13 +192,11 @@ function buildManifest(productLinesToRun = [], calculations) {
             }
         }
         
-        // Simplify layer hashes to one hash per layer for the report
         const layerComposition = {};
         for(const [lName, lStr] of Object.entries(usedLayerHashes)) {
             layerComposition[lName] = generateCodeHash(lStr);
         }
 
-        // Safe Mode Fallback
         let isSafeMode = false;
         if (usedDeps.length === 0) {
             isSafeMode = true;
@@ -158,16 +217,13 @@ function buildManifest(productLinesToRun = [], calculations) {
             userType: metadata.userType,
             dependencies: dependencies,
             pass: 0,
-            hash: intrinsicHash, // Will be updated with deps
-            
-            // [NEW] Composition Object for Audit
+            hash: intrinsicHash,
             composition: {
                 epoch: SYSTEM_EPOCH,
                 code: selfCodeHash,
                 layers: layerComposition,
-                deps: {} // Will be populated after topo sort
+                deps: {} 
             },
-            
             debugUsedLayers: isSafeMode ? ['ALL (Safe Mode)'] : usedDeps
         };
         
@@ -189,7 +245,6 @@ function buildManifest(productLinesToRun = [], calculations) {
     if (hasFatalError) throw new Error('Manifest build failed due to missing static methods.');
     log.success(`Loaded ${manifestMap.size} calculations.`);
 
-    // --- Topological Sort & Product Line Filtering ---
     const allNames = new Set(manifestMap.keys());
     for (const [name, entry] of manifestMap) {
         for (const dep of entry.dependencies) {
@@ -257,17 +312,23 @@ function buildManifest(productLinesToRun = [], calculations) {
         queue.sort(); 
     }
 
-    if (sortedManifest.length !== filteredManifestMap.size) throw new Error('Circular dependency detected.');
+    // UPGRADE: Use Tarjan's for precise cycle reporting
+    if (sortedManifest.length !== filteredManifestMap.size) {
+        const cycle = detectCircularDependencies(filteredManifestMap);
+        if (cycle) {
+            throw new Error(`Circular dependency detected: ${cycle}`);
+        } else {
+            throw new Error('Circular dependency detected (Unknown topology error).');
+        }
+    }
 
-    // --- Cascading Hash (Phase 2) ---
     for (const entry of sortedManifest) {
-        let dependencySignature = entry.hash; // Start with intrinsic
+        let dependencySignature = entry.hash; 
         
         if (entry.dependencies && entry.dependencies.length > 0) {
             const depHashes = entry.dependencies.map(depName => { 
                 const depEntry = filteredManifestMap.get(depName);
                 if (depEntry) {
-                    // Populate Composition
                     entry.composition.deps[depName] = depEntry.hash;
                     return depEntry.hash;
                 }

package/functions/computation-system/layers/extractors.js

@@ -1,7 +1,6 @@
 /**
  * @fileoverview Extractors Layer
  * Core access methods to raw data.
- * FIX: HistoryExtractor handles both Legacy and Modern (Granular) schemas.
  */
 
 const { SCHEMAS } = require('./profiling');
@@ -23,6 +22,39 @@ class TradeSeriesBuilder {
         }
         return curve;
     }
+
+    /**
+     * UPGRADE: Kadane's Algorithm style O(n) scan for Maximum Drawdown.
+     * Efficiently finds the largest peak-to-trough decline.
+     * @param {Array<number>} curve - The cumulative equity curve
+     * @returns {Object} { maxDrawdownPct: number, peakIndex: number, troughIndex: number }
+     */
+    static calculateMaxDrawdown(curve) {
+        if (!curve || curve.length < 2) return { maxDrawdownPct: 0, peakIndex: 0, troughIndex: 0 };
+        
+        let maxDrawdown = 0;
+        let peakValue = curve[0];
+        let peakIndex = 0;
+        let tempPeakIndex = 0;
+        let troughIndex = 0;
+
+        for (let i = 1; i < curve.length; i++) {
+            const currentVal = curve[i];
+            
+            if (currentVal > peakValue) {
+                peakValue = currentVal;
+                tempPeakIndex = i;
+            } else {
+                const drawdown = (peakValue - currentVal) / peakValue;
+                if (drawdown > maxDrawdown) {
+                    maxDrawdown = drawdown;
+                    peakIndex = tempPeakIndex;
+                    troughIndex = i;
+                }
+            }
+        }
+        return { maxDrawdownPct: maxDrawdown * 100, peakIndex, troughIndex };
+    }
 }
 
 class DataExtractor { 
@@ -106,31 +138,18 @@ class DataExtractor {
     static getOpenDateTime(position) { return (!position || !position.OpenDateTime) ? null : new Date(position.OpenDateTime); }
 
 
-    /**
-     * Returns trades that were active during the given date's 24-hour window.
-     * @param {Array} historyTrades - The PublicHistoryPositions array.
-     * @param {string} dateStr - YYYY-MM-DD string.
-     */
     static getActiveTradesForDate(historyTrades, dateStr) {
         if (!historyTrades || !Array.isArray(historyTrades)) return [];
-        
-        // Define the day's window
         const startTime = new Date(dateStr + "T00:00:00.000Z").getTime();
         const endTime = new Date(dateStr + "T23:59:59.999Z").getTime();
-
         return historyTrades.filter(t => {
             if (!t.OpenDateTime) return false;
             const openTime = new Date(t.OpenDateTime).getTime();
-            
-            // 1. Must be opened before the day ended
             if (openTime > endTime) return false;
-
-            // 2. If closed, must be closed after the day started
             if (t.CloseDateTime) {
                 const closeTime = new Date(t.CloseDateTime).getTime();
                 if (closeTime < startTime) return false;
             }
-
             return true;
         });
     }
@@ -140,7 +159,6 @@ class priceExtractor {
     static getHistory(pricesContext, tickerOrId) {
         if (!pricesContext || !pricesContext.history) return [];
         let assetData = pricesContext.history[tickerOrId];
-        
         if (!assetData) {
             const id = Object.keys(pricesContext.history).find(key => {
                 const data = pricesContext.history[key];
@@ -148,11 +166,9 @@ class priceExtractor {
             });
             if (id) assetData = pricesContext.history[id];
         }
-
         if (!assetData || !assetData.prices) return [];
         const priceMap = assetData.prices;
         const sortedDates = Object.keys(priceMap).sort((a, b) => a.localeCompare(b));
-        
         return sortedDates.map(date => ({
             date: date,
             price: priceMap[date]
@@ -177,15 +193,12 @@ class HistoryExtractor {
     }
 
     static getTradedAssets(historyDoc) {
-        // 1. Try Modern Granular Data (Derive Assets from Trades)
         if (historyDoc?.PublicHistoryPositions?.length) {
             const trades = historyDoc.PublicHistoryPositions;
             const assetsMap = new Map();
-            
             for (const t of trades) {
                 const instId = t.InstrumentID;
                 if (!instId) continue;
-                
                 if (!assetsMap.has(instId)) {
                     assetsMap.set(instId, { 
                         instrumentId: instId, 
@@ -193,12 +206,10 @@ class HistoryExtractor {
                         count: 0 
                     });
                 }
-                
                 const asset = assetsMap.get(instId);
                 const open = new Date(t.OpenDateTime);
                 const close = new Date(t.CloseDateTime);
                 const durationMins = (close - open) / 60000;
-                
                 if (durationMins > 0) {
                     asset.totalDuration += durationMins;
                     asset.count++;
@@ -209,12 +220,9 @@ class HistoryExtractor {
                 avgHoldingTimeInMinutes: a.count > 0 ? (a.totalDuration / a.count) : 0
             }));
         }
-
-        // 2. Fallback to Legacy 'assets' array
         if (historyDoc?.assets && Array.isArray(historyDoc.assets)) {
             return historyDoc.assets;
         }
-
         return [];
     }
 
@@ -227,7 +235,6 @@ class HistoryExtractor {
     }
 
     static getSummary(historyDoc) { 
-        // 1. Try Modern Granular Data (Derive Summary)
         if (historyDoc?.PublicHistoryPositions?.length) {
             const trades = historyDoc.PublicHistoryPositions;
             let totalTrades = trades.length;
@@ -237,7 +244,6 @@ class HistoryExtractor {
             let profCount = 0;
             let lossCount = 0;
             let totalDur = 0;
-
             for (const t of trades) {
                 if (t.NetProfit > 0) {
                     wins++;
@@ -251,7 +257,6 @@ class HistoryExtractor {
                 const close = new Date(t.CloseDateTime);
                 totalDur += (close - open) / 60000;
             }
-
             return { 
                 totalTrades:             totalTrades,
                 winRatio:                totalTrades > 0 ? (wins / totalTrades) * 100 : 0,
@@ -260,49 +265,20 @@ class HistoryExtractor {
                 avgHoldingTimeInMinutes: totalTrades > 0 ? totalDur / totalTrades : 0
             };
         }
-
-        // 2. Fallback to Legacy 'all' object
         if (historyDoc?.all) {
             return historyDoc.all;
         }
-
         return null;
     }
 }
 
-/**
- * FIXED: InsightsExtractor to properly handle document structure
- * Document structure: { fetchedAt: Timestamp, insights: [...] }
- */
-
 class InsightsExtractor {
-    /**
-     * Gets insights array for today (default) or yesterday
-     * @param {Object} context - Computation context
-     * @param {string} timeframe - 'today' or 'yesterday'
-     * @returns {Array} Array of insight objects
-     */
-
-    // MAJOR FIX TO GET INSIGHTS METHOD FOR THE CORRECT STRUCTURE AND SUPPORTING YESTERDAY + TODAY DATA REQUESTS
-    // THIS IS INJECTED TO BE USED LIKE :
-
-    // process(context) {
-       // const { insights: insightsHelper } = context.math;
-        // const insights = insightsHelper.getInsights(context); This is the direct call
-
     static getInsights(context, timeframe = 'today') {
         const insightsData = context.insights;
-        
         if (!insightsData) return [];
-        
-        // Get the document for the requested timeframe
-        const doc = insightsData[timeframe]; // { fetchedAt: ..., insights: [...] }
-        
+        const doc = insightsData[timeframe];
         if (!doc) return [];
-        
-        // Extract the insights array from the document
         if (doc.insights && Array.isArray(doc.insights)) { return doc.insights; }
-        
         return [];
     }
 

package/functions/computation-system/layers/mathematics.js

@@ -112,93 +112,98 @@ class MathPrimitives {
 }
 
 class FinancialEngineering {
-    /**
-     * Calculates the Sortino Ratio based on a series of trade returns.
-     * Uses Downside Deviation (risk of loss) rather than Standard Deviation (volatility).
-     * @param {number[]} returns - Array of PnL percentages from trades.
-     * @param {number} targetReturn - Minimum acceptable return (default 0).
-     */
     static sortinoRatio(returns, targetReturn = 0) {
         if (!returns || returns.length < 2) return 0;
-        
         const avgReturn = MathPrimitives.average(returns);
-        
-        // Calculate Downside Deviation (only negative deviations from target)
         const downsideDiffs = returns.map(r => Math.min(0, r - targetReturn));
         const downsideVariance = downsideDiffs.reduce((sum, d) => sum + (d * d), 0) / returns.length;
         const downsideDev = Math.sqrt(downsideVariance);
-        
-        if (downsideDev === 0) return 0; // No downside risk found
+        if (downsideDev === 0) return 0;
         return (avgReturn - targetReturn) / downsideDev;
     }
 
-    /**
-     * Calculates the Kelly Criterion (Optimal Leverage Fraction).
-     * f* = (bp - q) / b
-     * @param {number} winRatio - Win Rate (0-100).
-     * @param {number} avgWinPct - Average Win %.
-     * @param {number} avgLossPct - Average Loss % (must be negative or positive magnitude).
-     */
     static kellyCriterion(winRatio, avgWinPct, avgLossPct) {
         const p = winRatio / 100;
         const q = 1 - p;
         const lossMag = Math.abs(avgLossPct);
-        
-        if (lossMag === 0) return 0; // Infinite edge (or divide by zero error)
-        
-        const b = avgWinPct / lossMag; // Payoff odds (b to 1)
-        
-        // Kelly Formula: (bp - q) / b
+        if (lossMag === 0) return 0; 
+        const b = avgWinPct / lossMag; 
         const f = (b * p - q) / b;
-        
-        return Math.max(0, f); // Clamp negative Kelly to 0 (Do not bet)
+        return Math.max(0, f); 
     }
 }
 
 class TimeSeriesAnalysis {
-    /**
-     * Calculates the Hurst Exponent via Rescaled Range (R/S) Analysis.
-     * H = 0.5: Random Walk (Gambler).
-     * H > 0.5: Persistent/Trending (Momentum).
-     * H < 0.5: Anti-Persistent/Mean Reverting (Oscillator).
-     * @param {number[]} series - Time series data (e.g. cumulative PnL or prices).
-     */
     static hurstExponent(series) {
-        if (!series || series.length < 10) return 0.5; // Insufficient data
-
-        // Create logarithmic differences (returns)
+        if (!series || series.length < 10) return 0.5;
         const logReturns = [];
         for (let i = 1; i < series.length; i++) {
             logReturns.push(Math.log(series[i] / series[i-1]));
         }
-
-        // Simplified R/S calculation over full range
         const mean = MathPrimitives.average(logReturns);
         const stdDev = MathPrimitives.standardDeviation(logReturns);
-        
         if (stdDev === 0) return 0.5;
-
-        // Calculate Deviations from mean
         const deviations = logReturns.map(r => r - mean);
-        
-        // Calculate Cumulative Deviations (Cumulative Range)
         let sum = 0;
         const cumulativeDeviations = deviations.map(d => sum += d);
-        
         const maxDev = Math.max(...cumulativeDeviations);
         const minDev = Math.min(...cumulativeDeviations);
         const range = maxDev - minDev;
-        
         const rs = range / stdDev;
         const n = logReturns.length;
-        
-        // H = log(R/S) / log(n)
-        // Note: This is a point-estimate simplification of the full regression method
-        // but sufficient for behavioral classification.
         const hurst = Math.log(rs) / Math.log(n);
-        
         return Math.min(1, Math.max(0, hurst));
     }
+
+    /**
+     * UPGRADE: Fast Fourier Transform (Cooley-Tukey Algorithm) - O(n log n)
+     * Useful for detecting cycles in price data.
+     * @param {Array<number>} data - Input signal
+     * @returns {Array<Object>} Array of { real, imag } complex numbers
+     */
+    static fft(data) {
+        const n = data.length;
+        if (n <= 1) return data.map(v => ({ real: v, imag: 0 }));
+
+        if ((n & (n - 1)) !== 0) {
+            // If n is not power of 2, zero-pad to next power of 2 for O(n log n)
+            const nextPow2 = Math.pow(2, Math.ceil(Math.log2(n)));
+            const padded = new Array(nextPow2).fill(0);
+            for(let i=0; i<n; i++) padded[i] = data[i];
+            return this.fft(padded);
+        }
+
+        const even = new Array(n / 2);
+        const odd = new Array(n / 2);
+        for (let i = 0; i < n / 2; i++) {
+            even[i] = data[2 * i];
+            odd[i] = data[2 * i + 1];
+        }
+
+        const evenResult = this.fft(even);
+        const oddResult = this.fft(odd);
+
+        const result = new Array(n);
+        for (let k = 0; k < n / 2; k++) {
+            const t = -2 * Math.PI * k / n;
+            const expReal = Math.cos(t);
+            const expImag = Math.sin(t);
+            
+            // Multiply oddResult[k] by exp
+            const tReal = expReal * oddResult[k].real - expImag * oddResult[k].imag;
+            const tImag = expReal * oddResult[k].imag + expImag * oddResult[k].real;
+
+            result[k] = {
+                real: evenResult[k].real + tReal,
+                imag: evenResult[k].imag + tImag
+            };
+            result[k + n / 2] = {
+                real: evenResult[k].real - tReal,
+                imag: evenResult[k].imag - tImag
+            };
+        }
+        return result;
+    }
 }
 
 class SignalPrimitives {
@@ -206,7 +211,6 @@ class SignalPrimitives {
         if (!dependencies || !dependencies[calcName]) return fallback;
         const tickerData = dependencies[calcName][ticker];
         if (!tickerData) return fallback;
-        
         const val = tickerData[fieldName];
         return (typeof val === 'number') ? val : fallback;
     }
@@ -241,10 +245,7 @@ class SignalPrimitives {
         if (!previousComputed || !previousComputed[calcName]) return null;
         const tickerData = previousComputed[calcName][ticker];
         if (!tickerData) return null;
-
-        if (fieldName) {
-             return tickerData[fieldName];
-        }
+        if (fieldName) return tickerData[fieldName];
         return tickerData; 
     }
 }
@@ -255,18 +256,14 @@ class Aggregators {
         for (const [userId, portfolio] of Object.entries(usersData)) {
             const userType  = portfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
             const positions = DataExtractor.getPositions(portfolio, userType);
-            
             for (const pos of positions) {
                 const id = DataExtractor.getInstrumentId(pos);
                 const pnl = DataExtractor.getNetProfit(pos);
                 if (!id || pnl === 0) continue;
-                
                 const ticker = tickerMap[id];
                 if (!ticker) continue;
-
                 if (!buckets.has(ticker)) buckets.set(ticker, { winners: [], losers: [] });
                 const b = buckets.get(ticker);
-                
                 if (pnl > 0) b.winners.push(userId);
                 else b.losers.push(userId);
             }
@@ -276,20 +273,16 @@ class Aggregators {
 
     static getWeightedSentiment(positions) {
         if (!positions || positions.length === 0) return 0;
-
         let totalWeightedPnL = 0;
         let totalWeight = 0;
-
         for (const pos of positions) {
             const pnl = DataExtractor.getNetProfit(pos);
             const weight = DataExtractor.getPositionWeight(pos);
-
             if (weight > 0) {
                 totalWeightedPnL += (pnl * weight);
                 totalWeight += weight;
             }
         }
-
         if (totalWeight === 0) return 0;
         return totalWeightedPnL / totalWeight;
     }
@@ -299,61 +292,90 @@ class TimeSeries {
     static updateEMAState(value, state, alpha = 0.1) {
         const mean = state ? (state.mean || 0) : 0;
         const variance = state ? (state.variance || 1) : 1; 
-
         if (value === undefined || value === null || isNaN(value)) {
             return { mean, variance };
         }
-
         const diff = value - mean;
         const newMean = mean + (alpha * diff);
         const newVariance = (1 - alpha) * (variance + (alpha * diff * diff));
-
         return { mean: newMean, variance: newVariance };
     }
 
     static pearsonCorrelation(x, y) {
         if (!x || !y || x.length !== y.length || x.length === 0) return 0;
-        
         const n = x.length;
         let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
-
         for (let i = 0; i < n; i++) {
-            sumX  += x[i];
-            sumY  += y[i];
+            sumX  += x[i]; sumY  += y[i];
             sumXY += x[i] * y[i];
-            sumX2 += x[i] * x[i];
-            sumY2 += y[i] * y[i];
+            sumX2 += x[i] * x[i]; sumY2 += y[i] * y[i];
         }
-
         const numerator   = (n * sumXY) - (sumX * sumY);
         const denominator = Math.sqrt(((n * sumX2) - (sumX * sumX)) * ((n * sumY2) - (sumY * sumY)));
-
         return (denominator === 0) ? 0 : numerator / denominator;
     }
+
+    /**
+     * UPGRADE: Sliding Window Min/Max using Monotonic Queue - O(n)
+     * Calculates rolling min/max for a stream of numbers efficiently.
+     * @param {Array<number>} data - Input series
+     * @param {number} windowSize - The rolling window size
+     * @returns {Object} { min: Array, max: Array }
+     */
+    static slidingWindowExtrema(data, windowSize) {
+        if (!data || data.length === 0) return { min: [], max: [] };
+        const resultMin = [];
+        const resultMax = [];
+        const dequeMin = []; // Indexes for Min (increasing values)
+        const dequeMax = []; // Indexes for Max (decreasing values)
+
+        for (let i = 0; i < data.length; i++) {
+            // 1. Remove out of range
+            if (dequeMin.length > 0 && dequeMin[0] <= i - windowSize) dequeMin.shift();
+            if (dequeMax.length > 0 && dequeMax[0] <= i - windowSize) dequeMax.shift();
+
+            // 2. Maintain Monotonic properties
+            // Min: Remove elements from tail that are >= current
+            while (dequeMin.length > 0 && data[dequeMin[dequeMin.length - 1]] >= data[i]) {
+                dequeMin.pop();
+            }
+            // Max: Remove elements from tail that are <= current
+            while (dequeMax.length > 0 && data[dequeMax[dequeMax.length - 1]] <= data[i]) {
+                dequeMax.pop();
+            }
+
+            // 3. Add current
+            dequeMin.push(i);
+            dequeMax.push(i);
+
+            // 4. Record result (once window is full)
+            if (i >= windowSize - 1) {
+                resultMin.push(data[dequeMin[0]]);
+                resultMax.push(data[dequeMax[0]]);
+            }
+        }
+        return { min: resultMin, max: resultMax };
+    }
 }
 
 class DistributionAnalytics {
     static computeKDE(data, bandwidth, steps = 60) {
         if (!data || data.length === 0) return [];
-
         let min = Infinity, max = -Infinity;
         for (const p of data) {
             if (p.value < min) min = p.value;
             if (p.value > max) max = p.value;
         }
-        
         min -= bandwidth * 3;
         max += bandwidth * 3;
         const stepSize = (max - min) / steps;
         const curve = [];
-
         for (let i = 0; i <= steps; i++) {
             const x = min + (i * stepSize);
             let density = 0;
             for (const p of data) {
                 const diff = (x - p.value);
                 if (Math.abs(diff) > bandwidth * 3) continue;
-                
                 const u = diff / bandwidth;
                 const k = 0.39894228 * Math.exp(-0.5 * u * u); 
                 density += (p.weight * k) / bandwidth;
@@ -364,7 +386,7 @@ class DistributionAnalytics {
     }
 
     static integrateProfile(curve, startPrice, endPrice) {
-        if (!curve || !Array.isArray(curve)) return 0; // Fix for potential crash
+        if (!curve || !Array.isArray(curve)) return 0;
         let sum = 0;
         for (let i = 0; i < curve.length - 1; i++) {
             const p1 = curve[i];
@@ -379,16 +401,12 @@ class DistributionAnalytics {
     static linearRegression(xValues, yValues) {
         const n = xValues.length;
         if (n !== yValues.length || n < 2) return { slope: 0, r2: 0 };
-        
         let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0, sumYY = 0;
         for (let i = 0; i < n; i++) {
-            sumX  += xValues[i];
-            sumY  += yValues[i];
+            sumX  += xValues[i]; sumY  += yValues[i];
             sumXY += xValues[i] * yValues[i];
-            sumXX += xValues[i] * xValues[i];
-            sumYY += yValues[i] * yValues[i];
+            sumXX += xValues[i] * xValues[i]; sumYY += yValues[i] * yValues[i];
         }
-        
         const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
         return { slope, n };
     }

package/functions/computation-system/layers/profiling.js

@@ -21,15 +21,7 @@ const SCHEMAS = {
     }
 };
 
-// ========================================================================
-// 1. SMART MONEY SCORING ENGINE (NEW)
-// ========================================================================
-
 class SmartMoneyScorer {
-
-    /**
-     * Internal Helper: Calculate Pearson Correlation
-     */
     static _correlation(x, y) {
         if (!x || !y || x.length !== y.length || x.length < 2) return 0;
         const n = x.length;
@@ -44,14 +36,6 @@ class SmartMoneyScorer {
         return (denominator === 0) ? 0 : numerator / denominator;
     }
 
-    /**
-     * Mode 1: Portfolio-Based Scoring
-     * Heuristics:
-     * 1. Diversification (Sector/Asset count)
-     * 2. Allocation Efficiency (Correlation of Size vs Profit)
-     * 3. Shorting Competence
-     * 4. Concentration Risk (HHI)
-     */
     static scorePortfolio(portfolio, userType, prices, mappings, math) {
         const positions = math.extract.getPositions(portfolio, userType);
         if (!positions || positions.length === 0) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
@@ -66,10 +50,9 @@ class SmartMoneyScorer {
         const sectors = new Set();
         const tickers = new Set();
 
-        // 1. Data Aggregation
         for (const pos of positions) {
             const invested = math.extract.getPositionWeight(pos, userType);
-            const pnl = math.extract.getNetProfit(pos); // %
+            const pnl = math.extract.getNetProfit(pos); 
             const instId = math.extract.getInstrumentId(pos);
             const isShort = math.extract.getDirection(pos) === 'Sell';
             
@@ -94,56 +77,38 @@ class SmartMoneyScorer {
 
         if (totalInvested === 0) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
 
-        // 2. Metrics Calculation
         const avgPnL = weightedPnL / totalInvested;
-        
-        // A. Allocation Efficiency (Do they bet big on winners?)
-        // Correlation between Invested Amount and PnL %
-        const allocEfficiency = this._correlation(weights, pnls); // -1 to 1
+        const allocEfficiency = this._correlation(weights, pnls);
 
-        // B. Diversification & Concentration (HHI)
-        // Sum of squared market shares. 1.0 = Monopoly. 0.0 = Infinite.
         let hhi = 0;
         for (const w of weights) {
             const share = w / totalInvested;
             hhi += (share * share);
         }
         
-        // C. Shorting Competence
         const shortRatio = shortInvested / totalInvested;
         const avgShortPnL = shortInvested > 0 ? shortPnL / shortInvested : 0;
 
-        // 3. Scoring Logic
         let score = 50; 
 
-        // Efficiency Bonus: If > 0.5, they size winners up. (+20)
-        // If < -0.3, they are bagholding losers with large size (-15)
         if (allocEfficiency > 0.5) score += 20;
         else if (allocEfficiency < -0.3) score -= 15;
 
-        // Profitability (The ultimate metric)
         if (avgPnL > 5) score += 10;
         if (avgPnL > 20) score += 10;
         if (avgPnL < -10) score -= 10;
         if (avgPnL < -25) score -= 15;
 
-        // Concentration Logic
-        // High Concentration (HHI > 0.3) is "Smart" ONLY if profitable (Sniper)
-        // High Concentration and unprofitable is "Dumb" (Bagholder/Gambler)
         if (hhi > 0.3) {
-            if (avgPnL > 5) score += 10; // Sniper
-            else if (avgPnL < -5) score -= 10; // Reckless
+            if (avgPnL > 5) score += 10; 
+            else if (avgPnL < -5) score -= 10; 
         }
 
-        // Diversification Logic
-        // High Sector count (>3) reduces risk penalty
         if (sectors.size >= 4) score += 5;
 
-        // Shorting Logic
-        // Penalize speculation unless they are actually good at it
         if (shortRatio > 0.1) {
-            if (avgShortPnL > 0) score += 10; // Smart Short
-            else score -= 10; // Failed Speculation
+            if (avgShortPnL > 0) score += 10; 
+            else score -= 10; 
         }
 
         return {
@@ -152,33 +117,18 @@ class SmartMoneyScorer {
         };
     }
 
-    /**
-     * Mode 2: History-Based Scoring
-     * Heuristics:
-     * 1. Win/Loss Ratio & Profit Factor
-     * 2. Asset Consistency (Revenge trading vs Specialist)
-     * 3. Entry Efficiency (Buying Lows)
-     * 4. Exit Efficiency (Selling Highs - Opportunity Cost)
-     * 5. Churn (Overtrading)
-     * 6. DCA/Entry Patterns
-     */
     static scoreHistory(historyDoc, prices, mappings, math) {
-        // Handle V2 Schema (PublicHistoryPositions)
         const trades = historyDoc?.PublicHistoryPositions || [];
-        // Handle V1 Schema fallback if needed (though prompt implies V2)
         
         if (trades.length < 5) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
-
-        // Filter valid trades
         const validTrades = trades.filter(t => t.OpenDateTime && t.CloseDateTime && t.InstrumentID);
         if (validTrades.length < 5) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
 
         let wins = 0, losses = 0;
         let totalWinPct = 0, totalLossPct = 0;
         let entryScores = [];
-        const assetsTraded = new Map(); // ID -> { count, pnl }
+        const assetsTraded = new Map(); 
 
-        // Time sorting for Churn analysis
         validTrades.sort((a, b) => new Date(a.OpenDateTime) - new Date(b.OpenDateTime));
         const firstDate = new Date(validTrades[0].OpenDateTime);
         const lastDate = new Date(validTrades[validTrades.length-1].OpenDateTime);
@@ -187,21 +137,17 @@ class SmartMoneyScorer {
         for (const t of validTrades) {
             const ticker = mappings.instrumentToTicker[t.InstrumentID];
             
-            // Asset Consistency
             if (!assetsTraded.has(t.InstrumentID)) assetsTraded.set(t.InstrumentID, { count: 0, pnl: 0 });
             const assetStat = assetsTraded.get(t.InstrumentID);
             assetStat.count++;
             assetStat.pnl += t.NetProfit;
 
-            // A. Win/Loss Stats
             if (t.NetProfit > 0) { wins++; totalWinPct += t.NetProfit; }
             else { losses++; totalLossPct += Math.abs(t.NetProfit); }
 
-            // B. Entry Timing (Requires Price History)
             if (ticker && prices) {
                 const priceHist = math.priceExtractor.getHistory(prices, ticker);
                 if (priceHist && priceHist.length > 0) {
-                    // 1.0 = Perfect Low, 0.0 = Bought High
                     const eff = ExecutionAnalytics.calculateEfficiency(t.OpenRate, priceHist, t.OpenDateTime, t.IsBuy ? 'Buy' : 'Sell');
                     entryScores.push(eff);
                 }
@@ -212,45 +158,33 @@ class SmartMoneyScorer {
         const avgLoss = losses > 0 ? totalLossPct / losses : 1;
         const profitFactor = (wins * avgWin) / Math.max(1, (losses * avgLoss));
         
-        // C. Entry Skill
         const avgEntrySkill = entryScores.length > 0 ? math.compute.average(entryScores) : 0.5;
 
-        // D. Consistency / Specialization
-        // Do they trade 100 tickers once (Gambler) or 5 tickers 20 times (Specialist)?
         const totalTrades = validTrades.length;
         const uniqueAssets = assetsTraded.size;
-        const specializationRatio = 1 - (uniqueAssets / totalTrades); // Higher = More specialized
+        const specializationRatio = 1 - (uniqueAssets / totalTrades);
 
-        // E. Overtrading (Churn)
         const tradesPerDay = totalTrades / daysActive;
 
-        // F. Revenge Trading Check
-        // High count on a specific asset with negative total PnL
         let revengeScore = 0;
         for (const [id, stat] of assetsTraded.entries()) {
             if (stat.pnl < -20 && stat.count > 5) revengeScore += 1;
         }
 
-        // Scoring Logic
         let score = 50;
 
-        // Profit Factor (Primary Driver)
         if (profitFactor > 1.2) score += 10;
         if (profitFactor > 2.0) score += 15;
         if (profitFactor < 0.8) score -= 15;
 
-        // Entry Efficiency
-        if (avgEntrySkill > 0.7) score += 10; // Sniper
-        if (avgEntrySkill < 0.3) score -= 10; // FOMO
+        if (avgEntrySkill > 0.7) score += 10; 
+        if (avgEntrySkill < 0.3) score -= 10; 
 
-        // Specialization
-        if (specializationRatio > 0.6) score += 5; // Specialist bonus
-        if (specializationRatio < 0.1 && totalTrades > 20) score -= 5; // Scattergun penalty
+        if (specializationRatio > 0.6) score += 5; 
+        if (specializationRatio < 0.1 && totalTrades > 20) score -= 5; 
 
-        // Churn Penalty
-        if (tradesPerDay > 10 && profitFactor < 1.0) score -= 10; // Brokerage Cash Cow
+        if (tradesPerDay > 10 && profitFactor < 1.0) score -= 10; 
 
-        // Revenge Penalty
         if (revengeScore > 0) score -= (revengeScore * 5);
 
         return {
@@ -259,14 +193,9 @@ class SmartMoneyScorer {
         };
     }
 
-    /**
-     * Mode 3: Hybrid Scoring
-     * Merges Portfolio (Unrealized/Current) and History (Realized/Past).
-     */
     static scoreHybrid(context) {
         const { user, prices, mappings, math } = context;
         
-        // Get Sub-Scores
         const pScore = this.scorePortfolio(user.portfolio.today, user.type, prices, mappings, math);
         const hScore = this.scoreHistory(user.history.today, prices, mappings, math);
 
@@ -277,7 +206,6 @@ class SmartMoneyScorer {
         const hasPortfolio = pScore && pScore.score > 0;
 
         if (hasHistory && hasPortfolio) {
-            // Weighted: 60% Track Record (History), 40% Current Positioning (Portfolio)
             finalScore = (hScore.score * 0.6) + (pScore.score * 0.4);
             method = 'Hybrid';
         } else if (hasHistory) {
@@ -288,7 +216,6 @@ class SmartMoneyScorer {
             method = 'PortfolioOnly';
         }
 
-        // Classification Label
         let label = SCHEMAS.LABELS.NEUTRAL;
         if (finalScore >= 80) label = SCHEMAS.LABELS.ELITE;
         else if (finalScore >= 65) label = SCHEMAS.LABELS.SMART;
@@ -307,10 +234,6 @@ class SmartMoneyScorer {
     }
 }
 
-// ========================================================================
-// 2. SUPPORTING ANALYTICS ENGINES
-// ========================================================================
-
 class CognitiveBiases {
     static calculateAnchoringScore(openPositions, thresholdPct = 2.0, minDaysHeld = 14) {
         if (!openPositions || openPositions.length === 0) return 0;
@@ -376,6 +299,49 @@ class ExecutionAnalytics {
     }
 }
 
+/**
+ * UPGRADE: Risk Geometry Class
+ * Contains Convex Hull (Monotone Chain) for Efficient Frontier analysis.
+ */
+class RiskGeometry {
+    static crossProduct(o, a, b) {
+        return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+    }
+
+    /**
+     * Computes the Convex Hull of a set of 2D points using Monotone Chain algorithm.
+     * @param {Array<{x: number, y: number}>} points
+     * @returns {Array<{x: number, y: number}>} Points on the hull
+     */
+    static computeConvexHull(points) {
+        if (points.length <= 1) return points;
+        
+        // Sort by x coordinate (and y if x is same)
+        points.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
+
+        const lower = [];
+        for (const p of points) {
+            while (lower.length >= 2 && this.crossProduct(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+                lower.pop();
+            }
+            lower.push(p);
+        }
+
+        const upper = [];
+        for (let i = points.length - 1; i >= 0; i--) {
+            const p = points[i];
+            while (upper.length >= 2 && this.crossProduct(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+                upper.pop();
+            }
+            upper.push(p);
+        }
+
+        upper.pop();
+        lower.pop();
+        return lower.concat(upper);
+    }
+}
+
 class Psychometrics {
     static computeDispositionSkew(historyTrades, currentPositions) {
         const getMedian = (arr) => { if (!arr.length) return 0; const sorted = [...arr].sort((a, b) => a - b); const mid = Math.floor(sorted.length / 2); return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2; };
@@ -413,20 +379,16 @@ class AdaptiveAnalytics {
     }
 }
 
-// Legacy Wrapper for backward compatibility with older calculations
 class UserClassifier {
     static classify(context) {
-        // Delegate to the new robust Hybrid Scorer
         const result = SmartMoneyScorer.scoreHybrid(context);
-        
-        // Map new result structure to legacy structure expected by V1 calcs
         return {
             intelligence: { 
                 label: result.label, 
                 score: result.totalScore, 
                 isSmart: result.totalScore >= 65 
             },
-            style: { primary: SCHEMAS.STYLES.INVESTOR }, // Placeholder
+            style: { primary: SCHEMAS.STYLES.INVESTOR }, 
             metrics: {
                 profitFactor: result.components.history?.metrics?.profitFactor || 0,
                 allocEfficiency: result.components.portfolio?.metrics?.allocEfficiency || 0
@@ -438,10 +400,11 @@ class UserClassifier {
 module.exports = { 
     SCHEMAS, 
     UserClassifier,
-    SmartMoneyScorer, // <-- Exporting the new engine
+    SmartMoneyScorer, 
     ExecutionAnalytics,
     Psychometrics,
     AdaptiveAnalytics,
     CognitiveBiases,
-    SkillAttribution
+    SkillAttribution,
+    RiskGeometry
 };

package/functions/computation-system/workflows/bulltrackers_pipeline.yaml

@@ -49,7 +49,6 @@ main:
                             severity: "INFO"
 
                       # 1. TRIGGER DISPATCHER (Fire and Forget mechanism via HTTP)
-                      # The dispatcher analyzes missing data and queues tasks.
                       - trigger_dispatcher:
                           call: http.get
                           args:
@@ -62,7 +61,6 @@ main:
                           result: dispatch_response
 
                       # 2. PROPAGATION WAIT
-                      # Wait for dispatcher to queue tasks and workers to start/finish
                       - wait_for_propagation:
                           call: sys.log
                           args:
@@ -75,7 +73,6 @@ main:
                             seconds: ${propagation_wait_seconds}
 
                       # 3. MONITORING LOOP
-                      # Poll until RUNNING state clears
                       - monitor_loop:
                           call: http.get
                           args:
@@ -100,7 +97,8 @@ main:
                                     call: sys.sleep
                                     args:
                                       seconds: 60
-                                - next: monitor_loop
+                                - continue_monitoring:
+                                    next: monitor_loop
 
                             # CASE B: Clean Success -> Mark done, Break Retry Loop
                             - condition: ${status_resp.body.state == "SUCCESS"}
@@ -113,7 +111,8 @@ main:
                                 - mark_success:
                                     assign:
                                       - pass_success: true
-                                - next: pass_retry_loop # Will exit loop due to pass_success=true
+                                - proceed_to_next_pass:
+                                    next: pass_retry_loop # Exits inner loop because pass_success is now true
 
                             # CASE C: Failures Found -> Continue Retry Loop (will trigger dispatcher again)
                             - condition: ${status_resp.body.state == "HAS_FAILURES"}
@@ -123,7 +122,8 @@ main:
                                     args:
                                       text: ${"Pass " + pass_id + " has " + status_resp.body.failureCount + " FAILURES. Attempting Retry."}
                                       severity: "WARNING"
-                                - next: pass_retry_loop
+                                - retry_pass:
+                                    next: pass_retry_loop
 
             # -----------------------------------------------
             # END RETRY LOOP

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.285",
+  "version": "1.0.287",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [