bulltrackers-module 1.0.151 → 1.0.153

package/functions/task-engine/helpers/verify_helpers.js

@@ -3,27 +3,15 @@ const { FieldValue } = require('@google-cloud/firestore');
 async function fetchAndVerifyUser(user, { logger, headerManager, proxyManager }, { userType, SPECULATOR_INSTRUMENTS_ARRAY }) {
     const selectedHeader = await headerManager.selectHeader();
     if (!selectedHeader) return null;
-
     let wasSuccess = false;
-    try {
-        const res = await proxyManager.fetch(`${process.env.ETORO_API_PORTFOLIO_URL}?cid=${user.cid}`, { headers: selectedHeader.header });
-        if (!res.ok) return null;
-
+    try { const res = await proxyManager.fetch(`${process.env.ETORO_API_PORTFOLIO_URL}?cid=${user.cid}`, { headers: selectedHeader.header }); if (!res.ok) return null;
         wasSuccess = true;
         const portfolioData = await res.json();
-        if (userType === 'speculator') {
-            const instruments = portfolioData.AggregatedPositions.map(p => p.InstrumentID)
-                                .filter(id => SPECULATOR_INSTRUMENTS_ARRAY.includes(id));
-            if (!instruments.length) return null;
-            return { type: 'speculator', userId: user.cid, isBronze: user.isBronze, username: user.username, updateData: { instruments, lastVerified: new Date(), lastHeldSpeculatorAsset: new Date() } };
-        }
+        if (userType === 'speculator') { const instruments = portfolioData.AggregatedPositions.map(p => p.InstrumentID) .filter(id => SPECULATOR_INSTRUMENTS_ARRAY.includes(id));
+            if (!instruments.length) return null; return { type: 'speculator', userId: user.cid, isBronze: user.isBronze, username: user.username, updateData: { instruments, lastVerified: new Date(), lastHeldSpeculatorAsset: new Date() } }; }
         return { type: 'normal', userId: user.cid, isBronze: user.isBronze, username: user.username, updateData: { lastVerified: new Date() } };
-    } catch (err) {
-        logger.log('WARN', `[VERIFY] Error processing user ${user.cid}`, { errorMessage: err.message });
-        return null;
-    } finally {
-        if (selectedHeader) headerManager.updatePerformance(selectedHeader.id, wasSuccess);
-    }
+    } catch (err) { logger.log('WARN', `[VERIFY] Error processing user ${user.cid}`, { errorMessage: err.message }); return null;
+    } finally { if (selectedHeader) headerManager.updatePerformance(selectedHeader.id, wasSuccess); }
 }
 
 async function handleVerify(task, taskId, { db, logger, ...dependencies }, config) {
@@ -31,56 +19,23 @@ async function handleVerify(task, taskId, { db, logger, ...dependencies }, confi
     const batch = db.batch();
     const speculatorUpdates = {}, normalUpdates = {}, bronzeStates = {}, usernameMap = {};
     const specSet = new Set(config.SPECULATOR_INSTRUMENTS_ARRAY);
-
     const results = await Promise.allSettled(users.map(u => fetchAndVerifyUser(u, dependencies, { ...config, userType })));
-
     let validUserCount = 0;
     results.forEach(r => {
-        if (r.status === 'fulfilled' && r.value) {
-            const d = r.value;
-            usernameMap[d.userId] = { username: d.username };
-            bronzeStates[d.userId] = d.isBronze;
-            validUserCount++;
-            if (d.type === 'speculator') speculatorUpdates[`users.${d.userId}`] = d.updateData;
-            else normalUpdates[`users.${d.userId}`] = d.updateData;
-        }
-    });
-
+        if (r.status === 'fulfilled' && r.value) { const d = r.value; usernameMap[d.userId] = { username: d.username }; bronzeStates[d.userId] = d.isBronze; validUserCount++; if (d.type === 'speculator') speculatorUpdates[`users.${d.userId}`] = d.updateData; else normalUpdates[`users.${d.userId}`] = d.updateData; } });
     if (Object.keys(speculatorUpdates).length || Object.keys(normalUpdates).length) {
         const blockRef = db.collection(userType === 'speculator' ? config.FIRESTORE_COLLECTION_SPECULATOR_BLOCKS : config.FIRESTORE_COLLECTION_NORMAL_PORTFOLIOS).doc(String(blockId));
         batch.set(blockRef, userType === 'speculator' ? speculatorUpdates : normalUpdates, { merge: true });
         const bronzeRef = db.collection(userType === 'speculator' ? config.FIRESTORE_COLLECTION_BRONZE_SPECULATORS : config.FIRESTORE_COLLECTION_BRONZE_NORMAL).doc(String(blockId));
         batch.set(bronzeRef, bronzeStates, { merge: true });
+        if (validUserCount) { const countsRef = db.doc(userType === 'speculator' ? config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS : config.FIRESTORE_DOC_BLOCK_COUNTS); const field = userType === 'speculator' ? `counts.${instrument}_${blockId}` : `counts.${blockId}`; batch.set(countsRef, { [field]: FieldValue.increment(validUserCount) }, { merge: true }); } }
 
