bulltrackers-module 1.0.214 → 1.0.215

package/functions/computation-system/controllers/computation_controller.js

@@ -4,8 +4,7 @@
  */
 
 // Load all layers dynamically from the index
-const mathLayer = require('../layers/index');
-
+const mathLayer                                                                                   = require('../layers/index');
 const { loadDailyInsights, loadDailySocialPostInsights, getRelevantShardRefs, getPriceShardRefs } = require('../utils/data_loader');
 
 // Legacy Keys Mapping (Ensures backward compatibility with existing Calculations)
@@ -26,76 +25,20 @@ const LEGACY_MAPPING = {
 };
 
 class DataLoader {
-    constructor(config, dependencies) {
-        this.config = config;
-        this.deps = dependencies;
-        this.cache = { mappings: null, insights: new Map(), social: new Map(), prices: null };
-    }
-    
-    get mappings() { return this.cache.mappings; }
-
-    async loadMappings() {
-        if (this.cache.mappings) return this.cache.mappings;
-        const { calculationUtils } = this.deps;
-        this.cache.mappings = await calculationUtils.loadInstrumentMappings();
-        return this.cache.mappings;
-    }
-    async loadInsights(dateStr) {
-        if (this.cache.insights.has(dateStr)) return this.cache.insights.get(dateStr);
-        const insights = await loadDailyInsights(this.config, this.deps, dateStr);
-        this.cache.insights.set(dateStr, insights);
-        return insights;
-    }
-    async loadSocial(dateStr) {
-        if (this.cache.social.has(dateStr)) return this.cache.social.get(dateStr);
-        const social = await loadDailySocialPostInsights(this.config, this.deps, dateStr);
-        this.cache.social.set(dateStr, social);
-        return social;
-    }
-    
-    async getPriceShardReferences() {
-        return getPriceShardRefs(this.config, this.deps);
-    }
-    
-    async getSpecificPriceShardReferences(targetInstrumentIds) {
-        return getRelevantShardRefs(this.config, this.deps, targetInstrumentIds);
-    }
-
-    async loadPriceShard(docRef) {
-        try {
-            const snap = await docRef.get();
-            if (!snap.exists) return {};
-            return snap.data();
-        } catch (e) {
-            console.error(`Error loading shard ${docRef.path}:`, e);
-            return {};
-        }
-    }
+    constructor(config, dependencies)     { this.config = config; this.deps = dependencies; this.cache = { mappings: null, insights: new Map(), social: new Map(), prices: null }; }
+    get mappings()                        { return this.cache.mappings; }
+    async loadMappings()                  { if (this.cache.mappings) return this.cache.mappings; const { calculationUtils } = this.deps; this.cache.mappings = await calculationUtils.loadInstrumentMappings(); return this.cache.mappings; }
+    async loadInsights(dateStr)           { if (this.cache.insights.has(dateStr)) return this.cache.insights.get(dateStr); const insights = await loadDailyInsights(this.config, this.deps, dateStr); this.cache.insights.set(dateStr, insights); return insights; }
+    async loadSocial(dateStr)             { if (this.cache.social.has(dateStr)) return this.cache.social.get(dateStr); const social = await loadDailySocialPostInsights(this.config, this.deps, dateStr); this.cache.social.set(dateStr, social); return social; }
+    async getPriceShardReferences()       { return getPriceShardRefs(this.config, this.deps); }
+    async getSpecificPriceShardReferences (targetInstrumentIds) { return getRelevantShardRefs(this.config, this.deps, targetInstrumentIds); }
+    async loadPriceShard(docRef)          { try { const snap = await docRef.get(); if (!snap.exists) return {}; return snap.data(); } catch (e) { console.error(`Error loading shard ${docRef.path}:`, e); return {}; } }
 }
 
 class ContextBuilder { 
-    
-    /**
-     * dynamically constructs the 'math' object.
-     * 1. Iterates over all exports from layers/index.js
-     * 2. Maps standard classes to legacy keys (extract, compute, etc.)
-     * 3. Adds ALL classes by their actual name to support new features automatically.
-     */
     static buildMathContext() {
         const mathContext = {};
-
-        // 1. Auto-discover and map
-        for (const [key, value] of Object.entries(mathLayer)) {
-            // Add by actual name (e.g. math.NewFeature)
-            mathContext[key] = value;
-
-            // Map to legacy key if exists (e.g. math.extract)
-            const legacyKey = LEGACY_MAPPING[key];
-            if (legacyKey) {
-                mathContext[legacyKey] = value;
-            }
-        }
-        
+        for (const [key, value] of Object.entries(mathLayer)) { mathContext[key] = value; const legacyKey = LEGACY_MAPPING[key]; if (legacyKey) { mathContext[legacyKey] = value; } }
         return mathContext;
     }
 
@@ -107,7 +50,7 @@ class ContextBuilder {
             insights: { today: insights?.today, yesterday: insights?.yesterday },
             social: { today: socialData?.today, yesterday: socialData?.yesterday },
             mappings: mappings || {},
-            math: ContextBuilder.buildMathContext(), // DYNAMIC LOAD
+            math: ContextBuilder.buildMathContext(), 
             computed: computedDependencies || {},
             previousComputed: previousComputedDependencies || {},
             meta: metadata, config, deps
@@ -122,7 +65,7 @@ class ContextBuilder {
             social: { today: socialData?.today, yesterday: socialData?.yesterday },
             prices: prices || {},
             mappings: mappings || {},
-            math: ContextBuilder.buildMathContext(), // DYNAMIC LOAD
+            math: ContextBuilder.buildMathContext(), 
             computed: computedDependencies || {},
             previousComputed: previousComputedDependencies || {},
             meta: metadata, config, deps
@@ -133,23 +76,23 @@ class ContextBuilder {
 class ComputationExecutor {
     constructor(config, dependencies, dataLoader) {
         this.config = config;
-        this.deps = dependencies;
+        this.deps   = dependencies;
         this.loader = dataLoader;
     }
 
     async executePerUser(calcInstance, metadata, dateStr, portfolioData, yesterdayPortfolioData, historyData, computedDeps, prevDeps) {
-        const { logger } = this.deps;
+        const { logger }     = this.deps;
         const targetUserType = metadata.userType; 
-        const mappings = await this.loader.loadMappings();
-        const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
+        const mappings       = await this.loader.loadMappings();
+        const insights       = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
         
         // Access SCHEMAS dynamically from the loaded layer
         const SCHEMAS = mathLayer.SCHEMAS;
 
         for (const [userId, todayPortfolio] of Object.entries(portfolioData)) {
             const yesterdayPortfolio = yesterdayPortfolioData ? yesterdayPortfolioData[userId] : null;
-            const todayHistory = historyData ? historyData[userId] : null;
-            const actualUserType = todayPortfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
+            const todayHistory       = historyData ? historyData[userId] : null;
+            const actualUserType     = todayPortfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
             if (targetUserType !== 'all') {
                  const mappedTarget = (targetUserType === 'speculator') ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
                  if (mappedTarget !== actualUserType) continue;
@@ -160,10 +103,10 @@ class ComputationExecutor {
     }
 
     async executeOncePerDay(calcInstance, metadata, dateStr, computedDeps, prevDeps) {
-        const mappings = await this.loader.loadMappings();
+        const mappings   = await this.loader.loadMappings();
         const { logger } = this.deps;
-        const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
-        const social = metadata.rootDataDependencies?.includes('social') ? { today: await this.loader.loadSocial(dateStr) } : null;
+        const insights   = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
+        const social     = metadata.rootDataDependencies?.includes('social')   ? { today: await this.loader.loadSocial(dateStr)   } : null;
         
         if (metadata.rootDataDependencies?.includes('price')) {
             logger.log('INFO', `[Executor] Running Batched/Sharded Execution for ${metadata.name}`);
@@ -171,7 +114,7 @@ class ComputationExecutor {
             if (shardRefs.length === 0) { logger.log('WARN', '[Executor] No price shards found.'); return {}; }
             let processedCount = 0;
             for (const ref of shardRefs) {
-                const shardData = await this.loader.loadPriceShard(ref);
+                const shardData      = await this.loader.loadPriceShard(ref);
                 const partialContext = ContextBuilder.buildMetaContext({ dateStr, metadata, mappings, insights, socialData: social, prices: { history: shardData }, computedDependencies: computedDeps, previousComputedDependencies: prevDeps, config: this.config, deps: this.deps });
                 await calcInstance.process(partialContext);
                 partialContext.prices = null; 
@@ -189,9 +132,9 @@ class ComputationExecutor {
 
 class ComputationController {
     constructor(config, dependencies) {
-        this.config = config;
-        this.deps = dependencies;
-        this.loader = new DataLoader(config, dependencies);
+        this.config   = config;
+        this.deps     = dependencies;
+        this.loader   = new DataLoader(config, dependencies);
         this.executor = new ComputationExecutor(config, dependencies, this.loader);
     }
 }

package/functions/computation-system/helpers/computation_dispatcher.js

@@ -17,53 +17,42 @@ const TOPIC_NAME = 'computation-tasks';
  */
 async function dispatchComputationPass(config, dependencies, computationManifest) {
     const { logger } = dependencies;
-
-    // Create fresh PubSubUtils instance
     const pubsubUtils = new PubSubUtils(dependencies);
-
     const passToRun = String(config.COMPUTATION_PASS_TO_RUN);
-
-    if (!passToRun) {
-        return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.');
-    }
+    if (!passToRun) { return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.'); }
 
     // 1. Validate Pass Existence
     const passes = groupByPass(computationManifest);
     const calcsInThisPass = passes[passToRun] || [];
 
-    if (!calcsInThisPass.length) {
-        return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`);
-    }
+    if (!calcsInThisPass.length) { return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`); }
 
     const calcNames = calcsInThisPass.map(c => c.name).join(', ');
     logger.log('INFO', `🚀 [Dispatcher] Preparing PASS ${passToRun}.`);
     logger.log('INFO', `[Dispatcher] Included Calculations: [${calcNames}]`);
 
     // 2. Determine Date Range
-    // Hardcoded earliest dates - keep synced with PassRunner for now
     const earliestDates = {
         portfolio: new Date('2025-09-25T00:00:00Z'),
-        history: new Date('2025-11-05T00:00:00Z'),
-        social: new Date('2025-10-30T00:00:00Z'),
-        insights: new Date('2025-08-26T00:00:00Z'),
-        price: new Date('2025-08-01T00:00:00Z')
+        history:   new Date('2025-11-05T00:00:00Z'),
+        social:    new Date('2025-10-30T00:00:00Z'),
+        insights:  new Date('2025-08-26T00:00:00Z'),
+        price:     new Date('2025-08-01T00:00:00Z')
     };
-    const passEarliestDate = Object.values(earliestDates).reduce((a, b) => a < b ? a : b);
-    const endDateUTC = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
 
+    const passEarliestDate = Object.values(earliestDates).reduce((a, b) => a < b ? a : b);
+    const endDateUTC       = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
     const allExpectedDates = getExpectedDateStrings(passEarliestDate, endDateUTC);
 
     logger.log('INFO', `[Dispatcher] Dispatches checks for ${allExpectedDates.length} dates (${allExpectedDates[0]} to ${allExpectedDates[allExpectedDates.length - 1]}). Workers will validate dependencies.`);
 
     // 3. Dispatch Messages
     let dispatchedCount = 0;
-    const BATCH_SIZE = 50;
+    const BATCH_SIZE    = 50;
 
     // We can publish in parallel batches
     const chunks = [];
-    for (let i = 0; i < allExpectedDates.length; i += BATCH_SIZE) {
-        chunks.push(allExpectedDates.slice(i, i + BATCH_SIZE));
-    }
+    for (let i = 0; i < allExpectedDates.length; i += BATCH_SIZE) { chunks.push(allExpectedDates.slice(i, i + BATCH_SIZE)); }
 
     for (const chunk of chunks) {
         const messages = chunk.map(dateStr => ({
@@ -79,9 +68,7 @@ async function dispatchComputationPass(config, dependencies, computationManifest
             await pubsubUtils.publishMessageBatch(TOPIC_NAME, messages);
             dispatchedCount += messages.length;
             logger.log('INFO', `[Dispatcher] Dispatched batch of ${messages.length} tasks.`);
-        } catch (err) {
-            logger.log('ERROR', `[Dispatcher] Failed to dispatch batch: ${err.message}`);
-        }
+        } catch (err) { logger.log('ERROR', `[Dispatcher] Failed to dispatch batch: ${err.message}`); }
     }
 
     logger.log('INFO', `[Dispatcher] Finished. Dispatched ${dispatchedCount} checks for Pass ${passToRun}.`);

package/functions/computation-system/helpers/computation_manifest_builder.js

@@ -24,18 +24,14 @@ const ValidatorsLayer  = require('../layers/validators');
  * -------------------------------------------------- */
 
 function generateLayerHash(layerExports, layerName) {
-    const keys = Object.keys(layerExports).sort(); // Sort for determinism
+    const keys = Object.keys(layerExports).sort(); 
     let combinedSource = `LAYER:${layerName}`;
 
     for (const key of keys) {
         const item = layerExports[key];
-        if (typeof item === 'function') {
-            combinedSource += item.toString();
-        } else if (typeof item === 'object' && item !== null) {
-            combinedSource += JSON.stringify(item);
-        } else {
-            combinedSource += String(item);
-        }
+        if (typeof item === 'function')                       { combinedSource += item.toString();
+        } else if (typeof item === 'object' && item !== null) { combinedSource += JSON.stringify(item);
+        } else                                                { combinedSource += String(item); }
     }
     return generateCodeHash(combinedSource);
 }
@@ -43,9 +39,9 @@ function generateLayerHash(layerExports, layerName) {
 // Pre-compute layer hashes at startup
 const LAYER_HASHES = {
     'mathematics': generateLayerHash(MathematicsLayer, 'mathematics'),
-    'extractors':  generateLayerHash(ExtractorsLayer, 'extractors'),
-    'profiling':   generateLayerHash(ProfilingLayer, 'profiling'),
-    'validators':  generateLayerHash(ValidatorsLayer, 'validators')
+    'extractors':  generateLayerHash(ExtractorsLayer,  'extractors'),
+    'profiling':   generateLayerHash(ProfilingLayer,   'profiling'),
+    'validators':  generateLayerHash(ValidatorsLayer,  'validators')
 };
 
 // Map code patterns to Layer dependencies
@@ -81,11 +77,11 @@ const LAYER_TRIGGERS = {
  * Pretty Console Helpers
  * -------------------------------------------------- */
 const log = {
-    info:    (msg)   =>  console.log('ℹ︎ ' + msg),
-    step:    (msg)   =>  console.log('› ' + msg),
-    warn:    (msg)   =>  console.warn('⚠︎ ' + msg),
-    success: (msg)   =>  console.log('✔︎ ' + msg),
-    error:   (msg)   =>  console.error('✖ ' + msg),
+    info:    (msg)   =>   console.log('ℹ︎ ' + msg),
+    step:    (msg)   =>   console.log('› ' + msg),
+    warn:    (msg)   =>   console.warn('⚠︎ ' + msg),
+    success: (msg)   =>   console.log('✔︎ ' + msg),
+    error:   (msg)   =>   console.error('✖ ' + msg),
     fatal:   (msg)   => { console.error('✖ FATAL ✖ ' + msg); console.error('✖ FATAL ✖ Manifest build FAILED.'); },
     divider: (label) => { const line = ''.padEnd(60, '─'); console.log(`\n${line}\n${label}\n${line}\n`); },
 };
@@ -141,7 +137,7 @@ function buildManifest(productLinesToRun = [], calculations) {
         if (!Class || typeof Class !== 'function') return;
         const normalizedName = normalizeName(name);
         
-        if (typeof Class.getMetadata !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getMetadata().`); hasFatalError = true; return; }
+        if (typeof Class.getMetadata     !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getMetadata().`);     hasFatalError = true; return; }
         if (typeof Class.getDependencies !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getDependencies().`); hasFatalError = true;return; }
         
         const metadata     = Class.getMetadata();
@@ -161,10 +157,7 @@ function buildManifest(productLinesToRun = [], calculations) {
 
         // Check for specific layer usage
         for (const [layerName, triggers] of Object.entries(LAYER_TRIGGERS)) {
-            if (triggers.some(trigger => codeStr.includes(trigger))) {
-                compositeHashString += LAYER_HASHES[layerName]; 
-                usedLayers.push(layerName);
-            }
+            if (triggers.some(trigger => codeStr.includes(trigger))) { compositeHashString += LAYER_HASHES[layerName];  usedLayers.push(layerName); }
         }
 
         // Safe Mode Fallback
@@ -187,7 +180,7 @@ function buildManifest(productLinesToRun = [], calculations) {
             userType: metadata.userType,
             dependencies: dependencies,
             pass: 0,
-            hash: baseHash, // Intrinsic Hash (Updated later to include deps)
+            hash: baseHash,
             debugUsedLayers: isSafeMode ? ['ALL (Safe Mode)'] : usedLayers
         };
         
@@ -233,13 +226,8 @@ function buildManifest(productLinesToRun = [], calculations) {
 
     /* ---------------- 3. Filter for Product Lines ---------------- */
     const productLineEndpoints = [];
-    for (const [name, entry] of manifestMap.entries()) { 
-        if (productLinesToRun.includes(entry.category)) { productLineEndpoints.push(name); } 
-    }
-    // Always include core
-    for (const [name, entry] of manifestMap.entries()) { 
-        if (entry.sourcePackage === 'core') { productLineEndpoints.push(name); } 
-    }
+    for (const [name, entry] of manifestMap.entries()) {  if (productLinesToRun.includes(entry.category)) { productLineEndpoints.push(name); }  }
+    for (const [name, entry] of manifestMap.entries()) {  if (entry.sourcePackage === 'core') { productLineEndpoints.push(name); }  }
 
     const requiredCalcs = getDependencySet(productLineEndpoints, adjacency);
     log.info(`Filtered down to ${requiredCalcs.size} active calculations.`);
@@ -247,6 +235,7 @@ function buildManifest(productLinesToRun = [], calculations) {
     const filteredManifestMap      = new Map();
     const filteredInDegree         = new Map();
     const filteredReverseAdjacency = new Map();
+
     for (const name of requiredCalcs) { filteredManifestMap.set(name, manifestMap.get(name)); filteredInDegree.set(name, inDegree.get(name));
     const consumers = (reverseAdjacency.get(name) || []).filter(consumer => requiredCalcs.has(consumer)); filteredReverseAdjacency.set(name, consumers); }
 
@@ -272,26 +261,16 @@ function buildManifest(productLinesToRun = [], calculations) {
         throw new Error('Circular dependency detected. Manifest build failed.'); }
 
     /* ---------------- 5. Phase 2: Cascading Dependency Hashing ---------------- */
-    // Now that we have a topological order (Dependencies come BEFORE Consumers),
-    // we can update hashes sequentially.
     log.step('Computing Cascading Merkle Hashes...');
 
     for (const entry of sortedManifest) {
         // Start with the intrinsic hash (Code + Layers)
         let dependencySignature = entry.hash;
 
-        // Append the hashes of all dependencies
-        // Since we are iterating in topo order, dependencies are guaranteed to be processed/updated already.
         if (entry.dependencies && entry.dependencies.length > 0) {
-            const depHashes = entry.dependencies.map(depName => {
-                const depEntry = filteredManifestMap.get(depName);
-                if (!depEntry) return ''; // Should not happen given validation
-                return depEntry.hash;
-            }).join('|'); // Use separator to prevent collisions
-            
+            const depHashes = entry.dependencies.map(depName => { const depEntry = filteredManifestMap.get(depName); if (!depEntry) return '';  return depEntry.hash; }).join('|'); 
             dependencySignature += `|DEPS:${depHashes}`;
         }
-
         // Generate the Final Smart Hash
         entry.hash = generateCodeHash(dependencySignature);
     }

package/functions/computation-system/helpers/computation_pass_runner.js

@@ -33,24 +33,22 @@ async function runComputationPass(config, dependencies, computationManifest) {
         insights:  new Date('2025-08-26T00:00:00Z'),
         price:     new Date('2025-08-01T00:00:00Z')
     };
+
     earliestDates.absoluteEarliest = Object.values(earliestDates).reduce((a, b) => a < b ? a : b);
 
     const passes          = groupByPass(computationManifest);
     const calcsInThisPass = passes[passToRun] || [];
 
-    if (!calcsInThisPass.length)
-        return logger.log('WARN', `[PassRunner] No calcs for Pass ${passToRun}. Exiting.`);
-
-    const passEarliestDate = earliestDates.absoluteEarliest;
-    const endDateUTC       = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
-    const allExpectedDates = getExpectedDateStrings(passEarliestDate, endDateUTC);
+    if (!calcsInThisPass.length) return logger.log('WARN', `[PassRunner] No calcs for Pass ${passToRun}. Exiting.`);
 
-    const priceBatchCalcs = calcsInThisPass.filter(c => c.type === 'meta' && c.rootDataDependencies?.includes('price'));
+    const passEarliestDate          = earliestDates.absoluteEarliest;
+    const endDateUTC                = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
+    const allExpectedDates          = getExpectedDateStrings(passEarliestDate, endDateUTC);
+    const priceBatchCalcs           = calcsInThisPass.filter(c => c.type === 'meta' && c.rootDataDependencies?.includes('price'));
     const standardAndOtherMetaCalcs = calcsInThisPass.filter(c => !priceBatchCalcs.includes(c));
 
     if (priceBatchCalcs.length > 0) {
-        try {
-            await runBatchPriceComputation(config, dependencies, allExpectedDates, priceBatchCalcs); 
+        try { await runBatchPriceComputation(config, dependencies, allExpectedDates, priceBatchCalcs); 
         } catch (e) { logger.log('ERROR', 'Legacy Batch Price failed', e); }
     }
 
@@ -63,51 +61,26 @@ async function runComputationPass(config, dependencies, computationManifest) {
 }
 
 async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, dependencies, computationManifest) {
-    const { logger } = dependencies;
+    const { logger }    = dependencies;
     const dateToProcess = new Date(dateStr + 'T00:00:00Z');
-
-    const dailyStatus = await fetchComputationStatus(dateStr, config, dependencies);
-
-    // Filter AND Log reason for skipping
+    const dailyStatus   = await fetchComputationStatus(dateStr, config, dependencies);
     const calcsToAttempt = [];
-    
     for (const calc of calcsInThisPass) {
-        const cName = normalizeName(calc.name);
+        const cName        = normalizeName(calc.name);
         const storedStatus = dailyStatus[cName];
-        const currentHash = calc.hash;
+        const currentHash  = calc.hash;
 
         // 1. Dependency Check
-        if (calc.dependencies && calc.dependencies.length > 0) {
-            const missing = calc.dependencies.filter(depName => !dailyStatus[normalizeName(depName)]);
-            if (missing.length > 0) {
-                // Too noisy to log every skip, but useful for debugging if needed. 
-                // Only logging if it's NOT a bulk skip.
-                // logger.log('TRACE', `[Skip] ${cName} missing deps: ${missing.join(', ')}`);
-                continue; 
-            }
-        }
+        if (calc.dependencies && calc.dependencies.length > 0) { const missing = calc.dependencies.filter(depName => !dailyStatus[normalizeName(depName)]); if (missing.length > 0) { logger.log('TRACE', `[Skip] ${cName} missing deps: ${missing.join(', ')}`);  continue; } }
 
         // 2. Logic A: No previous run
-        if (!storedStatus) {
-            logger.log('INFO', `[Versioning] ${cName}: New run needed (No prior status).`);
-            calcsToAttempt.push(calc);
-            continue;
-        }
+        if (!storedStatus) { logger.log('INFO', `[Versioning] ${cName}: New run needed (No prior status).`); calcsToAttempt.push(calc); continue; }
 
         // 3. Logic B: Hash Mismatch
-        // FIX: Ensure storedStatus is a string before calling substring
-        if (typeof storedStatus === 'string' && currentHash && storedStatus !== currentHash) {
-            logger.log('INFO', `[Versioning] ${cName}: Code Changed. (Old: ${storedStatus.substring(0,6)}... New: ${currentHash.substring(0,6)}...)`);
-            calcsToAttempt.push(calc);
-            continue;
-        }
+        if (typeof storedStatus === 'string' && currentHash && storedStatus !== currentHash) { logger.log('INFO', `[Versioning] ${cName}: Code Changed. (Old: ${storedStatus.substring(0,6)}... New: ${currentHash.substring(0,6)}...)`); calcsToAttempt.push(calc); continue; }
 
         // 4. Logic C: Upgrade Legacy Boolean -> Hash
-        if (storedStatus === true && currentHash) {
-            logger.log('INFO', `[Versioning] ${cName}: Upgrading legacy status to Hash.`);
-            calcsToAttempt.push(calc);
-            continue;
-        }
+        if (storedStatus === true && currentHash) { logger.log('INFO', `[Versioning] ${cName}: Upgrading legacy status to Hash.`); calcsToAttempt.push(calc); continue; }
     }
 
     if (!calcsToAttempt.length) return null;
@@ -121,47 +94,34 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     };
 
     const rootData = await checkRootDataAvailability(dateStr, config, dependencies, earliestDates);
-    if (!rootData) {
-        logger.log('INFO', `[DateRunner] Root data missing for ${dateStr}. Skipping.`);
-        return null;
-    }
-
+    if (!rootData) { logger.log('INFO', `[DateRunner] Root data missing for ${dateStr}. Skipping.`); return null; }
     const runnableCalcs = calcsToAttempt.filter(c => checkRootDependencies(c, rootData.status).canRun);
-
     if (!runnableCalcs.length) return null;
-
     const standardToRun = runnableCalcs.filter(c => c.type === 'standard');
     const metaToRun = runnableCalcs.filter(c => c.type === 'meta');
-
     logger.log('INFO', `[DateRunner] Running ${dateStr}: ${standardToRun.length} std, ${metaToRun.length} meta`);
-
     const dateUpdates = {};
 
     try {
         const calcsRunning = [...standardToRun, ...metaToRun];
-
         const existingResults = await fetchExistingResults(dateStr, calcsRunning, computationManifest, config, dependencies, false);
         const prevDate        = new Date(dateToProcess); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
         const prevDateStr     = prevDate.toISOString().slice(0, 10);
         const previousResults = await fetchExistingResults(prevDateStr, calcsRunning, computationManifest, config, dependencies, true);
 
-        if (standardToRun.length) {
-            const updates = await runStandardComputationPass(dateToProcess, standardToRun, `Pass ${passToRun} (Std)`, config, dependencies, rootData, existingResults, previousResults, false);
-            Object.assign(dateUpdates, updates);
-        }
-        if (metaToRun.length) {
-            const updates = await runMetaComputationPass(dateToProcess, metaToRun, `Pass ${passToRun} (Meta)`, config, dependencies, existingResults, previousResults, rootData, false);
-            Object.assign(dateUpdates, updates);
-        }
+        if (standardToRun.length) { const updates = await runStandardComputationPass(dateToProcess, standardToRun, `Pass ${passToRun} (Std)`, config, dependencies, rootData, existingResults, previousResults, false);
+            Object.assign(dateUpdates, updates); }
+
+        if (metaToRun.length) { const updates = await runMetaComputationPass(dateToProcess, metaToRun, `Pass ${passToRun} (Meta)`, config, dependencies, existingResults, previousResults, rootData, false);
+            Object.assign(dateUpdates, updates); }
+
     } catch (err) {
         logger.log('ERROR', `[DateRunner] FAILED Pass ${passToRun} for ${dateStr}`, { errorMessage: err.message });
         [...standardToRun, ...metaToRun].forEach(c => dateUpdates[normalizeName(c.name)] = false);
         throw err; 
     }
 
-    if (Object.keys(dateUpdates).length > 0) {
-        await updateComputationStatus(dateStr, dateUpdates, config, dependencies);
-    }
+    if (Object.keys(dateUpdates).length > 0) { await updateComputationStatus(dateStr, dateUpdates, config, dependencies); }
 
     return { date: dateStr, updates: dateUpdates };
 }

package/functions/computation-system/helpers/computation_worker.js

@@ -17,70 +17,28 @@ async function handleComputationTask(message, config, dependencies, computationM
     let data;
     try {
         // 1. Handle Cloud Functions Gen 2 (CloudEvent)
-        // Structure: event.data.message.data (base64)
-        if (message.data && message.data.message && message.data.message.data) {
-            const buffer = Buffer.from(message.data.message.data, 'base64');
-            data = JSON.parse(buffer.toString());
-        }
+        if (message.data && message.data.message && message.data.message.data) { const buffer = Buffer.from(message.data.message.data, 'base64'); data = JSON.parse(buffer.toString()); }
         // 2. Handle Cloud Functions Gen 1 / Legacy PubSub
-        // Structure: message.data (base64) or message.json
-        else if (message.data && typeof message.data === 'string') {
-            const buffer = Buffer.from(message.data, 'base64');
-            data = JSON.parse(buffer.toString());
-        }
+        else if (message.data && typeof message.data === 'string') { const buffer = Buffer.from(message.data, 'base64'); data = JSON.parse(buffer.toString()); }
         // 3. Handle Direct JSON (Test harness or simulator)
-        else if (message.json) {
-            data = message.json;
-        }
+        else if (message.json) { data = message.json; }
         // 4. Fallback: Assume message is the payload
-        else {
-            data = message;
-        }
-    } catch (parseError) {
-        logger.log('ERROR', `[Worker] Failed to parse Pub/Sub payload.`, { error: parseError.message });
-        return;
-    }
+        else { data = message; }
+    } catch (parseError) { logger.log('ERROR', `[Worker] Failed to parse Pub/Sub payload.`, { error: parseError.message }); return; }
 
     try {
         // Validate Action
-        if (!data || data.action !== 'RUN_COMPUTATION_DATE') {
-            // Only log if data exists but action is wrong, prevents log spam on empty messages
-            if (data) logger.log('WARN', `[Worker] Unknown or missing action: ${data?.action}. Ignoring.`);
-            return;
-        }
-
+        if (!data || data.action !== 'RUN_COMPUTATION_DATE') { if (data) logger.log('WARN', `[Worker] Unknown or missing action: ${data?.action}. Ignoring.`); return; }
         const { date, pass } = data;
-
-        if (!date || !pass) {
-            logger.log('ERROR', `[Worker] Missing date or pass in payload: ${JSON.stringify(data)}`);
-            return;
-        }
-
+        if (!date || !pass) { logger.log('ERROR', `[Worker] Missing date or pass in payload: ${JSON.stringify(data)}`); return; }
         logger.log('INFO', `[Worker] Received task: Date=${date}, Pass=${pass}`);
-
-        // Resolve calculations for this pass
         const passes = groupByPass(computationManifest);
         const calcsInThisPass = passes[pass] || [];
-
-        if (!calcsInThisPass.length) {
-            logger.log('WARN', `[Worker] No calculations found for Pass ${pass}.`);
-            return;
-        }
-
-        // Execute the computation for this specific date
-        // The runner internally checks dependencies (Pass 1, 2, 3 status) and skips if not ready.
+        if (!calcsInThisPass.length) { logger.log('WARN', `[Worker] No calculations found for Pass ${pass}.`); return; }
         const result = await runDateComputation(date, pass, calcsInThisPass, config, dependencies, computationManifest);
-
-        if (result) {
-            logger.log('INFO', `[Worker] Successfully processed ${date} (Pass ${pass}). Updates: ${Object.keys(result.updates || {}).length}`);
-        } else {
-            logger.log('INFO', `[Worker] Processed ${date} (Pass ${pass}) - Skipped (Dependencies missing or already done).`);
-        }
-
-    } catch (err) {
-        logger.log('ERROR', `[Worker] Fatal error processing task: ${err.message}`, { stack: err.stack });
-        throw err; // Re-throw to trigger Pub/Sub retry
-    }
+        if (result) { logger.log('INFO', `[Worker] Successfully processed ${date} (Pass ${pass}). Updates: ${Object.keys(result.updates || {}).length}`);
+        } else { logger.log('INFO', `[Worker] Processed ${date} (Pass ${pass}) - Skipped (Dependencies missing or already done).`); }
+    } catch (err) { logger.log('ERROR', `[Worker] Fatal error processing task: ${err.message}`, { stack: err.stack }); throw err;  }
 }
 
 module.exports = { handleComputationTask };