bulltrackers-module 1.0.7 → 1.0.10

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

@@ -0,0 +1,266 @@
+/**
+ * @fileoverview Core orchestration logic for the Computation System.
+ * Contains both the high-level pass orchestrator and the low-level
+ * function for processing a single date.
+ */
+
+const { FieldPath } = require('@google-cloud/firestore');
+const { getPortfolioPartRefs, loadFullDayMap, loadDataByRefs } = require('../utils/data_loader.js');
+const {
+    historicalCalculations, dailyCalculations, HISTORICAL_CALC_NAMES,
+    withRetry, getExpectedDateStrings, processJobsInParallel, getFirstDateFromSourceData,
+    commitBatchInChunks, unifiedUtils
+} = require('../utils/utils.js');
+
+
+// --- CORE CALCULATION HELPERS (Moved from original utils.js) ---
+
+/** Initializes calculator instances from the provided calculation classes. */
+function initializeCalculators(calculationsToRun, sourcePackage) {
+    const state = {};
+    for (const { category, calcName } of calculationsToRun) {
+        const CalculationClass = sourcePackage[category]?.[calcName];
+        if (typeof CalculationClass === 'function') {
+            try {
+                state[`${category}/${calcName}`] = new CalculationClass();
+            } catch (e) {
+                // Use logger, but it's not passed here, so console.warn
+                console.warn(`[Orchestrator] Init failed for ${category}/${calcName}`, { errorMessage: e.message });
+                state[`${category}/${calcName}`] = null;
+            }
+        } else {
+            console.warn(`[Orchestrator] Calculation class not found: ${category}/${calcName}`);
+        }
+    }
+    return state;
+}
+
+/** Streams day's data and calls the process() method on all calculators. */
+async function streamAndProcess(firestore, dateStr, todayRefs, state, passName, logger, yesterdayPortfolios = {}) {
+    logger.log('INFO', `[${passName}] Streaming ${todayRefs.length} 'today' part docs for ${dateStr}...`);
+    const { instrumentToTicker, instrumentToSector } = await unifiedUtils.loadInstrumentMappings();
+    const context = { instrumentMappings: instrumentToTicker, sectorMapping: instrumentToSector };
+
+    for (let i = 0; i < todayRefs.length; i += 10) { // Process in chunks of 10 part files
+        const batchRefs = todayRefs.slice(i, i + 10);
+        const todayPortfoliosChunk = await loadDataByRefs(firestore, batchRefs);
+
+        for (const uid in todayPortfoliosChunk) {
+            const p = todayPortfoliosChunk[uid];
+            if (!p) continue;
+            
+            const userType = p.PublicPositions ? 'speculator' : 'normal';
+            
+            for (const key in state) {
+                const calc = state[key];
+                if (!calc || typeof calc.process !== 'function') continue;
+
+                const [category, calcName] = key.split('/');
+                let processArgs;
+
+                if (HISTORICAL_CALC_NAMES.has(calcName)) {
+                    const pYesterday = yesterdayPortfolios[uid];
+                    if (!pYesterday) continue; // Skip if no yesterday data for historical calc
+                    processArgs = [p, pYesterday, uid];
+                } else {
+                    // Filter daily calcs by user type
+                    if ((userType === 'normal' && category === 'speculators') ||
+                        (userType === 'speculator' && !['speculators', 'sanity'].includes(category))) {
+                        continue;
+                    }
+                    processArgs = [p, uid, context];
+                }
+                
+                try {
+                    await Promise.resolve(calc.process(...processArgs));
+                } catch (e) {
+                    logger.log('WARN', `Process error in ${key} for user ${uid}`, { err: e.message });
+                }
+            }
+        }
+    }
+}
+
+
+// --- LOW-LEVEL ORCHESTRATOR (Moved from pass_orchestrators.js) ---
+
+/**
+ * Runs a set of calculations for a given date and writes the final results.
+ * @param {Firestore} firestore A Firestore client instance.
+ * @param {Function} logger A logger instance.
+ * @param {Date} dateToProcess - The date to run computations for.
+ * @param {Array} calculationsToRun - List of { category, calcName } to run.
+ * @param {String} passName - The name of the pass for logging.
+ * @param {Object} sourcePackage - The object containing calculation classes.
+ * @returns {Object} A summary of the execution.
+ */
+async function runUnifiedComputation(firestore, logger, dateToProcess, calculationsToRun, passName, sourcePackage) {
+    const dateStr = dateToProcess.toISOString().slice(0, 10);
+    logger.log('INFO', `[${passName}] Starting run for ${dateStr} with ${calculationsToRun.length} calcs.`);
+
+    try {
+        // --- 1. Data Loading ---
+        const todayRefs = await getPortfolioPartRefs(firestore, dateStr);
+        if (todayRefs.length === 0) {
+            return { success: true, date: dateStr, message: "No portfolio data for today." };
+        }
+
+        let yesterdayPortfolios = {};
+        const requiresYesterday = calculationsToRun.some(c => sourcePackage[c.category]?.[c.calcName]?.prototype?.process.length === 3);
+
+        if (requiresYesterday) {
+            const prev = new Date(dateToProcess);
+            prev.setUTCDate(prev.getUTCDate() - 1);
+            const prevStr = prev.toISOString().slice(0, 10);
+            const yesterdayRefs = await getPortfolioPartRefs(firestore, prevStr);
+            yesterdayPortfolios = await loadFullDayMap(firestore, yesterdayRefs);
+        }
+
+        // --- 2. In-Memory Processing ---
+        const state = initializeCalculators(calculationsToRun, sourcePackage);
+        await streamAndProcess(firestore, dateStr, todayRefs, state, passName, logger, yesterdayPortfolios);
+
+        // --- 3. REFACTORED: Write results PER-CALCULATION ---
+        let successCount = 0;
+        const resultsSubcollection = firestore.collection('unified_insights').doc(dateStr).collection('results');
+
+        for (const key in state) {
+            const calc = state[key];
+            if (!calc || typeof calc.getResult !== 'function') continue;
+            
+            const [category, calcName] = key.split('/');
+            const pendingWrites = []; 
+            const summaryData = {};
+
+            try {
+                const result = await Promise.resolve(calc.getResult());
+
+                if (result && Object.keys(result).length > 0) {
+                    
+                    if (result.sharded_user_profitability) {
+                        for (const shardId in result.sharded_user_profitability) {
+                            const shardData = result.sharded_user_profitability[shardId];
+                            if (shardData && Object.keys(shardData).length > 0) {
+                                const shardRef = firestore.collection('unified_insights').doc(shardId);
+                                pendingWrites.push({ ref: shardRef, data: { profits: shardData } });
+                            }
+                        }
+                    } else {
+                        const computationDocRef = resultsSubcollection.doc(category)
+                                                          .collection('computations')
+                                                          .doc(calcName);
+                        pendingWrites.push({ ref: computationDocRef, data: result });
+                    }
+
+                    if (!summaryData[category]) summaryData[category] = {};
+                    summaryData[category][calcName] = true; 
+                    
+                    const docRef = firestore.collection('unified_insights').doc(dateStr);
+                    pendingWrites.push({ ref: docRef, data: summaryData });
+                
+                    await commitBatchInChunks(
+                        firestore,
+                        pendingWrites, 
+                        `Commit ${passName} ${dateStr} [${key}]`
+                    );
+                    successCount++;
+                }
+            } catch (e) {
+                logger.log('ERROR', `[${passName}] getResult/Commit failed for ${key}`, { err: e.message });
+            }
+        }
+        
+        logger.log('SUCCESS', `[${passName}] Completed ${dateStr}. Success: ${successCount}/${calculationsToRun.length}.`);
+        return { success: true, date: dateStr, successful: successCount, failed: calculationsToRun.length - successCount };
+
+    } catch (err) {
+        logger.log('ERROR', `[${passName}] Fatal error for ${dateStr}`, { errorMessage: err.message, stack: err.stack });
+        return { success: false, date: dateStr, error: err.message };
+    }
+}
+
+
+// --- HIGH-LEVEL ORCHESTRATOR (Moved from ComputationSystem.js) ---
+
+/**
+ * Main entry point for the Unified Computation System logic.
+ * @param {Firestore} firestore A Firestore client instance.
+ * @param {Function} logger A logger instance.
+ * @returns {Promise<Object>} A summary of all passes.
+ */
+async function runComputationOrchestrator(firestore, logger) {
+    const summary = { pass1_results: [], pass2_results: [] };
+    const yesterday = new Date();
+    yesterday.setUTCDate(yesterday.getUTCDate() - 1);
+    const endDateUTC = new Date(Date.UTC(yesterday.getUTCFullYear(), yesterday.getUTCMonth(), yesterday.getUTCDate()));
+
+    // --- Master Calculation Lists ---
+    const masterHistoricalList = Object.entries(historicalCalculations).flatMap(([cat, calcs]) =>
+        Object.keys(calcs).map(name => ({ category: cat, calcName: name }))
+    );
+    const masterDailyList = Object.entries(dailyCalculations).flatMap(([cat, calcs]) =>
+        Object.keys(calcs).map(name => ({ category: cat, calcName: name }))
+    );
+    const masterFullList = [...masterHistoricalList, ...masterDailyList];
+
+    // --- Date & Job Discovery ---
+    const firstDate = await getFirstDateFromSourceData(firestore);
+    const startDateUTC = new Date(Date.UTC(firstDate.getUTCFullYear(), firstDate.getUTCMonth(), firstDate.getUTCDate()));
+    
+    const allExpectedDates = getExpectedDateStrings(startDateUTC, endDateUTC);
+    const insightDocs = await withRetry(() => firestore.collection('unified_insights').get(), "ListAllInsightDocs");
+    const existingDateIds = new Set(insightDocs.docs.map(d => d.id).filter(id => /^\d{4}-\d{2}-\d{2}$/.test(id)));
+
+    // --- PASS 1: Find and process entirely missing days (DAILY CALCS ONLY) ---
+    const missingDates = allExpectedDates.filter(dateStr => !existingDateIds.has(dateStr));
+    const pass1Jobs = missingDates.map(date => ({ date, missing: masterDailyList }));
+    
+    const pass1Results = await processJobsInParallel(
+        pass1Jobs,
+        (date, missing) => runUnifiedComputation(firestore, logger, date, missing, 'Pass 1 (Daily Only)', dailyCalculations),
+        'Pass 1'
+    );
+    summary.pass1_results = pass1Results.map((r, i) => r.status === 'fulfilled' ? r.value : { success: false, date: pass1Jobs[i].date, error: r.reason?.message });
+
+    // --- PASS 2: Find and process incomplete days ---
+    const pass2Jobs = [];
+    const updatedInsightDocs = await withRetry(() => firestore.collection('unified_insights').where(FieldPath.documentId(), 'in', allExpectedDates).get(), "ListAllInsightDocs-Pass2");
+
+    updatedInsightDocs.forEach(doc => {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(doc.id)) return;
+
+        const data = doc.data();
+        const missingCalcs = masterFullList.filter(({ category, calcName }) => !data?.[category]?.[calcName]);
+
+        if (missingCalcs.length > 0) {
+            pass2Jobs.push({ date: doc.id, missing: missingCalcs });
+        }
+    });
+    
+    const pass2Results = await processJobsInParallel(
+        pass2Jobs,
+        (date, missing) => {
+            const historicalMissing = missing.filter(c => HISTORICAL_CALC_NAMES.has(c.calcName));
+            const dailyMissing = missing.filter(c => !HISTORICAL_CALC_NAMES.has(c.calcName));
+            const promises = [];
+            if (historicalMissing.length > 0) {
+                promises.push(runUnifiedComputation(firestore, logger, date, historicalMissing, 'Pass 2 (Historical)', historicalCalculations));
+            }
+            if (dailyMissing.length > 0) {
+                promises.push(runUnifiedComputation(firestore, logger, date, dailyMissing, 'Pass 2 (Daily)', dailyCalculations));
+            }
+            return Promise.all(promises);
+        },
+        'Pass 2'
+    );
+    summary.pass2_results = pass2Results.map((r, i) => r.status === 'fulfilled' ? r.value : { success: false, date: pass2Jobs[i].date, error: r.reason?.message });
+
+    // --- FINISH ---
+    // The wrapper function will log success and send the response.
+    return summary;
+}
+
+module.exports = {
+    runComputationOrchestrator,
+    // We don't need to export runUnifiedComputation as it's only used internally
+};