-        if (validUserCount) {
-            const countsRef = db.doc(userType === 'speculator' ? config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS : config.FIRESTORE_DOC_BLOCK_COUNTS);
-            const field = userType === 'speculator' ? `counts.${instrument}_${blockId}` : `counts.${blockId}`;
-            batch.set(countsRef, { [field]: FieldValue.increment(validUserCount) }, { merge: true });
-        }
-    }
-
-    // --- START FIX: MODIFIED FOR SHARDING ---
     if (Object.keys(usernameMap).length) {
-        // Group updates by shard
         const shardedUpdates = {};
-        for (const cid in usernameMap) {
-            // Re-implement the sharding logic here
-            const shardId = `cid_map_shard_${Math.floor(parseInt(cid) / 10000) % 10}`;
-            if (!shardedUpdates[shardId]) {
-                shardedUpdates[shardId] = {};
-            }
-            shardedUpdates[shardId][cid] = usernameMap[cid];
-        }
-
-        // Write each shard to its own document
-        for (const shardId in shardedUpdates) {
-            const mapRef = db.collection(config.FIRESTORE_COLLECTION_USERNAME_MAP).doc(shardId);
-            batch.set(mapRef, shardedUpdates[shardId], { merge: true });
-        }
-        logger.log('INFO', `[VERIFY] Staging username updates across ${Object.keys(shardedUpdates).length} shards.`);
-    }
-    // --- END FIX ---
-
+        for (const cid in usernameMap) { const shardId = `cid_map_shard_${Math.floor(parseInt(cid) / 10000) % 10}`;
+            if (!shardedUpdates[shardId]) { shardedUpdates[shardId] = {}; } shardedUpdates[shardId][cid] = usernameMap[cid]; }
+        for (const shardId in shardedUpdates) { const mapRef = db.collection(config.FIRESTORE_COLLECTION_USERNAME_MAP).doc(shardId); batch.set(mapRef, shardedUpdates[shardId], { merge: true }); }
+        logger.log('INFO', `[VERIFY] Staging username updates across ${Object.keys(shardedUpdates).length} shards.`); }
     await batch.commit();
     if (validUserCount) logger.log('INFO', `[VERIFY] Verified and stored ${validUserCount} new ${userType} users.`);
 }

package/functions/task-engine/utils/firestore_batch_manager.js

