bulltrackers-module 1.0.211 → 1.0.212

package/functions/computation-system/controllers/computation_controller.js

@@ -1,188 +1,199 @@
-/**
- * FIXED: computation_controller.js
- * V4.2: Added InsightsExtractor and UserClassifier to Context
- */
-
-const { DataExtractor, HistoryExtractor, MathPrimitives, Aggregators, Validators, SCHEMAS, SignalPrimitives, DistributionAnalytics, TimeSeries, priceExtractor, InsightsExtractor, UserClassifier } = require('../layers/math_primitives'); 
-const { loadDailyInsights, loadDailySocialPostInsights, getRelevantShardRefs, getPriceShardRefs } = require('../utils/data_loader');
-
-class DataLoader {
-    constructor(config, dependencies) {
-        this.config = config;
-        this.deps = dependencies;
-        this.cache = { mappings: null, insights: new Map(), social: new Map(), prices: null };
-    }
-    
-    // Helper to fix property access issues if any legacy code exists
-    get mappings() { return this.cache.mappings; }
-
-    async loadMappings() {
-        if (this.cache.mappings) return this.cache.mappings;
-        const { calculationUtils } = this.deps;
-        this.cache.mappings = await calculationUtils.loadInstrumentMappings();
-        return this.cache.mappings;
-    }
-    async loadInsights(dateStr) {
-        if (this.cache.insights.has(dateStr)) return this.cache.insights.get(dateStr);
-        const insights = await loadDailyInsights(this.config, this.deps, dateStr);
-        this.cache.insights.set(dateStr, insights);
-        return insights;
-    }
-    async loadSocial(dateStr) {
-        if (this.cache.social.has(dateStr)) return this.cache.social.get(dateStr);
-        const social = await loadDailySocialPostInsights(this.config, this.deps, dateStr);
-        this.cache.social.set(dateStr, social);
-        return social;
-    }
-    
-    /**
-     * NEW: Get references to all price shards without loading data.
-     */
-    async getPriceShardReferences() {
-        return getPriceShardRefs(this.config, this.deps);
-    }
-    
-    /**
-     * NEW: Get specific shard references based on instrument IDs (Smart Lookup)
-     */
-    async getSpecificPriceShardReferences(targetInstrumentIds) {
-        return getRelevantShardRefs(this.config, this.deps, targetInstrumentIds);
-    }
-
-    /**
-     * NEW: Load a single price shard.
-     */
-    async loadPriceShard(docRef) {
-        try {
-            const snap = await docRef.get();
-            if (!snap.exists) return {};
-            return snap.data();
-        } catch (e) {
-            console.error(`Error loading shard ${docRef.path}:`, e);
-            return {};
-        }
-    }
-}
-
-class ContextBuilder { 
-    static buildPerUserContext(options) {
-        const { todayPortfolio, yesterdayPortfolio, todayHistory, yesterdayHistory, userId, userType, dateStr, metadata, mappings, insights, socialData, computedDependencies, previousComputedDependencies, config, deps } = options;
-        return {
-            user: { id: userId, type: userType, portfolio: { today: todayPortfolio, yesterday: yesterdayPortfolio }, history: { today: todayHistory, yesterday: yesterdayHistory } },
-            date: { today: dateStr },
-            insights: { today: insights?.today, yesterday: insights?.yesterday },
-            social: { today: socialData?.today, yesterday: socialData?.yesterday },
-            mappings: mappings || {},
-            math: { 
-                extract: DataExtractor, 
-                history: HistoryExtractor, 
-                compute: MathPrimitives, 
-                aggregate: Aggregators, 
-                validate: Validators, 
-                signals: SignalPrimitives, 
-                schemas: SCHEMAS, 
-                distribution : DistributionAnalytics, 
-                TimeSeries: TimeSeries, 
-                priceExtractor : priceExtractor,
-                insights: InsightsExtractor, // Mapped for new Meta calcs
-                classifier: UserClassifier   // Mapped for Smart/Dumb logic
-            },
-            computed: computedDependencies || {},
-            previousComputed: previousComputedDependencies || {},
-            meta: metadata, config, deps
-        };
-    }
-
-    static buildMetaContext(options) {
-        const { dateStr, metadata, mappings, insights, socialData, prices, computedDependencies, previousComputedDependencies, config, deps } = options;
-        return {
-            date: { today: dateStr },
-            insights: { today: insights?.today, yesterday: insights?.yesterday },
-            social: { today: socialData?.today, yesterday: socialData?.yesterday },
-            prices: prices || {},
-            mappings: mappings || {},
-            math: { 
-                extract: DataExtractor, 
-                history: HistoryExtractor, 
-                compute: MathPrimitives, 
-                aggregate: Aggregators, 
-                validate: Validators, 
-                signals: SignalPrimitives, 
-                schemas: SCHEMAS, 
-                distribution: DistributionAnalytics, 
-                TimeSeries: TimeSeries, 
-                priceExtractor : priceExtractor,
-                insights: InsightsExtractor, // Mapped for new Meta calcs
-                classifier: UserClassifier   // Mapped for Smart/Dumb logic
-            },
-            computed: computedDependencies || {},
-            previousComputed: previousComputedDependencies || {},
-            meta: metadata, config, deps
-        };
-    }
-}
-
-class ComputationExecutor {
-    constructor(config, dependencies, dataLoader) {
-        this.config = config;
-        this.deps = dependencies;
-        this.loader = dataLoader;
-    }
-
-    async executePerUser(calcInstance, metadata, dateStr, portfolioData, yesterdayPortfolioData, historyData, computedDeps, prevDeps) {
-        const { logger } = this.deps;
-        const targetUserType = metadata.userType; 
-        const mappings = await this.loader.loadMappings();
-        const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
-        
-        for (const [userId, todayPortfolio] of Object.entries(portfolioData)) {
-            const yesterdayPortfolio = yesterdayPortfolioData ? yesterdayPortfolioData[userId] : null;
-            const todayHistory = historyData ? historyData[userId] : null;
-            const actualUserType = todayPortfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
-            if (targetUserType !== 'all') {
-                 const mappedTarget = (targetUserType === 'speculator') ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
-                 if (mappedTarget !== actualUserType) continue;
-            }
-            const context = ContextBuilder.buildPerUserContext({ todayPortfolio, yesterdayPortfolio, todayHistory, userId, userType: actualUserType, dateStr, metadata, mappings, insights, computedDependencies: computedDeps, previousComputedDependencies: prevDeps, config: this.config, deps: this.deps });
-            try { await calcInstance.process(context); } catch (e) { logger.log('WARN', `Calc ${metadata.name} failed for user ${userId}: ${e.message}`); }
-        }
-    }
-
-    async executeOncePerDay(calcInstance, metadata, dateStr, computedDeps, prevDeps) {
-        const mappings = await this.loader.loadMappings();
-        const { logger } = this.deps;
-        const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
-        const social = metadata.rootDataDependencies?.includes('social') ? { today: await this.loader.loadSocial(dateStr) } : null;
-        
-        if (metadata.rootDataDependencies?.includes('price')) {
-            logger.log('INFO', `[Executor] Running Batched/Sharded Execution for ${metadata.name}`);
-            const shardRefs = await this.loader.getPriceShardReferences();
-            if (shardRefs.length === 0) { logger.log('WARN', '[Executor] No price shards found.'); return {}; }
-            let processedCount = 0;
-            for (const ref of shardRefs) {
-                const shardData = await this.loader.loadPriceShard(ref);
-                const partialContext = ContextBuilder.buildMetaContext({ dateStr, metadata, mappings, insights, socialData: social, prices: { history: shardData }, computedDependencies: computedDeps, previousComputedDependencies: prevDeps, config: this.config, deps: this.deps });
-                await calcInstance.process(partialContext);
-                partialContext.prices = null; 
-                processedCount++;
-                if (processedCount % 10 === 0) { if (global.gc) { global.gc(); } }
-            }
-            logger.log('INFO', `[Executor] Finished Batched Execution for ${metadata.name} (${processedCount} shards).`);
-            return calcInstance.getResult ? await calcInstance.getResult() : {};
-        } else {
-            const context = ContextBuilder.buildMetaContext({ dateStr, metadata, mappings, insights, socialData: social, prices: {}, computedDependencies: computedDeps, previousComputedDependencies: prevDeps, config: this.config, deps: this.deps });
-            return await calcInstance.process(context);
-        }
-    }
-}
-
-class ComputationController {
-    constructor(config, dependencies) {
-        this.config = config;
-        this.deps = dependencies;
-        this.loader = new DataLoader(config, dependencies);
-        this.executor = new ComputationExecutor(config, dependencies, this.loader);
-    }
-}
-
-module.exports = { ComputationController };
+/**
+ * FIXED: computation_controller.js
+ * V5.0: Dynamic Layer Loading via Barrel File
+ */
+
+// Load all layers dynamically from the index
+const mathLayer = require('../layers/index');
+
+const { loadDailyInsights, loadDailySocialPostInsights, getRelevantShardRefs, getPriceShardRefs } = require('../utils/data_loader');
+
+// Legacy Keys Mapping (Ensures backward compatibility with existing Calculations)
+// Maps the new modular class names to the property names expected by existing code (e.g. math.extract)
+const LEGACY_MAPPING = {
+    DataExtractor: 'extract',
+    HistoryExtractor: 'history',
+    MathPrimitives: 'compute',
+    Aggregators: 'aggregate',
+    Validators: 'validate',
+    SignalPrimitives: 'signals',
+    SCHEMAS: 'schemas',
+    DistributionAnalytics: 'distribution',
+    TimeSeries: 'TimeSeries',
+    priceExtractor: 'priceExtractor',
+    InsightsExtractor: 'insights',
+    UserClassifier: 'classifier'
+};
+
+class DataLoader {
+    constructor(config, dependencies) {
+        this.config = config;
+        this.deps = dependencies;
+        this.cache = { mappings: null, insights: new Map(), social: new Map(), prices: null };
+    }
+    
+    get mappings() { return this.cache.mappings; }
+
+    async loadMappings() {
+        if (this.cache.mappings) return this.cache.mappings;
+        const { calculationUtils } = this.deps;
+        this.cache.mappings = await calculationUtils.loadInstrumentMappings();
+        return this.cache.mappings;
+    }
+    async loadInsights(dateStr) {
+        if (this.cache.insights.has(dateStr)) return this.cache.insights.get(dateStr);
+        const insights = await loadDailyInsights(this.config, this.deps, dateStr);
+        this.cache.insights.set(dateStr, insights);
+        return insights;
+    }
+    async loadSocial(dateStr) {
+        if (this.cache.social.has(dateStr)) return this.cache.social.get(dateStr);
+        const social = await loadDailySocialPostInsights(this.config, this.deps, dateStr);
+        this.cache.social.set(dateStr, social);
+        return social;
+    }
+    
+    async getPriceShardReferences() {
+        return getPriceShardRefs(this.config, this.deps);
+    }
+    
+    async getSpecificPriceShardReferences(targetInstrumentIds) {
+        return getRelevantShardRefs(this.config, this.deps, targetInstrumentIds);
+    }
+
+    async loadPriceShard(docRef) {
+        try {
+            const snap = await docRef.get();
+            if (!snap.exists) return {};
+            return snap.data();
+        } catch (e) {
+            console.error(`Error loading shard ${docRef.path}:`, e);
+            return {};
+        }
+    }
+}
+
+class ContextBuilder { 
+    
+    /**
+     * dynamically constructs the 'math' object.
+     * 1. Iterates over all exports from layers/index.js
+     * 2. Maps standard classes to legacy keys (extract, compute, etc.)
+     * 3. Adds ALL classes by their actual name to support new features automatically.
+     */
+    static buildMathContext() {
+        const mathContext = {};
+
+        // 1. Auto-discover and map
+        for (const [key, value] of Object.entries(mathLayer)) {
+            // Add by actual name (e.g. math.NewFeature)
+            mathContext[key] = value;
+
+            // Map to legacy key if exists (e.g. math.extract)
+            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 } = options;
+        return {
+            user: { id: userId, type: userType, portfolio: { today: todayPortfolio, yesterday: yesterdayPortfolio }, history: { today: todayHistory, yesterday: yesterdayHistory } },
+            date: { today: dateStr },
+            insights: { today: insights?.today, yesterday: insights?.yesterday },
+            social: { today: socialData?.today, yesterday: socialData?.yesterday },
+            mappings: mappings || {},
+            math: ContextBuilder.buildMathContext(), // DYNAMIC LOAD
+            computed: computedDependencies || {},
+            previousComputed: previousComputedDependencies || {},
+            meta: metadata, config, deps
+        };
+    }
+
+    static buildMetaContext(options) {
+        const { dateStr, metadata, mappings, insights, socialData, prices, computedDependencies, previousComputedDependencies, config, deps } = options;
+        return {
+            date: { today: dateStr },
+            insights: { today: insights?.today, yesterday: insights?.yesterday },
+            social: { today: socialData?.today, yesterday: socialData?.yesterday },
+            prices: prices || {},
+            mappings: mappings || {},
+            math: ContextBuilder.buildMathContext(), // DYNAMIC LOAD
+            computed: computedDependencies || {},
+            previousComputed: previousComputedDependencies || {},
+            meta: metadata, config, deps
+        };
+    }
+}
+
+class ComputationExecutor {
+    constructor(config, dependencies, dataLoader) {
+        this.config = config;
+        this.deps = dependencies;
+        this.loader = dataLoader;
+    }
+
+    async executePerUser(calcInstance, metadata, dateStr, portfolioData, yesterdayPortfolioData, historyData, computedDeps, prevDeps) {
+        const { logger } = this.deps;
+        const targetUserType = metadata.userType; 
+        const mappings = await this.loader.loadMappings();
+        const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
+        
+        // Access SCHEMAS dynamically from the loaded layer
+        const SCHEMAS = mathLayer.SCHEMAS;
+
+        for (const [userId, todayPortfolio] of Object.entries(portfolioData)) {
+            const yesterdayPortfolio = yesterdayPortfolioData ? yesterdayPortfolioData[userId] : null;
+            const todayHistory = historyData ? historyData[userId] : null;
+            const actualUserType = todayPortfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
+            if (targetUserType !== 'all') {
+                 const mappedTarget = (targetUserType === 'speculator') ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
+                 if (mappedTarget !== actualUserType) continue;
+            }
+            const context = ContextBuilder.buildPerUserContext({ todayPortfolio, yesterdayPortfolio, todayHistory, userId, userType: actualUserType, dateStr, metadata, mappings, insights, computedDependencies: computedDeps, previousComputedDependencies: prevDeps, config: this.config, deps: this.deps });
+            try { await calcInstance.process(context); } catch (e) { logger.log('WARN', `Calc ${metadata.name} failed for user ${userId}: ${e.message}`); }
+        }
+    }
+
+    async executeOncePerDay(calcInstance, metadata, dateStr, computedDeps, prevDeps) {
+        const mappings = await this.loader.loadMappings();
+        const { logger } = this.deps;
+        const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
+        const social = metadata.rootDataDependencies?.includes('social') ? { today: await this.loader.loadSocial(dateStr) } : null;
+        
+        if (metadata.rootDataDependencies?.includes('price')) {
+            logger.log('INFO', `[Executor] Running Batched/Sharded Execution for ${metadata.name}`);
+            const shardRefs = await this.loader.getPriceShardReferences();
+            if (shardRefs.length === 0) { logger.log('WARN', '[Executor] No price shards found.'); return {}; }
+            let processedCount = 0;
+            for (const ref of shardRefs) {
+                const shardData = await this.loader.loadPriceShard(ref);
+                const partialContext = ContextBuilder.buildMetaContext({ dateStr, metadata, mappings, insights, socialData: social, prices: { history: shardData }, computedDependencies: computedDeps, previousComputedDependencies: prevDeps, config: this.config, deps: this.deps });
+                await calcInstance.process(partialContext);
+                partialContext.prices = null; 
+                processedCount++;
+                if (processedCount % 10 === 0) { if (global.gc) { global.gc(); } }
+            }
+            logger.log('INFO', `[Executor] Finished Batched Execution for ${metadata.name} (${processedCount} shards).`);
+            return calcInstance.getResult ? await calcInstance.getResult() : {};
+        } else {
+            const context = ContextBuilder.buildMetaContext({ dateStr, metadata, mappings, insights, socialData: social, prices: {}, computedDependencies: computedDeps, previousComputedDependencies: prevDeps, config: this.config, deps: this.deps });
+            return await calcInstance.process(context);
+        }
+    }
+}
+
+class ComputationController {
+    constructor(config, dependencies) {
+        this.config = config;
+        this.deps = dependencies;
+        this.loader = new DataLoader(config, dependencies);
+        this.executor = new ComputationExecutor(config, dependencies, this.loader);
+    }
+}
+
+module.exports = { ComputationController };

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

