bulltrackers-module 1.0.262 → 1.0.264

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

@@ -2,14 +2,15 @@
  * @fileoverview Handles saving computation results with observability and Smart Cleanup.
  * UPDATED: Returns detailed failure reports AND metrics for the Audit Logger.
  * UPDATED: Stops retrying on non-transient errors.
+ * UPDATED: Supports Multi-Date Fan-Out (Time Machine Mode) with CONCURRENCY THROTTLING.
  */
 const { commitBatchInChunks }              = require('./FirestoreUtils');
 const { updateComputationStatus }          = require('./StatusRepository');
 const { batchStoreSchemas }                = require('../utils/schema_capture');
 const { generateProcessId, PROCESS_TYPES } = require('../logger/logger');
-
 const { HeuristicValidator }               = require('./ResultsValidator');
 const validationOverrides                  = require('../config/validation_overrides'); 
+const pLimit                               = require('p-limit'); // <--- CRITICAL IMPORT
 
 const NON_RETRYABLE_ERRORS = [
     'INVALID_ARGUMENT',      // Schema/Type mismatch
@@ -26,7 +27,8 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     const { logger, db } = deps;
     const pid            = generateProcessId(PROCESS_TYPES.STORAGE, passName, dStr);
     
-    const passNum = passName.replace(/[^0-9]/g, '');
+    // SAFETY LIMIT: Only allow 10 concurrent daily writes to prevent network saturation during Fan-Out
+    const fanOutLimit = pLimit(10); 
 
     for (const name in stateObj) {
         const calc = stateObj[name];
@@ -44,144 +46,88 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
             const healthCheck = HeuristicValidator.analyze(calc.manifest.name, result, overrides);
 
             if (!healthCheck.valid) {
-                // If validation failed, we consider it an anomaly but we BLOCK the write (throw error)
                 runMetrics.validation.isValid = false;
                 runMetrics.validation.anomalies.push(healthCheck.reason);
                 throw { message: healthCheck.reason, stage: 'QUALITY_CIRCUIT_BREAKER' };
             }
             
-            // Check for minor anomalies (validation warnings that didn't fail) - optional implementation
-            // For now, we assume if valid=true, anomalies are empty unless we add warning logic later.
-
             const isEmpty = !result || (typeof result === 'object' && Object.keys(result).length === 0) || (typeof result === 'number' && result === 0);
             if (isEmpty) { 
-                // Log empty success
                 if (calc.manifest.hash) { 
-                    successUpdates[name] = {  
-                        hash: false,  
-                        category: calc.manifest.category,
-                        metrics: runMetrics // Return empty metrics
-                    }; 
+                    successUpdates[name] = { hash: false, category: calc.manifest.category, metrics: runMetrics }; 
                 } 
                 continue; 
             }
             
-            // Calculate Key Count rough estimate
             if (typeof result === 'object') runMetrics.storage.keys = Object.keys(result).length;
 
-            const mainDocRef = db.collection(config.resultsCollection)
-                .doc(dStr)
-                .collection(config.resultsSubcollection)
-                .doc(calc.manifest.category)
-                .collection(config.computationsSubcollection)
-                .doc(name);
-
-            // --- REACTIVE SELF-HEALING LOOP ---
-            let committed = false;
-            // Strategy: 1=Normal, 2=Safe (Halved), 3=Aggressive (Quartered + Key Limit)
-            const strategies = [
-                { bytes: 900 * 1024, keys: null },      // Attempt 1: Standard
-                { bytes: 450 * 1024, keys: 10000 },     // Attempt 2: High Index usage
-                { bytes: 200 * 1024, keys: 2000 }       // Attempt 3: Extreme fragmentation
-            ];
-
-            let lastError = null;
-
-            for (let attempt = 0; attempt < strategies.length; attempt++) {
-                if (committed) break;
+            // --- MULTI-DATE FAN-OUT DETECTION ---
+            // If the result keys are ALL date strings (YYYY-MM-DD), we split the writes.
+            const resultKeys = Object.keys(result || {});
+            const isMultiDate = resultKeys.length > 0 && resultKeys.every(k => /^\d{4}-\d{2}-\d{2}$/.test(k));
+
+            if (isMultiDate) {
+                logger.log('INFO', `[ResultCommitter] 🕰️ Multi-Date Output detected for ${name} (${resultKeys.length} days). Throttled Fan-Out...`);
                 
-                const constraints = strategies[attempt];
+                // Group updates by DATE. result is { "2024-01-01": { user1: ... }, "2024-01-02": { user1: ... } }
+                // We execute a fan-out commit for each date using p-limit.
                 
-                try {
-                    // 1. Prepare Shards with current constraints
-                    // This function now needs to help us determine sharding info
-                    const updates = await prepareAutoShardedWrites(result, mainDocRef, logger, constraints.bytes, constraints.keys);
-                    
-                    // METRICS CALCULATION
-                    const pointer = updates.find(u => u.data._completed === true);
-                    const isSharded = pointer && pointer.data._sharded === true;
-                    const shardCount = isSharded ? (pointer.data._shardCount || 1) : 1;
-                    const totalSize = updates.reduce((acc, u) => acc + (u.data ? JSON.stringify(u.data).length : 0), 0);
-                    
-                    runMetrics.storage.sizeBytes = totalSize;
-                    runMetrics.storage.isSharded = isSharded;
-                    runMetrics.storage.shardCount = shardCount;
-
-                    // 2. Audit Ledger (Only add to the first update batch)
-                    if (passNum && calc.manifest) {
-                        const ledgerRef = db.collection(`computation_audit_ledger/${dStr}/passes/${passNum}/tasks`).doc(name);
-                        updates.push({
-                            ref: ledgerRef,
-                            data: {
-                                status: 'COMPLETED',
-                                completedAt: new Date(),
-                                actualHash: calc.manifest.hash,
-                                _verified: true,
-                                _shardingStrategy: attempt + 1
-                            },
-                            options: { merge: true }
-                        });
-                    }
-
-                    // 3. Attempt Commit
-                    await commitBatchInChunks(config, deps, updates, `${name} Results (Att ${attempt+1})`);
-                    
-                    // Log Success
-                    if (logger && logger.logStorage) { 
-                        logger.logStorage(pid, name, dStr, mainDocRef.path, totalSize, isSharded); 
-                    }
-                    
-                    committed = true; // Exit loop
-
-                } catch (commitErr) {
-                    lastError = commitErr;
-                    const msg = commitErr.message || '';
-                    
-                    const isNonRetryable = NON_RETRYABLE_ERRORS.includes(commitErr.code);
-                    if (isNonRetryable) {
-                        logger.log('ERROR', `[SelfHealing] ${name} encountered FATAL error (Attempt ${attempt + 1}): ${msg}. Aborting.`);
-                        throw commitErr; 
-                    }
-
-                    const isSizeError  = msg.includes('Transaction too big')    || msg.includes('payload is too large');
-                    const isIndexError = msg.includes('too many index entries') || msg.includes('INVALID_ARGUMENT'); 
-
-                    if (isSizeError || isIndexError) {
-                        logger.log('WARN', `[SelfHealing] ${name} failed write attempt ${attempt + 1}. Retrying with tighter constraints...`, { error: msg });
-                        continue; // Try next strategy
-                    } else {
-                        logger.log('WARN', `[SelfHealing] ${name} unknown error (Attempt ${attempt + 1}). Retrying...`, { error: msg });
-                    }
+                const datePromises = resultKeys.map((historicalDate) => fanOutLimit(async () => {
+                    const dailyData = result[historicalDate];
+                    if (!dailyData || Object.keys(dailyData).length === 0) return;
+
+                    const historicalDocRef = db.collection(config.resultsCollection)
+                        .doc(historicalDate) // Use the HISTORICAL date, not dStr
+                        .collection(config.resultsSubcollection)
+                        .doc(calc.manifest.category)
+                        .collection(config.computationsSubcollection)
+                        .doc(name);
+
+                    // Re-use the existing sharding logic for this specific date payload
+                    await writeSingleResult(dailyData, historicalDocRef, name, historicalDate, logger, config, deps);
+                }));
+                
+                await Promise.all(datePromises);
+                
+                // Mark success for the Target Date (dStr) so the workflow continues
+                if (calc.manifest.hash) { 
+                    successUpdates[name] = {  
+                        hash: calc.manifest.hash, 
+                        category: calc.manifest.category, 
+                        metrics: runMetrics // Pass metrics up
+                    }; 
                 }
-            }
 
-            if (!committed) {
-                throw { 
-                    message: `Exhausted sharding strategies. Last error: ${lastError?.message}`, 
-                    stack: lastError?.stack, 
-                    stage: 'SHARDING_LIMIT_EXCEEDED' 
-                };
-            }
-            // ----------------------------------
-
-            // Mark Success & Pass Metrics
-            if (calc.manifest.hash) { 
-                successUpdates[name] = {  
-                    hash: calc.manifest.hash, 
-                    category: calc.manifest.category,
-                    metrics: runMetrics // Pass metrics up
-                }; 
+            } else {
+                // --- STANDARD MODE (Single Date) ---
+                const mainDocRef = db.collection(config.resultsCollection)
+                    .doc(dStr)
+                    .collection(config.resultsSubcollection)
+                    .doc(calc.manifest.category)
+                    .collection(config.computationsSubcollection)
+                    .doc(name);
+
+                // Use the encapsulated write function
+                const writeStats = await writeSingleResult(result, mainDocRef, name, dStr, logger, config, deps);
+                
+                runMetrics.storage.sizeBytes = writeStats.totalSize;
+                runMetrics.storage.isSharded = writeStats.isSharded;
+                runMetrics.storage.shardCount = writeStats.shardCount;
+
+                // Mark Success & Pass Metrics
+                if (calc.manifest.hash) { 
+                    successUpdates[name] = {  
+                        hash: calc.manifest.hash, 
+                        category: calc.manifest.category,
+                        metrics: runMetrics 
+                    }; 
+                }
             }
 
             // Capture Schema
             if (calc.manifest.class.getSchema) {
                 const { class: _cls, ...safeMetadata } = calc.manifest;
-                schemas.push({ 
-                    name, 
-                    category: calc.manifest.category, 
-                    schema: calc.manifest.class.getSchema(), 
-                    metadata: safeMetadata 
-                });
+                schemas.push({ name, category: calc.manifest.category, schema: calc.manifest.class.getSchema(), metadata: safeMetadata });
             }
 
             // Cleanup Migration
@@ -210,6 +156,80 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     return { successUpdates, failureReport };
 }
 
+/**
+ * Encapsulated write logic for reuse in Fan-Out.
+ * Handles sharding strategy and retries.
+ */
+async function writeSingleResult(result, docRef, name, dateContext, logger, config, deps) {
+    // Strategy: 1=Normal, 2=Safe (Halved), 3=Aggressive (Quartered + Key Limit)
+    const strategies = [
+        { bytes: 900 * 1024, keys: null },      // Attempt 1: Standard
+        { bytes: 450 * 1024, keys: 10000 },     // Attempt 2: High Index usage
+        { bytes: 200 * 1024, keys: 2000 }       // Attempt 3: Extreme fragmentation
+    ];
+
+    let committed = false;
+    let lastError = null;
+    let finalStats = { totalSize: 0, isSharded: false, shardCount: 1 };
+
+    for (let attempt = 0; attempt < strategies.length; attempt++) {
+        if (committed) break;
+        
+        const constraints = strategies[attempt];
+        
+        try {
+            // 1. Prepare Shards with current constraints
+            const updates = await prepareAutoShardedWrites(result, docRef, logger, constraints.bytes, constraints.keys);
+            
+            // Stats
+            const pointer = updates.find(u => u.data._completed === true);
+            finalStats.isSharded = pointer && pointer.data._sharded === true;
+            finalStats.shardCount = finalStats.isSharded ? (pointer.data._shardCount || 1) : 1;
+            finalStats.totalSize = updates.reduce((acc, u) => acc + (u.data ? JSON.stringify(u.data).length : 0), 0);
+
+            // 2. Attempt Commit
+            await commitBatchInChunks(config, deps, updates, `${name}::${dateContext} (Att ${attempt+1})`);
+            
+            // Log Success
+            if (logger && logger.logStorage) { 
+                logger.logStorage(null, name, dateContext, docRef.path, finalStats.totalSize, finalStats.isSharded); 
+            }
+            
+            committed = true; // Exit loop
+
+        } catch (commitErr) {
+            lastError = commitErr;
+            const msg = commitErr.message || '';
+            
+            const isNonRetryable = NON_RETRYABLE_ERRORS.includes(commitErr.code);
+            if (isNonRetryable) {
+                logger.log('ERROR', `[SelfHealing] ${name} encountered FATAL error (Attempt ${attempt + 1}): ${msg}. Aborting.`);
+                throw commitErr; 
+            }
+
+            const isSizeError  = msg.includes('Transaction too big')    || msg.includes('payload is too large');
+            const isIndexError = msg.includes('too many index entries') || msg.includes('INVALID_ARGUMENT'); 
+
+            if (isSizeError || isIndexError) {
+                logger.log('WARN', `[SelfHealing] ${name} on ${dateContext} failed write attempt ${attempt + 1}. Retrying with tighter constraints...`, { error: msg });
+                continue; // Try next strategy
+            } else {
+                logger.log('WARN', `[SelfHealing] ${name} on ${dateContext} unknown error (Attempt ${attempt + 1}). Retrying...`, { error: msg });
+            }
+        }
+    }
+
+    if (!committed) {
+        throw { 
+            message: `Exhausted sharding strategies for ${name} on ${dateContext}. Last error: ${lastError?.message}`, 
+            stack: lastError?.stack, 
+            stage: 'SHARDING_LIMIT_EXCEEDED' 
+        };
+    }
+
+    return finalStats;
+}
+
 /**
  * Deletes result documents from a previous category location.
  */
@@ -227,9 +247,8 @@ async function deleteOldCalculationData(dateStr, oldCategory, calcName, config,
 
         const shardsCol  = oldDocRef.collection('_shards');
         const shardsSnap = await withRetry(() => shardsCol.listDocuments(), 'ListOldShards');
-        
-        const batch = db.batch();
-        let ops = 0;
+        const batch      = db.batch();
+        let ops          = 0;
 
         for (const shardDoc of shardsSnap) { batch.delete(shardDoc); ops++; }
         batch.delete(oldDocRef);

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

@@ -97,32 +97,20 @@ class HeuristicValidator {
         // If we found numeric values, check if they are all the same
         let isFlatline = false;
         if (numericValues.length > 5) {
-            const first = numericValues[0];
+            const first          = numericValues[0];
             const identicalCount = numericValues.filter(v => Math.abs(v - first) < 0.000001).length;
-            const flatlinePct = (identicalCount / numericValues.length) * 100;
+            const flatlinePct    = (identicalCount / numericValues.length) * 100;
             
             // Only flag flatline if the value isn't 0 (0 is handled by maxZeroPct)
-            if (flatlinePct > thresholds.maxFlatlinePct && Math.abs(first) > 0.0001) {
-                isFlatline = true;
-            }
+            if (flatlinePct > thresholds.maxFlatlinePct && Math.abs(first) > 0.0001) { isFlatline = true; }
         }
 
         // 6. Evaluations
-        if (nanPct > thresholds.maxNanPct) {
-            return { valid: false, reason: `Mathematical Error: ${nanPct.toFixed(1)}% of sampled results contain NaN or Infinity.` };
-        }
-
-        if (zeroPct > thresholds.maxZeroPct) {
-            return { valid: false, reason: `Data Integrity: ${zeroPct.toFixed(1)}% of sampled results are 0. (Suspected Logic Failure)` };
-        }
+        if (nanPct  > thresholds.maxNanPct)  { return { valid: false, reason: `Mathematical Error: ${nanPct.toFixed(1)}% of sampled results contain NaN or Infinity.` }; }
+        if (zeroPct > thresholds.maxZeroPct) { return { valid: false, reason: `Data Integrity:     ${zeroPct.toFixed(1)}% of sampled results are 0. (Suspected Logic Failure)` }; }
+        if (nullPct > thresholds.maxNullPct) { return { valid: false, reason: `Data Integrity:     ${nullPct.toFixed(1)}% of sampled results are Empty/Null.` }; }
 
-        if (nullPct > thresholds.maxNullPct) {
-            return { valid: false, reason: `Data Integrity: ${nullPct.toFixed(1)}% of sampled results are Empty/Null.` };
-        }
-
-        if (isFlatline) {
-            return { valid: false, reason: `Anomaly: Detected Result Flatline. >${thresholds.maxFlatlinePct}% of outputs are identical (non-zero).` };
-        }
+        if (isFlatline) { return { valid: false, reason: `Anomaly: Detected Result Flatline. >${thresholds.maxFlatlinePct}% of outputs are identical (non-zero).` }; }
         
         // Special check for Distribution/Profile calculations
         if (calcName.includes('profile') || calcName.includes('distribution')) {

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

@@ -48,7 +48,7 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
     
     // History Doc: Stores this specific run
     // ID Format: targetDate_triggerTimestamp (Sortable by data date, then execution time)
-    const runId = `${targetDate}_${triggerTimestamp}`;
+    const runId     = `${targetDate}_${triggerTimestamp}`;
     const runDocRef = computationDocRef.collection('history').doc(runId);
 
     // 2. Prepare Metrics & Environment Info
@@ -56,16 +56,11 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
     
     // Calculate size in MB
     let sizeMB = 0;
-    if (detailedMetrics.storage && detailedMetrics.storage.sizeBytes) {
-        sizeMB = Number((detailedMetrics.storage.sizeBytes / (1024 * 1024)).toFixed(4));
-    }
+    if (detailedMetrics.storage && detailedMetrics.storage.sizeBytes) { sizeMB = Number((detailedMetrics.storage.sizeBytes / (1024 * 1024)).toFixed(4)); }
 
     // Extract Validation Anomalies (Unusual Keys/Values)
     const anomalies = detailedMetrics.validation?.anomalies || [];
-    if (error && error.message && error.message.includes('Data Integrity')) {
-        // If the error itself was a validation failure, add it to anomalies
-        anomalies.push(error.message);
-    }
+    if (error && error.message && error.message.includes('Data Integrity')) { anomalies.push(error.message); }
 
     // 3. Construct the Run Log Entry
     const runEntry = {

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

@@ -5,23 +5,17 @@
 
 async function fetchComputationStatus(dateStr, config, { db }) {
     if (!dateStr) throw new Error('fetchStatus requires a key'); 
-    
     const collection = config.computationStatusCollection || 'computation_status';
-    const docRef = db.collection(collection).doc(dateStr);
-    
-    const snap = await docRef.get();
+    const docRef     = db.collection(collection).doc(dateStr);
+    const snap       = await docRef.get();
     if (!snap.exists) return {};
-
-    const rawData = snap.data();
+    const rawData    = snap.data();
     const normalized = {};
 
     // Normalize V1 (String) to V2 (Object)
     for (const [name, value] of Object.entries(rawData)) {
-        if (typeof value === 'string') {
-            normalized[name] = { hash: value, category: null }; // Legacy entry
-        } else {
-            normalized[name] = value; // V2 entry { hash, category }
-        }
+        if (typeof value === 'string') { normalized[name] = { hash: value, category: null }; // Legacy entry
+        } else { normalized[name] = value; }
     }
 
     return normalized;
@@ -34,18 +28,10 @@ async function updateComputationStatus(dateStr, updates, config, { db }) {
     const collection = config.computationStatusCollection || 'computation_status';
     const docRef = db.collection(collection).doc(dateStr);
     
-    // We expect updates to be an object: { "CalcName": { hash: "...", category: "..." } }
-    // But result committer might still pass strings if we don't update it. 
-    // We will enforce the structure here just in case.
-    
     const safeUpdates = {};
     for (const [key, val] of Object.entries(updates)) {
-        if (typeof val === 'string') {
-             // Fallback if caller wasn't updated (shouldn't happen with full patch)
-            safeUpdates[key] = { hash: val, category: 'unknown', lastUpdated: new Date() };
-        } else {
-            safeUpdates[key] = { ...val, lastUpdated: new Date() };
-        }
+        if (typeof val === 'string') { safeUpdates[key] = { hash: val, category: 'unknown', lastUpdated: new Date() };
+        } else { safeUpdates[key] = { ...val, lastUpdated: new Date() }; }
     }
 
     await docRef.set(safeUpdates, { merge: true });

package/functions/computation-system/tools/BuildReporter.js

@@ -1,17 +1,17 @@
 /**
  * @fileoverview Build Reporter & Auto-Runner.
  * Generates a "Pre-Flight" report of what the computation system WILL do.
- * UPDATED: Optimized with Parallel Status Fetches inside the date loop.
+ * UPDATED: Fixed 'latest' document overwrite bug.
  */
 
-const { analyzeDateExecution } = require('../WorkflowOrchestrator');
-const { fetchComputationStatus } = require('../persistence/StatusRepository');
+const { analyzeDateExecution }                                             = require('../WorkflowOrchestrator');
+const { fetchComputationStatus }                                           = require('../persistence/StatusRepository');
 const { normalizeName, getExpectedDateStrings, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils');
-const { checkRootDataAvailability } = require('../data/AvailabilityChecker');
-const pLimit = require('p-limit');
-const path = require('path');
-const packageJson = require(path.join(__dirname, '..', '..', '..', 'package.json'));
-const packageVersion = packageJson.version;
+const { checkRootDataAvailability }                                        = require('../data/AvailabilityChecker');
+const pLimit                                                               = require('p-limit');
+const path                                                                 = require('path');
+const packageJson                                                          = require(path.join(__dirname, '..', '..', '..', 'package.json'));
+const packageVersion                                                       = packageJson.version;
 
 /**
  * AUTO-RUN ENTRY POINT
@@ -20,11 +20,13 @@ const packageVersion = packageJson.version;
 async function ensureBuildReport(config, dependencies, manifest) {
     const { db, logger } = dependencies;
     const now = new Date();
+    // Create a standardized build ID
     const buildId = `v${packageVersion}_${now.getFullYear()}-${String(now.getMonth()+1).padStart(2,'0')}-${String(now.getDate()).padStart(2,'0')}_${String(now.getHours()).padStart(2,'0')}-${String(now.getMinutes()).padStart(2,'0')}-${String(now.getSeconds()).padStart(2,'0')}`;
     const latestRef = db.collection('computation_build_records').doc('latest');
 
     try {
         const latestDoc = await latestRef.get();
+        // Check using 'packageVersion' key to match what we store
         const priorVersion = latestDoc.exists ? latestDoc.data().packageVersion : null;
 
         if (priorVersion === packageVersion) {
@@ -33,13 +35,9 @@ async function ensureBuildReport(config, dependencies, manifest) {
         }
 
         logger.log('INFO', `[BuildReporter] 🚀 New Version Detected (${packageVersion}). Auto-running Pre-flight Report...`);
-        await generateBuildReport(config, dependencies, manifest, 90, buildId);
         
-        await latestRef.set({
-            packageVersion,
-            buildId,
-            generatedAt: now.toISOString()
-        });
+        // Run generation. This function handles writing the 'latest' document with FULL data.
+        await generateBuildReport(config, dependencies, manifest, 90, buildId);
 
     } catch (e) {
         logger.log('ERROR', `[BuildReporter] Auto-run check failed: ${e.message}`);
@@ -56,23 +54,23 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
     logger.log('INFO', `[BuildReporter] Generating Build Report: ${buildId} (Scope: ${daysBack} days)...`);
 
     // 1. Determine Date Range
-    const today = new Date();
+    const today     = new Date();
     const startDate = new Date();
     startDate.setDate(today.getDate() - daysBack);
     
     const datesToCheck = getExpectedDateStrings(startDate, today);
-    const manifestMap = new Map(manifest.map(c => [normalizeName(c.name), c]));
+    const manifestMap  = new Map(manifest.map(c => [normalizeName(c.name), c]));
     
     const reportData = {
         buildId,
-        version: packageVersion,
+        packageVersion: packageVersion, 
         generatedAt: new Date().toISOString(),
         summary: {},
         dates: {}
     };
 
     let totalReRuns = 0;
-    let totalNew = 0;
+    let totalNew    = 0;
 
     // 2. PARALLEL PROCESSING
     const limit = pLimit(20);
@@ -105,21 +103,17 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
             // If we fetched prevStatus, it's at index 2
             const prevDailyStatus = (prevDateStr && results[2]) ? results[2] : (prevDateStr ? {} : null);
 
-            const rootDataStatus = availability ? availability.status : {
-                hasPortfolio: false, hasHistory: false, hasSocial: false, hasInsights: false, hasPrices: false
-            };
+            const rootDataStatus = availability ? availability.status : { hasPortfolio: false, hasHistory: false, hasSocial: false, hasInsights: false, hasPrices: false };
 
             // D. Run Logic Analysis
             const analysis = analyzeDateExecution(dateStr, manifest, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus);
 
             // E. Format Findings
-            const dateSummary = {
-                willRun: [], willReRun: [], blocked: [], impossible: [] 
-            };
+            const dateSummary = { willRun: [], willReRun: [], blocked: [], impossible: [] };
 
-            analysis.runnable.forEach(item => dateSummary.willRun.push({ name: item.name, reason: "New / No Previous Record" }));
-            analysis.reRuns.forEach(item => dateSummary.willReRun.push({ name: item.name, reason: item.previousCategory ? "Migration" : "Hash Mismatch" }));
-            analysis.impossible.forEach(item => dateSummary.impossible.push({ name: item.name, reason: item.reason }));
+            analysis.runnable.forEach   (item => dateSummary.willRun.push    ({ name: item.name, reason: "New / No Previous Record" }));
+            analysis.reRuns.forEach     (item => dateSummary.willReRun.push  ({ name: item.name, reason: item.previousCategory ? "Migration" : "Hash Mismatch" }));
+            analysis.impossible.forEach (item => dateSummary.impossible.push ({ name: item.name, reason: item.reason }));
             [...analysis.blocked, ...analysis.failedDependency].forEach(item => dateSummary.blocked.push({ name: item.name, reason: item.reason || 'Dependency' }));
 
             const hasUpdates = dateSummary.willRun.length || dateSummary.willReRun.length || dateSummary.blocked.length || dateSummary.impossible.length;
@@ -155,10 +149,7 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
     await reportRef.set(reportData);
 
     // 5. Update 'latest' pointer
-    await db.collection('computation_build_records').doc('latest').set({
-        ...reportData,
-        note: "Latest build report pointer."
-    });
+    await db.collection('computation_build_records').doc('latest').set({ ...reportData, note: "Latest build report pointer." });
 
     logger.log('SUCCESS', `[BuildReporter] Report ${buildId} saved. Re-runs: ${totalReRuns}, New: ${totalNew}.`);
     

package/functions/computation-system/utils/data_loader.js

@@ -187,15 +187,10 @@ async function ensurePriceShardIndex(config, deps) {
     const snap = await indexDocRef.get();
     if (snap.exists) {
         const data = snap.data();
-        
-        // [FIX] Check TTL (24 hours)
         const lastUpdated = data.lastUpdated ? new Date(data.lastUpdated).getTime() : 0;
         const now = Date.now();
         const oneDayMs = 24 * 60 * 60 * 1000;
-
-        if ((now - lastUpdated) < oneDayMs) {
-            return data.index || {};
-        }
+        if ((now - lastUpdated) < oneDayMs) { return data.index || {}; }
         logger.log('INFO', '[ShardIndex] Index is stale (>24h). Rebuilding...');
     } else {
         logger.log('INFO', '[ShardIndex] Index not found. Building new Price Shard Index...');

package/functions/computation-system/utils/schema_capture.js

@@ -17,14 +17,9 @@ function validateSchema(schema) {
         
         // 2. Ensure it's not too large (Firestore limit: 1MB, reserve 100KB for metadata)
         const size = Buffer.byteLength(jsonStr);
-        if (size > 900 * 1024) {
-            return { valid: false, reason: `Schema exceeds 900KB limit (${(size/1024).toFixed(2)} KB)` };
-        }
-        
+        if (size > 900 * 1024) { return { valid: false, reason: `Schema exceeds 900KB limit (${(size/1024).toFixed(2)} KB)` }; }
         return { valid: true };
-    } catch (e) {
-        return { valid: false, reason: `Serialization failed: ${e.message}` };
-    }
+    } catch (e) { return { valid: false, reason: `Serialization failed: ${e.message}` }; }
 }
 
 /**
@@ -65,10 +60,10 @@ async function batchStoreSchemas(dependencies, config, schemas) {
             // Critical: Always overwrite 'lastUpdated' to now
             batch.set(docRef, {
                 computationName: item.name,
-                category: item.category,
-                schema: item.schema,
-                metadata: item.metadata || {},
-                lastUpdated: new Date() 
+                category:        item.category,
+                schema:          item.schema,
+                metadata:        item.metadata || {},
+                lastUpdated:     new Date() 
             }, { merge: true });
             
             validCount++;

package/functions/computation-system/utils/utils.js

@@ -159,13 +159,13 @@ async function getFirstDateFromCollection(config, deps, collectionName) {
 async function getEarliestDataDates(config, deps) {
     const { logger } = deps;
     const [ investorDate, speculatorDate, investorHistoryDate, speculatorHistoryDate, insightsDate, socialDate, priceDate ] = await Promise.all([
-        getFirstDateFromCollection(config, deps, config.normalUserPortfolioCollection),
-        getFirstDateFromCollection(config, deps, config.speculatorPortfolioCollection),
-        getFirstDateFromCollection(config, deps, config.normalUserHistoryCollection),
-        getFirstDateFromCollection(config, deps, config.speculatorHistoryCollection),
-        getFirstDateFromSimpleCollection(config, deps, config.insightsCollectionName),
-        getFirstDateFromSimpleCollection(config, deps, config.socialInsightsCollectionName),
-        getFirstDateFromPriceCollection(config, deps)
+        getFirstDateFromCollection       (config, deps, config.normalUserPortfolioCollection),
+        getFirstDateFromCollection       (config, deps, config.speculatorPortfolioCollection),
+        getFirstDateFromCollection       (config, deps, config.normalUserHistoryCollection),
+        getFirstDateFromCollection       (config, deps, config.speculatorHistoryCollection),
+        getFirstDateFromSimpleCollection (config, deps, config.insightsCollectionName),
+        getFirstDateFromSimpleCollection (config, deps, config.socialInsightsCollectionName),
+        getFirstDateFromPriceCollection  (config, deps)
     ]);
 
     const getMinDate = (...dates) => {
@@ -221,5 +221,5 @@ module.exports = {
     getEarliestDataDates, 
     generateCodeHash,
     withRetry,
-    DEFINITIVE_EARLIEST_DATES // [NEW EXPORT]
+    DEFINITIVE_EARLIEST_DATES
 };