@@ -12,7 +12,6 @@ class FirestoreBatchManager {
         this.headerManager = headerManager;
         this.logger = logger;
         this.config = config;
-
         this.portfolioBatch = {};
         this.timestampBatch = {};
         this.tradingHistoryBatch = {};
@@ -21,64 +20,41 @@ class FirestoreBatchManager {
         this.usernameMapUpdates = {};
         this.usernameMapLastLoaded = 0;
         this.processedSpeculatorCids = new Set();
-
         this.usernameMapCollectionName = config.FIRESTORE_COLLECTION_USERNAME_MAP;
         this.normalHistoryCollectionName = config.FIRESTORE_COLLECTION_NORMAL_HISTORY;
         this.speculatorHistoryCollectionName = config.FIRESTORE_COLLECTION_SPECULATOR_HISTORY;
-
         this.batchTimeout = null;
-
         logger.log('INFO', 'FirestoreBatchManager initialized.');
     }
 
-    // --- START FIX: ADDED SHARDING HELPER ---
-    _getUsernameShardId(cid) {
-        // Shard across 10 documents (supports ~200k users assuming 50 bytes/user)
-        return `cid_map_shard_${Math.floor(parseInt(cid) / 10000) % 10}`;
-    }
-    // --- END FIX ---
+    _getUsernameShardId(cid) { return `cid_map_shard_${Math.floor(parseInt(cid) / 10000) % 10}`; }
 
-    _scheduleFlush() {
-        if (!this.batchTimeout) this.batchTimeout = setTimeout(() => this.flushBatches(), this.config.TASK_ENGINE_FLUSH_INTERVAL_MS);
-    }
+    _scheduleFlush() { if (!this.batchTimeout) this.batchTimeout = setTimeout(() => this.flushBatches(), this.config.TASK_ENGINE_FLUSH_INTERVAL_MS); }
 
     async loadUsernameMap() {
         if (Date.now() - this.usernameMapLastLoaded < 3600000) return;
         this.usernameMap.clear();
         this.logger.log('INFO', '[BATCH] Refreshing username map from Firestore...');
         try {
-            // This correctly gets ALL documents (shards) in the collection
             const snapshot = await this.db.collection(this.usernameMapCollectionName).get();
-            snapshot.forEach(doc => {
-                const data = doc.data();
-                for (const cid in data) if (data[cid]?.username) this.usernameMap.set(String(cid), data[cid].username);
-            });
+            snapshot.forEach(doc => { const data = doc.data(); for (const cid in data) if (data[cid]?.username) this.usernameMap.set(String(cid), data[cid].username); });
             this.usernameMapLastLoaded = Date.now();
             this.logger.log('INFO', `[BATCH] Loaded ${this.usernameMap.size} usernames.`);
-        } catch (e) {
-            this.logger.log('ERROR', '[BATCH] Failed to load username map.', { errorMessage: e.message });
-        }
+        } catch (e) { this.logger.log('ERROR', '[BATCH] Failed to load username map.', { errorMessage: e.message }); }
     }
 
     getUsername(cid) { return this.usernameMap.get(String(cid)); }
 
-    // --- START FIX: MODIFIED FOR SHARDING ---
     addUsernameMapUpdate(cid, username) {
         if (!username) return;
         const cidStr = String(cid);
         this.usernameMap.set(cidStr, username);
-
-        // Organize updates by shard ID
         const shardId = this._getUsernameShardId(cidStr);
-        if (!this.usernameMapUpdates[shardId]) {
-            this.usernameMapUpdates[shardId] = {};
-        }
+        if (!this.usernameMapUpdates[shardId]) { this.usernameMapUpdates[shardId] = {}; }
         this.usernameMapUpdates[shardId][cidStr] = { username };
-
         this.logger.log('TRACE', `[BATCH] Queued username update for ${cidStr} in ${shardId}.`);
         this._scheduleFlush();
     }
