bulltrackers-module 1.0.263 → 1.0.265

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

@@ -1,6 +1,7 @@
 /**
- * @fileoverview Profiling Layer - Intelligence Engine (V5)
+ * @fileoverview Profiling Layer - Intelligence Engine (V6)
  * Encapsulates advanced behavioral profiling, psychological scoring, and classification schemas.
+ * UPDATED: Added SmartMoneyScorer for advanced multi-factor user classification.
  */
 
 const SCHEMAS = {
@@ -21,118 +22,332 @@ const SCHEMAS = {
 };
 
 // ========================================================================
-// 1. BEHAVIORAL ANALYTICS ENGINES
+// 1. SMART MONEY SCORING ENGINE (NEW)
 // ========================================================================
 
-class CognitiveBiases {
+class SmartMoneyScorer {
+
     /**
-     * Anchoring Bias Detector.
-     * Checks if the user holds "dead money" positions that are hovering near breakeven
-     * for extended periods, refusing to close them.
-     * @param {Array} openPositions - Current holdings. Needs OpenDateTime (Speculators).
-     * @param {number} thresholdPct - +/- % range around 0 PnL (e.g. 2%).
-     * @param {number} minDaysHeld - Minimum days held to qualify as "Anchored".
+     * Internal Helper: Calculate Pearson Correlation
      */
-    static calculateAnchoringScore(openPositions, thresholdPct = 2.0, minDaysHeld = 14) {
-        if (!openPositions || openPositions.length === 0) return 0;
+    static _correlation(x, y) {
+        if (!x || !y || x.length !== y.length || x.length < 2) 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];
+            sumXY += x[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;
+    }
+
+    /**
+     * 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 };
+
+        let totalInvested = 0;
+        let weightedPnL = 0;
+        let shortInvested = 0;
+        let shortPnL = 0;
         
-        let anchoredCount = 0;
-        let validPositions = 0;
-        const now = Date.now();
-        const msPerDay = 86400000;
+        const weights = [];
+        const pnls = [];
+        const sectors = new Set();
+        const tickers = new Set();
 
-        for (const pos of openPositions) {
-            // Only applicable if we have OpenDateTime (Speculator Schema)
-            if (pos.OpenDateTime) {
-                validPositions++;
-                const ageDays = (now - new Date(pos.OpenDateTime).getTime()) / msPerDay;
+        // 1. Data Aggregation
+        for (const pos of positions) {
+            const invested = math.extract.getPositionWeight(pos, userType);
+            const pnl = math.extract.getNetProfit(pos); // %
+            const instId = math.extract.getInstrumentId(pos);
+            const isShort = math.extract.getDirection(pos) === 'Sell';
+            
+            const sector = mappings.instrumentToSector[instId];
+            const ticker = mappings.instrumentToTicker[instId];
+
+            if (invested > 0) {
+                totalInvested += invested;
+                weightedPnL += (pnl * invested);
+                weights.push(invested);
+                pnls.push(pnl);
                 
-                // Is the trade old AND hovering near 0% PnL?
-                if (ageDays > minDaysHeld && Math.abs(pos.NetProfit) < thresholdPct) {
-                    anchoredCount++;
+                if (sector) sectors.add(sector);
+                if (ticker) tickers.add(ticker);
+
+                if (isShort) {
+                    shortInvested += invested;
+                    shortPnL += (pnl * invested);
                 }
             }
         }
+
+        if (totalInvested === 0) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
+
+        // 2. Metrics Calculation
+        const avgPnL = weightedPnL / totalInvested;
         
-        return validPositions > 0 ? (anchoredCount / validPositions) : 0;
+        // A. Allocation Efficiency (Do they bet big on winners?)
+        // Correlation between Invested Amount and PnL %
+        const allocEfficiency = this._correlation(weights, pnls); // -1 to 1
+
+        // 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
+        }
+
+        // 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
+        }
+
+        return {
+            score: Math.max(0, Math.min(100, score)),
+            metrics: { allocEfficiency, hhi, avgPnL, shortRatio, sectorCount: sectors.size }
+        };
     }
 
     /**
-     * Disposition Effect (Loss Aversion in Time Domain).
-     * Calculates ratio of Avg Hold Time (Losers) / Avg Hold Time (Winners).
-     * Value > 1.0 means they hold losers longer than winners (Bad).
+     * 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 calculateDispositionEffect(historyTrades) {
-        let winDur = 0, winCount = 0;
-        let lossDur = 0, lossCount = 0;
+    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 };
 
-        for (const t of historyTrades) {
-            if (!t.OpenDateTime || !t.CloseDateTime) continue;
-            
-            const dur = (new Date(t.CloseDateTime) - new Date(t.OpenDateTime)) / 3600000; // Hours
+        // 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 }
+
+        // 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);
+        const daysActive = Math.max(1, (lastDate - firstDate) / 86400000);
+
+        for (const t of validTrades) {
+            const ticker = mappings.instrumentToTicker[t.InstrumentID];
             
-            if (t.NetProfit > 0) {
-                winDur += dur;
-                winCount++;
-            } else if (t.NetProfit < 0) {
-                lossDur += dur;
-                lossCount++;
+            // 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);
+                }
             }
         }
 
-        const avgWinHold = winCount > 0 ? winDur / winCount : 0;
-        const avgLossHold = lossCount > 0 ? lossDur / lossCount : 0;
+        const avgWin = wins > 0 ? totalWinPct / wins : 0;
+        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;
 
-        if (avgWinHold === 0) return 2.0; // Infinite bias if they never hold winners
-        return avgLossHold / avgWinHold;
+        // 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
+
+        // 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
+
+        // Specialization
+        if (specializationRatio > 0.6) score += 5; // Specialist bonus
+        if (specializationRatio < 0.1 && totalTrades > 20) score -= 5; // Scattergun penalty
+
+        // Churn Penalty
+        if (tradesPerDay > 10 && profitFactor < 1.0) score -= 10; // Brokerage Cash Cow
+
+        // Revenge Penalty
+        if (revengeScore > 0) score -= (revengeScore * 5);
+
+        return {
+            score: Math.max(0, Math.min(100, score)),
+            metrics: { profitFactor, avgEntrySkill, specializationRatio, tradesPerDay, revengeScore }
+        };
     }
 
     /**
-     * Prospect Theory Utility Function (Kahneman/Tversky).
-     * Models the psychological "utility" (pain/pleasure) of a return.
-     * Losses hurt approx 2.25x more than gains feel good.
-     * @param {number} pnl - Net Profit %.
+     * Mode 3: Hybrid Scoring
+     * Merges Portfolio (Unrealized/Current) and History (Realized/Past).
      */
-    static prospectUtility(pnl, lambda = 2.25, alpha = 0.88) {
-        if (pnl >= 0) {
-            return Math.pow(pnl, alpha);
-        } else {
-            return -lambda * Math.pow(Math.abs(pnl), alpha);
+    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);
+
+        let finalScore = 50;
+        let method = 'Neutral';
+
+        const hasHistory = hScore && hScore.score > 0;
+        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) {
+            finalScore = hScore.score;
+            method = 'HistoryOnly';
+        } else if (hasPortfolio) {
+            finalScore = pScore.score;
+            method = 'PortfolioOnly';
+        }
+
+        // Classification Label
+        let label = SCHEMAS.LABELS.NEUTRAL;
+        if (finalScore >= 80) label = SCHEMAS.LABELS.ELITE;
+        else if (finalScore >= 65) label = SCHEMAS.LABELS.SMART;
+        else if (finalScore <= 35) label = SCHEMAS.LABELS.GAMBLER;
+        else if (finalScore <= 50) label = SCHEMAS.LABELS.DUMB;
+
+        return {
+            totalScore: Math.round(finalScore),
+            label: label,
+            method: method,
+            components: {
+                portfolio: pScore,
+                history: hScore
+            }
+        };
+    }
+}
+
+// ========================================================================
+// 2. SUPPORTING ANALYTICS ENGINES
+// ========================================================================
+
+class CognitiveBiases {
+    static calculateAnchoringScore(openPositions, thresholdPct = 2.0, minDaysHeld = 14) {
+        if (!openPositions || openPositions.length === 0) return 0;
+        let anchoredCount = 0, validPositions = 0;
+        const now = Date.now(), msPerDay = 86400000;
+        for (const pos of openPositions) {
+            if (pos.OpenDateTime) {
+                validPositions++;
+                const ageDays = (now - new Date(pos.OpenDateTime).getTime()) / msPerDay;
+                if (ageDays > minDaysHeld && Math.abs(pos.NetProfit) < thresholdPct) { anchoredCount++; }
+            }
+        }
+        return validPositions > 0 ? (anchoredCount / validPositions) : 0;
+    }
+
+    static calculateDispositionEffect(historyTrades) {
+        let winDur = 0, winCount = 0, lossDur = 0, lossCount = 0;
+        for (const t of historyTrades) {
+            if (!t.OpenDateTime || !t.CloseDateTime) continue;
+            const dur = (new Date(t.CloseDateTime) - new Date(t.OpenDateTime)) / 3600000; 
+            if (t.NetProfit > 0) { winDur += dur; winCount++; } else if (t.NetProfit < 0) { lossDur += dur; lossCount++; }
         }
+        const avgWinHold = winCount > 0 ? winDur / winCount : 0;
+        const avgLossHold = lossCount > 0 ? lossDur / lossCount : 0;
+        if (avgWinHold === 0) return 2.0; 
+        return avgLossHold / avgWinHold;
     }
 }
 
 class SkillAttribution {
-    /**
-     * Calculates Selection Skill (Alpha) by comparing User PnL vs Asset Benchmark.
-     * Note: Since we don't have individual asset performance histories easily available
-     * in the user context, we use the 'Insights' global growth as a daily benchmark proxy.
-     * @param {Array} userPositions - Current open positions.
-     * @param {Object} dailyInsights - Map of InstrumentID -> Insight Data (which contains 'growth').
-     */
     static calculateSelectionAlpha(userPositions, dailyInsights) {
-        let totalAlpha = 0;
-        let count = 0;
-
+        let totalAlpha = 0, count = 0;
         for (const pos of userPositions) {
             const instrumentId = pos.InstrumentID;
-            // Note: Schema 5 (Insights) is an array, we assume it's converted to a map or we find it.
-            // If passed as array, we find the item.
-            let insight = null;
-            if (Array.isArray(dailyInsights)) {
-                insight = dailyInsights.find(i => i.instrumentId === instrumentId);
-            }
-
+            let insight = Array.isArray(dailyInsights) ? dailyInsights.find(i => i.instrumentId === instrumentId) : null;
             if (insight && typeof insight.growth === 'number') {
-                // User PnL for today isn't explicitly stored, but Total PnL is.
-                // We use NetProfit as a proxy for "Performance" state.
-                // A Better proxy: Is their NetProfit > The Asset's Weekly Growth?
-                // This is a rough heuristic given schema limitations.
-                
-                // If the user is long and PnL > 0, and Growth is negative, that's high alpha (Bucking the trend).
-                // Simplified: Just returning the difference.
-                const diff = pos.NetProfit - insight.growth;
-                totalAlpha += diff;
+                totalAlpha += (pos.NetProfit - insight.growth);
                 count++;
             }
         }
@@ -198,90 +413,35 @@ class AdaptiveAnalytics {
     }
 }
 
+// Legacy Wrapper for backward compatibility with older calculations
 class UserClassifier {
     static classify(context) {
-        const { user, math, prices } = context;
-        const history = user.history.today?.PublicHistoryPositions || [];
-        const validHistory = history.filter(t => t.OpenDateTime);
-        validHistory.sort((a, b) => new Date(a.OpenDateTime) - new Date(b.OpenDateTime));
-        const portfolio = math.extract.getPositions(user.portfolio.today, user.type);
-        const summary = math.history.getSummary(user.history.today);
-        if (!summary) return { intelligence: { label: SCHEMAS.LABELS.NEUTRAL, score: 0 }, style: { primary: SCHEMAS.STYLES.INVESTOR } };
-
-        let entryScores = [];
-        const recentTrades = validHistory.slice(-20); 
-        for (const t of recentTrades) {
-            const ticker = context.mappings.instrumentToTicker[t.InstrumentID];
-            const priceData = math.priceExtractor.getHistory(prices, ticker);
-            if (priceData && priceData.length > 0) { entryScores.push(ExecutionAnalytics.calculateEfficiency(t.OpenRate, priceData, t.OpenDateTime, 'Buy')); }
-        }
-        const avgEntryEff = math.compute.average(entryScores) || 0.5;
-        const dispositionSkew = Psychometrics.computeDispositionSkew(validHistory, portfolio);
-        const revengeScore = Psychometrics.detectRevengeTrading(validHistory);
-        const adaptationScore = AdaptiveAnalytics.analyzeDrawdownAdaptation(validHistory);
-        
-        // New Cognitive Bias Checks
-        const anchoring = CognitiveBiases.calculateAnchoringScore(portfolio);
-        const dispositionTime = CognitiveBiases.calculateDispositionEffect(validHistory);
-
-        const riskAdjustedReturn = summary.avgLossPct === 0 ? 10 : (summary.avgProfitPct / Math.abs(summary.avgLossPct));
-        let smartScore = 50; 
-        if (riskAdjustedReturn > 1.5) smartScore += 10;
-        if (riskAdjustedReturn > 3.0) smartScore += 10;
-        if (summary.winRatio > 60) smartScore += 10;
-        if (avgEntryEff > 0.7) smartScore += 10; 
-        if (avgEntryEff < 0.3) smartScore -= 5;  
-        if (dispositionSkew > 15) smartScore -= 20; else if (dispositionSkew < 5) smartScore += 10; 
-        if (revengeScore > 0.3) smartScore -= 25; 
-        if (adaptationScore > 0.5) smartScore += 5; if (adaptationScore < -0.5) smartScore -= 10; 
+        // Delegate to the new robust Hybrid Scorer
+        const result = SmartMoneyScorer.scoreHybrid(context);
         
-        // Penalty for biases
-        if (anchoring > 0.3) smartScore -= 10;
-        if (dispositionTime > 1.5) smartScore -= 10;
-
-        let label = SCHEMAS.LABELS.NEUTRAL;
-        if (smartScore >= 80) label = SCHEMAS.LABELS.ELITE;
-        else if (smartScore >= 65) label = SCHEMAS.LABELS.SMART;
-        else if (smartScore <= 30) label = SCHEMAS.LABELS.GAMBLER;
-        else if (smartScore <= 45) label = SCHEMAS.LABELS.DUMB;
-
-        const styleProfile = this.classifyStyle(validHistory, portfolio);
+        // Map new result structure to legacy structure expected by V1 calcs
         return {
-            intelligence: { label: label, score: Math.max(0, Math.min(100, smartScore)), isSmart: smartScore >= 65 },
-            style: styleProfile,
+            intelligence: { 
+                label: result.label, 
+                score: result.totalScore, 
+                isSmart: result.totalScore >= 65 
+            },
+            style: { primary: SCHEMAS.STYLES.INVESTOR }, // Placeholder
             metrics: {
-                entryEfficiency: avgEntryEff,
-                dispositionSkew: dispositionSkew,
-                revengeTendency: revengeScore,
-                riskRewardRatio: riskAdjustedReturn,
-                drawdownAdaptation: adaptationScore,
-                biasAnchoring: anchoring,
-                biasDispositionTime: dispositionTime
+                profitFactor: result.components.history?.metrics?.profitFactor || 0,
+                allocEfficiency: result.components.portfolio?.metrics?.allocEfficiency || 0
             }
         };
     }
-
-    static classifyStyle(history, portfolio) {
-        let totalMinutes = 0; let validTrades = 0;
-        history.forEach(t => { if (t.OpenDateTime && t.CloseDateTime) { const open = new Date(t.OpenDateTime); const close = new Date(t.CloseDateTime); totalMinutes += (close - open) / 60000; validTrades++; } });
-        const avgHoldTime = validTrades > 0 ? totalMinutes / validTrades : 0;
-        let baseStyle = SCHEMAS.STYLES.INVESTOR;
-        if (validTrades > 0) { if (avgHoldTime < 60) baseStyle = SCHEMAS.STYLES.SCALPER; else if (avgHoldTime < 60 * 24) baseStyle = SCHEMAS.STYLES.DAY_TRADER; else if (avgHoldTime < 60 * 24 * 7) baseStyle = SCHEMAS.STYLES.SWING_TRADER; }
-        const subStyles = new Set();
-        const assets = [...history, ...portfolio]; let leverageCount = 0;
-        assets.forEach(p => { if ((p.Leverage || 1) > 1) leverageCount++; });
-        const tradeCount = assets.length || 1;
-        if ((leverageCount / tradeCount) > 0.3) subStyles.add("Speculative"); if ((leverageCount / tradeCount) > 0.8) subStyles.add("High-Leverage");
-        return { primary: baseStyle, tags: Array.from(subStyles), avgHoldTimeMinutes: avgHoldTime };
-    }
 }
 
 module.exports = { 
     SCHEMAS, 
     UserClassifier,
+    SmartMoneyScorer, // <-- Exporting the new engine
     ExecutionAnalytics,
     Psychometrics,
     AdaptiveAnalytics,
-    CognitiveBiases, // New
-    SkillAttribution // New
+    CognitiveBiases,
+    SkillAttribution
 };

package/functions/computation-system/persistence/FirestoreUtils.js

@@ -42,18 +42,10 @@ async function commitBatchInChunks(config, deps, writes, operationName) {
     for (const write of writes) {
         let docSize = 100;
         try { if (write.data) docSize = JSON.stringify(write.data).length; } catch (e) { }
-
-        if (docSize > 900 * 1024) {
-            logger.log('WARN', `[${operationName}] Large document detected (~${(docSize / 1024).toFixed(2)} KB).`);
-        }
-
-        if ((currentOpsCount + 1 > MAX_BATCH_OPS) || (currentBytesEst + docSize > MAX_BATCH_BYTES)) {
-            await commitAndReset();
-        }
-
+        if (docSize > 900 * 1024) { logger.log('WARN', `[${operationName}] Large document detected (~${(docSize / 1024).toFixed(2)} KB).`); }
+        if ((currentOpsCount + 1 > MAX_BATCH_OPS) || (currentBytesEst + docSize > MAX_BATCH_BYTES)) { await commitAndReset(); }
         const options = write.options || { merge: true };
         currentBatch.set(write.ref, write.data, options);
-        
         currentOpsCount++;
         currentBytesEst += docSize;
     }