@@ -1,91 +1,91 @@
-/**
- * FILENAME: bulltrackers-module/functions/computation-system/helpers/computation_dispatcher.js
- * PURPOSE: Dispatches computation tasks to Pub/Sub for scalable execution.
- * FIXED: Instantiates PubSubUtils locally to ensure valid logger/dependencies are used.
- * IMPROVED: Logging now explicitly lists the calculations being scheduled.
- */
-
-const { getExpectedDateStrings } = require('../utils/utils.js');
-const { groupByPass } = require('./orchestration_helpers.js');
-const { PubSubUtils } = require('../../core/utils/pubsub_utils');
-
-const TOPIC_NAME = 'computation-tasks';
-
-/**
- * Dispatches computation tasks for a specific pass.
- * Instead of running them, it queues them in Pub/Sub.
- */
-async function dispatchComputationPass(config, dependencies, computationManifest) {
-    const { logger } = dependencies;
-
-    // Create fresh PubSubUtils instance
-    const pubsubUtils = new PubSubUtils(dependencies);
-
-    const passToRun = String(config.COMPUTATION_PASS_TO_RUN);
-
-    if (!passToRun) {
-        return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.');
-    }
-
-    // 1. Validate Pass Existence
-    const passes = groupByPass(computationManifest);
-    const calcsInThisPass = passes[passToRun] || [];
-
-    if (!calcsInThisPass.length) {
-        return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`);
-    }
-
-    const calcNames = calcsInThisPass.map(c => c.name).join(', ');
-    logger.log('INFO', `🚀 [Dispatcher] Preparing PASS ${passToRun}.`);
-    logger.log('INFO', `[Dispatcher] Included Calculations: [${calcNames}]`);
-
-    // 2. Determine Date Range
-    // Hardcoded earliest dates - keep synced with PassRunner for now
-    const earliestDates = {
-        portfolio: new Date('2025-09-25T00:00:00Z'),
-        history: new Date('2025-11-05T00:00:00Z'),
-        social: new Date('2025-10-30T00:00:00Z'),
-        insights: new Date('2025-08-26T00:00:00Z'),
-        price: new Date('2025-08-01T00:00:00Z')
-    };
-    const passEarliestDate = Object.values(earliestDates).reduce((a, b) => a < b ? a : b);
-    const endDateUTC = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
-
-    const allExpectedDates = getExpectedDateStrings(passEarliestDate, endDateUTC);
-
-    logger.log('INFO', `[Dispatcher] Dispatches checks for ${allExpectedDates.length} dates (${allExpectedDates[0]} to ${allExpectedDates[allExpectedDates.length - 1]}). Workers will validate dependencies.`);
-
-    // 3. Dispatch Messages
-    let dispatchedCount = 0;
-    const BATCH_SIZE = 50;
-
-    // We can publish in parallel batches
-    const chunks = [];
-    for (let i = 0; i < allExpectedDates.length; i += BATCH_SIZE) {
-        chunks.push(allExpectedDates.slice(i, i + BATCH_SIZE));
-    }
-
-    for (const chunk of chunks) {
-        const messages = chunk.map(dateStr => ({
-            json: {
-                action: 'RUN_COMPUTATION_DATE',
-                date: dateStr,
-                pass: passToRun,
-                timestamp: Date.now()
-            }
-        }));
-
-        try {
-            await pubsubUtils.publishMessageBatch(TOPIC_NAME, messages);
-            dispatchedCount += messages.length;
-            logger.log('INFO', `[Dispatcher] Dispatched batch of ${messages.length} tasks.`);
-        } catch (err) {
-            logger.log('ERROR', `[Dispatcher] Failed to dispatch batch: ${err.message}`);
-        }
-    }
-
-    logger.log('INFO', `[Dispatcher] Finished. Dispatched ${dispatchedCount} checks for Pass ${passToRun}.`);
-    return { dispatched: dispatchedCount };
-}
-
+/**
+ * FILENAME: bulltrackers-module/functions/computation-system/helpers/computation_dispatcher.js
+ * PURPOSE: Dispatches computation tasks to Pub/Sub for scalable execution.
+ * FIXED: Instantiates PubSubUtils locally to ensure valid logger/dependencies are used.
+ * IMPROVED: Logging now explicitly lists the calculations being scheduled.
+ */
+
+const { getExpectedDateStrings } = require('../utils/utils.js');
+const { groupByPass } = require('./orchestration_helpers.js');
+const { PubSubUtils } = require('../../core/utils/pubsub_utils');
+
+const TOPIC_NAME = 'computation-tasks';
+
+/**
+ * Dispatches computation tasks for a specific pass.
+ * Instead of running them, it queues them in Pub/Sub.
+ */
+async function dispatchComputationPass(config, dependencies, computationManifest) {
+    const { logger } = dependencies;
+
+    // Create fresh PubSubUtils instance
+    const pubsubUtils = new PubSubUtils(dependencies);
+
+    const passToRun = String(config.COMPUTATION_PASS_TO_RUN);
+
+    if (!passToRun) {
+        return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.');
+    }
+
+    // 1. Validate Pass Existence
+    const passes = groupByPass(computationManifest);
+    const calcsInThisPass = passes[passToRun] || [];
+
+    if (!calcsInThisPass.length) {
+        return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`);
+    }
+
+    const calcNames = calcsInThisPass.map(c => c.name).join(', ');
+    logger.log('INFO', `🚀 [Dispatcher] Preparing PASS ${passToRun}.`);
+    logger.log('INFO', `[Dispatcher] Included Calculations: [${calcNames}]`);
+
+    // 2. Determine Date Range
+    // Hardcoded earliest dates - keep synced with PassRunner for now
+    const earliestDates = {
+        portfolio: new Date('2025-09-25T00:00:00Z'),
+        history: new Date('2025-11-05T00:00:00Z'),
+        social: new Date('2025-10-30T00:00:00Z'),
+        insights: new Date('2025-08-26T00:00:00Z'),
+        price: new Date('2025-08-01T00:00:00Z')
+    };
+    const passEarliestDate = Object.values(earliestDates).reduce((a, b) => a < b ? a : b);
+    const endDateUTC = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
+
+    const allExpectedDates = getExpectedDateStrings(passEarliestDate, endDateUTC);
+
+    logger.log('INFO', `[Dispatcher] Dispatches checks for ${allExpectedDates.length} dates (${allExpectedDates[0]} to ${allExpectedDates[allExpectedDates.length - 1]}). Workers will validate dependencies.`);
+
+    // 3. Dispatch Messages
+    let dispatchedCount = 0;
+    const BATCH_SIZE = 50;
+
+    // We can publish in parallel batches
+    const chunks = [];
+    for (let i = 0; i < allExpectedDates.length; i += BATCH_SIZE) {
+        chunks.push(allExpectedDates.slice(i, i + BATCH_SIZE));
+    }
+
+    for (const chunk of chunks) {
+        const messages = chunk.map(dateStr => ({
+            json: {
+                action: 'RUN_COMPUTATION_DATE',
+                date: dateStr,
+                pass: passToRun,
+                timestamp: Date.now()
+            }
+        }));
+
+        try {
+            await pubsubUtils.publishMessageBatch(TOPIC_NAME, messages);
+            dispatchedCount += messages.length;
+            logger.log('INFO', `[Dispatcher] Dispatched batch of ${messages.length} tasks.`);
+        } catch (err) {
+            logger.log('ERROR', `[Dispatcher] Failed to dispatch batch: ${err.message}`);
+        }
+    }
+
+    logger.log('INFO', `[Dispatcher] Finished. Dispatched ${dispatchedCount} checks for Pass ${passToRun}.`);
+    return { dispatched: dispatchedCount };
+}
+
 module.exports = { dispatchComputationPass };