package/functions/computation-system/index.js

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Exports the computation system's main logic.
+ */
+
+const { runComputationOrchestrator } = require('./helpers/orchestration_helpers.js');
+
+module.exports = {
+  runComputationOrchestrator,
+};

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

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview Data loader for the Computation System.
+ * Provides functions for finding data references and loading data in chunks.
+ */
+
+const { logger } = require("sharedsetup")(__filename);
+// Import withRetry from the unified calculations package
+const { withRetry } = require('aiden-shared-calculations-unified').utils;
+
+const COLLECTIONS_TO_QUERY = ['NormalUserPortfolios', 'SpeculatorUserPortfolios'];
+const PART_REF_BATCH_SIZE = 50; // Number of document snapshots to load at once
+
+/**
+ * Gets a list of all portfolio "part" document references for a given date.
+ * This function is lightweight and only fetches references, not data.
+ *
+ * @param {Firestore} firestore A Firestore client instance.
+ * @param {string} dateString The date in YYYY-MM-DD format.
+ * @returns {Promise<Firestore.DocumentReference[]>} An array of DocumentReferences.
+ */
+async function getPortfolioPartRefs(firestore, dateString) {
+    logger.log('INFO', `Getting portfolio part references for date: ${dateString}`);
+    const allPartRefs = [];
+
+    for (const collectionName of COLLECTIONS_TO_QUERY) {
+        const blockDocsQuery = firestore.collection(collectionName);
+        const blockDocRefs = await withRetry(
+            () => blockDocsQuery.listDocuments(),
+            `listDocuments(${collectionName})`
+        );
+
+        if (blockDocRefs.length === 0) {
+            logger.log('WARN', `No block documents found in collection: ${collectionName}`);
+            continue; 
+        }
+
+        for (const blockDocRef of blockDocRefs) {
+            const partsCollectionRef = blockDocRef.collection('snapshots').doc(dateString).collection('parts');
+            const partDocs = await withRetry(
+                () => partsCollectionRef.listDocuments(),
+                `listDocuments(${partsCollectionRef.path})`
+            );
+            allPartRefs.push(...partDocs);
+        }
+    }
+
+    logger.log('INFO', `Found ${allPartRefs.length} part document references for ${dateString}.`);
+    return allPartRefs;
+}
+
+
+/**
+ * Loads data from an array of DocumentReferences using firestore.getAll().
+ * Merges all data into a single map keyed by user ID.
+ *
+ * @param {Firestore} firestore A Firestore client instance.
+ * @param {Firestore.DocumentReference[]} refs An array of DocumentReferences to load.
+ * @returns {Promise<object>} A single map of { [userId]: portfolioData }.
+ */
+async function loadDataByRefs(firestore, refs) {
+    if (!refs || refs.length === 0) {
+        return {};
+    }
+
+    const mergedPortfolios = {};
+
+    for (let i = 0; i < refs.length; i += PART_REF_BATCH_SIZE) {
+        const batchRefs = refs.slice(i, i + PART_REF_BATCH_SIZE);
+
+        const snapshots = await withRetry(
+            () => firestore.getAll(...batchRefs),
+            `getAll(batch ${Math.floor(i / PART_REF_BATCH_SIZE)})`
+        );
+
+        for (const doc of snapshots) {
+            if (doc.exists) {
+                const data = doc.data();
+                 if (data && typeof data === 'object') {
+                    Object.assign(mergedPortfolios, data);
+                } else {
+                     logger.log('WARN', `Document ${doc.id} exists but data is not an object. Data:`, data);
+                 }
+            }
+        }
+    }
+    return mergedPortfolios;
+}
+
+/** Loads all portfolio data for a day by streaming part references. */
+async function loadFullDayMap(firestore, partRefs) {
+    if (partRefs.length === 0) return {};
+    logger.log('TRACE', `Loading full day map from ${partRefs.length} references...`);
+    const fullMap = await loadDataByRefs(firestore, partRefs);
+    logger.log('TRACE', `Full day map loaded with ${Object.keys(fullMap).length} users.`);
+    return fullMap;
+}
+
+module.exports = {
+    getPortfolioPartRefs,
+    loadDataByRefs,
+    loadFullDayMap
+};

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

