bulltrackers-module 1.0.732 → 1.0.734

package/functions/orchestrator/index.js

@@ -1,7 +1,6 @@
 /**
  * @fileoverview Main orchestration logic.
  * REFACTORED: Implements 'Active Scheduling' via Cloud Tasks to enforce 1-hour gaps.
- * This allows the Workflow to finish immediately while Cloud Tasks manages the pacing.
  */
 const { checkDiscoveryNeed, getDiscoveryCandidates, dispatchDiscovery } = require('./helpers/discovery_helpers');
 const { getUpdateTargets, dispatchUpdates } = require('./helpers/update_helpers');
@@ -11,6 +10,12 @@ const { CloudTasksClient } = require('@google-cloud/tasks');
 // Initialize Cloud Tasks Client
 const cloudTasksClient = new CloudTasksClient();
 
+// --- CONFIGURATION (Now via Env Vars) ---
+// These are injected by deploy.mjs based on config.mjs
+const QUEUE_NAME = process.env.ORCHESTRATOR_QUEUE || 'task-engine-queue';
+const LOCATION = process.env.GCP_REGION || 'europe-west1'; 
+const PROJECT = process.env.GCP_PROJECT_ID;
+
 /**
  * ENTRY POINT: HTTP Handler for Workflow Interaction
  */
@@ -28,11 +33,11 @@ async function handleOrchestratorHttp(req, res, dependencies, config) {
                 throw new Error("Missing userType or date for PLAN action");
             }
             
-            // Determine self-URL for callback
-            const project = process.env.GCP_PROJECT || process.env.GOOGLE_CLOUD_PROJECT;
-            const location = process.env.GCP_LOCATION || 'us-central1'; // Default to us-central1 if not set
-            // Fallback URL construction or use passed override
-            const orchestratorUrl = orchestratorUrlOverride || `https://${location}-${project}.cloudfunctions.net/orchestrator-http`;
+            // Determine self-URL for callback (Cloud Task needs to call this function back)
+            // We use the env var passed by GCF (FUNCTION_URI) or construct it manually
+            const orchestratorUrl = orchestratorUrlOverride || 
+                process.env.FUNCTION_URI || 
+                `https://${LOCATION}-${PROJECT}.cloudfunctions.net/${process.env.K_SERVICE || 'orchestrator-http'}`;
             
             const result = await planDailyUpdates(userType, date, windows || 10, config, dependencies, orchestratorUrl);
             res.status(200).send(result);
