bulltrackers-module 1.0.258 → 1.0.260

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

@@ -1,18 +1,26 @@
 /**
  * @fileoverview Handles saving computation results with observability and Smart Cleanup.
  * UPDATED: Returns detailed failure reports for the Run Ledger.
+ * UPDATED: Stops retrying on non-transient errors (Permissions, Invalid Args).
  */
-const { commitBatchInChunks }     = require('./FirestoreUtils');
-const { updateComputationStatus } = require('./StatusRepository');
-const { batchStoreSchemas }       = require('../utils/schema_capture');
+const { commitBatchInChunks }              = require('./FirestoreUtils');
+const { updateComputationStatus }          = require('./StatusRepository');
+const { batchStoreSchemas }                = require('../utils/schema_capture');
 const { generateProcessId, PROCESS_TYPES } = require('../logger/logger');
 
-const { HeuristicValidator } = require('./ResultsValidator'); // Validator
-const validationOverrides = require('../config/validation_overrides'); // Override file
+const { HeuristicValidator }               = require('./ResultsValidator');
+const validationOverrides                  = require('../config/validation_overrides'); 
+
+const NON_RETRYABLE_ERRORS = [
+    'INVALID_ARGUMENT',      // Schema/Type mismatch
+    'PERMISSION_DENIED',     // Auth issue
+    'DATA_LOSS',             // Firestore corruption
+    'FAILED_PRECONDITION'    // Transaction requirements not met
+];
 
 async function commitResults(stateObj, dStr, passName, config, deps, skipStatusWrite = false) {
     const successUpdates = {};
-    const failureReport  = []; // [NEW] Track failures per calculation
+    const failureReport  = [];
     const schemas        = [];
     const cleanupTasks   = []; 
     const { logger, db } = deps;
@@ -25,21 +33,18 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
         try {
             const result = await calc.getResult();
 
-            const overrides = validationOverrides[calc.manifest.name] || {};
+            const overrides   = validationOverrides[calc.manifest.name] || {};
             const healthCheck = HeuristicValidator.analyze(calc.manifest.name, result, overrides);
 
             if (!healthCheck.valid) {
-            // We throw a specific error stage so we know to BLOCK it, not retry it.
-                throw { 
-                    message: healthCheck.reason, 
-                    stage: 'QUALITY_CIRCUIT_BREAKER' 
-                };
+                throw { message: healthCheck.reason, stage: 'QUALITY_CIRCUIT_BREAKER' };
             }
             
-            // Validate Result
-            const isEmpty = !result ||  (typeof result === 'object' && Object.keys(result).length === 0) || (typeof result === 'number' && result === 0);
-
-            if (isEmpty) { if (calc.manifest.hash) { successUpdates[name] = {  hash: false,  category: calc.manifest.category  }; } continue; }
+            const isEmpty = !result || (typeof result === 'object' && Object.keys(result).length === 0) || (typeof result === 'number' && result === 0);
+            if (isEmpty) { 
+                if (calc.manifest.hash) { successUpdates[name] = {  hash: false,  category: calc.manifest.category  }; } 
+                continue; 
+            }
 
             const mainDocRef = db.collection(config.resultsCollection)
                 .doc(dStr)
@@ -48,29 +53,92 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                 .collection(config.computationsSubcollection)
                 .doc(name);
 
-            // [CRITICAL UPDATE] Catch errors specifically during Sharding/Prep
-            let updates;
-            try {
-                updates = await prepareAutoShardedWrites(result, mainDocRef, logger);
-            } catch (prepError) {
-                // If this fails, it's likely a memory or logic issue before DB commit
-                throw { message: prepError.message, stack: prepError.stack, stage: 'PREPARE_SHARDS' };
+            // --- REACTIVE SELF-HEALING LOOP ---
+            let committed = false;
+            // Strategy: 1=Normal, 2=Safe (Halved), 3=Aggressive (Quartered + Key Limit)
+            const strategies = [
+                { bytes: 900 * 1024, keys: null },      // Attempt 1: Standard
+                { bytes: 450 * 1024, keys: 10000 },     // Attempt 2: High Index usage
+                { bytes: 200 * 1024, keys: 2000 }       // Attempt 3: Extreme fragmentation
+            ];
+
+            let lastError = null;
+
+            for (let attempt = 0; attempt < strategies.length; attempt++) {
+                if (committed) break;
+                
+                const constraints = strategies[attempt];
+                
+                try {
+                    // 1. Prepare Shards with current constraints
+                    const updates = await prepareAutoShardedWrites(result, mainDocRef, logger, constraints.bytes, constraints.keys);
+
+                    // 2. Audit Ledger (Only add to the first update batch)
+                    if (passNum && calc.manifest) {
+                        const ledgerRef = db.collection(`computation_audit_ledger/${dStr}/passes/${passNum}/tasks`).doc(name);
+                        updates.push({
+                            ref: ledgerRef,
+                            data: {
+                                status: 'COMPLETED',
+                                completedAt: new Date(),
+                                actualHash: calc.manifest.hash,
+                                _verified: true,
+                                _shardingStrategy: attempt + 1 // Track which strategy worked
+                            },
+                            options: { merge: true }
+                        });
+                    }
+
+                    // 3. Attempt Commit
+                    const totalSize = updates.reduce((acc, u) => acc + (u.data ? JSON.stringify(u.data).length : 0), 0);
+                    const isSharded = updates.some(u => u.data._sharded === true);
+
+                    await commitBatchInChunks(config, deps, updates, `${name} Results (Att ${attempt+1})`);
+                    
+                    // Log Success
+                    if (logger && logger.logStorage) { 
+                        logger.logStorage(pid, name, dStr, mainDocRef.path, totalSize, isSharded); 
+                    }
+                    
+                    committed = true; // Exit loop
+
+                } catch (commitErr) {
+                    lastError = commitErr;
+                    const msg = commitErr.message || '';
+                    
+                    // [IMPROVED] Check for non-retryable errors
+                    const isNonRetryable = NON_RETRYABLE_ERRORS.some(code => msg.includes(code));
+                    if (isNonRetryable) {
+                        logger.log('ERROR', `[SelfHealing] ${name} encountered FATAL error (Attempt ${attempt + 1}): ${msg}. Aborting.`);
+                        throw commitErr; // Stop immediately
+                    }
+
+                    // Check if error is related to size/indexes
+                    const isSizeError  = msg.includes('Transaction too big')    || msg.includes('payload is too large');
+                    const isIndexError = msg.includes('too many index entries') || msg.includes('INVALID_ARGUMENT'); // Note: InvalidArg can be ambiguous, but usually index related in FS
+
+                    if (isSizeError || isIndexError) {
+                        logger.log('WARN', `[SelfHealing] ${name} failed write attempt ${attempt + 1}. Retrying with tighter constraints...`, { error: msg });
+                        continue; // Try next strategy
+                    } else {
+                        // If it's a network error or unknown, re-throw or handle based on policy. 
+                        // For now, we allow retrying loop if it wasn't explicitly fatal.
+                        logger.log('WARN', `[SelfHealing] ${name} unknown error (Attempt ${attempt + 1}). Retrying...`, { error: msg });
+                    }
+                }
             }
 
-            // Audit Ledger
-            if (passNum && calc.manifest) {
-                const ledgerRef = db.collection(`computation_audit_ledger/${dStr}/passes/${passNum}/tasks`).doc(name);
-                updates.push({
-                    ref: ledgerRef,
-                    data: {
-                        status: 'COMPLETED',
-                        completedAt: new Date(),
-                        actualHash: calc.manifest.hash,
-                        _verified: true
-                    },
-                    options: { merge: true }
-                });
+            if (!committed) {
+                throw { 
+                    message: `Exhausted sharding strategies. Last error: ${lastError?.message}`, 
+                    stack: lastError?.stack, 
+                    stage: 'SHARDING_LIMIT_EXCEEDED' 
+                };
             }
+            // ----------------------------------
+
+            // Mark Success
+            if (calc.manifest.hash) { successUpdates[name] = {  hash: calc.manifest.hash, category: calc.manifest.category  }; }
 
             // Capture Schema
             if (calc.manifest.class.getSchema) {
@@ -83,33 +151,12 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                 });
             }
 
-            if (updates.length > 0) {
-                const totalSize = updates.reduce((acc, u) => acc + (u.data ? JSON.stringify(u.data).length : 0), 0);
-                const isSharded = updates.some(u => u.data._sharded === true);
-                
-                try {
-                    await commitBatchInChunks(config, deps, updates, `${name} Results`);
-                } catch (commitErr) {
-                    // Check for Firestore specific limits
-                    let stage = 'COMMIT_BATCH';
-                    let msg = commitErr.message;
-                    if (msg.includes('Transaction too big') || msg.includes('payload is too large')) { stage = 'SHARDING_LIMIT_EXCEEDED'; msg = `Firestore Limit Exceeded: ${msg}`; }
-                    throw { message: msg, stack: commitErr.stack, stage };
-                }
-                
-                // Log Storage
-                if (logger && logger.logStorage) { logger.logStorage(pid, name, dStr, mainDocRef.path, totalSize, isSharded); }
-                
-                // Mark Success
-                if (calc.manifest.hash) { successUpdates[name] = {  hash: calc.manifest.hash, category: calc.manifest.category  }; }
-
-                // Cleanup Migration
-                if (calc.manifest.previousCategory && calc.manifest.previousCategory !== calc.manifest.category) {
-                    cleanupTasks.push(deleteOldCalculationData(dStr, calc.manifest.previousCategory, name, config, deps));
-                }
+            // Cleanup Migration
+            if (calc.manifest.previousCategory && calc.manifest.previousCategory !== calc.manifest.category) {
+                cleanupTasks.push(deleteOldCalculationData(dStr, calc.manifest.previousCategory, name, config, deps));
             }
+
         } catch (e) {
-            // [NEW] Intelligent Failure Reporting
             const stage = e.stage || 'EXECUTION';
             const msg   = e.message || 'Unknown error';
             
@@ -123,20 +170,14 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     }
 
     if (schemas.length) batchStoreSchemas(deps, config, schemas).catch(() => {});
-
     if (cleanupTasks.length > 0) { await Promise.allSettled(cleanupTasks); }
-
     if (!skipStatusWrite && Object.keys(successUpdates).length > 0) { await updateComputationStatus(dStr, successUpdates, config, deps); }
     
-    // [UPDATE] Return both success and failures so the Worker can log them
     return { successUpdates, failureReport };
 }
 
 /**
  * Deletes result documents from a previous category location.
- *  This function exists to handle the deleteion of old data,
- *  The general use case is that if a developer changes a calculations' category, 
- *  We want to clean up and delete the old path, the change of a category would trigger a re-run of the calculation to naturally move the data to the new location
  */
 async function deleteOldCalculationData(dateStr, oldCategory, calcName, config, deps) {
 
@@ -151,7 +192,7 @@ async function deleteOldCalculationData(dateStr, oldCategory, calcName, config,
             .collection(config.computationsSubcollection)
             .doc(calcName);
 
-        const shardsCol = oldDocRef.collection('_shards');
+        const shardsCol  = oldDocRef.collection('_shards');
         const shardsSnap = await withRetry(() => shardsCol.listDocuments(), 'ListOldShards');
         
         const batch = db.batch();
@@ -182,19 +223,24 @@ function calculateFirestoreBytes(value) {
     return 0;
 }
 
-async function prepareAutoShardedWrites(result, docRef, logger) {
-    const SAFETY_THRESHOLD_BYTES = 1000 * 1024; 
+async function prepareAutoShardedWrites(result, docRef, logger, maxBytes = 900 * 1024, maxKeys = null) {
     const OVERHEAD_ALLOWANCE     = 20 * 1024;
-    const CHUNK_LIMIT            = SAFETY_THRESHOLD_BYTES - OVERHEAD_ALLOWANCE;
+    const CHUNK_LIMIT            = maxBytes - OVERHEAD_ALLOWANCE;
+    
+    // We only calculate totalSize loosely here for the "skip sharding" check.
+    // The loop below enforces the real limits.
     const totalSize              = calculateFirestoreBytes(result);
     const docPathSize            = Buffer.byteLength(docRef.path, 'utf8') + 16;
+    
     const writes                 = [];
     const shardCollection        = docRef.collection('_shards');
     let currentChunk             = {};
     let currentChunkSize         = 0;
+    let currentKeyCount          = 0;
     let shardIndex               = 0;
 
-    if ((totalSize + docPathSize) < CHUNK_LIMIT) {  
+    // Fast path: If small enough AND keys are safe
+    if (!maxKeys && (totalSize + docPathSize) < CHUNK_LIMIT) {  
         const data = { 
             ...result, 
             _completed: true, 
@@ -210,17 +256,24 @@ async function prepareAutoShardedWrites(result, docRef, logger) {
         const valueSize = calculateFirestoreBytes(value);
         const itemSize  = keySize + valueSize;
 
-        if (currentChunkSize + itemSize > CHUNK_LIMIT) { 
+        const byteLimitReached = (currentChunkSize + itemSize > CHUNK_LIMIT);
+        const keyLimitReached = (maxKeys && currentKeyCount + 1 >= maxKeys);
+
+        if (byteLimitReached || keyLimitReached) { 
             writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } });
             shardIndex++;
             currentChunk     = {};
             currentChunkSize = 0;
+            currentKeyCount  = 0;
         }
         currentChunk[key] = value;
         currentChunkSize += itemSize;
+        currentKeyCount++;
     }
 
-    if (Object.keys(currentChunk).length > 0) {  writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } });  }
+    if (Object.keys(currentChunk).length > 0) {  
+        writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } });  
+    }
     
     const pointerData = { 
         _completed: true, 

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

@@ -1,14 +1,13 @@
 /**
  * @fileoverview Build Reporter & Auto-Runner.
  * Generates a "Pre-Flight" report of what the computation system WILL do.
- * UPDATED: Now fetches 'prevDailyStatus' to enforce strict historical continuity checks.
+ * UPDATED: Optimized with Parallel Status Fetches inside the date loop.
  */
 
 const { analyzeDateExecution } = require('../WorkflowOrchestrator');
 const { fetchComputationStatus } = require('../persistence/StatusRepository');
 const { normalizeName, getExpectedDateStrings, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils');
 const { checkRootDataAvailability } = require('../data/AvailabilityChecker');
-const { FieldValue } = require('@google-cloud/firestore');
 const pLimit = require('p-limit');
 const path = require('path');
 const packageJson = require(path.join(__dirname, '..', '..', '..', 'package.json'));
@@ -21,11 +20,7 @@ const packageVersion = packageJson.version;
 async function ensureBuildReport(config, dependencies, manifest) {
     const { db, logger } = dependencies;
     const now = new Date();
-
-    // BuildId still includes timestamp for uniqueness
     const buildId = `v${packageVersion}_${now.getFullYear()}-${String(now.getMonth()+1).padStart(2,'0')}-${String(now.getDate()).padStart(2,'0')}_${String(now.getHours()).padStart(2,'0')}-${String(now.getMinutes()).padStart(2,'0')}-${String(now.getSeconds()).padStart(2,'0')}`;
-
-    // Reference to "latest" doc
     const latestRef = db.collection('computation_build_records').doc('latest');
 
     try {
@@ -38,10 +33,8 @@ async function ensureBuildReport(config, dependencies, manifest) {
         }
 
         logger.log('INFO', `[BuildReporter] 🚀 New Version Detected (${packageVersion}). Auto-running Pre-flight Report...`);
-
         await generateBuildReport(config, dependencies, manifest, 90, buildId);
-
-        // Update "latest" pointer
+        
         await latestRef.set({
             packageVersion,
             buildId,
@@ -55,11 +48,6 @@ async function ensureBuildReport(config, dependencies, manifest) {
 
 /**
  * Generates the report and saves to Firestore.
- * @param {object} config 
- * @param {object} dependencies 
- * @param {Array} manifest 
- * @param {number} daysBack - Days to simulate (Default 90)
- * @param {string} customBuildId - Optional ID override
  */
 async function generateBuildReport(config, dependencies, manifest, daysBack = 90, customBuildId = null) {
     const { db, logger } = dependencies;
@@ -86,99 +74,61 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
     let totalReRuns = 0;
     let totalNew = 0;
 
-    // 2. PARALLEL PROCESSING (Fix for DEADLINE_EXCEEDED)
-    // Run 20 reads in parallel. 
+    // 2. PARALLEL PROCESSING
     const limit = pLimit(20);
 
     const processingPromises = datesToCheck.map(dateStr => limit(async () => {
         try {
-            // A. Fetch REAL status from DB (What ran previously?)
-            const dailyStatus = await fetchComputationStatus(dateStr, config, dependencies);
-
-            // [NEW] B. Fetch YESTERDAY'S Status (For strict continuity checks)
-            let prevDailyStatus = null;
-            
-            // Only fetch if ANY calculation in the manifest is historical
-            // (Optimization: In BuildReporter we pass the full manifest, so we check if any exist generally)
+            // [IMPROVED] Fetch all statuses in parallel
+            const fetchPromises = [
+                // A. Real status
+                fetchComputationStatus(dateStr, config, dependencies),
+                // C. Real Root Data
+                checkRootDataAvailability(dateStr, config, dependencies, DEFINITIVE_EARLIEST_DATES)
+            ];
+
+            // B. Yesterday's Status (only if needed)
+            let prevDateStr = null;
             if (manifest.some(c => c.isHistorical)) {
                 const prevDate = new Date(dateStr + 'T00:00:00Z');
                 prevDate.setUTCDate(prevDate.getUTCDate() - 1);
-                const prevDateStr = prevDate.toISOString().slice(0, 10);
+                prevDateStr = prevDate.toISOString().slice(0, 10);
                 
-                // Ensure we don't look before the dawn of time
                 if (prevDate >= DEFINITIVE_EARLIEST_DATES.absoluteEarliest) {
-                    prevDailyStatus = await fetchComputationStatus(prevDateStr, config, dependencies);
-                } else {
-                    prevDailyStatus = {}; // Pre-epoch is valid empty context
+                    fetchPromises.push(fetchComputationStatus(prevDateStr, config, dependencies));
                 }
             }
 
-            // C. REAL Root Data Check
-            // Uses the new Indexer logic (returns null refs, but valid status flags)
-            const availability = await checkRootDataAvailability(dateStr, config, dependencies, DEFINITIVE_EARLIEST_DATES);
-            
+            const results = await Promise.all(fetchPromises);
+            const dailyStatus = results[0];
+            const availability = results[1];
+            // If we fetched prevStatus, it's at index 2
+            const prevDailyStatus = (prevDateStr && results[2]) ? results[2] : (prevDateStr ? {} : null);
+
             const rootDataStatus = availability ? availability.status : {
-                hasPortfolio: false,
-                hasHistory:   false,
-                hasSocial:    false,
-                hasInsights:  false,
-                hasPrices:    false
+                hasPortfolio: false, hasHistory: false, hasSocial: false, hasInsights: false, hasPrices: false
             };
 
             // D. Run Logic Analysis
-            // Now passes prevDailyStatus to enable the "Blocked if yesterday missing" logic
             const analysis = analyzeDateExecution(dateStr, manifest, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus);
 
             // E. Format Findings
             const dateSummary = {
-                willRun: [],
-                willReRun: [],
-                blocked: [],
-                impossible: [] 
+                willRun: [], willReRun: [], blocked: [], impossible: [] 
             };
 
-            // -- Runnable (New) --
-            analysis.runnable.forEach(item => {
-                dateSummary.willRun.push({ name: item.name, reason: "New / No Previous Record" });
-            });
+            analysis.runnable.forEach(item => dateSummary.willRun.push({ name: item.name, reason: "New / No Previous Record" }));
+            analysis.reRuns.forEach(item => dateSummary.willReRun.push({ name: item.name, reason: item.previousCategory ? "Migration" : "Hash Mismatch" }));
+            analysis.impossible.forEach(item => dateSummary.impossible.push({ name: item.name, reason: item.reason }));
+            [...analysis.blocked, ...analysis.failedDependency].forEach(item => dateSummary.blocked.push({ name: item.name, reason: item.reason || 'Dependency' }));
 
-            // -- Re-Runs (Hash Mismatch / Migration) --
-            analysis.reRuns.forEach(item => {
-                let reason = "Hash Mismatch";
-                let details = `Old: ${item.oldHash?.substring(0,6)}... New: ${item.newHash?.substring(0,6)}...`;
-                
-                if (item.previousCategory) {
-                    reason = "Migration";
-                    details = `Moving ${item.previousCategory} -> ${item.newCategory}`;
-                }
-
-                dateSummary.willReRun.push({ name: item.name, reason, details });
-            });
-
-            // -- Impossible (Permanent) --
-            analysis.impossible.forEach(item => {
-                dateSummary.impossible.push({ name: item.name, reason: item.reason });
-            });
-
-            // -- Blocked (Retriable) --
-            analysis.blocked.forEach(item => {
-                dateSummary.blocked.push({ name: item.name, reason: item.reason });
-            });
-            analysis.failedDependency.forEach(item => {
-                dateSummary.blocked.push({ name: item.name, reason: `Dependency Missing: ${item.missing.join(', ')}` });
-            });
-
-            // Return result for aggregation
             const hasUpdates = dateSummary.willRun.length || dateSummary.willReRun.length || dateSummary.blocked.length || dateSummary.impossible.length;
             
             return {
                 dateStr,
                 dateSummary,
                 hasUpdates,
-                stats: {
-                    new: dateSummary.willRun.length,
-                    rerun: dateSummary.willReRun.length
-                }
+                stats: { new: dateSummary.willRun.length, rerun: dateSummary.willReRun.length }
             };
 
         } catch (err) {
@@ -187,7 +137,6 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
         }
     }));
 
-    // Wait for all dates to process
     const results = await Promise.all(processingPromises);
 
     // 3. Aggregate Results

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

@@ -1,12 +1,34 @@
 /**
  * @fileoverview Schema capture utility for computation outputs
  * This module batches and stores pre-defined static schemas in Firestore.
+ * UPDATED: Added schema validation to prevent silent batch failures.
  */
 
+/**
+ * Validates a schema object before storage.
+ * Checks for circular references and size limits.
+ * @param {object} schema 
+ * @returns {object} { valid: boolean, reason: string }
+ */
+function validateSchema(schema) {
+    try {
+        // 1. Detect circular references
+        const jsonStr = JSON.stringify(schema);
+        
+        // 2. Ensure it's not too large (Firestore limit: 1MB, reserve 100KB for metadata)
+        const size = Buffer.byteLength(jsonStr);
+        if (size > 900 * 1024) {
+            return { valid: false, reason: `Schema exceeds 900KB limit (${(size/1024).toFixed(2)} KB)` };
+        }
+        
+        return { valid: true };
+    } catch (e) {
+        return { valid: false, reason: `Serialization failed: ${e.message}` };
+    }
+}
+
 /**
  * Batch store schemas for multiple computations.
- * This function now expects a fully-formed schema, not sample output.
- * It strictly stamps a 'lastUpdated' field to support stale-schema filtering in the API.
  *
  * @param {object} dependencies - Contains db, logger
  * @param {object} config - Configuration object
@@ -31,6 +53,13 @@ async function batchStoreSchemas(dependencies, config, schemas) {
                 continue;
             }
 
+            // [IMPROVED] Validate before adding to batch
+            const validation = validateSchema(item.schema);
+            if (!validation.valid) {
+                logger.log('WARN', `[SchemaCapture] Invalid schema for ${item.name}: ${validation.reason}`);
+                continue;
+            }
+
             const docRef = db.collection(schemaCollection).doc(item.name);
             
             // Critical: Always overwrite 'lastUpdated' to now

package/index.js

@@ -27,7 +27,6 @@ const { handleUpdate }                                    = require('./functions
 
 // Computation System
 const { build: buildManifest }                            = require('./functions/computation-system/context/ManifestBuilder');
-// const { runDateComputation: runComputationPass }          = require('./functions/computation-system/WorkflowOrchestrator'); Depreciated
 const { dispatchComputationPass }                         = require('./functions/computation-system/helpers/computation_dispatcher');
 const { handleComputationTask }                           = require('./functions/computation-system/helpers/computation_worker');
 // [NEW] Import Report Tools
@@ -54,7 +53,7 @@ const { handlePost }                                      = require('./functions
 
 // NEW
 
-const { runRootDataIndexer } = require('./functions/root-data-indexer/index'); // <--- IMPORT
+const { runRootDataIndexer } = require('./functions/root-data-indexer/index'); 
 
 const core = {
   IntelligentHeaderManager,
@@ -88,7 +87,6 @@ const taskEngine = {
 };
 
 const computationSystem = {
-  runComputationPass,
   dispatchComputationPass,
   handleComputationTask,
   dataLoader,
@@ -112,7 +110,7 @@ const maintenance = {
   runSocialOrchestrator,
   handleSocialTask,
   runBackfillAssetPrices,
-  runRootDataIndexer, // <--- EXPORT
+  runRootDataIndexer,
 };
 
 const proxy = { handlePost };

package/package.json

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