bulltrackers-module 1.0.244 → 1.0.245

package/functions/computation-system/WorkflowOrchestrator.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Main Orchestrator. Coordinates the topological execution.
- * UPDATED: Added 'executeDispatchTask' for trusted execution from Smart Dispatcher.
+ * UPDATED: Implements State Simulation for accurate single-pass reporting.
  */
 const { normalizeName, DEFINITIVE_EARLIEST_DATES }         = require('./utils/utils');
 const { checkRootDataAvailability }                        = require('./data/AvailabilityChecker');
@@ -21,6 +21,8 @@ function groupByPass(manifest) {
 
 /**
  * Analyzes whether calculations should run, be skipped, or are blocked.
+ * NOW WITH SIMULATION: Updates a local status map as it progresses to ensure
+ * downstream dependencies 'see' the decisions made by upstream calculations.
  */
 function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus = null) {
     const report = {
@@ -32,11 +34,16 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         skipped: []           
     };
 
+    // [SIMULATION STATE] Clone the initial DB status. 
+    // We will update this locally as we make decisions, allowing 'future' calcs 
+    // in this list to see the predicted state of their dependencies.
+    const simulationStatus = { ...dailyStatus };
+
     const isTargetToday = (dateStr === new Date().toISOString().slice(0, 10));
 
-    const isDepSatisfied = (depName, dailyStatus, manifestMap) => {
+    const isDepSatisfied = (depName, currentStatusMap, manifestMap) => {
         const norm = normalizeName(depName);
-        const stored = dailyStatus[norm]; 
+        const stored = currentStatusMap[norm]; 
         const depManifest = manifestMap.get(norm);
 
         if (!stored) return false;
@@ -49,20 +56,37 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 
     for (const calc of calcsInPass) {
         const cName = normalizeName(calc.name);
-        const stored = dailyStatus[cName];
+        
+        // Use simulationStatus instead of dailyStatus
+        const stored = simulationStatus[cName];
         
         const storedHash = stored ? stored.hash : null;
         const storedCategory = stored ? stored.category : null;
         const currentHash = calc.hash;
 
+        // Decision Helpers
+        const markImpossible = (reason) => {
+            report.impossible.push({ name: cName, reason });
+            // UPDATE SIMULATION: Downstream deps will now see this as IMPOSSIBLE
+            simulationStatus[cName] = { hash: STATUS_IMPOSSIBLE, category: calc.category };
+        };
+
+        const markRunnable = (isReRun = false, reRunDetails = null) => {
+            if (isReRun) report.reRuns.push(reRunDetails);
+            else report.runnable.push(calc);
+            // UPDATE SIMULATION: Downstream deps will see this as SUCCESS (matching hash)
+            simulationStatus[cName] = { hash: currentHash, category: calc.category };
+        };
+
         let migrationOldCategory = null;
         if (storedCategory && storedCategory !== calc.category) {
             migrationOldCategory = storedCategory;
         }
 
-        // 1. Check Impossible
+        // 1. Check Impossible (Previously recorded)
         if (storedHash === STATUS_IMPOSSIBLE) {
             report.skipped.push({ name: cName, reason: 'Permanently Impossible' });
+            // Simulation state remains IMPOSSIBLE
             continue;
         }
 
@@ -80,40 +104,46 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 
         if (missingRoots.length > 0) {
             if (!isTargetToday) {
-                report.impossible.push({ name: cName, reason: `Missing Root Data: ${missingRoots.join(', ')} (Historical)` });
+                // If it's a past date and root data is missing, it's permanently impossible.
+                markImpossible(`Missing Root Data: ${missingRoots.join(', ')} (Historical)`);
             } else {
+                // If it's today, we might just be early. Block, don't Impossible.
                 report.blocked.push({ name: cName, reason: `Missing Root Data: ${missingRoots.join(', ')} (Waiting)` });
+                // We DO NOT update simulationStatus here because it's not permanently dead, just waiting.
             }
             continue;
         }
 
-        // 3. Dependency Check
+        // 3. Dependency Check (Using Simulation Status)
         let dependencyIsImpossible = false;
         const missingDeps = [];
         
         if (calc.dependencies) {
             for (const dep of calc.dependencies) {
                 const normDep = normalizeName(dep);
-                const depStored = dailyStatus[normDep];
+                
+                // LOOK AT SIMULATION STATUS, NOT DB SNAPSHOT
+                const depStored = simulationStatus[normDep];
                 
                 if (depStored && depStored.hash === STATUS_IMPOSSIBLE) {
                     dependencyIsImpossible = true;
                     break; 
                 }
 
-                if (!isDepSatisfied(dep, dailyStatus, manifestMap)) {
+                if (!isDepSatisfied(dep, simulationStatus, manifestMap)) {
                     missingDeps.push(dep);
                 }
             }
         }
 
         if (dependencyIsImpossible) {
-            report.impossible.push({ name: cName, reason: 'Dependency is Impossible' });
+            markImpossible('Dependency is Impossible');
             continue;
         }
 
         if (missingDeps.length > 0) {
             report.failedDependency.push({ name: cName, missing: missingDeps });
+            // Do not update simulation status; downstream will see this as 'missing' (Blocked)
             continue;
         }
 
@@ -137,16 +167,16 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 
         // 5. Runnable Decision
         if (!storedHash) { 
-            report.runnable.push(calc);
+            markRunnable();
         } else if (storedHash !== currentHash) {
-            report.reRuns.push({ 
+            markRunnable(true, { 
                 name: cName, 
                 oldHash: storedHash, 
                 newHash: currentHash,
                 previousCategory: migrationOldCategory 
             });
         } else if (migrationOldCategory) {
-            report.reRuns.push({ 
+            markRunnable(true, { 
                 name: cName, 
                 reason: 'Category Migration', 
                 previousCategory: migrationOldCategory, 
@@ -154,6 +184,8 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
             });
         } else {
             report.skipped.push({ name: cName });
+            // Even if skipped, ensure simulation status is fresh/set (it usually is from clone)
+            simulationStatus[cName] = { hash: currentHash, category: calc.category };
         }
     }
 
@@ -177,10 +209,8 @@ async function executeDispatchTask(dateStr, pass, targetComputation, config, dep
     }
 
     // 2. Fetch Root Data References (Required for execution streaming)
-    // Even though Dispatcher checked existence, we need the actual Refs/Data objects now.
     const rootData = await checkRootDataAvailability(dateStr, config, dependencies, DEFINITIVE_EARLIEST_DATES);
     
-    // Safety Fallback (Should be impossible if Dispatcher is working)
     if (!rootData) {
         logger.log('ERROR', `[Executor] FATAL: Root data missing for ${targetComputation} on ${dateStr}. Dispatcher desync?`);
         return;
@@ -239,18 +269,14 @@ async function executeDispatchTask(dateStr, pass, targetComputation, config, dep
 
 /**
  * Legacy/Orchestrator Mode execution (Performs analysis).
- * Kept for manual runs or full-system validation.
  */
 async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, dependencies, computationManifest) {
-    // ... [Previous implementation of runDateComputation can remain here if needed for backward compatibility, 
-    // ... or can be removed if the system is fully migrated. Keeping logic for "Dispatcher uses analyzeDateExecution"]
-    
-    // Re-exporting executeDispatchTask as the primary worker entry point.
+    // Legacy support logic...
 }
 
 module.exports = { 
     runDateComputation, 
-    executeDispatchTask, // <--- NEW EXPORT
+    executeDispatchTask, 
     groupByPass, 
     analyzeDateExecution 
 };

package/package.json

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