@@ -0,0 +1,169 @@
+/**
+ * @fileoverview Helper functions for the Unified Computation System.
+ * This module imports all calculations and utilities from the single
+ * `aiden-shared-calculations-unified` package and categorizes them for the orchestrator.
+ */
+
+const { FieldValue, FieldPath } = require('@google-cloud/firestore');
+const { logger } = require("sharedsetup")(__filename);
+const { calculations, utils } = require('aiden-shared-calculations-unified');
+
+const { withRetry } = utils; // Get withRetry from the package.
+
+// --- Configuration ---
+const BATCH_SIZE_LIMIT = 500;
+const MAX_CONCURRENT_DATES = 3;
+
+// --- Calculation Categorization ---
+const HISTORICAL_CALC_NAMES = new Set([
+    'paper-vs-diamond-hands', 'smart-money-flow', 'profitability-migration',
+    'user-profitability-tracker', 'sector-rotation', 'crowd-conviction-score',
+    'risk-appetite-change', 'drawdown-response', 'gain-response',
+    'tsl-effectiveness', 'position-count-pnl', 'diversification-pnl'
+]);
+
+const historicalCalculations = {};
+const dailyCalculations = {};
+
+for (const category in calculations) {
+    for (const calcName in calculations[category]) {
+        if (HISTORICAL_CALC_NAMES.has(calcName)) {
+            if (!historicalCalculations[category]) historicalCalculations[category] = {};
+            historicalCalculations[category][calcName] = calculations[category][calcName];
+        } else {
+            if (!dailyCalculations[category]) dailyCalculations[category] = {};
+            dailyCalculations[category][calcName] = calculations[category][calcName];
+        }
+    }
+}
+
+
+// --- UTILITY FUNCTIONS ---
+
+/** Commits Firestore batch writes in chunks to respect the 500 operation limit. */
+async function commitBatchInChunks(firestore, writes, operationName) {
+    if (writes.length === 0) {
+        logger.log('WARN', `[${operationName}] No writes to commit.`);
+        return;
+    }
+    for (let i = 0; i < writes.length; i += BATCH_SIZE_LIMIT) {
+        const batch = firestore.batch();
+        const chunk = writes.slice(i, i + BATCH_SIZE_LIMIT);
+        chunk.forEach(write => batch.set(write.ref, write.data, { merge: true }));
+        
+        const chunkNum = (i / BATCH_SIZE_LIMIT) + 1;
+        const totalChunks = Math.ceil(writes.length / BATCH_SIZE_LIMIT);
+        await withRetry(
+            () => batch.commit(),
+            `${operationName} (Chunk ${chunkNum}/${totalChunks})`
+        );
+        logger.log('INFO', `[${operationName}] Committed chunk ${chunkNum}/${totalChunks} (${chunk.length} ops).`);
+    }
+}
+
+// --- DATE & FLOW CONTROL HELPERS ---
+
+/** Generates a list of date strings between a start and end date (inclusive). */
+function getExpectedDateStrings(startDate, endDate) {
+    const dateStrings = [];
+    if (startDate <= endDate) {
+        for (let d = new Date(startDate); d <= endDate; d.setUTCDate(d.getUTCDate() + 1)) {
+            dateStrings.push(new Date(d).toISOString().slice(0, 10));
+        }
+    }
+    return dateStrings;
+}
+
+/** Processes job objects in parallel batches. */
+async function processJobsInParallel(jobs, taskFunction, passName) {
+    const results = [];
+     if (jobs.length > 0) {
+        logger.log('INFO', `[${passName}] Processing ${jobs.length} jobs with ${MAX_CONCURRENT_DATES} parallel workers.`);
+        jobs.sort((a, b) => new Date(a.date) - new Date(b.date)); // Ensure chronological processing
+        for (let i = 0; i < jobs.length; i += MAX_CONCURRENT_DATES) {
+            const jobBatch = jobs.slice(i, i + MAX_CONCURRENT_DATES);
+            const promises = jobBatch.map(job => taskFunction(new Date(job.date), job.missing));
+            results.push(...await Promise.allSettled(promises));
+        }
+    } else {
+        logger.log('INFO', `[${passName}] No jobs to process.`);
+    }
+    return results;
+}
+
+/**
+ * Finds the earliest date document by searching inside the 'snapshots' subcollection
+ * of all block documents (e.g., '1M', '2M') within a given collection.
+ */
+async function getFirstDateFromCollection(firestore, collectionName) {
+    let earliestDate = null;
+    try {
+        const blockDocRefs = await withRetry(
+            () => firestore.collection(collectionName).listDocuments(),
+            `GetBlocks(${collectionName})`
+        );
+
+        if (blockDocRefs.length === 0) {
+            logger.log('WARN', `No block documents found in collection: ${collectionName}`);
+            return null;
+        }
+
+        for (const blockDocRef of blockDocRefs) {
+            const snapshotQuery = blockDocRef.collection('snapshots')
+                .where(FieldPath.documentId(), '>=', '2000-01-01') 
+                .orderBy(FieldPath.documentId(), 'asc')
+                .limit(1);
+
+            const snapshotSnap = await withRetry(
+                () => snapshotQuery.get(),
+                `GetEarliestSnapshot(${blockDocRef.path})`
+            );
+
+            if (!snapshotSnap.empty && /^\d{4}-\d{2}-\d{2}$/.test(snapshotSnap.docs[0].id)) {
+                const foundDate = new Date(snapshotSnap.docs[0].id);
+                if (!earliestDate || foundDate < earliestDate) {
+                    earliestDate = foundDate;
+                }
+            }
+        }
+    } catch (e) {
+        logger.log('ERROR', `GetFirstDate failed for ${collectionName}`, { errorMessage: e.message });
+    }
+    return earliestDate;
+}
+
+/**
+ * Determines the absolute earliest date from source portfolio data collections.
+ */
+async function getFirstDateFromSourceData(firestore) {
+    logger.log('INFO', 'Querying for the earliest date from source portfolio data...');
+    
+    const investorDate = await getFirstDateFromCollection(firestore, 'NormalUserPortfolios');
+    const speculatorDate = await getFirstDateFromCollection(firestore, 'SpeculatorUserPortfolios');
+
+    let earliestDate;
+
+    if (investorDate && speculatorDate) {
+        earliestDate = investorDate < speculatorDate ? investorDate : speculatorDate;
+    } else {
+        earliestDate = investorDate || speculatorDate;
+    }
+
+    if (earliestDate) {
+        logger.log('INFO', `Found earliest source data date: ${earliestDate.toISOString().slice(0, 10)}`);
+        return earliestDate;
+    }
+
+    // Fallback if no source data is found at all.
+    const d = new Date();
+    d.setUTCDate(d.getUTCDate() - 30);
+    logger.log('WARN', `No source data found. Defaulting first date to: ${d.toISOString().slice(0, 10)}`);
+    return d;
+}
+
+module.exports = {
+    FieldValue, FieldPath,
+    historicalCalculations, dailyCalculations, unifiedUtils: utils, HISTORICAL_CALC_NAMES,
+    withRetry, commitBatchInChunks,
+    getExpectedDateStrings, processJobsInParallel, getFirstDateFromSourceData,
+};

package/index.js

@@ -4,12 +4,14 @@
  * to be shared across multiple Cloud Functions.
  */
 
-const core = require('./functions/core/utils');
+const core = require('./functions/core');
 const Orchestrator = require('./functions/orchestrator');
-const TaskEngine = require('./functions/task-engine'); // <-- ADD THIS
+const TaskEngine = require('./functions/task-engine');
+const ComputationSystem = require('./functions/computation-system'); // Add this
 
 module.exports = {
   core,
   Orchestrator,
-  TaskEngine, // <-- AND ADD THIS
+  TaskEngine,
+  ComputationSystem, // Add this
 };

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.7",
+  "version": "1.0.10",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [
     "index.js",
     "functions/orchestrator/",
     "functions/task-engine/",
-    "functions/core/"
+    "functions/core/",
+    "functions/computation-system/"
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -22,7 +23,8 @@
   "dependencies": {
     "@google-cloud/firestore": "^7.11.3",
     "sharedsetup": "latest",
-    "require-all": "^3.0.0"
+    "require-all": "^3.0.0",
+    "aiden-shared-calculations-unified": "1.0.0"
   },
   "engines": {
     "node": ">=20"