bulltrackers-module 1.0.279 → 1.0.281

package/functions/computation-system/executors/MetaExecutor.js

@@ -2,7 +2,7 @@
  * @fileoverview Executor for "Meta" (global) calculations.
  * UPDATED: Uses CachedDataLoader for all data access.
  * UPDATED: Tracks processed shard/item counts.
- * UPDATED: Removed global.gc() calls.
+ * UPDATED: Sends 'isInitialWrite: true' for robust cleanup.
  */
 const { normalizeName }    = require('../utils/utils');
 const { CachedDataLoader } = require('../data/CachedDataLoader');
@@ -27,7 +27,9 @@ class MetaExecutor {
                 deps.logger.log('ERROR', `Meta calc failed ${mCalc.name}: ${e.message}`); 
             }
         }
-        return await commitResults(state, dStr, passName, config, deps, skipStatusWrite);
+        
+        // [UPDATED] Meta Calcs run once per day, so isInitialWrite is always true
+        return await commitResults(state, dStr, passName, config, deps, skipStatusWrite, { isInitialWrite: true });
     }
 
     static async executeOncePerDay(calcInstance, metadata, dateStr, computedDeps, prevDeps, config, deps, loader) {
@@ -35,7 +37,6 @@ class MetaExecutor {
         const { logger } = deps;
         const stats = { processedShards: 0, processedItems: 0 };
         
-        // Lazy fetch insights/social using the loader
         const insights   = metadata.rootDataDependencies?.includes('insights') ? { today: await loader.loadInsights(dateStr) } : null;
         const social     = metadata.rootDataDependencies?.includes('social')   ? { today: await loader.loadSocial(dateStr)   } : null;
         
@@ -59,12 +60,9 @@ class MetaExecutor {
                 
                 stats.processedShards++;
                 stats.processedItems += Object.keys(shardData).length;
-
-                // Removed global.gc()
             }
             logger.log('INFO', `[Executor] Finished Batched Execution for ${metadata.name} (${processedCount} shards).`);
             
-            // Attach stats
             calcInstance._executionStats = stats;
             return calcInstance.getResult ? await calcInstance.getResult() : {};
         } else {
@@ -75,7 +73,7 @@ class MetaExecutor {
             });
             const res = await calcInstance.process(context);
             
-            stats.processedItems = 1; // "Global" item
+            stats.processedItems = 1; 
             calcInstance._executionStats = stats;
             
             return res;
@@ -83,4 +81,4 @@ class MetaExecutor {
     }
 }
 
-module.exports = { MetaExecutor };
+module.exports = { MetaExecutor };

package/functions/computation-system/executors/StandardExecutor.js

@@ -3,6 +3,7 @@
  * UPDATED: Implements Batch Flushing to prevent OOM on large datasets.
  * UPDATED: Removes manual global.gc() calls.
  * UPDATED: Manages incremental sharding states.
+ * UPDATED: Implements 'isInitialWrite' flag for robust cleanup.
  */
 const { normalizeName }                                                = require('../utils/utils');
 const { streamPortfolioData, streamHistoryData, getPortfolioPartRefs } = require('../utils/data_loader');
@@ -10,6 +11,7 @@ const { CachedDataLoader }                                             = require
 const { ContextFactory }                                               = require('../context/ContextFactory');
 const { commitResults }                                                = require('../persistence/ResultCommitter');
 const mathLayer                                                        = require('../layers/index');