-    // --- END FIX ---
 
     async addToTradingHistoryBatch(userId, blockId, date, historyData, userType) {
         const collection = userType === 'speculator' ? this.speculatorHistoryCollectionName : this.normalHistoryCollectionName;
@@ -108,10 +84,7 @@ class FirestoreBatchManager {
     deleteFromTimestampBatch(userId, userType, instrumentId) {
         const collection = userType === 'speculator' ? this.config.FIRESTORE_COLLECTION_SPECULATOR_PORTFOLIOS : this.config.FIRESTORE_COLLECTION_NORMAL_PORTFOLIOS;
         const docPath = `${collection}/${userType === 'speculator' ? 'speculators' : 'normal'}`;
-        if (this.timestampBatch[docPath]) {
-            const key = userType === 'speculator' ? `${userId}_${instrumentId}` : userId;
-            delete this.timestampBatch[docPath][key];
-        }
+        if (this.timestampBatch[docPath]) { const key = userType === 'speculator' ? `${userId}_${instrumentId}` : userId; delete this.timestampBatch[docPath][key]; }
     }
 
     addProcessedSpeculatorCids(cids) { cids.forEach(cid => this.processedSpeculatorCids.add(cid)); }
@@ -131,11 +104,7 @@ class FirestoreBatchManager {
             const users = batchData[basePath];
             const userIds = Object.keys(users);
             if (!userIds.length) continue;
-            for (let i = 0; i < userIds.length; i += this.config.TASK_ENGINE_MAX_USERS_PER_SHARD) {
-                const chunkData = Object.fromEntries(userIds.slice(i, i + this.config.TASK_ENGINE_MAX_USERS_PER_SHARD).map(id => [id, users[id]]));
-                firestoreBatch.set(this.db.collection(`${basePath}/parts`).doc(), chunkData);
-                count++;
-            }
+            for (let i = 0; i < userIds.length; i += this.config.TASK_ENGINE_MAX_USERS_PER_SHARD) { const chunkData = Object.fromEntries(userIds.slice(i, i + this.config.TASK_ENGINE_MAX_USERS_PER_SHARD).map(id => [id, users[id]])); firestoreBatch.set(this.db.collection(`${basePath}/parts`).doc(), chunkData); count++; }
             this.logger.log('INFO', `[BATCH] Staged ${userIds.length} ${logName} users in ${Math.ceil(userIds.length / this.config.TASK_ENGINE_MAX_USERS_PER_SHARD)} shards for ${basePath}.`);
             delete batchData[basePath];
         }
@@ -144,13 +113,10 @@ class FirestoreBatchManager {
 
     async flushBatches() {
         if (this.batchTimeout) { clearTimeout(this.batchTimeout); this.batchTimeout = null; }
-
         const firestoreBatch = this.db.batch();
         let batchOps = 0;
-
         batchOps += this._flushDataBatch(this.portfolioBatch, firestoreBatch, 'Portfolio');
         batchOps += this._flushDataBatch(this.tradingHistoryBatch, firestoreBatch, 'Trade History');
-
         for (const docPath in this.timestampBatch) {
             const timestamps = this.timestampBatch[docPath];
             if (!Object.keys(timestamps).length) continue;
@@ -168,39 +134,22 @@ class FirestoreBatchManager {
             delete this.speculatorTimestampFixBatch[docPath];
         }
 
-        // --- START FIX: MODIFIED FOR SHARDING ---
-        // Loop over each shardId in the updates object
         for (const shardId in this.usernameMapUpdates) {
             const updates = this.usernameMapUpdates[shardId];
-            if (updates && Object.keys(updates).length > 0) {
-                firestoreBatch.set(
-                    this.db.collection(this.usernameMapCollectionName).doc(shardId),
-                    updates,
-                    { merge: true }
-                );
-                batchOps++;
-                this.logger.log('INFO', `[BATCH] Flushing ${Object.keys(updates).length} username updates to ${shardId}.`);
-            }
-        }
-        this.usernameMapUpdates = {}; // Clear updates after staging them
-        // --- END FIX ---
+            if (updates && Object.keys(updates).length > 0) { firestoreBatch.set( this.db.collection(this.usernameMapCollectionName).doc(shardId), updates, { merge: true } ); batchOps++; this.logger.log('INFO', `[BATCH] Flushing ${Object.keys(updates).length} username updates to ${shardId}.`); } }
+        this.usernameMapUpdates = {}; 
 
         if (this.processedSpeculatorCids.size) {
             const cids = Array.from(this.processedSpeculatorCids);
             this.processedSpeculatorCids.clear();
             const snapshot = await this.db.collection(this.config.PENDING_SPECULATORS_COLLECTION).get();
-            snapshot.forEach(doc => {
-                const docData = doc.data().users || {};
-                const cidsInDoc = cids.filter(cid => docData[cid]);
-                if (!cidsInDoc.length) return;
-                const delBatch = this.db.batch();
-                const updates = Object.fromEntries(cidsInDoc.map(cid => [`users.${cid}`, FieldValue.delete()]));
-                delBatch.update(doc.ref, updates);
-                delBatch.commit();
-                this.logger.log('INFO', `[BATCH] Deleted ${cidsInDoc.length} CIDs from ${doc.id}`);
-            });
-        }
-
+            snapshot.forEach(doc => { const docData = doc.data().users || {}; const cidsInDoc = cids.filter(cid => docData[cid]); if (!cidsInDoc.length) return;
+            const delBatch = this.db.batch();
+            const updates = Object.fromEntries(cidsInDoc.map(cid => [`users.${cid}`, FieldValue.delete()]));
+            delBatch.update(doc.ref, updates);
+            delBatch.commit();
+            this.logger.log('INFO', `[BATCH] Deleted ${cidsInDoc.length} CIDs from ${doc.id}`); }); }
+            
         if (batchOps) await firestoreBatch.commit();
         await this.headerManager.flushPerformanceUpdates();
         this.logger.log('INFO', '[BATCH] All batches flushed successfully.');

package/functions/task-engine/utils/task_engine_utils.js

@@ -21,10 +21,7 @@ function parseTaskPayload(message, logger) {
     let payload;
     try { payload = JSON.parse(Buffer.from(message.data, 'base64').toString()); }
     catch (e) { logger.log('ERROR', '[TaskEngine] Failed to parse message', { error: e.message }); return null; }
-    if (!Array.isArray(payload.tasks) || payload.tasks.length === 0) {
-        logger.log(payload.tasks?.length ? 'WARN' : 'ERROR', '[TaskEngine] Invalid or empty tasks array.', { payload });
-        return null;
-    }
+    if (!Array.isArray(payload.tasks) || payload.tasks.length === 0) { logger.log(payload.tasks?.length ? 'WARN' : 'ERROR', '[TaskEngine] Invalid or empty tasks array.', { payload }); return null; }
     return payload.tasks;
 }
 
@@ -35,11 +32,7 @@ async function prepareTaskBatches(tasks, batchManager, logger) {
     const tasksToRun = [], cidsToLookup = new Map(), otherTasks = [];
     await batchManager.loadUsernameMap();
     for (const task of tasks) {
-        if (task.type === 'update') {
-            const username = batchManager.getUsername(task.userId);
-            username ? tasksToRun.push({ task, username }) : cidsToLookup.set(String(task.userId), task);
-        } else otherTasks.push(task);
-    }
+        if (task.type === 'update') { const username = batchManager.getUsername(task.userId); username ? tasksToRun.push({ task, username }) : cidsToLookup.set(String(task.userId), task); } else otherTasks.push(task); }
     logger.log('INFO', `[TaskEngine] Sorting complete. Known: ${tasksToRun.length}, Lookup: ${cidsToLookup.size}, Other: ${otherTasks.length}`);
     return { tasksToRun, cidsToLookup, otherTasks };
 }
@@ -51,12 +44,7 @@ async function runUsernameLookups(tasksToRun, cidsToLookup, dependencies, config
     if (!cidsToLookup.size) return;
     logger.log('INFO', `[TaskEngine] Looking up ${cidsToLookup.size} usernames...`);
     const foundUsers = await lookupUsernames([...cidsToLookup.keys()], dependencies, config);
-    for (const u of foundUsers) {
-        const cid = String(u.CID), username = u.Value.UserName;
-        batchManager.addUsernameMapUpdate(cid, username);
-        const task = cidsToLookup.get(cid);
-        if (task) { tasksToRun.push({ task, username }); cidsToLookup.delete(cid); }
-    }
+    for (const u of foundUsers) { const cid = String(u.CID), username = u.Value.UserName; batchManager.addUsernameMapUpdate(cid, username); const task = cidsToLookup.get(cid); if (task) { tasksToRun.push({ task, username }); cidsToLookup.delete(cid); } }
     if (cidsToLookup.size) logger.log('WARN', `[TaskEngine] Could not find ${cidsToLookup.size} usernames (likely private).`, { skippedCids: [...cidsToLookup.keys()] });
 }
 
@@ -65,34 +53,17 @@ async function runUsernameLookups(tasksToRun, cidsToLookup, dependencies, config
  */
 async function executeTasks(tasksToRun, otherTasks, dependencies, config, taskId) {
     const { logger } = dependencies;
-    
-    // --- START MODIFICATION ---
-    // This Set will track history fetches *only for this batch*.
     const historyFetchedForUser = new Set();
-    // --- END MODIFICATION ---
-
-
-    // Process discover/verify tasks
     for (const task of otherTasks) {
         const subTaskId = `${task.type}-${task.userType || 'unknown'}-${task.userId || task.cids?.[0] || 'sub'}`;
         const handler = { discover: handleDiscover, verify: handleVerify }[task.type];
         if (handler) try { await handler(task, subTaskId, dependencies, config); } 
         catch (err) { logger.log('ERROR', `[TaskEngine/${taskId}] Error in ${task.type} for ${subTaskId}`, { errorMessage: err.message }); }
-        else logger.log('ERROR', `[TaskEngine/${taskId}] Unknown task type: ${task.type}`);
-    }
-
-    // Process update tasks (all have usernames)
+        else logger.log('ERROR', `[TaskEngine/${taskId}] Unknown task type: ${task.type}`); }
     for (const { task, username } of tasksToRun) {
         const subTaskId = `${task.type}-${task.userType || 'unknown'}-${task.userId}`;
-        try {
-            // --- START MODIFICATION ---
-            // Pass the Set to the update handler
-            await handleUpdate(task, subTaskId, dependencies, config, username, historyFetchedForUser);
-            // --- END MODIFICATION ---
-        }
-        catch (err) { logger.log('ERROR', `[TaskEngine/${taskId}] Error in handleUpdate for ${task.userId}`, { errorMessage: err.message }); }
-    }
-
+        try { await handleUpdate(task, subTaskId, dependencies, config, username, historyFetchedForUser);}
+        catch (err) { logger.log('ERROR', `[TaskEngine/${taskId}] Error in handleUpdate for ${task.userId}`, { errorMessage: err.message }); } }
     logger.log('SUCCESS', `[TaskEngine/${taskId}] Processed all tasks.`);
 }
 

package/index.js

@@ -7,84 +7,86 @@
 // --- Core Utilities (Classes and Stateless Helpers) ---
 
 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'),
-    pubsubUtils: require('./functions/core/utils/pubsub_utils'),
+    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'),
+    pubsubUtils              : require('./functions/core/utils/pubsub_utils'),
 };
 
 // --- Pipe 1: Orchestrator ---
 
 const orchestrator = {
     // Main Pipes (Entry points for Cloud Functions)
-    runDiscoveryOrchestrator: require('./functions/orchestrator/index').runDiscoveryOrchestrator,
-    runUpdateOrchestrator: require('./functions/orchestrator/index').runUpdateOrchestrator,
+    runDiscoveryOrchestrator : require('./functions/orchestrator/index').runDiscoveryOrchestrator,
+    runUpdateOrchestrator    : require('./functions/orchestrator/index').runUpdateOrchestrator,
     
     // Sub-Pipes (Discovery)
-    checkDiscoveryNeed: require('./functions/orchestrator/helpers/discovery_helpers').checkDiscoveryNeed,
-    getDiscoveryCandidates: require('./functions/orchestrator/helpers/discovery_helpers').getDiscoveryCandidates,
-    dispatchDiscovery: require('./functions/orchestrator/helpers/discovery_helpers').dispatchDiscovery,
+    checkDiscoveryNeed       : require('./functions/orchestrator/helpers/discovery_helpers').checkDiscoveryNeed,
+    getDiscoveryCandidates   : require('./functions/orchestrator/helpers/discovery_helpers').getDiscoveryCandidates,
+    dispatchDiscovery        : require('./functions/orchestrator/helpers/discovery_helpers').dispatchDiscovery,
 
     // Sub-Pipes (Updates)
-    getUpdateTargets: require('./functions/orchestrator/helpers/update_helpers').getUpdateTargets,
-    dispatchUpdates: require('./functions/orchestrator/helpers/update_helpers').dispatchUpdates,
+    getUpdateTargets         : require('./functions/orchestrator/helpers/update_helpers').getUpdateTargets,
+    dispatchUpdates          : require('./functions/orchestrator/helpers/update_helpers').dispatchUpdates,
 };
 
