bulltrackers-module 1.0.2 → 1.0.4

package/functions/orchestrator/helpers/discovery_helpers.js

@@ -228,7 +228,7 @@ async function dispatchDiscovery(userType, candidates, config) {
         }
     }
 
-    await pubsubUtils.batchWriteShardedTasks(
+    await pubsubUtils.batchPublishTasks(
         topicName, 
         tasks, 
         `${userType} discovery`,

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

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Helper function for the 'discover' task.
+ */
+const { logger } = require("sharedsetup")(__filename);
+
+/**
+ * Handles the 'discover' task.
+ * @param {object} task The Pub/Sub task payload.
+ * @param {string} taskId A unique ID for logging.
+ * @param {object} clients Contains { headerManager, proxyManager, pubsub, batchManager }.
+ * @param {object} config The configuration object.
+ */
+async function handleDiscover(task, taskId, clients, config) {
+    const { cids, blockId, instrument, userType } = task;
+    const url = `${config.ETORO_API_RANKINGS_URL}?Period=LastTwoYears`;
+    const selectedHeader = await clients.headerManager.selectHeader();
+    if (!selectedHeader) throw new Error("Could not select a header.");
+
+    let wasSuccess = false;
+    try {
+        if (userType === 'speculator') {
+            clients.batchManager.addProcessedSpeculatorCids(cids);
+            logger.log('INFO', `[DISCOVER] Added ${cids.length} speculator CIDs to the in-memory set to be flushed.`);
+        }
+        
+        const { response } = await clients.proxyManager.fetch(url, {
+            method: 'POST',
+            headers: { ...selectedHeader.headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify(cids),
+        });
+        if (!response.ok) {
+            throw new Error(`API status ${response.status}`);
+        }
+        wasSuccess = true;
+
+        const publicUsers = await response.json();
+        if (!Array.isArray(publicUsers)) return;
+
+        // --- REFACTORED FILTERING & CHAINING ---
+        const oneMonthAgo = new Date();
+        oneMonthAgo.setMonth(oneMonthAgo.getMonth() - 1);
+
+        const preliminaryActiveUsers = publicUsers.filter(user => 
+            new Date(user.Value.LastActivity) > oneMonthAgo &&
+            user.Value.DailyGain !== 0 &&
+            user.Value.Exposure !== 0 &&
+            user.Value.RiskScore !== 0
+        );
+        
+        let finalActiveUsers = [];
+        const invalidCidsToLog = [];
+
+        if (userType === 'speculator') {
+            const publicUserCids = new Set(publicUsers.map(u => u.CID));
+            
+            if (publicUserCids.size > 0 && publicUserCids.size < cids.length) {
+                const privateUserCids = cids.filter(cid => !publicUserCids.has(cid));
+                invalidCidsToLog.push(...privateUserCids);
+            }
+
+            const activeUserCids = new Set(preliminaryActiveUsers.map(u => u.CID));
+            const inactiveUserCids = publicUsers
+                .filter(u => !activeUserCids.has(u.CID))
+                .map(u => u.CID);
+            invalidCidsToLog.push(...inactiveUserCids);
+
+            logger.log('INFO', `[DISCOVER] Applying new speculator pre-filter to ${preliminaryActiveUsers.length} active users.`);
+            const nonSpeculatorCids = [];
+            
+            for (const user of preliminaryActiveUsers) {
+                const v = user.Value;
+                const totalLeverage = (v.MediumLeveragePct || 0) + (v.HighLeveragePct || 0);
+
+                const isLikelySpeculator = (
+                    (v.Trades || 0) > 500 ||
+                    (v.TotalTradedInstruments || 0) > 50 ||
+                    totalLeverage > 50 ||
+                    (v.WeeklyDD || 0) < -25
+                );
+
+                if (isLikelySpeculator) {
+                    finalActiveUsers.push(user);
+                } else {
+                    nonSpeculatorCids.push(user.CID);
+                }
+            }
+            
+            invalidCidsToLog.push(...nonSpeculatorCids);
+            logger.log('INFO', `[DISCOVER] Pre-filter complete. ${finalActiveUsers.length} users passed. ${nonSpeculatorCids.length} users failed heuristic.`);
+            
+            if (invalidCidsToLog.length > 0) {
+                await clients.pubsub.topic(config.PUBSUB_TOPIC_INVALID_SPECULATOR_LOG)
+                                  .publishMessage({ json: { invalidCids: invalidCidsToLog } });
+                logger.log('INFO', `[DISCOVER] Reported ${invalidCidsToLog.length} invalid (private, inactive, or failed heuristic) speculator IDs.`);
+            }
+
+        } else { // 'normal' users
+            finalActiveUsers = preliminaryActiveUsers;
+        }
+
+        if (finalActiveUsers.length > 0) {
+            const verificationTask = {
+                type: 'verify',
+                users: finalActiveUsers.map(u => ({ cid: u.CID, isBronze: u.Value.IsBronze })),
+                blockId,
+                instrument,
+                userType
+            };
+            await clients.pubsub.topic(config.PUBSUB_TOPIC_USER_FETCH)
+                               .publishMessage({ json: verificationTask });
+            logger.log('INFO', `[DISCOVER] Verification message published was : ${JSON.stringify(verificationTask)} `);
+            logger.log('INFO', `[DISCOVER] Chaining to 'verify' task for ${finalActiveUsers.length} active users.`);
+        }
+        // --- END REFACTORED LOGIC ---
+
+    } finally {
+        if (selectedHeader) clients.headerManager.updatePerformance(selectedHeader.id, wasSuccess);
+    }
+}
+
+module.exports = { handleDiscover };

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

@@ -0,0 +1,10 @@
+// bulltrackers-module/functions/task-engine/helpers/index.js
+const { handleDiscover } = require('./discover_helpers');
+const { handleVerify } = require('./verify_helpers');
+const { handleUpdate } = require('./update_helpers');
+
+module.exports = {
+  handleDiscover,
+  handleVerify,
+  handleUpdate,
+};

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

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Helper function for the 'update' task.
+ */
+const { FieldValue } = require('@google-cloud/firestore');
+const { logger } = require("sharedsetup")(__filename);
+
+/**
+ * Handles the 'update' task.
+ * @param {object} task The Pub/Sub task payload.
+ * @param {string} taskId A unique ID for logging.
+ * @param {object} clients Contains { headerManager, proxyManager, nativeFirestore, batchManager }.
+ * @param {object} config The configuration object.
+ */
+async function handleUpdate(task, taskId, clients, config) {
+    const { userId, instrumentId, userType } = task;
+    const selectedHeader = await clients.headerManager.selectHeader();
+    if (!selectedHeader) throw new Error("Could not select a header.");
+
+    let wasSuccess = false;
+    try {
+        const url = userType === 'speculator' 
+            ? `${config.ETORO_API_POSITIONS_URL}?cid=${userId}&InstrumentID=${instrumentId}` 
+            : `${config.ETORO_API_PORTFOLIO_URL}?cid=${userId}`;
+        
+        logger.log('INFO', `[UPDATE] Fetching portfolio for user ${userId} (${userType} with url ${url})`);
+        const { response } = await clients.proxyManager.fetch(url, { headers: selectedHeader.headers });
+        const responseBody = await response.text();
+
+        if (responseBody.includes("user is PRIVATE")) {
+            logger.log('WARN', `User ${userId} is private. Removing from future updates and decrementing block count.`);
+            
+            // Use the batch manager to delete the timestamp from the pending batch
+            clients.batchManager.deleteFromTimestampBatch(userId, userType, instrumentId);
+
+            const blockId = `${Math.floor(parseInt(userId) / 1000000)}M`;
+            const blockCountsRef = clients.nativeFirestore.doc(userType === 'speculator' 
+                ? config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS 
+                : config.FIRESTORE_DOC_BLOCK_COUNTS);
+            
+            const incrementField = userType === 'speculator' 
+                ? `counts.${instrumentId}_${blockId}` 
+                : `counts.${blockId}`;
+                
+            await blockCountsRef.set({ [incrementField]: FieldValue.increment(-1) }, { merge: true });
+
+            return;
+        }
+        
+        if (!response.ok) {
+            throw new Error(`API Error: Status ${response.status}`);
+        }
+        wasSuccess = true;
+        const portfolioData = JSON.parse(responseBody);
+
+        const today = new Date().toISOString().slice(0, 10);
+        const blockId = `${Math.floor(parseInt(userId) / 1000000)}M`;
+
+        // Use the batch manager to add portfolio data
+        await clients.batchManager.addToPortfolioBatch(userId, blockId, today, portfolioData, userType, instrumentId);
+
+        // --- DEPRECATED LOGIC ---
+        // The PreCompute system is deprecated. All related logic is removed.
+        // --- END DEPRECATED LOGIC ---
+
+        // Use the batch manager to update the timestamp
+        await clients.batchManager.updateUserTimestamp(userId, userType, instrumentId);
+
+    } finally {
+        if (selectedHeader) clients.headerManager.updatePerformance(selectedHeader.id, wasSuccess);
+    }
+}
+
+module.exports = { handleUpdate };

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

@@ -0,0 +1,100 @@
+/**
+ * @fileoverview Helper function for the 'verify' task.
+ */
+const { FieldValue } = require('@google-cloud/firestore');
+const { logger } = require("sharedsetup")(__filename);
+
+/**
+ * Handles the 'verify' task.
+ * @param {object} task The Pub/Sub task payload.
+ * @param {string} taskId A unique ID for logging.
+ * @param {object} clients Contains { headerManager, proxyManager, nativeFirestore }.
+ * @param {object} config The configuration object.
+ */
+async function handleVerify(task, taskId, clients, config) {
+    const { users, blockId, instrument, userType } = task;
+    const batch = clients.nativeFirestore.batch();
+    let validUserCount = 0;
+    const speculatorUpdates = {};
+    const normalUserUpdates = {};
+    const bronzeStateUpdates = {};
+
+    // Create the set from the config array for efficient lookups
+    const speculatorInstrumentSet = new Set(config.SPECULATOR_INSTRUMENTS_ARRAY);
+    
+    for (const user of users) {
+        const userId = user.cid;
+        
+        const portfolioUrl = `${config.ETORO_API_PORTFOLIO_URL}?cid=${userId}`;
+        const selectedHeader = await clients.headerManager.selectHeader();
+        if (!selectedHeader) continue;
+
+        let wasSuccess = false;
+        try {
+            const { response } = await clients.proxyManager.fetch(portfolioUrl, { headers: selectedHeader.headers });
+            if (!response.ok) continue;
+            wasSuccess = true;
+            
+            const portfolioData = await response.json();
+
+            if (userType === 'speculator') {
+                const matchingInstruments = portfolioData.AggregatedPositions
+                    .map(p => p.InstrumentID)
+                    .filter(id => speculatorInstrumentSet.has(id)); // Use the Set
+
+                if (matchingInstruments.length > 0) {
+                    speculatorUpdates[`users.${userId}`] = {
+                        instruments: matchingInstruments,
+                        lastVerified: new Date(),
+                        lastHeldSpeculatorAsset: new Date()
+                    };
+                    bronzeStateUpdates[userId] = user.isBronze;
+                    logger.log('INFO', `[VERIFY] Speculator user ${userId} holds speculator assets: ${matchingInstruments.join(', ')}`);
+                    validUserCount++;
+                }
+                else {
+                    logger.log('INFO', `[VERIFY] Speculator user ${userId} does not hold any speculator assets.`);
+                }
+            } else { // Normal user verification
+                normalUserUpdates[`users.${userId}`] = {
+                    lastVerified: new Date()
+                };
+                 bronzeStateUpdates[userId] = user.isBronze;
+                validUserCount++;
+            }
+        } finally {
+            if (selectedHeader) clients.headerManager.updatePerformance(selectedHeader.id, wasSuccess);
+        }
+    }
+
+    if (Object.keys(speculatorUpdates).length > 0 || Object.keys(normalUserUpdates).length > 0) {
+        if (userType === 'speculator') {
+            const speculatorBlockRef = clients.nativeFirestore.collection(config.FIRESTORE_COLLECTION_SPECULATOR_BLOCKS).doc(String(blockId));
+            batch.set(speculatorBlockRef, speculatorUpdates, { merge: true });
+            const bronzeStateRef = clients.nativeFirestore.collection(config.FIRESTORE_COLLECTION_BRONZE_SPECULATORS).doc(String(blockId));
+            batch.set(bronzeStateRef, bronzeStateUpdates, {merge: true});
+
+        } else {
+            const normalBlockRef = clients.nativeFirestore.collection(config.FIRESTORE_COLLECTION_NORMAL_PORTFOLIOS).doc(String(blockId));
+            batch.set(normalBlockRef, normalUserUpdates, { merge: true });
+            const bronzeStateRef = clients.nativeFirestore.collection(config.FIRESTORE_COLLECTION_BRONZE_NORMAL).doc(String(blockId));
+            batch.set(bronzeStateRef, bronzeStateUpdates, {merge: true});
+        }
+        
+        if (validUserCount > 0) {
+            const blockCountsRef = clients.nativeFirestore.doc(userType === 'speculator' 
+                ? config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS 
+                : config.FIRESTORE_DOC_BLOCK_COUNTS);
+            
+            const incrementField = userType === 'speculator' ? `counts.${instrument}_${blockId}` : `counts.${blockId}`;
+            batch.set(blockCountsRef, { [incrementField]: FieldValue.increment(validUserCount) }, { merge: true });
+        }
+    }
+    
+    await batch.commit();
+    if(validUserCount > 0) {
+        logger.log('INFO', `[VERIFY] Verified and stored ${validUserCount} new ${userType} users.`);
+    }
+}
+
+module.exports = { handleVerify };

package/functions/task-engine/index.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Exports modules related to the TaskEngine functions.
+ */
+
+const helpers = require('./helpers');
+const utils = require('./utils');
+
+module.exports = {
+  helpers,
+  utils,
+};

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

@@ -0,0 +1,225 @@
+/**
+ * @fileoverview Utility class to manage all stateful Firestore write batches
+ * for the Task Engine. This includes sharding portfolios, batching timestamp
+ * updates, and flushing processed speculator CIDs from the pending list.
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+const { logger } = require("sharedsetup")(__filename);
+
+class FirestoreBatchManager {
+    /**
+     * @param {Firestore} firestore A Firestore instance.
+     * @param {IntelligentHeaderManager} headerManager An IntelligentHeaderManager instance.
+     * @param {object} config Configuration object.
+     */
+    constructor(firestore, headerManager, config) {
+        this.firestore = firestore;
+        this.headerManager = headerManager;
+        this.config = config; // { TASK_ENGINE_MAX_BATCH_SIZE, TASK_ENGINE_FLUSH_INTERVAL_MS, TASK_ENGINE_MAX_USERS_PER_SHARD, ...collectionNames }
+
+        this.portfolioBatch = {};
+        this.timestampBatch = {};
+        this.processedSpeculatorCids = new Set();
+        this.batchTimeout = null;
+
+        logger.log('INFO', 'FirestoreBatchManager initialized.');
+    }
+
+    /**
+     * Schedules a flush if one isn't already scheduled.
+     */
+    _scheduleFlush() {
+        if (!this.batchTimeout) {
+            this.batchTimeout = setTimeout(
+                () => this.flushBatches(),
+                this.config.TASK_ENGINE_FLUSH_INTERVAL_MS
+            );
+        }
+    }
+
+    /**
+     * Adds a portfolio to the batch.
+     * @param {string} userId 
+     * @param {string} blockId 
+     * @param {string} date
+     * @param {object} portfolioData 
+     * @param {string} userType 
+     * @param {string|null} instrumentId 
+     */
+    async addToPortfolioBatch(userId, blockId, date, portfolioData, userType, instrumentId = null) {
+        const collection = userType === 'speculator'
+            ? this.config.FIRESTORE_COLLECTION_SPECULATOR_PORTFOLIOS
+            : this.config.FIRESTORE_COLLECTION_NORMAL_PORTFOLIOS;
+        const basePath = `${collection}/${blockId}/snapshots/${date}`;
+
+        if (!this.portfolioBatch[basePath]) {
+            this.portfolioBatch[basePath] = {};
+        }
+
+        this.portfolioBatch[basePath][userId] = portfolioData;
+
+        const totalUsersInBatch = Object.values(this.portfolioBatch).reduce((sum, users) => sum + Object.keys(users).length, 0);
+
+        if (totalUsersInBatch >= this.config.TASK_ENGINE_MAX_BATCH_SIZE) {
+            await this.flushBatches();
+        } else {
+            this._scheduleFlush();
+        }
+    }
+
+    /**
+     * Adds a user timestamp update to the batch.
+     * @param {string} userId 
+     * @param {string} userType 
+     * @param {string|null} instrumentId 
+     */
+    async updateUserTimestamp(userId, userType, instrumentId = null) {
+        const collection = userType === 'speculator'
+            ? this.config.FIRESTORE_COLLECTION_SPECULATOR_PORTFOLIOS
+            : this.config.FIRESTORE_COLLECTION_NORMAL_PORTFOLIOS;
+        const docId = userType === 'speculator' ? 'speculators' : 'normal';
+        const docPath = `${collection}/${docId}`;
+
+        if (!this.timestampBatch[docPath]) {
+            this.timestampBatch[docPath] = {};
+        }
+
+        const timestampKey = userType === 'speculator' ? `${userId}_${instrumentId}` : userId;
+        this.timestampBatch[docPath][timestampKey] = new Date();
+
+        if (Object.keys(this.timestampBatch[docPath]).length >= this.config.TASK_ENGINE_MAX_BATCH_SIZE) {
+            await this.flushBatches();
+        } else {
+            this._scheduleFlush();
+        }
+    }
+
+    /**
+     * Removes a user timestamp from the batch (e.g., if user is private).
+     * @param {string} userId 
+     * @param {string} userType 
+     * @param {string|null} instrumentId 
+     */
+    deleteFromTimestampBatch(userId, userType, instrumentId) {
+        const collection = userType === 'speculator'
+            ? this.config.FIRESTORE_COLLECTION_SPECULATOR_PORTFOLIOS
+            : this.config.FIRESTORE_COLLECTION_NORMAL_PORTFOLIOS;
+        const docId = userType === 'speculator' ? 'speculators' : 'normal';
+        const docPath = `${collection}/${docId}`;
+
+        if (this.timestampBatch[docPath]) {
+            const timestampKey = userType === 'speculator' ? `${userId}_${instrumentId}` : userId;
+            delete this.timestampBatch[docPath][timestampKey];
+        }
+    }
+
+    /**
+     * Adds discovered speculator CIDs to the in-memory set for later deletion.
+     * @param {Array<string>} cids 
+     */
+    addProcessedSpeculatorCids(cids) {
+        cids.forEach(cid => this.processedSpeculatorCids.add(cid));
+    }
+
+    /**
+     * Flushes all pending writes to Firestore and updates header performance.
+     */
+    async flushBatches() {
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
+
+        const promises = [];
+
+        // --- REVISED SHARDING AND FLUSH LOGIC ---
+        const firestoreBatch = this.firestore.batch();
+        let batchOperationCount = 0;
+
+        for (const basePath in this.portfolioBatch) {
+            const userPortfolios = this.portfolioBatch[basePath];
+            const userIds = Object.keys(userPortfolios);
+
+            if (userIds.length > 0) {
+                for (let i = 0; i < userIds.length; i += this.config.TASK_ENGINE_MAX_USERS_PER_SHARD) {
+                    const chunkUserIds = userIds.slice(i, i + this.config.TASK_ENGINE_MAX_USERS_PER_SHARD);
+                    const shardIndex = Math.floor(i / this.config.TASK_ENGINE_MAX_USERS_PER_SHARD);
+
+                    const chunkData = {};
+                    chunkUserIds.forEach(userId => {
+                        chunkData[userId] = userPortfolios[userId];
+                    });
+
+                    const docRef = this.firestore.collection(`${basePath}/parts`).doc(`part_${shardIndex}`);
+                    firestoreBatch.set(docRef, chunkData, { merge: true });
+                    batchOperationCount++;
+                }
+                logger.log('INFO', `[BATCH] Staged ${userIds.length} users into ${Math.ceil(userIds.length / this.config.TASK_ENGINE_MAX_USERS_PER_SHARD)} shards for ${basePath}.`);
+            }
+            delete this.portfolioBatch[basePath];
+        }
+
+        // Process timestamp updates
+        for (const docPath in this.timestampBatch) {
+            if (Object.keys(this.timestampBatch[docPath]).length > 0) {
+                const [collection] = docPath.split('/');
+                const docRef = this.firestore.collection(collection).doc('timestamps').collection('users').doc('normal');
+
+                if (batchOperationCount < 450) { // Keep buffer
+                    firestoreBatch.set(docRef, { users: this.timestampBatch[docPath] }, { merge: true });
+                    batchOperationCount++;
+                } else {
+                    promises.push(firestoreBatch.commit());
+                    const newBatch = this.firestore.batch();
+                    newBatch.set(docRef, { users: this.timestampBatch[docPath] }, { merge: true });
+                    promises.push(newBatch.commit());
+                    batchOperationCount = 1; // Reset count
+                }
+                delete this.timestampBatch[docPath];
+            }
+        }
+
+        // --- Logic for flushing processed speculator CIDs ---
+        if (this.processedSpeculatorCids.size > 0) {
+            logger.log('INFO', `[BATCH] Flushing ${this.processedSpeculatorCids.size} processed speculator CIDs from pending list documents.`);
+            const cidsToDelete = Array.from(this.processedSpeculatorCids);
+            this.processedSpeculatorCids.clear(); // Clear immediately
+
+            const pendingDocsSnapshot = await this.firestore.collection(this.config.PENDING_SPECULATORS_COLLECTION).get();
+
+            if (!pendingDocsSnapshot.empty) {
+                const deletePromises = [];
+                pendingDocsSnapshot.forEach(doc => {
+                    const docData = doc.data().users || {};
+                    const cidsInThisDoc = cidsToDelete.filter(cid => docData.hasOwnProperty(cid));
+
+                    if (cidsInThisDoc.length > 0) {
+                        const deleteBatch = this.firestore.batch();
+                        const updates = {};
+                        cidsInThisDoc.forEach(cid => {
+                            updates[`users.${cid}`] = FieldValue.delete();
+                        });
+                        deleteBatch.update(doc.ref, updates);
+                        deletePromises.push(deleteBatch.commit());
+                        logger.log('INFO', `[BATCH] Staged deletion of ${cidsInThisDoc.length} CIDs from document: ${doc.id}`);
+                    }
+                });
+                promises.push(...deletePromises);
+            }
+        }
+        // --- End new logic ---
+
+        if (batchOperationCount > 0) {
+            promises.push(firestoreBatch.commit());
+        }
+
+        // Flush header performance updates
+        promises.push(this.headerManager.flushPerformanceUpdates());
+
+        await Promise.all(promises);
+        logger.log('INFO', '[BATCH] All batches flushed successfully.');
+    }
+}
+
+module.exports = { FirestoreBatchManager };

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

@@ -0,0 +1,6 @@
+// bulltrackers-module/functions/task-engine/utils/index.js
+const { FirestoreBatchManager } = require('./firestore_batch_manager');
+
+module.exports = {
+  FirestoreBatchManager,
+};

package/index.js

@@ -1,16 +1,15 @@
 /**
- * @fileoverview Main entry point for the BulltrackersModule package.
- * Exports core utilities and function-specific modules.
+ * @fileoverview Main entry point for the Bulltrackers shared module.
+ * This module consolidates core utilities and abstracted function logic
+ * to be shared across multiple Cloud Functions.
  */
 
-const coreUtils = require('./functions/core/utils');
-const orchestrator = require('./functions/orchestrator'); // Adjust path as needed
+const core = require('./functions/core/utils');
+const Orchestrator = require('./functions/orchestrator');
+const TaskEngine = require('./functions/task-engine'); // <-- ADD THIS
 
 module.exports = {
-  core: {
-    utils: coreUtils,
-    logging: coreUtils.logging // Expose logging wrapper directly under core
-  },
-  Orchestrator: orchestrator,
-  // Add other function modules here as they are refactored (e.g., TaskEngine, ComputationSystem)
+  core,
+  Orchestrator,
+  TaskEngine, // <-- AND ADD THIS
 };

package/package.json

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