+const { performance }                                                  = require('perf_hooks');
 
 class StandardExecutor {
     static async run(date, calcs, passName, config, deps, rootData, fetchedDeps, previousFetchedDeps, skipStatusWrite = false) {
@@ -40,7 +42,6 @@ class StandardExecutor {
         }
 
         // 3. Stream, Process & Batch Flush
-        // The return value contains the aggregated success/failure reports from all flushes
         return await StandardExecutor.streamAndProcess(dStr, state, passName, config, deps, fullRoot, rootData.portfolioRefs, rootData.historyRefs, fetchedDeps, previousFetchedDeps, skipStatusWrite);
     }
 
@@ -53,20 +54,30 @@ class StandardExecutor {
         
         logger.log('INFO', `[${passName}] Streaming for ${streamingCalcs.length} computations...`);
         
-        // Metrics & State Tracking
         const executionStats = {};
-        const shardIndexMap  = {}; // Tracks sharding offsets per calculation
+        const shardIndexMap  = {}; 
         const aggregatedSuccess = {};
         const aggregatedFailures = [];
 
         Object.keys(state).forEach(name => {
-            executionStats[name] = { processedUsers: 0, skippedUsers: 0 };
+            executionStats[name] = { 
+                processedUsers: 0, 
+                skippedUsers: 0,
+                timings: { setup: 0, stream: 0, processing: 0 }
+            };
             shardIndexMap[name]  = 0;
         });
 
+        // Track if we have performed a flush yet (for cleanup logic)
+        let hasFlushed = false;
+
+        const startSetup = performance.now();
         const cachedLoader = new CachedDataLoader(config, deps);
         await cachedLoader.loadMappings();
+        const setupDuration = performance.now() - startSetup;
         
+        Object.keys(executionStats).forEach(name => executionStats[name].timings.setup += setupDuration);
+
         const prevDate    = new Date(dateStr + 'T00:00:00Z'); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
         const prevDateStr = prevDate.toISOString().slice(0, 10);
         
@@ -78,18 +89,20 @@ class StandardExecutor {
 
         let yP_chunk = {}, tH_chunk = {};
         
-        // OOM Protection: Batch Flushing Configuration
-        const BATCH_SIZE = 5000; // Flush every 5000 users
+        const BATCH_SIZE = 5000;
         let usersSinceLastFlush = 0;
 
         try {
             for await (const tP_chunk of tP_iter) {
+                const startStream = performance.now();
                 if (yP_iter) yP_chunk = (await yP_iter.next()).value || {};
                 if (tH_iter) tH_chunk = (await tH_iter.next()).value || {};
-                
+                const streamDuration = performance.now() - startStream;
+                Object.keys(executionStats).forEach(name => executionStats[name].timings.stream += streamDuration);
+
                 const chunkSize = Object.keys(tP_chunk).length;
 
-                // Execute chunk for all calcs
+                const startProcessing = performance.now();
                 const promises = streamingCalcs.map(calc =>  
                     StandardExecutor.executePerUser(
                         calc, calc.manifest, dateStr, tP_chunk, yP_chunk, tH_chunk, 
@@ -98,18 +111,20 @@ class StandardExecutor {
                     ) 
                 );
                 await Promise.all(promises);
+                const procDuration = performance.now() - startProcessing;
+                
+                Object.keys(executionStats).forEach(name => executionStats[name].timings.processing += procDuration);
 
                 usersSinceLastFlush += chunkSize;
 
-                // --- BATCH FLUSH CHECK ---
                 if (usersSinceLastFlush >= BATCH_SIZE) {
                     logger.log('INFO', `[${passName}] 🛁 Flushing buffer after ${usersSinceLastFlush} users...`);
                     
-                    const flushResult = await StandardExecutor.flushBuffer(state, dateStr, passName, config, deps, shardIndexMap, executionStats, 'INTERMEDIATE', true);
+                    // [UPDATED] Pass isInitialWrite: true only on the first flush
+                    const flushResult = await StandardExecutor.flushBuffer(state, dateStr, passName, config, deps, shardIndexMap, executionStats, 'INTERMEDIATE', true, !hasFlushed);
                     
-                    // Aggregate metrics
+                    hasFlushed = true;
                     StandardExecutor.mergeReports(aggregatedSuccess, aggregatedFailures, flushResult);
-                    
                     usersSinceLastFlush = 0;
                 }
             }
@@ -118,34 +133,27 @@ class StandardExecutor {
             if (tH_iter && tH_iter.return) await tH_iter.return();
         }
         
-        // --- FINAL FLUSH ---
         logger.log('INFO', `[${passName}] Streaming complete. Performing final commit.`);
-        const finalResult = await StandardExecutor.flushBuffer(state, dateStr, passName, config, deps, shardIndexMap, executionStats, 'FINAL', skipStatusWrite);
+        // [UPDATED] If we never flushed in the loop, this is the initial write
+        const finalResult = await StandardExecutor.flushBuffer(state, dateStr, passName, config, deps, shardIndexMap, executionStats, 'FINAL', skipStatusWrite, !hasFlushed);
         
         StandardExecutor.mergeReports(aggregatedSuccess, aggregatedFailures, finalResult);
 
         return { successUpdates: aggregatedSuccess, failureReport: aggregatedFailures };
     }
 
-    static async flushBuffer(state, dateStr, passName, config, deps, shardIndexMap, executionStats, mode, skipStatusWrite) {
+    static async flushBuffer(state, dateStr, passName, config, deps, shardIndexMap, executionStats, mode, skipStatusWrite, isInitialWrite = false) {
         const transformedState = {};
-        const { logger } = deps;
-
-        // 1. Prepare and Clear Instances
+        
         for (const [name, inst] of Object.entries(state)) {
-            // Get data from the standard storage location
             const rawResult = inst.results || {};
             
-            // Handle Multi-Date Fan-Out (Transposition)
-            // Logic: Checks if result is { userId: { date: data } }
             const firstUser = Object.keys(rawResult)[0];
             let dataToCommit = rawResult;
-            let isMultiDate = false;
 
             if (firstUser && rawResult[firstUser] && typeof rawResult[firstUser] === 'object') {
                 const innerKeys = Object.keys(rawResult[firstUser]);
                 if (innerKeys.length > 0 && innerKeys.every(k => /^\d{4}-\d{2}-\d{2}$/.test(k))) {
-                    isMultiDate = true;
                     const transposed = {};
                     for (const [userId, dateMap] of Object.entries(rawResult)) {
                         for (const [dateKey, dailyData] of Object.entries(dateMap)) {
@@ -157,24 +165,22 @@ class StandardExecutor {
                 }
             }
 
-            // Create a mock instance for the committer that returns just this batch
             transformedState[name] = {
                 manifest: inst.manifest,
                 getResult: async () => dataToCommit,
-                _executionStats: executionStats[name] // Attach current stats
+                _executionStats: executionStats[name]
             };
 
-            // ⚠️ CRITICAL: CLEAR MEMORY
             inst.results = {};
         }
 
-        // 2. Commit Batch
+        // [UPDATED] Pass isInitialWrite to ResultCommitter
         const result = await commitResults(transformedState, dateStr, passName, config, deps, skipStatusWrite, {
-            flushMode: mode,      // 'INTERMEDIATE' or 'FINAL'
-            shardIndexes: shardIndexMap // Pass the tracking map
+            flushMode: mode,      
+            shardIndexes: shardIndexMap,
+            isInitialWrite: isInitialWrite 
         });
 
-        // 3. Update Shard Indexes from result
         if (result.shardIndexes) {
             Object.assign(shardIndexMap, result.shardIndexes);
         }
@@ -185,23 +191,29 @@ class StandardExecutor {
     static mergeReports(successAcc, failureAcc, newResult) {
         if (!newResult) return;
         
-        // Merge Success Updates (Sums metrics)
         for (const [name, update] of Object.entries(newResult.successUpdates)) {
             if (!successAcc[name]) {
                 successAcc[name] = update;
             } else {
-                // Sum storage metrics
                 if (update.metrics?.storage) {
                     successAcc[name].metrics.storage.sizeBytes += (update.metrics.storage.sizeBytes || 0);
                     successAcc[name].metrics.storage.keys      += (update.metrics.storage.keys || 0);
                     successAcc[name].metrics.storage.shardCount = Math.max(successAcc[name].metrics.storage.shardCount, update.metrics.storage.shardCount || 1);
                 }
-                // Keep the latest hash/composition info
+                
+                if (update.metrics?.execution?.timings) {
+                     if (!successAcc[name].metrics.execution) successAcc[name].metrics.execution = { timings: { setup:0, stream:0, processing:0 }};
+                     const tDest = successAcc[name].metrics.execution.timings;
+                     const tSrc  = update.metrics.execution.timings;
+                     
+                     tDest.setup += (tSrc.setup || 0);
+                     tDest.stream += (tSrc.stream || 0);
+                     tDest.processing += (tSrc.processing || 0);
+                }
                 successAcc[name].hash = update.hash;
             }
         }
 
-        // Merge Failures
         if (newResult.failureReport) {
             failureAcc.push(...newResult.failureReport);
         }
@@ -243,4 +255,4 @@ class StandardExecutor {
     }
 }
 
-module.exports = { StandardExecutor };
+module.exports = { StandardExecutor };

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

@@ -2,7 +2,8 @@
  * @fileoverview Handles saving computation results with observability and Smart Cleanup.
  * UPDATED: Implements GZIP Compression for efficient storage.
  * UPDATED: Implements Content-Based Hashing (ResultHash) for dependency short-circuiting.
- * UPDATED: Auto-enforces Weekend Mode validation for 'Price-Only' computations.
+ * UPDATED: Auto-enforces Weekend Mode validation.
+ * UPDATED: Implements "Initial Write" logic to wipe stale data/shards on a fresh run.
  */
 const { commitBatchInChunks, generateDataHash } = require('../utils/utils');
 const { updateComputationStatus }          = require('./StatusRepository');
@@ -30,6 +31,7 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     
     // Options defaults
     const flushMode        = options.flushMode || 'STANDARD';
+    const isInitialWrite   = options.isInitialWrite === true; // [NEW] Flag for clean run
     const shardIndexes     = options.shardIndexes || {};
     const nextShardIndexes = {};
 
@@ -50,29 +52,22 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
             const result = await calc.getResult();
             const configOverrides = validationOverrides[calc.manifest.name] || {};
             
-            // --- [NEW] AUTO-ENFORCE WEEKEND MODE FOR PRICE-ONLY CALCS ---
-            // If a calculation depends SOLELY on 'price', we assume market closures
-            // will cause 0s/Flatlines on weekends, so we enforce lenient validation.
             const dataDeps = calc.manifest.rootDataDependencies || [];
             const isPriceOnly = (dataDeps.length === 1 && dataDeps[0] === 'price');
             
             let effectiveOverrides = { ...configOverrides };
             
             if (isPriceOnly && !effectiveOverrides.weekend) {
-                // Apply strict leniency for weekend/holiday price actions
                 effectiveOverrides.weekend = {
                     maxZeroPct: 100,
                     maxFlatlinePct: 100,
                     maxNullPct: 100 
                 };
             }
-            // -----------------------------------------------------------
 
             // Validation
             if (result && Object.keys(result).length > 0) {
-                // [FIX] Added 'dStr' as 3rd argument to match HeuristicValidator signature
                 const healthCheck = HeuristicValidator.analyze(calc.manifest.name, result, dStr, effectiveOverrides);
-                
                 if (!healthCheck.valid) {
                     runMetrics.validation.isValid = false;
                     runMetrics.validation.anomalies.push(healthCheck.reason);
@@ -83,11 +78,8 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
             }
             
             const isEmpty = !result || (typeof result === 'object' && Object.keys(result).length === 0);
-            
-            // Calculate Result Hash (Content-Based)
             const resultHash = isEmpty ? 'empty' : generateDataHash(result);
 
-            // Handle Empty Results
             if (isEmpty) { 
                 if (flushMode === 'INTERMEDIATE') {
                     nextShardIndexes[name] = currentShardIndex; 
@@ -123,7 +115,9 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                         .collection(config.computationsSubcollection)
                         .doc(name);
 
-                    await writeSingleResult(dailyData, historicalDocRef, name, historicalDate, logger, config, deps, 0, 'STANDARD');
+                    // Note: Multi-date fan-out rarely hits sharding, and tracking isInitialWrite per-date is complex.
+                    // We assume standard merging here.
+                    await writeSingleResult(dailyData, historicalDocRef, name, historicalDate, logger, config, deps, 0, 'STANDARD', false);
                 }));
                 await Promise.all(datePromises);
                 
@@ -146,7 +140,7 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                     .collection(config.computationsSubcollection)
                     .doc(name);
 
-                const writeStats = await writeSingleResult(result, mainDocRef, name, dStr, logger, config, deps, currentShardIndex, flushMode);
+                const writeStats = await writeSingleResult(result, mainDocRef, name, dStr, logger, config, deps, currentShardIndex, flushMode, isInitialWrite);
                 
                 runMetrics.storage.sizeBytes  = writeStats.totalSize;
                 runMetrics.storage.isSharded  = writeStats.isSharded;
@@ -192,8 +186,32 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     return { successUpdates, failureReport, shardIndexes: nextShardIndexes };
 }
 
-async function writeSingleResult(result, docRef, name, dateContext, logger, config, deps, startShardIndex = 0, flushMode = 'STANDARD') {
+async function writeSingleResult(result, docRef, name, dateContext, logger, config, deps, startShardIndex = 0, flushMode = 'STANDARD', isInitialWrite = false) {
     
+    // [NEW] Transition & Cleanup Logic
+    // If this is the initial write of a run, we verify the existing state to prevent "Ghost Data".
+    let wasSharded = false;
+    let hadRootData = false;
+    let shouldWipeShards = false;
+
+    // Default: Merge updates. But if Initial Write, overwrite (merge: false) to clear stale fields.
+    let rootMergeOption = !isInitialWrite; 
+
+    if (isInitialWrite) {
+        try {
+            const currentSnap = await docRef.get();
+            if (currentSnap.exists) {
+                const d = currentSnap.data();
+                wasSharded = (d._sharded === true);
+                // If it was sharded, we MUST wipe the old shards because we are re-writing from scratch.
+                // Even if we write new shards, we want to ensure shard_10 doesn't persist if we only write up to shard_5.
+                if (wasSharded) shouldWipeShards = true;
+                
+                // If it wasn't sharded, it had root data. overwriting (merge: false) handles that automatically.
+            }
+        } catch (e) { /* ignore read error */ }
+    }
+
     // --- COMPRESSION STRATEGY ---
     try {
         const jsonString = JSON.stringify(result);
@@ -212,7 +230,22 @@ async function writeSingleResult(result, docRef, name, dateContext, logger, conf
                     payload: compressedBuffer
                 };
                 
-                await docRef.set(compressedPayload, { merge: true });
+                // Cleanup: If it was sharded, or if we are wiping shards on initial write
+                if (shouldWipeShards) {
+                    logger.log('INFO', `[Cleanup] ${name}: Wiping old shards before Compressed Write.`);
+                    const updates = [];
+                    const shardCol = docRef.collection('_shards');
+                    const shardDocs = await shardCol.listDocuments();
+                    shardDocs.forEach(d => updates.push({ type: 'DELETE', ref: d }));
+                    
+                    // Root update with merge: false (overwrites everything)
+                    updates.push({ ref: docRef, data: compressedPayload, options: { merge: false } });
+                    
+                    await commitBatchInChunks(config, deps, updates, `${name}::Cleanup+Compress`);
+                } else {
+                    // Standard update (respecting calculated rootMergeOption)
+                    await docRef.set(compressedPayload, { merge: rootMergeOption });
+                }
                 
                 return { 
                     totalSize: compressedBuffer.length, 
@@ -242,12 +275,29 @@ async function writeSingleResult(result, docRef, name, dateContext, logger, conf
         const constraints = strategies[attempt];
         try {
             const updates = await prepareAutoShardedWrites(result, docRef, logger, constraints.bytes, constraints.keys, startShardIndex, flushMode);
-            const pointer = updates.find(u => u.data._completed !== undefined || u.data._sharded !== undefined);
             
+            // [NEW] Inject Cleanup Ops
+            if (shouldWipeShards) {
+                 logger.log('INFO', `[Cleanup] ${name}: Wiping old shards before Write (Initial).`);
+                 const shardCol = docRef.collection('_shards');
+                 const shardDocs = await shardCol.listDocuments();
+                 // Prepend DELETEs
+                 shardDocs.forEach(d => updates.unshift({ type: 'DELETE', ref: d }));
+                 shouldWipeShards = false; // Done for this loop
+            }
+
+            // Ensure the root document write respects our merge option
+            const rootUpdate = updates.find(u => u.ref.path === docRef.path && u.type !== 'DELETE');
+            if (rootUpdate) {
+                rootUpdate.options = { merge: rootMergeOption };
+            }
+
+            const pointer = updates.find(u => u.data && (u.data._completed !== undefined || u.data._sharded !== undefined));
             finalStats.totalSize = updates.reduce((acc, u) => acc + (u.data ? JSON.stringify(u.data).length : 0), 0);
             
             let maxIndex = startShardIndex;
             updates.forEach(u => {
+                if (u.type === 'DELETE') return;
                 const segs = u.ref.path.split('/');
                 const last = segs[segs.length - 1];
                 if (last.startsWith('shard_')) {
@@ -360,4 +410,4 @@ function calculateFirestoreBytes(value) {
     if (typeof value === 'object') { let sum = 0; for (const k in value) { if (Object.prototype.hasOwnProperty.call(value, k)) { sum += (Buffer.byteLength(k, 'utf8') + 1) + calculateFirestoreBytes(value[k]); } } return sum; } return 0;
 }
 
-module.exports = { commitResults };
+module.exports = { commitResults };

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

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Utility for recording computation run attempts (The Audit Logger).
  * UPDATED: Stores 'trigger' reason and 'execution' stats.
+ * UPDATED (IDEA 2): Stores granular timing profiles.
  */
 
 const { FieldValue } = require('../utils/utils'); 
@@ -37,6 +38,10 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
     const anomalies = detailedMetrics.validation?.anomalies || [];
     if (error && error.message && error.message.includes('Data Integrity')) { anomalies.push(error.message); }
 
+    // [IDEA 2] Prepare Execution Stats & Timings
+    const rawExecStats = detailedMetrics.execution || {};
+    const timings = rawExecStats.timings || {};
+
     const runEntry = {
         runId: runId,
         computationName: computation,
@@ -53,8 +58,17 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
             type: (triggerReason && triggerReason.includes('Layer')) ? 'CASCADE' : ((triggerReason && triggerReason.includes('New')) ? 'INIT' : 'UPDATE')
         },
 
-        // [NEW] Execution Stats (Internal Loop Data)
-        executionStats: detailedMetrics.execution || {},
+        // [IDEA 2] Enhanced Execution Stats
+        executionStats: {
+            processedUsers: rawExecStats.processedUsers || 0,
+            skippedUsers:   rawExecStats.skippedUsers || 0,
+            // Explicitly break out timings for BigQuery/Analysis
+            timings: {
+                setupMs:      Math.round(timings.setup || 0),
+                streamMs:     Math.round(timings.stream || 0),
+                processingMs: Math.round(timings.processing || 0)
+            }
+        },
 
         outputStats: {
             sizeMB: sizeMB,
@@ -64,7 +78,7 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
         },
 
         anomalies: anomalies,
-        _schemaVersion: '2.1'
+        _schemaVersion: '2.2' // Bumped for profiler
     };
 
     if (error) {

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

@@ -4,6 +4,7 @@
  * REFACTORED: Strict 5-category reporting with date-based exclusion logic.
  * UPDATED: Replaced Batch Writes with Parallel Writes to prevent DEADLINE_EXCEEDED timeouts.
  * FIXED: Ensures 'latest' pointer updates even if detail writes fail.
+ * UPDATED (IDEA 1): Added Dependency Impact Analysis ("Blast Radius").
  */
 
 const { analyzeDateExecution }                                             = require('../WorkflowOrchestrator');
@@ -41,6 +42,34 @@ function isDateBeforeAvailability(dateStr, calcManifest) {
     return false;
 }
 
+/**
+ * Helper: Calculates the transitive closure of dependents (Blast Radius).
+ * Returns the count of direct and total cascading dependents.
+ */
+function calculateBlastRadius(targetCalcName, reverseGraph) {
+    const impactSet = new Set();
+    const queue = [targetCalcName];
+    
+    // BFS Traversal
+    while(queue.length > 0) {
+        const current = queue.shift();
+        const dependents = reverseGraph.get(current) || [];
+        
+        dependents.forEach(child => {
+            if (!impactSet.has(child)) {
+                impactSet.add(child);
+                queue.push(child);
+            }
+        });
+    }
+
+    return {
+        directDependents: (reverseGraph.get(targetCalcName) || []).length,
+        totalCascadingDependents: impactSet.size,
+        affectedCalculations: Array.from(impactSet).slice(0, 50) // Cap list size for storage safety
+    };
+}
+
 /**
  * AUTO-RUN ENTRY POINT
  * Uses transactional locking to prevent race conditions.
@@ -100,6 +129,19 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
     const datesToCheck = getExpectedDateStrings(startDate, today);
     const manifestMap  = new Map(manifest.map(c => [normalizeName(c.name), c]));
     
+    // [IDEA 1] Build Reverse Dependency Graph (Parent -> Children)
+    const reverseGraph = new Map();
+    manifest.forEach(c => {
+        const parentName = normalizeName(c.name);
+        if (c.dependencies) {
+            c.dependencies.forEach(dep => {
+                const depName = normalizeName(dep);
+                if (!reverseGraph.has(depName)) reverseGraph.set(depName, []);
+                reverseGraph.get(depName).push(parentName);
+            });
+        }
+    });
+
     // Main Report Header
     const reportHeader = {
         buildId,
@@ -169,11 +211,18 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
                     return; // EXCLUDED: Date is before data exists
                 }
                 
-                targetArray.push({ 
+                const entry = { 
                     name:   item.name, 
                     reason: item.reason || extraReason,
                     pass:   calcManifest ? calcManifest.pass : '?'
-                });
+                };
+
+                // [IDEA 1] If this is a Re-Run, calculate Blast Radius
+                if (targetArray === dateSummary.rerun) {
+                    entry.impact = calculateBlastRadius(item.name, reverseGraph);
+                }
+
+                targetArray.push(entry);
             };
 
             // 1. RUN (New)

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

@@ -78,7 +78,7 @@ async function withRetry(fn, operationName, maxRetries = 3) {
 }
 
 /** Stage 2: Commit a batch of writes in chunks 
- * FIXED: Now respects write.options (e.g. { merge: false }) to allow overwrites/deletes.
+ * UPDATED: Now supports { type: 'DELETE' } in the write object.
  */
 async function commitBatchInChunks(config, deps, writes, operationName) {
     const { db, logger } = deps;
@@ -118,6 +118,17 @@ async function commitBatchInChunks(config, deps, writes, operationName) {
     };
 
     for (const write of writes) {
+        // [NEW] Handle DELETE operations
+        if (write.type === 'DELETE') {
+            if ((currentOpsCount + 1 > MAX_BATCH_OPS)) {
+                await commitAndReset();
+            }
+            currentBatch.delete(write.ref);
+            currentOpsCount++;
+            continue;
+        }
+
+        // Standard SET/UPDATE operations
         let docSize = 100;
         try { if (write.data) docSize = JSON.stringify(write.data).length; } catch (e) { }
 
@@ -251,4 +262,4 @@ module.exports = {
     generateDataHash, // Exported
     withRetry,
     DEFINITIVE_EARLIEST_DATES
-};
+};

package/package.json

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