bulltrackers-module 1.0.219 → 1.0.221

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

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Manages computation status tracking in Firestore.
+ */
+
+async function fetchComputationStatus(dateStr, config, { db }) {
+    // FIX: Check dateStr directly, or define 'key' before checking it.
+    if (!dateStr) throw new Error('fetchStatus requires a key'); 
+    
+    const key = dateStr;
+    const collection = config.computationStatusCollection || 'computation_status';
+    const docRef = db.collection(collection).doc(key);
+    
+    const snap = await docRef.get();
+    return snap.exists ? snap.data() : {};
+}
+
+async function updateComputationStatus(dateStr, updates, config, { db }) {
+    if (!dateStr) throw new Error('updateStatus requires a key');
+    
+    if (!updates || Object.keys(updates).length === 0) return;
+    
+    const collection = config.computationStatusCollection || 'computation_status';
+    const docRef = db.collection(collection).doc(dateStr);
+    
+    await docRef.set(updates, { merge: true });
+    return true;
+}
+
+module.exports = { fetchComputationStatus, updateComputationStatus };

package/functions/computation-system/topology/HashManager.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Manages code versioning, hashing, and legacy mappings.
+ */
+const crypto = require('crypto');
+
+// Legacy Keys Mapping (Ensures backward compatibility)
+const LEGACY_MAPPING = {
+    DataExtractor: 'extract',
+    HistoryExtractor: 'history',
+    MathPrimitives: 'compute',
+    Aggregators: 'aggregate',
+    Validators: 'validate',
+    SignalPrimitives: 'signals',
+    SCHEMAS: 'schemas',
+    DistributionAnalytics: 'distribution',
+    TimeSeries: 'TimeSeries',
+    priceExtractor: 'priceExtractor',
+    InsightsExtractor: 'insights',
+    UserClassifier: 'classifier',
+    Psychometrics: 'psychometrics',
+    CognitiveBiases: 'bias',
+    SkillAttribution: 'skill',
+    ExecutionAnalytics: 'execution',
+    AdaptiveAnalytics: 'adaptive'
+};
+
+function generateCodeHash(codeString) {
+    if (!codeString) return 'unknown';
+    let clean = codeString.replace(/\/\/.*$/gm, '');
+    clean = clean.replace(/\/\*[\s\S]*?\*\//g, '');
+    clean = clean.replace(/\s+/g, '');
+    return crypto.createHash('sha256').update(clean).digest('hex');
+}
+
+module.exports = { LEGACY_MAPPING, generateCodeHash };

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

@@ -3,7 +3,7 @@
  */
 
 const { FieldValue, FieldPath } = require('@google-cloud/firestore');
-const crypto = require('crypto');
+const crypto                    = require('crypto');
 
 /** Stage 1: Normalize a calculation name to kebab-case */
 function normalizeName(name) { return name.replace(/_/g, '-'); }
@@ -19,12 +19,34 @@ function generateCodeHash(codeString) {
     return crypto.createHash('sha256').update(clean).digest('hex');
 }
 
+/**
+ * Executes a function with exponential backoff retry logic.
+ * @param {Function} fn - Async function to execute
+ * @param {string} operationName - Label for logging
+ * @param {number} maxRetries - Max attempts (default 3)
+ */
+async function withRetry(fn, operationName, maxRetries = 3) {
+    let attempt = 0;
+    while (attempt < maxRetries) {
+        try {
+            return await fn();
+        } catch (error) {
+            attempt++;
+            console.warn(`[Retry] ${operationName} failed (Attempt ${attempt}/${maxRetries}): ${error.message}`);
+            if (attempt >= maxRetries) throw error;
+            // Exponential backoff: 1s, 2s, 4s...
+            await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, attempt - 1)));
+        }
+    }
+}
+
 /** * Stage 2: Commit a batch of writes in chunks 
  * FIXED: Now respects write.options (e.g. { merge: false }) to allow overwrites/deletes.
  */
 async function commitBatchInChunks(config, deps, writes, operationName) {
-    const { db, logger, calculationUtils } = deps;
-    const { withRetry } = calculationUtils;
+    const { db, logger } = deps;
+    // Use the local withRetry if not provided in deps
+    const retryFn = (deps.calculationUtils && deps.calculationUtils.withRetry) ? deps.calculationUtils.withRetry : withRetry;
 
     if (!writes || !writes.length) {
         logger.log('WARN', `[${operationName}] No writes to commit.`);
@@ -42,7 +64,7 @@ async function commitBatchInChunks(config, deps, writes, operationName) {
     const commitAndReset = async () => {
         if (currentOpsCount > 0) {
             try {
-                await withRetry(
+                await retryFn(
                     () => currentBatch.commit(),
                     `${operationName} (Chunk ${batchIndex})`
                 );
@@ -94,8 +116,7 @@ function getExpectedDateStrings(startDate, endDate) {
 
 /** Stage 4: Get the earliest date in a *flat* collection where doc IDs are dates. */
 async function getFirstDateFromSimpleCollection(config, deps, collectionName) {
-    const { db, logger, calculationUtils } = deps;
-    const { withRetry } = calculationUtils;
+    const { db, logger } = deps;
     try {
         if (!collectionName) { logger.log('WARN', `[Core Utils] Collection name not provided for simple date query.`); return null; }
         const query = db.collection(collectionName).where(FieldPath.documentId(), '>=', '2000-01-01').orderBy(FieldPath.documentId(), 'asc').limit(1);
@@ -107,8 +128,7 @@ async function getFirstDateFromSimpleCollection(config, deps, collectionName) {
 
 /** Stage 4: Get the earliest date in a sharded collection */
 async function getFirstDateFromCollection(config, deps, collectionName) {
-    const { db, logger, calculationUtils } = deps;
-    const { withRetry } = calculationUtils;
+    const { db, logger } = deps;
     let earliestDate = null;
     try {
         if (!collectionName) { logger.log('WARN', `[Core Utils] Collection name not provided for sharded date query.`); return null; }
@@ -165,8 +185,7 @@ async function getEarliestDataDates(config, deps) {
 }
 
 async function getFirstDateFromPriceCollection(config, deps) {
-    const { db, logger, calculationUtils } = deps;
-    const { withRetry } = calculationUtils;
+    const { db, logger } = deps;
     const collection = config.priceCollection || 'asset_prices';
     try {
         const snapshot = await withRetry(() => db.collection(collection).limit(10).get(), `GetPriceShards(${collection})`);
@@ -184,4 +203,13 @@ async function getFirstDateFromPriceCollection(config, deps) {
     } catch (e) { logger.log('ERROR', `Failed to get earliest price date from ${collection}`, { errorMessage: e.message }); return null; }
 }
 
-module.exports = { FieldValue, FieldPath, normalizeName, commitBatchInChunks, getExpectedDateStrings, getEarliestDataDates, generateCodeHash };
+module.exports = { 
+    FieldValue, 
+    FieldPath, 
+    normalizeName, 
+    commitBatchInChunks, 
+    getExpectedDateStrings, 
+    getEarliestDataDates, 
+    generateCodeHash,
+    withRetry // Exported here
+};

package/index.js

@@ -43,14 +43,19 @@ const taskEngine = {
     handleUpdate: require('./functions/task-engine/helpers/update_helpers').handleUpdate
 };
 
-// --- NEW IMPORT ---
-const { build: buildManifestFunc } = require('./functions/computation-system/helpers/computation_manifest_builder');
+// --- UPDATED IMPORT: Point to the new Context Domain ---
+const { build: buildManifestFunc } = require('./functions/computation-system/context/ManifestBuilder');
 
 // Computation System
 const computationSystem = {
-    runComputationPass: require('./functions/computation-system/helpers/computation_pass_runner').runComputationPass,
+    // UPDATED: Point to the new Workflow Orchestrator
+    runComputationPass: require('./functions/computation-system/WorkflowOrchestrator').runComputationPass,
+    
+    // These helpers wrap the Orchestrator, so they stay, but we updated their internals (see below)
     dispatchComputationPass: require('./functions/computation-system/helpers/computation_dispatcher').dispatchComputationPass,
     handleComputationTask: require('./functions/computation-system/helpers/computation_worker').handleComputationTask,
+    
+    // Utils
     dataLoader: require('./functions/computation-system/utils/data_loader'),
     computationUtils: require('./functions/computation-system/utils/utils'),
     buildManifest: buildManifestFunc

package/package.json

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

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

@@ -1,320 +0,0 @@
-/**
- * @fileoverview
- * Dynamic Manifest Builder (v6.1 - Granular Merkle Tree Dependency Hashing)
- *
- * KEY FEATURES:
- * 1. Smart Granular Hashing: Detects SPECIFIC classes used within layers to avoid unnecessary re-runs.
- * - Changing 'MathPrimitives' won't invalidate computations that only use 'SignalPrimitives'.
- * 2. Cascading Invalidation (Merkle Hashing): 
- * The final hash of a computation is derived from:
- * [Own Code] + [Specific Layer Class Hashes] + [Hashes of all Dependencies]
- */
-
-const { generateCodeHash } = require('../utils/utils');
-
-// 1. Import Layers directly to generate their "State Hashes"
-const MathematicsLayer = require('../layers/mathematics');
-const ExtractorsLayer  = require('../layers/extractors');
-const ProfilingLayer   = require('../layers/profiling');
-const ValidatorsLayer  = require('../layers/validators');
-
-/* --------------------------------------------------
- * 1. Granular Layer Hash Generation
- * -------------------------------------------------- */
-
-/**
- * Generates a map of hashes for every export in a layer.
- * Returns: { 'MathPrimitives': 'sha256...', 'SignalPrimitives': 'sha256...', ... }
- */
-function generateLayerHashes(layerExports, layerName) {
-    const hashes = {};
-    const keys = Object.keys(layerExports).sort(); 
-
-    for (const key of keys) {
-        const item = layerExports[key];
-        // We hash the specific export content prefixed with its identity
-        let source = `LAYER:${layerName}:EXPORT:${key}`;
-
-        if (typeof item === 'function') {
-            source += item.toString();
-        } else if (typeof item === 'object' && item !== null) {
-            source += JSON.stringify(item);
-        } else {
-            source += String(item);
-        }
-        
-        hashes[key] = generateCodeHash(source);
-    }
-    return hashes;
-}
-
-// Pre-compute granular layer hashes at startup
-// Structure: { mathematics: { MathPrimitives: '...', SignalPrimitives: '...' }, ... }
-const LAYER_HASHES = {
-    'mathematics': generateLayerHashes(MathematicsLayer, 'mathematics'),
-    'extractors':  generateLayerHashes(ExtractorsLayer,  'extractors'),
-    'profiling':   generateLayerHashes(ProfilingLayer,   'profiling'),
-    'validators':  generateLayerHashes(ValidatorsLayer,  'validators')
-};
-
-// Map code patterns to SPECIFIC Layer Exports
-// Structure: { LayerName: { ExportName: [Triggers...] } }
-const LAYER_TRIGGERS = {
-    'mathematics': {
-        'MathPrimitives':        ['math.compute', 'MathPrimitives'],
-        'SignalPrimitives':      ['math.signals', 'SignalPrimitives', 'signals.'],
-        'Aggregators':           ['math.aggregate', 'Aggregators'],
-        'TimeSeries':            ['math.timeseries', 'TimeSeries', 'timeSeries.'],
-        'TimeSeriesAnalysis':    ['TimeSeriesAnalysis'],
-        'DistributionAnalytics': ['math.distribution', 'DistributionAnalytics', 'distribution.'],
-        'FinancialEngineering':  ['math.financial', 'FinancialEngineering']
-    },
-    'extractors': {
-        'DataExtractor':         ['math.extract', 'DataExtractor'],
-        'HistoryExtractor':      ['math.history', 'HistoryExtractor'],
-        'priceExtractor':        ['math.prices', 'priceExtractor'],
-        'InsightsExtractor':     ['math.insights', 'InsightsExtractor', 'insights.'],
-        'TradeSeriesBuilder':    ['math.tradeSeries', 'TradeSeriesBuilder']
-    },
-    'profiling': {
-        'SCHEMAS':               ['math.profiling', 'SCHEMAS'],
-        'UserClassifier':        ['math.classifier', 'UserClassifier'],
-        'Psychometrics':         ['math.psychometrics', 'Psychometrics'],
-        'CognitiveBiases':       ['math.bias', 'CognitiveBiases'],
-        'SkillAttribution':      ['math.skill', 'SkillAttribution'],
-        'ExecutionAnalytics':    ['ExecutionAnalytics'],
-        'AdaptiveAnalytics':     ['AdaptiveAnalytics']
-    },
-    'validators': {
-        'Validators':            ['math.validate', 'Validators']
-    }
-};
-
-/* --------------------------------------------------
- * 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),
-    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`); },
-};
-
-/* --------------------------------------------------
- * Helper Utilities
- * -------------------------------------------------- */
-
-const normalizeName = (name) => { if (typeof name !== 'string') return name; return name.trim().replace(/,$/, '').replace(/_/g, '-').toLowerCase(); };
-
-function suggestClosest(name, candidates, n = 3) {
-    const levenshtein = (a = '', b = '') => {
-        const m = a.length, n = b.length;
-        if (!m) return n; if (!n) return m;
-        const dp = Array.from({ length: m + 1 }, (_, i) => Array(n + 1).fill(i));
-        for (let j = 0; j <= n; j++) dp[0][j] = j;
-        for (let i = 1; i <= m; i++)
-        for (let j = 1; j <= n; j++)
-        dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : Math.min(dp[i - 1][j - 1], dp[i][j - 1], dp[i - 1][j]) + 1;
-        return dp[m][n];
-    };
-    const scores = candidates.map(c => [c, levenshtein(name, c)]);
-    scores.sort((a, b)              => a[1] - b[1]);
-    return scores.slice(0, n).map(s => s[0]);
-}
-
-function getDependencySet(endpoints, adjacencyList) {
-    const required = new Set(endpoints);
-    const queue    = [...endpoints];
-    while (queue.length > 0) { const calcName = queue.shift(); const dependencies = adjacencyList.get(calcName);
-    if (dependencies) { for (const dep of dependencies) { if (!required.has(dep)) { required.add(dep); queue.push(dep); } } } }
-    return required;
-}
-
-/* --------------------------------------------------
- * Core Manifest Builder
- * -------------------------------------------------- */
-
-function buildManifest(productLinesToRun = [], calculations) {
-    log.divider('Building Dynamic Manifest (Granular Merkle Hashing)');
-    log.info(`Target Product Lines: [${productLinesToRun.join(', ')}]`);
-    
-    const manifestMap      = new Map();
-    const adjacency        = new Map(); 
-    const reverseAdjacency = new Map(); 
-    const inDegree         = new Map();
-    let hasFatalError      = false;
-    
-    /* ---------------- 1. Load All Calculations (Phase 1: Intrinsic Hash) ---------------- */
-    log.step('Loading and validating all calculation classes…');
-
-    function processCalc(Class, name, folderName) {
-        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.getDependencies !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getDependencies().`); hasFatalError = true;return; }
-        
-        const metadata     = Class.getMetadata();
-        const dependencies = Class.getDependencies().map(normalizeName);
-        
-        const codeStr = Class.toString();
-        if (metadata.isHistorical === true && !codeStr.includes('yesterday') && !codeStr.includes('previousComputed')) { 
-            log.warn(`Calculation "${normalizedName}" marked 'isHistorical' but no 'previousComputed' state reference found.`); 
-        }
-
-        let finalCategory = folderName === 'core' && metadata.category ? metadata.category : folderName;
-
-        // --- PHASE 1: INTRINSIC HASH (Code + Granular Layers) ---
-        let compositeHashString = generateCodeHash(codeStr); 
-        const usedDeps = [];
-
-        // Check for specific layer usage (Granular Check)
-        for (const [layerName, exportsMap] of Object.entries(LAYER_TRIGGERS)) {
-            const layerHashes = LAYER_HASHES[layerName]; // { Export: Hash }
-
-            for (const [exportName, triggers] of Object.entries(exportsMap)) {
-                // If code uses this specific export...
-                if (triggers.some(trigger => codeStr.includes(trigger))) {
-                    const exportHash = layerHashes[exportName];
-                    if (exportHash) {
-                        compositeHashString += exportHash;
-                        usedDeps.push(`${layerName}.${exportName}`);
-                    }
-                }
-            }
-        }
-
-        // Safe Mode Fallback: If no dependencies detected, assume usage of ALL to be safe.
-        let isSafeMode = false;
-        if (usedDeps.length === 0) {
-            isSafeMode = true;
-            Object.values(LAYER_HASHES).forEach(layerObj => {
-                Object.values(layerObj).forEach(h => compositeHashString += h);
-            });
-        }
-
-        const baseHash = generateCodeHash(compositeHashString);
-
-        const manifestEntry = {
-            name: normalizedName,
-            class: Class,
-            category: finalCategory,     
-            sourcePackage: folderName,   
-            type: metadata.type,
-            isHistorical: metadata.isHistorical, 
-            rootDataDependencies: metadata.rootDataDependencies || [],
-            userType: metadata.userType,
-            dependencies: dependencies,
-            pass: 0,
-            hash: baseHash,
-            debugUsedLayers: isSafeMode ? ['ALL (Safe Mode)'] : usedDeps
-        };
-        
-        manifestMap.set(normalizedName, manifestEntry);
-        adjacency.set(normalizedName, dependencies);
-        inDegree.set(normalizedName, dependencies.length);
-        dependencies.forEach(dep => { if (!reverseAdjacency.has(dep)) reverseAdjacency.set(dep, []); reverseAdjacency.get(dep).push(normalizedName); }); 
-    }
-    
-    if (!calculations || typeof calculations !== 'object') {
-        throw new Error('Manifest build failed: Invalid calculations object.');
-    }
-
-    for (const folderName in calculations) {
-        if (folderName === 'legacy') continue;
-        const group = calculations[folderName];
-        for (const key in group) {
-            const entry = group[key];
-            if (typeof entry === 'function') { processCalc(entry, key, folderName);  } 
-        } 
-    }
-
-    if (hasFatalError) { throw new Error('Manifest build failed due to missing static methods.'); }
-    log.success(`Loaded ${manifestMap.size} calculations.`);
-
-    /* ---------------- 2. Validate Dependency Links ---------------- */
-    const allNames = new Set(manifestMap.keys());
-    let invalidLinks = false;
-    for (const [name, entry] of manifestMap) {
-        for (const dep of entry.dependencies) {
-            if (!allNames.has(dep)) {
-                invalidLinks = true;
-                const guesses = suggestClosest(dep, Array.from(allNames));
-                log.error(`${name} depends on unknown calculation "${dep}". Did you mean: ${guesses.join(', ')}?`);
-            }
-            if (dep === name) {
-                invalidLinks = true;
-                log.error(`${name} has a circular dependency on *itself*!`);
-            }
-        }
-    }
-    if (invalidLinks) { throw new Error('Manifest validation failed.'); }
-
-    /* ---------------- 3. Filter for Product Lines ---------------- */
-    const productLineEndpoints = [];
-    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.`);
-
-    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); }
-
-    /* ---------------- 4. Topological Sort ---------------- */
-    const sortedManifest = [];
-    const queue          = [];
-    let maxPass          = 0;
-
-    for (const [name, degree] of filteredInDegree) { if (degree === 0) { queue.push(name); filteredManifestMap.get(name).pass = 1; maxPass = 1; } }
-    queue.sort();
-    while (queue.length) {
-        const currentName = queue.shift();
-        const currentEntry = filteredManifestMap.get(currentName);
-        sortedManifest.push(currentEntry);
-        
-        for (const neighborName of (filteredReverseAdjacency.get(currentName) || [])) { const newDegree = filteredInDegree.get(neighborName) - 1; filteredInDegree.set(neighborName, newDegree);
-            const neighborEntry = filteredManifestMap.get(neighborName);
-            if (neighborEntry.pass <= currentEntry.pass) { neighborEntry.pass = currentEntry.pass + 1; if (neighborEntry.pass > maxPass) maxPass = neighborEntry.pass; }
-            if (newDegree === 0) { queue.push(neighborName); } }
-        queue.sort(); }
-
-    if (sortedManifest.length !== filteredManifestMap.size) {
-        throw new Error('Circular dependency detected. Manifest build failed.'); }
-
-    /* ---------------- 5. Phase 2: Cascading Dependency Hashing ---------------- */
-    log.step('Computing Cascading Merkle Hashes...');
-
-    for (const entry of sortedManifest) {
-        // Start with the intrinsic hash (Code + Granular Layers)
-        let dependencySignature = entry.hash;
-
-        if (entry.dependencies && entry.dependencies.length > 0) {
-            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);
-    }
-
-    log.success(`Total passes required: ${maxPass}`);
-    return sortedManifest;
-}
-
-function build(productLinesToRun, calculations) {
-    try {
-        return buildManifest(productLinesToRun, calculations);
-    } catch (error) { 
-        log.error(error.message); 
-        return null; 
-    }
-}
-
-module.exports = { build };

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

@@ -1,119 +0,0 @@
-/**
- * FILENAME: bulltrackers-module/functions/computation-system/helpers/computation_pass_runner.js
- * FIXED: 'storedStatus.substring' crash and 'missing dependency' log clarity.
- */
-
-const {
-    groupByPass,
-    checkRootDataAvailability,
-    fetchExistingResults,
-    fetchComputationStatus,
-    updateComputationStatus,
-    runStandardComputationPass,
-    runMetaComputationPass,
-    checkRootDependencies,
-    runBatchPriceComputation
-} = require('./orchestration_helpers.js');
-
-const { getExpectedDateStrings, normalizeName } = require('../utils/utils.js');
-
-const PARALLEL_BATCH_SIZE = 7;
-
-async function runComputationPass(config, dependencies, computationManifest) {
-    const { logger } = dependencies;
-    const passToRun  = String(config.COMPUTATION_PASS_TO_RUN);
-    if (!passToRun) return logger.log('ERROR', '[PassRunner] No pass defined. Aborting.');
-
-    logger.log('INFO', `🚀 Starting PASS ${passToRun} (Legacy Mode)...`);
-
-    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')
-    };
-
-    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);
-    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); 
-        } catch (e) { logger.log('ERROR', 'Legacy Batch Price failed', e); }
-    }
-
-    if (standardAndOtherMetaCalcs.length === 0) return;
-
-    for (let i = 0; i < allExpectedDates.length; i += PARALLEL_BATCH_SIZE) {
-        const batch = allExpectedDates.slice(i, i + PARALLEL_BATCH_SIZE);
-        await Promise.all(batch.map(dateStr => runDateComputation(dateStr, passToRun, standardAndOtherMetaCalcs, config, dependencies, computationManifest)));
-    }
-}
-
-async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, dependencies, computationManifest) {
-    const { logger }    = dependencies;
-    const dateToProcess = new Date(dateStr + 'T00:00:00Z');
-    const dailyStatus   = await fetchComputationStatus(dateStr, config, dependencies);
-    const calcsToAttempt = [];
-    for (const calc of calcsInThisPass) {
-        const cName        = normalizeName(calc.name);
-        const storedStatus = dailyStatus[cName];
-        const currentHash  = calc.hash;
-
-        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; } }
-        if (!storedStatus) { logger.log('INFO', `[Versioning] ${cName}: New run needed (No prior status).`); 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; }
-        if (storedStatus === true && currentHash) { logger.log('INFO', `[Versioning] ${cName}: Upgrading legacy status to Hash.`); calcsToAttempt.push(calc); continue; }
-    }
-
-    if (!calcsToAttempt.length) return null;
-
-    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')
-    };
-
-    const rootData = await checkRootDataAvailability(dateStr, config, dependencies, earliestDates);
-    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); }
-
-    } 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); }
-
-    return { date: dateStr, updates: dateUpdates };
-}
-
-module.exports = { runComputationPass, runDateComputation };