+
 // --- Pipe 2: Dispatcher ---
-// ... (identical to original file)
+
 const dispatcher = {
-    handleRequest: require('./functions/dispatcher/index').handleRequest,
-    dispatchTasksInBatches: require('./functions/dispatcher/helpers/dispatch_helpers').dispatchTasksInBatches,
+    handleRequest            : require('./functions/dispatcher/index').handleRequest,
+    dispatchTasksInBatches   : require('./functions/dispatcher/helpers/dispatch_helpers').dispatchTasksInBatches,
 };
 
+
 // --- Pipe 3: Task Engine ---
-// ... (identical to original file)
+
 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            : 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,
 };
 
+
 // --- Pipe 4: Computation System ---
+
 const computationSystem = {
-    // --- (MODIFICATION) ---
-    // The main pipe is now the new pass runner
-    runComputationPass: require('./functions/computation-system/helpers/computation_pass_runner').runComputationPass,
-    // --- (END MODIFICATION) ---
-    
-    // Sub-Pipes (Exposing utils for potential external use)
-    dataLoader: require('./functions/computation-system/utils/data_loader'),
-    computationUtils: require('./functions/computation-system/utils/utils'),
+    runComputationPass       : require('./functions/computation-system/helpers/computation_pass_runner').runComputationPass,    
+    dataLoader               : require('./functions/computation-system/utils/data_loader'),
+    computationUtils         : require('./functions/computation-system/utils/utils'),
 };
 
+
 // --- Pipe 5: API ---
-// ... (identical to original file)
+
 const api = {
-    createApiApp: require('./functions/generic-api/index').createApiApp,
-    helpers: require('./functions/generic-api/helpers/api_helpers'),
+    createApiApp             : require('./functions/generic-api/index').createApiApp,
+    helpers                  : require('./functions/generic-api/helpers/api_helpers'),
 };
 
+
 // --- Pipe 6: Maintenance ---
-// ... (identical to original file)
+
 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     : 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,
 };
 
+
 // --- Pipe 7: Proxy ---
-// ... (identical to original file)
+
 const proxy = {
-    handlePost: require('./functions/appscript-api/index').handlePost,
+    handlePost               : require('./functions/appscript-api/index').handlePost,
 };
 
-// --- EXPORT THE FINAL PIPE OBJECT ---
+
 module.exports = {
     pipe: {
         core,
@@ -96,4 +98,4 @@ module.exports = {
         maintenance,
         proxy,
     }
-};
+};

package/package.json

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