bulltrackers-module 1.0.234 → 1.0.236

package/functions/computation-system/WorkflowOrchestrator.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Main Orchestrator. Coordinates the topological execution.
- * UPDATED: Removed legacy boolean 'true' logic.
+ * UPDATED: Detects Category changes to trigger migration/cleanup.
+ * FIX: Decouples migration detection from hash verification to handle simultaneous code & category changes.
  */
 const { normalizeName }                                    = require('./utils/utils');
 const { checkRootDataAvailability }                        = require('./data/AvailabilityChecker');
@@ -33,22 +34,34 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 
     const isDepSatisfied = (depName, dailyStatus, manifestMap) => {
         const norm = normalizeName(depName);
-        const storedDepHash = dailyStatus[norm];
+        const stored = dailyStatus[norm]; // Now an object or null
         const depManifest = manifestMap.get(norm);
 
-        if (storedDepHash === STATUS_IMPOSSIBLE) return false; 
-        if (!storedDepHash) return false; 
+        if (!stored) return false;
+        
+        // Handle IMPOSSIBLE flag (stored as object property or legacy string check)
+        if (stored.hash === STATUS_IMPOSSIBLE) return false;
+
         if (!depManifest) return false;
-        if (storedDepHash !== depManifest.hash) return false;
+        if (stored.hash !== depManifest.hash) return false;
 
         return true;
     };
 
     for (const calc of calcsInPass) {
         const cName = normalizeName(calc.name);
-        const storedHash = dailyStatus[cName];
+        const stored = dailyStatus[cName]; // Object { hash, category }
+        
+        const storedHash = stored ? stored.hash : null;
+        const storedCategory = stored ? stored.category : null;
         const currentHash = calc.hash;
 
+        // [SMART MIGRATION] Detect if category changed, independent of hash check
+        let migrationOldCategory = null;
+        if (storedCategory && storedCategory !== calc.category) {
+            migrationOldCategory = storedCategory;
+        }
+
         // 1. Check Impossible
         if (storedHash === STATUS_IMPOSSIBLE) {
             report.skipped.push({ name: cName, reason: 'Permanently Impossible' });
@@ -83,8 +96,9 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         if (calc.dependencies) {
             for (const dep of calc.dependencies) {
                 const normDep = normalizeName(dep);
+                const depStored = dailyStatus[normDep];
                 
-                if (dailyStatus[normDep] === STATUS_IMPOSSIBLE) {
+                if (depStored && depStored.hash === STATUS_IMPOSSIBLE) {
                     dependencyIsImpossible = true;
                     break; 
                 }
@@ -105,13 +119,28 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
             continue;
         }
 
-        // 4. Hash / State Check (Legacy 'true' logic removed)
-        if (!storedHash || storedHash === false) { 
+        // 4. Hash & Category Check (Smart Migration Logic)
+        if (!storedHash) { 
             report.runnable.push(calc);
         } else if (storedHash !== currentHash) {
-            report.reRuns.push({ name: cName, oldHash: storedHash, newHash: currentHash });
+            // Hash Mismatch (Code Changed).
+            // Pass migration info here too, in case category ALSO changed.
+            report.reRuns.push({ 
+                name: cName, 
+                oldHash: storedHash, 
+                newHash: currentHash,
+                previousCategory: migrationOldCategory 
+            });
+        } else if (migrationOldCategory) {
+            // Hash Matches, BUT category changed. Force Re-run.
+            report.reRuns.push({ 
+                name: cName, 
+                reason: 'Category Migration', 
+                previousCategory: migrationOldCategory, 
+                newCategory: calc.category 
+            });
         } else {
-            // Stored Hash === Current Hash
+            // Stored Hash === Current Hash AND Category matches
             report.skipped.push({ name: cName });
         }
     }
@@ -122,7 +151,7 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, dependencies, computationManifest) {
     const { logger } = dependencies;
     const orchestratorPid = generateProcessId(PROCESS_TYPES.ORCHESTRATOR, passToRun, dateStr);
-    const dateToProcess = new Date(dateStr + 'T00:00:00Z');
+    const dateToProcess   = new Date(dateStr + 'T00:00:00Z');
     
     // 1. Fetch State
     const dailyStatus = await fetchComputationStatus(dateStr, config, dependencies);
@@ -154,21 +183,42 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
 
     // 5. UPDATE STATUS FOR NON-RUNNABLE ITEMS
     const statusUpdates = {};
-    analysisReport.blocked.forEach(item => statusUpdates[item.name] = false);
-    analysisReport.failedDependency.forEach(item => statusUpdates[item.name] = false);
-    analysisReport.impossible.forEach(item => statusUpdates[item.name] = STATUS_IMPOSSIBLE);
+    
+    analysisReport.blocked.forEach(item => statusUpdates[item.name] = { hash: false, category: 'unknown' });
+    analysisReport.failedDependency.forEach(item => statusUpdates[item.name] = { hash: false, category: 'unknown' });
+    analysisReport.impossible.forEach(item => statusUpdates[item.name] = { hash: STATUS_IMPOSSIBLE, category: 'unknown' });
     
     if (Object.keys(statusUpdates).length > 0) {
         await updateComputationStatus(dateStr, statusUpdates, config, dependencies);
     }
 
     // 6. EXECUTE RUNNABLES
+    
+    // [SMART MIGRATION] Build map of items needing cleanup
+    const migrationMap = {};
+    analysisReport.reRuns.forEach(item => {
+        if (item.previousCategory) {
+            migrationMap[normalizeName(item.name)] = item.previousCategory;
+        }
+    });
+
     const calcsToRunNames = new Set([
         ...analysisReport.runnable.map(c => c.name),
-        ...analysisReport.reRuns.map(c => c.name)
+        ...analysisReport.reRuns.map(c => c.name) 
     ]);
 
-    const finalRunList = calcsInThisPass.filter(c => calcsToRunNames.has(normalizeName(c.name)));
+    // [SMART MIGRATION] Create Safe Copies with previousCategory attached
+    // We clone the manifest object so we don't pollute the global cache with run-specific flags
+    const finalRunList = calcsInThisPass
+        .filter(c => calcsToRunNames.has(normalizeName(c.name)))
+        .map(c => {
+            const clone = { ...c }; // Shallow copy
+            const prevCat = migrationMap[normalizeName(c.name)];
+            if (prevCat) {
+                clone.previousCategory = prevCat;
+            }
+            return clone;
+        });
 
     if (!finalRunList.length) {
         return { 

package/functions/computation-system/context/ManifestBuilder.js

@@ -4,6 +4,8 @@
 const { generateCodeHash, LEGACY_MAPPING } = require('../topology/HashManager.js');
 const { normalizeName }                    = require('../utils/utils');
 
+const SYSTEM_EPOCH = require('../system_epoch');
+
 // Import Layers
 const MathematicsLayer = require('../layers/mathematics');
 const ExtractorsLayer  = require('../layers/extractors');
@@ -99,7 +101,7 @@ function buildManifest(productLinesToRun = [], calculations) {
         const dependencies = Class.getDependencies().map(normalizeName);
         const codeStr      = Class.toString();
         
-        let compositeHashString = generateCodeHash(codeStr); 
+        let compositeHashString = generateCodeHash(codeStr) + `|EPOCH:${SYSTEM_EPOCH}`; // Here we build the hash
         const usedDeps = [];
 
         for (const [layerName, exportsMap] of Object.entries(LAYER_TRIGGERS)) {
@@ -166,8 +168,12 @@ function buildManifest(productLinesToRun = [], calculations) {
     }
 
     const productLineEndpoints = [];
+    
+    // [UPDATE] Check if we should run ALL product lines (if empty or wildcard)
+    const runAll = !productLinesToRun || productLinesToRun.length === 0 || productLinesToRun.includes('*');
+
     for (const [name, entry] of manifestMap.entries()) {  
-        if (productLinesToRun.includes(entry.category) || entry.sourcePackage === 'core') { 
+        if (runAll || productLinesToRun.includes(entry.category) || entry.sourcePackage === 'core') { 
             productLineEndpoints.push(name); 
         }  
     }

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

@@ -69,7 +69,17 @@ async function runBatchPriceComputation(config, deps, dateStrings, calcs, target
                                         .doc(calcManifest.category)
                                         .collection(config.computationsSubcollection)
                                         .doc(normalizeName(calcManifest.name));
-                                    writes.push({ ref: docRef, data: { ...dataToWrite, _completed: true }, options: { merge: true } });
+                                    
+                                    // [UPDATE] Add _lastUpdated timestamp
+                                    writes.push({ 
+                                        ref: docRef, 
+                                        data: { 
+                                            ...dataToWrite, 
+                                            _completed: true,
+                                            _lastUpdated: new Date().toISOString() 
+                                        }, 
+                                        options: { merge: true } 
+                                    });
                                 }
                             }
                         } catch (err) { logger.log('ERROR', `[BatchPrice] \u2716 Failed ${calcManifest.name} for ${dateStr}: ${err.message}`); }

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

@@ -6,10 +6,10 @@
 
 const { runDateComputation, groupByPass } = require('../WorkflowOrchestrator.js');
 const { getManifest }                     = require('../topology/ManifestLoader');
-const { StructuredLogger }                = require('../logger/logger'); // <--- CRITICAL IMPORT
+const { StructuredLogger }                = require('../logger/logger'); 
 
 // 1. IMPORT CALCULATIONS
-// We import the specific package containing your strategies (gem, pyro, core, etc.)
+// We import the specific package containing the strategies (gem, pyro, core, etc.)
 let calculationPackage;
 try {
     // Primary: Try to load from the installed npm package
@@ -33,17 +33,13 @@ const calculations = calculationPackage.calculations;
 async function handleComputationTask(message, config, dependencies) {
     
     // 2. INITIALIZE SYSTEM LOGGER
-    // We ignore the generic 'dependencies.logger' and instantiate our specialized one.
-    // This ensures methods like 'logDateAnalysis' and 'logStorage' exist.
     const systemLogger = new StructuredLogger({
         minLevel: config.minLevel || 'INFO',
         enableStructured: true,
-        ...config // Apply any other relevant config overrides
+        ...config 
     });
 
     // 3. OVERRIDE DEPENDENCIES
-    // We create a new dependencies object to pass downstream.
-    // This fixes the "logger.logStorage is not a function" error in ResultCommitter.js
     const runDependencies = {
         ...dependencies,
         logger: systemLogger
@@ -57,7 +53,7 @@ async function handleComputationTask(message, config, dependencies) {
         computationManifest = getManifest(
             config.activeProductLines || [], 
             calculations, 
-            runDependencies // Pass the updated dependencies
+            runDependencies 
         );
     } catch (manifestError) {
         logger.log('FATAL', `[Worker] Failed to load Manifest: ${manifestError.message}`);
@@ -111,7 +107,7 @@ async function handleComputationTask(message, config, dependencies) {
             pass, 
             calcsInThisPass, 
             config, 
-            runDependencies, // <--- IMPORTANT: Pass the dependencies with the System Logger
+            runDependencies,
             computationManifest
         );
         

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

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Handles saving computation results with observability.
+ * @fileoverview Handles saving computation results with observability and Smart Cleanup.
  */
 const { commitBatchInChunks }     = require('./FirestoreUtils');
 const { updateComputationStatus } = require('./StatusRepository');
@@ -9,6 +9,7 @@ const { generateProcessId, PROCESS_TYPES } = require('../logger/logger');
 async function commitResults(stateObj, dStr, passName, config, deps, skipStatusWrite = false) {
     const successUpdates = {};
     const schemas        = [];
+    const cleanupTasks   = []; // Tasks to delete old data
     const { logger }     = deps;
     const pid            = generateProcessId(PROCESS_TYPES.STORAGE, passName, dStr);
 
@@ -16,7 +17,23 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
         const calc = stateObj[name];
         try {
             const result = await calc.getResult();
-            if (!result) continue;
+            
+            // [UPDATE] Validate Result: Check for Null, Empty Object, or Zero
+            const isEmpty = !result || 
+                            (typeof result === 'object' && Object.keys(result).length === 0) ||
+                            (typeof result === 'number' && result === 0);
+
+            if (isEmpty) {
+                // [UPDATE] Mark status as FALSE (Failed/Empty) so it re-runs or is flagged
+                if (calc.manifest.hash) {
+                    successUpdates[name] = { 
+                        hash: false, 
+                        category: calc.manifest.category 
+                    };
+                }
+                // Do not store empty results
+                continue; 
+            }
 
             const mainDocRef = deps.db.collection(config.resultsCollection)
                 .doc(dStr)
@@ -49,9 +66,18 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                     logger.logStorage(pid, name, dStr, mainDocRef.path, totalSize, isSharded);
                 }
                 
-                // Update success tracking
+                // Update success tracking (Include Category)
                 if (calc.manifest.hash) {
-                    successUpdates[name] = calc.manifest.hash;
+                    successUpdates[name] = { 
+                        hash: calc.manifest.hash, 
+                        category: calc.manifest.category 
+                    };
+                }
+
+                // CHECK FOR MIGRATION CLEANUP
+                if (calc.manifest.previousCategory && calc.manifest.previousCategory !== calc.manifest.category) {
+                    logger.log('INFO', `[Migration] Scheduled cleanup for ${name} from '${calc.manifest.previousCategory}'`);
+                    cleanupTasks.push(deleteOldCalculationData(dStr, calc.manifest.previousCategory, name, config, deps));
                 }
             }
         } catch (e) {
@@ -63,12 +89,58 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
 
     if (schemas.length) batchStoreSchemas(deps, config, schemas).catch(() => {});
 
+    // Execute Cleanup Tasks (orphaned data from category changes)
+    if (cleanupTasks.length > 0) {
+        await Promise.allSettled(cleanupTasks);
+    }
+
     if (!skipStatusWrite && Object.keys(successUpdates).length > 0) {
         await updateComputationStatus(dStr, successUpdates, config, deps);
     }
     return successUpdates;
 }
 
+/**
+ * Deletes result documents from a previous category location.
+ * Must handle standard docs AND sharded docs (subcollections).
+ */
+async function deleteOldCalculationData(dateStr, oldCategory, calcName, config, deps) {
+    const { db, logger, calculationUtils } = deps;
+    const { withRetry } = calculationUtils || { withRetry: (fn) => fn() };
+    
+    try {
+        const oldDocRef = db.collection(config.resultsCollection)
+            .doc(dateStr)
+            .collection(config.resultsSubcollection)
+            .doc(oldCategory)
+            .collection(config.computationsSubcollection)
+            .doc(calcName);
+
+        // 1. Check for Shards Subcollection
+        const shardsCol = oldDocRef.collection('_shards');
+        const shardsSnap = await withRetry(() => shardsCol.listDocuments(), 'ListOldShards');
+        
+        const batch = db.batch();
+        let ops = 0;
+
+        // Delete shards
+        for (const shardDoc of shardsSnap) {
+            batch.delete(shardDoc);
+            ops++;
+        }
+
+        // Delete main doc
+        batch.delete(oldDocRef);
+        ops++;
+
+        await withRetry(() => batch.commit(), 'CleanupOldCategory');
+        logger.log('INFO', `[Migration] Cleaned up ${ops} docs for ${calcName} in old category '${oldCategory}'`);
+
+    } catch (e) {
+        logger.log('WARN', `[Migration] Failed to clean up old data for ${calcName}: ${e.message}`);
+    }
+}
+
 function calculateFirestoreBytes(value) {
     if (value === null) return 1;
     if (value === undefined) return 0;
@@ -94,7 +166,16 @@ async function prepareAutoShardedWrites(result, docRef, logger) {
     let currentChunkSize         = 0;
     let shardIndex               = 0;
 
-    if ((totalSize + docPathSize) < CHUNK_LIMIT) {  const data = { ...result, _completed: true, _sharded: false };  return [{ ref: docRef, data, options: { merge: true } }];  }
+    // [UPDATE] Add _lastUpdated to non-sharded writes
+    if ((totalSize + docPathSize) < CHUNK_LIMIT) {  
+        const data = { 
+            ...result, 
+            _completed: true, 
+            _sharded: false,
+            _lastUpdated: new Date().toISOString() 
+        };  
+        return [{ ref: docRef, data, options: { merge: true } }];  
+    }
 
     for (const [key, value] of Object.entries(result)) { 
         if (key.startsWith('_')) continue;
@@ -114,7 +195,12 @@ async function prepareAutoShardedWrites(result, docRef, logger) {
 
     if (Object.keys(currentChunk).length > 0) {  writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } });  }
     
-    const pointerData = { _completed: true, _sharded: true, _shardCount: shardIndex + 1, _lastUpdated: new Date().toISOString() };
+    const pointerData = { 
+        _completed: true, 
+        _sharded: true, 
+        _shardCount: shardIndex + 1, 
+        _lastUpdated: new Date().toISOString() 
+    };
     writes.push({ ref: docRef, data: pointerData, options: { merge: false } });
     return writes;
 }

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

@@ -1,28 +1,54 @@
 /**
  * @fileoverview Manages computation status tracking in Firestore.
+ * UPDATED: Supports Schema V2 (Object with Category) for smart migrations.
  */
 
 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 docRef = db.collection(collection).doc(dateStr);
     
     const snap = await docRef.get();
-    return snap.exists ? snap.data() : {};
+    if (!snap.exists) return {};
+
+    const rawData = snap.data();
+    const normalized = {};
+
+    // Normalize V1 (String) to V2 (Object)
+    for (const [name, value] of Object.entries(rawData)) {
+        if (typeof value === 'string') {
+            normalized[name] = { hash: value, category: null }; // Legacy entry
+        } else {
+            normalized[name] = value; // V2 entry { hash, category }
+        }
+    }
+
+    return normalized;
 }
 
 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 });
+    // We expect updates to be an object: { "CalcName": { hash: "...", category: "..." } }
+    // But result committer might still pass strings if we don't update it. 
+    // We will enforce the structure here just in case.
+    
+    const safeUpdates = {};
+    for (const [key, val] of Object.entries(updates)) {
+        if (typeof val === 'string') {
+             // Fallback if caller wasn't updated (shouldn't happen with full patch)
+            safeUpdates[key] = { hash: val, category: 'unknown', lastUpdated: new Date() };
+        } else {
+            safeUpdates[key] = { ...val, lastUpdated: new Date() };
+        }
+    }
+
+    await docRef.set(safeUpdates, { merge: true });
     return true;
 }
 

package/functions/computation-system/system_epoch.js

@@ -0,0 +1,2 @@
+// Change this string to force a global re-computation
+module.exports = "v1.0-epoch-1";

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

@@ -267,5 +267,5 @@ module.exports = {
     streamHistoryData,
     getPriceShardRefs,
     ensurePriceShardIndex,
-    getRelevantShardRefs // Export new function
+    getRelevantShardRefs
 };

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

@@ -166,21 +166,21 @@ async function getEarliestDataDates(config, deps) {
     };
 
     const earliestPortfolioDate = getMinDate(investorDate, speculatorDate);
-    const earliestHistoryDate = getMinDate(investorHistoryDate, speculatorHistoryDate);
-    const earliestInsightsDate = getMinDate(insightsDate);
-    const earliestSocialDate = getMinDate(socialDate);
-    const earliestPriceDate = getMinDate(priceDate);
-    const absoluteEarliest = getMinDate(earliestPortfolioDate, earliestHistoryDate, earliestInsightsDate, earliestSocialDate, earliestPriceDate);
+    const earliestHistoryDate   = getMinDate(investorHistoryDate, speculatorHistoryDate);
+    const earliestInsightsDate  = getMinDate(insightsDate);
+    const earliestSocialDate    = getMinDate(socialDate);
+    const earliestPriceDate     = getMinDate(priceDate);
+    const absoluteEarliest      = getMinDate(earliestPortfolioDate, earliestHistoryDate, earliestInsightsDate, earliestSocialDate, earliestPriceDate);
 
     const fallbackDate = new Date(config.earliestComputationDate + 'T00:00:00Z' || '2023-01-01T00:00:00Z');
 
     return {
-        portfolio: earliestPortfolioDate || new Date('2999-12-31T00:00:00Z'),
-        history: earliestHistoryDate || new Date('2999-12-31T00:00:00Z'),
-        insights: earliestInsightsDate || new Date('2999-12-31T00:00:00Z'),
-        social: earliestSocialDate || new Date('2999-12-31T00:00:00Z'),
-        price: earliestPriceDate || new Date('2999-12-31T00:00:00Z'),
-        absoluteEarliest: absoluteEarliest || fallbackDate
+        portfolio:        earliestPortfolioDate || new Date('2999-12-31T00:00:00Z'),
+        history:          earliestHistoryDate   || new Date('2999-12-31T00:00:00Z'),
+        insights:         earliestInsightsDate  || new Date('2999-12-31T00:00:00Z'),
+        social:           earliestSocialDate    || new Date('2999-12-31T00:00:00Z'),
+        price:            earliestPriceDate     || new Date('2999-12-31T00:00:00Z'),
+        absoluteEarliest: absoluteEarliest      || fallbackDate
     };
 }
 
@@ -211,5 +211,5 @@ module.exports = {
     getExpectedDateStrings, 
     getEarliestDataDates, 
     generateCodeHash,
-    withRetry // Exported here
+    withRetry 
 };

package/index.js

@@ -3,82 +3,109 @@
  * Export the pipes!
  */
 
-// Import the PubSub Module
-const pubsubModule = require('./functions/core/utils/pubsub_utils');
+// Core utilities
+const pubsubUtils                  = require('./functions/core/utils/pubsub_utils');
+const { IntelligentHeaderManager } = require('./functions/core/utils/intelligent_header_manager');
+const { IntelligentProxyManager }  = require('./functions/core/utils/intelligent_proxy_manager');
+const { FirestoreBatchManager }    = require('./functions/task-engine/utils/firestore_batch_manager');
+const firestoreUtils               = require('./functions/core/utils/firestore_utils');
+
+// Orchestrator
+const { runDiscoveryOrchestrator, runUpdateOrchestrator }               = require('./functions/orchestrator/index');
+const { checkDiscoveryNeed, getDiscoveryCandidates, dispatchDiscovery } = require('./functions/orchestrator/helpers/discovery_helpers');
+const { getUpdateTargets, dispatchUpdates }                             = require('./functions/orchestrator/helpers/update_helpers');
+
+// Dispatcher
+const { handleRequest: dispatchRequest }                  = require('./functions/dispatcher/index');
+const { dispatchTasksInBatches }                          = require('./functions/dispatcher/helpers/dispatch_helpers');
+
+// Task Engine
+const { handleRequest: taskRequest }                      = require('./functions/task-engine/handler_creator');
+const { handleDiscover }                                  = require('./functions/task-engine/helpers/discover_helpers');
+const { handleVerify }                                    = require('./functions/task-engine/helpers/verify_helpers');
+const { handleUpdate }                                    = require('./functions/task-engine/helpers/update_helpers');
+
+// Computation System
+const { build: buildManifest }                            = require('./functions/computation-system/context/ManifestBuilder');
+const { runDateComputation: runComputationPass }          = require('./functions/computation-system/WorkflowOrchestrator');
+const { dispatchComputationPass }                         = require('./functions/computation-system/helpers/computation_dispatcher');
+const { handleComputationTask }                           = require('./functions/computation-system/helpers/computation_worker');
+const dataLoader                                          = require('./functions/computation-system/utils/data_loader');
+const computationUtils                                    = require('./functions/computation-system/utils/utils');
+
+// API
+const { createApiApp }                                    = require('./functions/generic-api/index');
+const apiHelpers                                          = require('./functions/generic-api/helpers/api_helpers');
+
+// Maintenance
+const { runCleanup }                                      = require('./functions/speculator-cleanup-orchestrator/helpers/cleanup_helpers');
+const { handleInvalidSpeculator }                         = require('./functions/invalid-speculator-handler/helpers/handler_helpers');
+const { fetchAndStoreInsights }                           = require('./functions/fetch-insights/helpers/handler_helpers');
+const { fetchAndStorePrices }                             = require('./functions/etoro-price-fetcher/helpers/handler_helpers');
+const { runSocialOrchestrator }                           = require('./functions/social-orchestrator/helpers/orchestrator_helpers');
+const { handleSocialTask }                                = require('./functions/social-task-handler/helpers/handler_helpers');
+const { runBackfillAssetPrices }                          = require('./functions/price-backfill/helpers/handler_helpers');
+
+// Proxy
+const { handlePost }                                      = require('./functions/appscript-api/index');
 
-// Core
 const core = {
-    IntelligentHeaderManager: require('./functions/core/utils/intelligent_header_manager').IntelligentHeaderManager,
-    IntelligentProxyManager: require('./functions/core/utils/intelligent_proxy_manager').IntelligentProxyManager,
-    FirestoreBatchManager: require('./functions/task-engine/utils/firestore_batch_manager').FirestoreBatchManager,
-    firestoreUtils: require('./functions/core/utils/firestore_utils'),
-
-    // EXPORT FIX:
-    pubsubUtils: pubsubModule,              // Keeps stateless function access
-    PubSubUtils: pubsubModule.PubSubUtils   // Exposes the Class for 'new pipe.core.PubSubUtils()'
+  IntelligentHeaderManager,
+  IntelligentProxyManager,
+  FirestoreBatchManager,
+  firestoreUtils,
+  pubsubUtils,
+  PubSubUtils: pubsubUtils.PubSubUtils,
 };
 
-// Orchestrator
 const orchestrator = {
-    runDiscoveryOrchestrator: require('./functions/orchestrator/index').runDiscoveryOrchestrator,
-    runUpdateOrchestrator: require('./functions/orchestrator/index').runUpdateOrchestrator,
-    checkDiscoveryNeed: require('./functions/orchestrator/helpers/discovery_helpers').checkDiscoveryNeed,
-    getDiscoveryCandidates: require('./functions/orchestrator/helpers/discovery_helpers').getDiscoveryCandidates,
-    dispatchDiscovery: require('./functions/orchestrator/helpers/discovery_helpers').dispatchDiscovery,
-    getUpdateTargets: require('./functions/orchestrator/helpers/update_helpers').getUpdateTargets,
-    dispatchUpdates: require('./functions/orchestrator/helpers/update_helpers').dispatchUpdates
+  runDiscoveryOrchestrator,
+  runUpdateOrchestrator,
+  checkDiscoveryNeed,
+  getDiscoveryCandidates,
+  dispatchDiscovery,
+  getUpdateTargets,
+  dispatchUpdates,
 };
 
-// Dispatcher
 const dispatcher = {
-    handleRequest: require('./functions/dispatcher/index').handleRequest,
-    dispatchTasksInBatches: require('./functions/dispatcher/helpers/dispatch_helpers').dispatchTasksInBatches
+  handleRequest: dispatchRequest,
+  dispatchTasksInBatches,
 };
 
-// Task Engine
 const taskEngine = {
-    handleRequest: require('./functions/task-engine/handler_creator').handleRequest,
-    handleDiscover: require('./functions/task-engine/helpers/discover_helpers').handleDiscover,
-    handleVerify: require('./functions/task-engine/helpers/verify_helpers').handleVerify,
-    handleUpdate: require('./functions/task-engine/helpers/update_helpers').handleUpdate
+  handleRequest: taskRequest,
+  handleDiscover,
+  handleVerify,
+  handleUpdate,
 };
 
-// --- UPDATED IMPORT: Point to the new Context Domain ---
-const { build: buildManifestFunc } = require('./functions/computation-system/context/ManifestBuilder');
-
-// Computation System
 const computationSystem = {
-    // 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
+  runComputationPass,
+  dispatchComputationPass,
+  handleComputationTask,
+  dataLoader,
+  computationUtils,
+  buildManifest,
 };
 
-// API
 const api = {
-    createApiApp: require('./functions/generic-api/index').createApiApp,
-    helpers: require('./functions/generic-api/helpers/api_helpers')
+  createApiApp,
+  helpers: apiHelpers,
 };
 
-// Maintenance
 const maintenance = {
-    runSpeculatorCleanup: require('./functions/speculator-cleanup-orchestrator/helpers/cleanup_helpers').runCleanup,
-    handleInvalidSpeculator: require('./functions/invalid-speculator-handler/helpers/handler_helpers').handleInvalidSpeculator,
-    runFetchInsights: require('./functions/fetch-insights/helpers/handler_helpers').fetchAndStoreInsights,
-    runFetchPrices: require('./functions/etoro-price-fetcher/helpers/handler_helpers').fetchAndStorePrices,
-    runSocialOrchestrator: require('./functions/social-orchestrator/helpers/orchestrator_helpers').runSocialOrchestrator,
-    handleSocialTask: require('./functions/social-task-handler/helpers/handler_helpers').handleSocialTask,
-    runBackfillAssetPrices: require('./functions/price-backfill/helpers/handler_helpers').runBackfillAssetPrices
+  runSpeculatorCleanup: runCleanup,
+  handleInvalidSpeculator,
+  runFetchInsights: fetchAndStoreInsights,
+  runFetchPrices: fetchAndStorePrices,
+  runSocialOrchestrator,
+  handleSocialTask,
+  runBackfillAssetPrices,
 };
 
-// Proxy
-const proxy = { handlePost: require('./functions/appscript-api/index').handlePost };
+const proxy = { handlePost };
 
-module.exports = { pipe: { core, orchestrator, dispatcher, taskEngine, computationSystem, api, maintenance, proxy } };
+module.exports = {
+  pipe: { core, orchestrator, dispatcher, taskEngine, computationSystem, api, maintenance, proxy },
+};

package/package.json

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