@@ -60,21 +65,12 @@ async function handleOrchestratorHttp(req, res, dependencies, config) {
 
 /**
  * LOGIC: Plan the updates (Split into windows AND Schedule Execution)
- * 1. Fetches all users needing updates.
- * 2. Shuffles them.
- * 3. Splits them into 'n' windows.
- * 4. Schedules Cloud Tasks for each window with a 1-hour delay between them.
  */
 async function planDailyUpdates(userType, date, numberOfWindows, config, deps, orchestratorUrl) {
     const { logger, db } = deps;
     
-    // Cloud Tasks Config
-    const project = process.env.GCP_PROJECT || process.env.GOOGLE_CLOUD_PROJECT;
-    const location = process.env.GCP_LOCATION || 'us-central1'; 
-    const queue = process.env.GCP_QUEUE_NAME || 'orchestrator-queue'; // MUST EXIST in Cloud Console
-
-    // Construct the fully qualified queue name
-    const parentQueue = cloudTasksClient.queuePath(project, location, queue);
+    // Use Configured Queue
+    const parentQueue = cloudTasksClient.queuePath(PROJECT, LOCATION, QUEUE_NAME);
 
     // 1. Get ALL targets
     const now = new Date();
@@ -102,7 +98,6 @@ async function planDailyUpdates(userType, date, numberOfWindows, config, deps, o
     const planId = `plan_${userType}_${date}`;
     const batchWriter = db.batch();
     
-    // We collect task creation promises to await them at the end
     const tasksToCreate = [];
 
     for (let i = 0; i < numberOfWindows; i++) {
@@ -147,9 +142,10 @@ async function planDailyUpdates(userType, date, numberOfWindows, config, deps, o
                         url: orchestratorUrl,
                         headers: { 'Content-Type': 'application/json' },
                         body: Buffer.from(JSON.stringify(taskPayload)).toString('base64'),
-                        oidcToken: {
-                            serviceAccountEmail: process.env.GCP_SERVICE_ACCOUNT_EMAIL
-                        }
+                        // Use OIDC if service account is available in env
+                        oidcToken: process.env.GCP_SERVICE_ACCOUNT_EMAIL 
+                            ? { serviceAccountEmail: process.env.GCP_SERVICE_ACCOUNT_EMAIL }
+                            : undefined
                     },
                     scheduleTime: {
                         seconds: scheduleTimeSeconds
@@ -161,20 +157,21 @@ async function planDailyUpdates(userType, date, numberOfWindows, config, deps, o
         }
     }
 
-    // Commit Firestore Writes First (Essential so tasks don't fail looking for data)
+    // Commit Firestore Writes First
     await batchWriter.commit();
     logger.log('SUCCESS', `[Orchestrator Plan] Plan ${planId} saved to Firestore.`);
 
     // Dispatch Cloud Tasks
-    logger.log('INFO', `[Orchestrator Plan] Scheduling ${tasksToCreate.length} tasks for ${userType}...`);
+    logger.log('INFO', `[Orchestrator Plan] Scheduling ${tasksToCreate.length} tasks for ${userType} to queue ${QUEUE_NAME}...`);
     
-    // Create tasks in parallel (with limit if needed, but usually fine for <50 tasks)
     const scheduleResults = await Promise.allSettled(tasksToCreate.map(req => cloudTasksClient.createTask(req)));
     
     const failedCount = scheduleResults.filter(r => r.status === 'rejected').length;
     if (failedCount > 0) {
         logger.log('ERROR', `[Orchestrator Plan] Failed to schedule ${failedCount} tasks.`);
-        // Note: We don't rollback Firestore here; manual retry or idempotency handles it.
+        scheduleResults.forEach((r, idx) => {
+            if (r.status === 'rejected') logger.log('ERROR', `Task ${idx} error:`, r.reason);
+        });
     }
 
     return {
@@ -188,7 +185,6 @@ async function planDailyUpdates(userType, date, numberOfWindows, config, deps, o
 
 /**
  * LOGIC: Execute a specific window
- * Triggered by Cloud Tasks when the schedule time arrives.
  */
 async function executeUpdateWindow(planId, windowId, userType, config, deps) {
     const { logger, db } = deps;
@@ -203,7 +199,7 @@ async function executeUpdateWindow(planId, windowId, userType, config, deps) {
 
     const data = windowDoc.data();
     
-    // Idempotency: Don't run if already done
+    // Idempotency
     if (data.status === 'completed') {
         logger.log('WARN', `[Orchestrator Execute] Window ${windowId} already completed. Skipping.`);
         return { dispatchedCount: 0, status: 'already_completed' };
@@ -226,8 +222,7 @@ async function executeUpdateWindow(planId, windowId, userType, config, deps) {
     return { dispatchedCount: targets.length, status: 'success' };
 }
 
-// --- Legacy / Helper Wrappers (Preserved for compatibility) ---
-
+// --- Legacy Wrappers ---
 async function runDiscoveryOrchestrator(config, deps) {
     const { logger, firestoreUtils } = deps;
     logger.log('INFO', '🚀 Discovery Orchestrator triggered...');
@@ -255,7 +250,6 @@ async function runUpdateOrchestrator(config, deps) {
 }
 
 async function runDiscovery(userType, userConfig, globalConfig, deps) {
-    const { logger } = deps;
     const { needsDiscovery, blocksToFill } = await checkDiscoveryNeed(userType, userConfig, deps);
     if (!needsDiscovery) return;
     const candidates = await getDiscoveryCandidates(userType, blocksToFill, userConfig, deps);

package/index.js

@@ -30,24 +30,12 @@ const { handleDiscover }                                  = require('./functions
 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 { dispatchComputationPass }                         = require('./functions/computation-system/helpers/computation_dispatcher');
-const { handleComputationTask }                           = require('./functions/computation-system/helpers/computation_worker');
-const { 
-    requestBuildReport, 
-    handleBuildReportTrigger, 
-    generateBuildReport 
-} = require('./functions/computation-system/tools/BuildReporter');
-
-const { checkPassStatus }                                 = require('./functions/computation-system/helpers/monitor');
-
-const dataLoader                                          = require('./functions/computation-system/utils/data_loader');
-const computationUtils                                    = require('./functions/computation-system/utils/utils');
-
+// --- COMPUTATION SYSTEM V2 (Replaces v1) ---
+const computationSystemV2 = require('./functions/computation-system-v2/handlers/index');
 
 const { createApiV2App } = require('./functions/api-v2/index');
 
+// Maintenance & Backfills
 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');
@@ -103,16 +91,11 @@ const taskEngine = {
   handleUpdate,
 };
 
+// Expose v2 handlers directly
 const computationSystem = {
-  dispatchComputationPass,
-  handleComputationTask,
-  dataLoader,
-  computationUtils,
-  buildManifest,
-  requestBuildReport,
-  handleBuildReportTrigger,
-  generateBuildReport,
-  checkPassStatus
+  computeScheduler:  computationSystemV2.computeScheduler,
+  computeDispatcher: computationSystemV2.computeDispatcher,
+  computeOnDemand:   computationSystemV2.computeOnDemand
 };
 
 const api = {
@@ -154,7 +137,7 @@ module.exports = {
 if (require.main === module) {
   const args = process.argv.slice(2);
   
-  // Check if this looks like a backfill command (has --startDate or --endDate)
+  // Check if this looks like a backfill command
   const isBackfillCommand = args.some(arg => 
     arg.startsWith('--startDate=') || 
     arg.startsWith('--endDate=') || 
@@ -162,14 +145,10 @@ if (require.main === module) {
   );
   
   if (isBackfillCommand) {
-    // Route to backfill function
     console.log('🚀 Starting backfill from main entry point...\n');
     backfillTaskEngineData(null, null).catch(error => {
       console.error('Fatal error:', error);
       process.exit(1);
     });
-  } else {
-    // No recognized command, just export (normal module behavior)
-    // This allows the file to still work as a module when imported
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.732",
+  "version": "1.0.734",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [
@@ -28,7 +28,8 @@
     "functions/maintenance/backfill-pi-alert-history",
     "functions/maintenance/backfill-pi-page-views",
     "functions/maintenance/backfill-pi-ratings",
-    "functions/maintenance/backfill-watchlist-membership"
+    "functions/maintenance/backfill-watchlist-membership",
+    "functions/computation-system-v2/"
   ],
   "keywords": [
     "bulltrackers",

package/functions/computation-system/WorkflowOrchestrator.js

@@ -1,213 +0,0 @@
-/**
- * FILENAME: computation-system/WorkflowOrchestrator.js
- * UPDATED: Fixed 'Version Mismatch' deadlock for historical chains.
- * UPDATED: Added Force-Run logic for 'isTest' computations on current day.
- */
-
-const { normalizeName, DEFINITIVE_EARLIEST_DATES }         = require('./utils/utils');
-const { checkRootDataAvailability, checkRootDependencies } = require('./data/AvailabilityChecker');
-const { fetchExistingResults }                             = require('./data/DependencyFetcher');
-const { fetchComputationStatus, updateComputationStatus }  = require('./persistence/StatusRepository'); // Unused
-const { StandardExecutor }                                 = require('./executors/StandardExecutor');
-const { MetaExecutor }                                     = require('./executors/MetaExecutor');
-
-const STATUS_IMPOSSIBLE_PREFIX = 'IMPOSSIBLE';
-
-function groupByPass(manifest) {
-    const passes = {};
-    manifest.forEach(calc => {
-        if (!passes[calc.pass]) passes[calc.pass] = [];
-        passes[calc.pass].push(calc);
-    });
-    return passes;
-}
-
-function isDependencyReady(depName, isHistoricalSelf, currentStatusMap, prevStatusMap, manifestMap, storedStatus) {
-    const norm = normalizeName(depName);
-    const targetStatus = isHistoricalSelf ? (prevStatusMap ? prevStatusMap[norm] : null) : currentStatusMap[norm];
-    const depManifest = manifestMap.get(norm);
-    
-    if (!targetStatus) return { ready: false, reason: 'Missing' };
-    if (String(targetStatus.hash).startsWith(STATUS_IMPOSSIBLE_PREFIX)) return { ready: false, reason: 'Impossible Upstream' };
-    
-    if (depManifest && targetStatus.hash !== depManifest.hash) {
-        return { ready: false, reason: 'Dependency Version Mismatch' };
-    }
-
-    if (storedStatus && storedStatus.dependencyResultHashes) {
-        // FIX: Normalize the dependency name for lookup
-        const lastSeenResultHash = storedStatus.dependencyResultHashes[depName] || storedStatus.dependencyResultHashes[norm];
-        if (lastSeenResultHash && targetStatus.resultHash !== lastSeenResultHash) {
-             return { ready: true, dataChanged: true, reason: 'Dependency Data Update' };
-        }
-    }
-
-    return { ready: true, dataChanged: false };
-}
-
-function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus = null) {
-    const report = { runnable: [], blocked: [], impossible: [], failedDependency: [], reRuns: [], skipped: [] };
-    const simulationStatus = { ...dailyStatus };
-    const isToday = dateStr === new Date().toISOString().slice(0, 10);
-
-    for (const calc of calcsInPass) {
-        const cName = normalizeName(calc.name);
-        const stored = simulationStatus[cName];
-        const currentHash = calc.hash;
-
-        // [NEW] Rule: 'isTest' computations always re-run on the current day.
-        // This ensures debug/test probes fire immediately to test system changes.
-        const shouldForceRun = isToday && (calc.isTest === true);
-
-        // 1. Root Data Check
-        const rootCheck = checkRootDependencies(calc, rootDataStatus);
-        if (!rootCheck.canRun) {
-            if (dateStr !== new Date().toISOString().slice(0, 10)) {
-                report.impossible.push({ name: cName, reason: `Missing Root: ${rootCheck.missing.join(', ')}` });
-                simulationStatus[cName] = { hash: `${STATUS_IMPOSSIBLE_PREFIX}:NO_DATA` };
-            } else {
-                report.blocked.push({ name: cName, reason: `Waiting for Root Data` });
-            }
-            continue;
-        }
-
-        // --- OPTIMIZATION: Early skip if code matches AND data is stable ---
-        // [UPDATED] We bypass this optimization if shouldForceRun is true
-        if (stored?.hash === currentHash && !shouldForceRun) {
-            let hasDataDrift = false;
-            let isBlocked = false;
-            let missingDeps = [];
-
-            if (calc.dependencies) {
-                for (const dep of calc.dependencies) {
-                    const check = isDependencyReady(dep, false, simulationStatus, null, manifestMap, stored);
-                    if (!check.ready) missingDeps.push(dep);
-                    else if (check.dataChanged) { hasDataDrift = true; break; }
-                }
-            }
-
-            if (!hasDataDrift && missingDeps.length === 0 && calc.isHistorical) {
-                const yesterday = new Date(dateStr + 'T00:00:00Z');
-                yesterday.setUTCDate(yesterday.getUTCDate() - 1);
-                if (yesterday >= DEFINITIVE_EARLIEST_DATES.absoluteEarliest) {
-                    const check = isDependencyReady(calc.name, true, null, prevDailyStatus, manifestMap, stored);
-                    if (!check.ready) {
-                        // [FIX]: Treat Missing OR Version Mismatch as Data Drift (Fresh Start)
-                        if (check.reason === 'Missing' || check.reason === 'Dependency Version Mismatch') {
-                            hasDataDrift = true;
-                        } else {
-                            isBlocked = true;
-                        }
-                    }
-                    else if (check.dataChanged) hasDataDrift = true;
-                }
-            }
-
-            if (!hasDataDrift && !isBlocked && missingDeps.length === 0) {
-                report.skipped.push({ name: cName, reason: "Up To Date" });
-                continue;
-            }
-        }
-        // --- END OPTIMIZATION ---
-
-        const missingDeps = [];
-        let hasDataDrift = false;
-        let isBlocked = false;
-
-        if (calc.dependencies) {
-            for (const dep of calc.dependencies) {
-                const check = isDependencyReady(dep, false, simulationStatus, null, manifestMap, stored);
-                if (!check.ready) missingDeps.push(dep);
-                else if (check.dataChanged) hasDataDrift = true;
-            }
-        }
-
-        if (calc.isHistorical) {
-            const yesterday = new Date(dateStr + 'T00:00:00Z');
-            yesterday.setUTCDate(yesterday.getUTCDate() - 1);
-            if (yesterday >= DEFINITIVE_EARLIEST_DATES.absoluteEarliest) {
-                const check = isDependencyReady(calc.name, true, null, prevDailyStatus, manifestMap, stored);
-                if (!check.ready) {
-                    // [FIX]: Allow fresh start if yesterday is Missing OR has different Code Version
-                    if (check.reason === 'Missing' || check.reason === 'Dependency Version Mismatch') {
-                        hasDataDrift = true; 
-                    } else {
-                        isBlocked = true;
-                    }
-                }
-                else if (check.dataChanged) hasDataDrift = true;
-            }
-        }
-
-        if (missingDeps.length > 0) {
-            const isImpossible = missingDeps.some(d => String(simulationStatus[normalizeName(d)]?.hash).startsWith(STATUS_IMPOSSIBLE_PREFIX));
-            if (isImpossible) {
-                report.impossible.push({ name: cName, reason: 'Upstream Impossible' });
-                simulationStatus[cName] = { hash: `${STATUS_IMPOSSIBLE_PREFIX}:UPSTREAM` };
-            } else {
-                report.failedDependency.push({ name: cName, missing: missingDeps });
-            }
-            continue;
-        }
-
-        if (isBlocked) {
-            report.blocked.push({ name: cName, reason: 'Waiting for Yesterday' });
-            continue;
-        }
-
-        const currentDependencyResultHashes = {};
-        if (calc.dependencies) {
-            calc.dependencies.forEach(d => {
-                const resHash = simulationStatus[normalizeName(d)]?.resultHash;
-                if (resHash) currentDependencyResultHashes[d] = resHash;
-            });
-        }
-        
-        const taskPayload = { name: cName, dependencyResultHashes: currentDependencyResultHashes };
-
-        if (!stored?.hash) {
-            report.runnable.push({ ...taskPayload, reason: "New Calculation" });
-        } else if (stored.hash !== currentHash) {
-            report.reRuns.push({ ...taskPayload, oldHash: stored.hash, newHash: currentHash, reason: "Hash Mismatch" });
-        } else if (shouldForceRun) {
-            // [NEW] Logic to handle the forced run for Test probes
-            report.reRuns.push({ ...taskPayload, oldHash: stored.hash, newHash: currentHash, reason: "Test Computation (Always Run Today)" });
-        } else if (hasDataDrift) {
-            report.runnable.push({ ...taskPayload, reason: "Input Data Changed" });
-        }
-    }
-    return report;
-}
-
-async function executeDispatchTask(dateStr, pass, targetComputation, config, dependencies, computationManifest, previousCategory = null, dependencyResultHashes = {}, metadata = {}) {
-    const { logger } = dependencies;
-    const manifestMap = new Map(computationManifest.map(c => [normalizeName(c.name), c]));
-    const calcManifest = manifestMap.get(normalizeName(targetComputation));
-    
-    if (!calcManifest) throw new Error(`Calc '${targetComputation}' not found.`);
-    
-    // Merge runtime metadata (like targetCid) into the manifest
-    // This allows the Executor to access it via 'calcInstance.manifest'
-    Object.assign(calcManifest, metadata);
-    
-    calcManifest.dependencyResultHashes = dependencyResultHashes;
-
-    const rootData = await checkRootDataAvailability(dateStr, config, dependencies, DEFINITIVE_EARLIEST_DATES);
-    const calcsToRun = [calcManifest];
-    
-    const existingResults = await fetchExistingResults(dateStr, calcsToRun, computationManifest, config, dependencies, false);
-    let previousResults = {};
-    if (calcManifest.isHistorical) {
-        const prev = new Date(dateStr + 'T00:00:00Z'); prev.setUTCDate(prev.getUTCDate() - 1);
-        previousResults = await fetchExistingResults(prev.toISOString().slice(0, 10), calcsToRun, computationManifest, config, dependencies, true);
-    }
-
-    const execDate = new Date(dateStr + 'T00:00:00Z');
-    const updates = (calcManifest.type === 'standard') 
-        ? await StandardExecutor.run(execDate, calcsToRun, `Pass ${pass}`, config, dependencies, rootData, existingResults, previousResults)
-        : await MetaExecutor.run(execDate, calcsToRun, `Pass ${pass}`, config, dependencies, rootData, existingResults, previousResults);
-
-    return { date: dateStr, updates };
-}
-
-module.exports = { executeDispatchTask, analyzeDateExecution, groupByPass };

package/functions/computation-system/config/monitoring_config.js

@@ -1,31 +0,0 @@
-/**
- * computation-system/config/monitoring_config.js
- * Configuration for Google Cloud Monitoring, Logging, and Tracing.
- */
-
-module.exports = {
-    // Toggle to easily disable all GCP telemetry without changing code
-    enabled: true,
-    
-    // Your Google Cloud Project ID
-    project: process.env.GOOGLE_CLOUD_PROJECT_ID || process.env.GCP_PROJECT || 'your-project-id',
-    
-    // Configuration for the "Eyeball" (Trace)
-    trace: {
-        enabled: true,
-        // Force sampling for these computations (can use '*' for all)
-        sampledTasks: ['*'] 
-    },
-
-    // Definitions for Custom Metrics
-    metrics: {
-        // The heartbeat metric replaces the Firestore 'active' check over time
-        heartbeat: 'custom.googleapis.com/computation/worker_heartbeat',
-        
-        // Tracks memory usage per worker/task
-        memory: 'custom.googleapis.com/computation/memory_usage',
-        
-        // Tracks duration of specific processing stages
-        duration: 'custom.googleapis.com/computation/stage_duration'
-    }
-};

package/functions/computation-system/config/validation_overrides.js

@@ -1,10 +0,0 @@
-module.exports = {
-    // Only add calculations here if the HeuristicValidator is too aggressive
-    // EXAMPLES :
-    // "bankruptcy-detector": { maxZeroPct: 100 }, // It's rare, so 100% 0s is fine
-    // "sparse-signal-generator": { maxNullPct: 99 }
-
-    "instrument-price-change-1d":        { maxZeroPct: 100 }, // Because weekeends/holidays return 0 change, technically crypto means this can't hit 100% but it's usually quite close, so we override
-    "instrument-price-momentum-20d ":    { maxZeroPct: 100 }, // Some assets can be very stagnant over a month, especially bonds or stablecoins
-    "mimetic-latency":                   { maxFlatlinePct: 100 },
-};

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

@@ -1,143 +0,0 @@
-/**
- * @fileoverview Factory for creating the Computation Context.
- * UPDATED: Injects verification and rankings data into context globally and locally.
- * UPDATED: Added support for historical ranking data in both Standard and Meta contexts.
- * UPDATED: Added support for 'series' data (historical root data or computation results) in Global Data.
- * UPDATED: Added 'utils.fetchLatest' to support on-demand BigQuery fallback.
- */
-const mathLayer          = require('../layers/index');
-const DataLoader         = require('../utils/data_loader'); // [NEW] Import DataLoader
-const { LEGACY_MAPPING } = require('../topology/HashManager');
-
-class ContextFactory { 
-    static buildMathContext() {
-        const mathContext = {};
-        for (const [key, value] of Object.entries(mathLayer)) { 
-            mathContext[key] = value; 
-            const legacyKey = LEGACY_MAPPING[key]; 
-            if (legacyKey) { mathContext[legacyKey] = value; } 
-        }
-        return mathContext;
-    }
-
-    static buildPerUserContext(options) {
-        const { 
-            todayPortfolio, 
-            yesterdayPortfolio, 
-            todayHistory, 
-            yesterdayHistory, 
-            userId, 
-            userType, 
-            dateStr, 
-            metadata, 
-            mappings, 
-            insights, 
-            socialData, 
-            computedDependencies, 
-            previousComputedDependencies, 
-            config, 
-            deps,
-            verification, 
-            rankings,
-            yesterdayRankings,         
-            allRankings,                
-            allRankingsYesterday,   
-            allVerifications,
-            ratings, 
-            pageViews, 
-            watchlistMembership, 
-            alertHistory,
-            piMasterList,
-            seriesData
-        } = options;
-        
-        return {
-            user: { 
-                id: userId, 
-                type: userType, 
-                portfolio: { today: todayPortfolio, yesterday: yesterdayPortfolio }, 
-                history: { today: todayHistory, yesterday: yesterdayHistory },
-                verification: verification || null,
-                rankEntry: rankings || null,
-                rankEntryYesterday: yesterdayRankings || null
-            },
-            date: { today: dateStr },
-            insights: { today: insights?.today, yesterday: insights?.yesterday },
-            social: { today: socialData?.today, yesterday: socialData?.yesterday },
-            mappings: mappings || {},
-            math: ContextFactory.buildMathContext(), 
-            computed: computedDependencies || {},
-            previousComputed: previousComputedDependencies || {},
-            meta: metadata, config, deps,
-            
-            // [NEW] UTILS FOR ON-DEMAND FETCHING
-            utils: {
-                fetchLatest: async (rootType, lookbackDays) => {
-                    return DataLoader.fetchLatestRootData(config, deps, rootType, userId, userType, lookbackDays);
-                }
-            },
-
-            globalData: {
-                rankings: allRankings || [],
-                rankingsYesterday: allRankingsYesterday || [],
-                verifications: allVerifications || {},
-                ratings: ratings || {},
-                pageViews: pageViews || {},
-                watchlistMembership: watchlistMembership || {},
-                alertHistory: alertHistory || {},
-                piMasterList: piMasterList || {},
-                series: seriesData || {} 
-            }
-        };
-    }
-
-    static buildMetaContext(options) {
-        // ... (No changes needed for MetaContext yet)
-        const { 
-            dateStr, 
-            metadata, 
-            mappings, 
-            insights, 
-            socialData, 
-            prices, 
-            computedDependencies, 
-            previousComputedDependencies, 
-            config, 
-            deps,
-            allRankings, 
-            allRankingsYesterday,
-            allVerifications,
-            ratings, 
-            pageViews, 
-            watchlistMembership, 
-            alertHistory,
-            seriesData,
-            piMasterList
-        } = options;
-        
-        return {
-            date: { today: dateStr },
-            insights: { today: insights?.today, yesterday: insights?.yesterday },
-            social: { today: socialData?.today, yesterday: socialData?.yesterday },
-            prices: prices || {},
-            mappings: mappings || {},
-            math: ContextFactory.buildMathContext(), 
-            computed: computedDependencies || {},
-            previousComputed: previousComputedDependencies || {},
-            meta: metadata, config, deps,
-            globalData: {
-                rankings: allRankings || [],
-                rankingsYesterday: allRankingsYesterday || [], 
-                verifications: allVerifications || {},
-                ratings: ratings || {},
-                pageViews: pageViews || {},
-                watchlistMembership: watchlistMembership || {},
-                alertHistory: alertHistory || {},
-                series: seriesData || {},
-                piMasterList: piMasterList || {} 
-            }
-        };
-    }
-}
-
-module.exports = { ContextFactory };