bulltrackers-module 1.0.732 → 1.0.733

package/functions/computation-system/persistence/ResultCommitter.js

@@ -1,283 +0,0 @@
-/**
- * @fileoverview Handles saving computation results.
- * REFACTORED:
- * 1. Writes ALL data to BigQuery (Source of Truth).
- * 2. Writes to Firestore ONLY for 'Page' (Fan-out) and 'Alert' computations.
- * 3. Removes GCS/Compression complexity for standard data (now BQ-only).
- */
-const { commitBatchInChunks, generateDataHash, FieldValue } = require('../utils/utils');
-const { updateComputationStatus } = require('./StatusRepository');
-const { batchStoreSchemas } = require('../utils/schema_capture');
-const { generateProcessId, PROCESS_TYPES } = require('../logger/logger');
-const { HeuristicValidator } = require('./ResultsValidator');
-const ContractValidator = require('./ContractValidator');
-const validationOverrides = require('../config/validation_overrides');
-const pLimit = require('p-limit');
-
-const DEFAULT_TTL_DAYS = 90;
-const SIMHASH_REGISTRY_COLLECTION = 'system_simhash_registry';
-const CONTRACTS_COLLECTION = 'system_contracts';
-
-async function commitResults(stateObj, dStr, passName, config, deps, skipStatusWrite = false, options = {}) {
-    const successUpdates = {};
-    const failureReport = [];
-    const schemas = [];
-    const alertTriggers = [];
-    const { logger, db, calculationUtils } = deps;
-
-    const pid = generateProcessId(PROCESS_TYPES.STORAGE, passName, dStr);
-    const flushMode = options.flushMode || 'STANDARD';
-    const isInitialWrite = options.isInitialWrite === true;
-
-    // Pre-fetch contracts and hashes
-    const calcNames = Object.keys(stateObj);
-    const hashKeys = calcNames.map(n => stateObj[n].manifest?.hash).filter(Boolean);
-    const [contractMap, simHashMap] = await Promise.all([
-        fetchContracts(db, calcNames),
-        batchFetchSimHashes(db, hashKeys)
-    ]);
-
-    for (const name in stateObj) {
-        const calc = stateObj[name];
-        const execStats = calc._executionStats || { processedUsers: 0, skippedUsers: 0 };
-
-        const runMetrics = {
-            storage: { sizeBytes: 0, location: 'BIGQUERY', keys: 0 },
-            validation: { isValid: true, anomalies: [] },
-            execution: execStats,
-            io: { writes: 0, deletes: 0 }
-        };
-
-        const manifest = calc.manifest;
-        const isAlert = manifest.isAlertComputation === true;
-        const isPage = manifest.isPage === true;
-        const ttlDays = manifest.ttlDays !== undefined ? manifest.ttlDays : DEFAULT_TTL_DAYS;
-
-        try {
-            const result = await calc.getResult();
-            
-            // --- 1. VALIDATION ---
-            const configOverrides = validationOverrides[manifest.name] || {};
-            const dataDeps = manifest.rootDataDependencies || [];
-            // Relax validation for price-only computations
-            if (dataDeps.length === 1 && dataDeps[0] === 'price') {
-                Object.assign(configOverrides, { maxZeroPct: 100, maxFlatlinePct: 100, maxNullPct: 100, maxNanPct: 100 });
-                delete configOverrides.weekend;
-            }
-
-            // Contract Validation
-            const contract = contractMap[name];
-            if (contract) {
-                const contractCheck = ContractValidator.validate(result, contract);
-                if (!contractCheck.valid) throw new Error(`[SEMANTIC_GATE] ${contractCheck.reason}`);
-            }
-
-            // Heuristic Validation (Circuit Breaker)
-            if (result && Object.keys(result).length > 0) {
-                const healthCheck = HeuristicValidator.analyze(manifest.name, result, dStr, configOverrides);
-                if (!healthCheck.valid) {
-                    runMetrics.validation.isValid = false;
-                    runMetrics.validation.anomalies.push(healthCheck.reason);
-                    throw new Error(`[QUALITY_CIRCUIT_BREAKER] ${healthCheck.reason}`);
-                }
-            }
-
-            const isEmpty = !result || (typeof result === 'object' && Object.keys(result).length === 0);
-            const resultHash = isEmpty ? 'empty' : generateDataHash(result);
-            const simHash = (flushMode !== 'INTERMEDIATE') ? (simHashMap[manifest.hash] || null) : null;
-
-            // --- 2. HANDLE EMPTY RESULTS ---
-            if (isEmpty) {
-                if (flushMode === 'INTERMEDIATE') continue;
-                if (manifest.hash) {
-                    successUpdates[name] = {
-                        hash: manifest.hash, simHash, resultHash,
-                        dependencyResultHashes: manifest.dependencyResultHashes || {},
-                        category: manifest.category, composition: manifest.composition, metrics: runMetrics
-                    };
-                }
-                continue;
-            }
-
-            // --- 3. WRITE TO BIGQUERY (UNIVERSAL) ---
-            // ALL data goes to BigQuery first. This is the primary storage.
-            // Using a fire-and-forget approach or await based on critical need. 
-            // We await here to ensure data safety before reporting success.
-            await writeToBigQuery(result, name, dStr, manifest.category, logger, isAlert).catch(err => {
-                logger.log('WARN', `[BigQuery] Write warning for ${name}: ${err.message}`);
-            });
-            
-            // If it's NOT Page or Alert, we are done (No Firestore write)
-            if (!isPage && !isAlert) {
-                if (manifest.hash) {
-                    successUpdates[name] = {
-                        hash: manifest.hash, simHash, resultHash,
-                        dependencyResultHashes: manifest.dependencyResultHashes || {},
-                        category: manifest.category, composition: manifest.composition, metrics: runMetrics
-                    };
-                }
-                continue; // Skip Firestore logic
-            }
-
-            // --- 4. FIRESTORE WRITES (SELECTIVE) ---
-            const expireAt = calculateExpirationDate(dStr, ttlDays);
-
-            // A. PAGE COMPUTATIONS (Fan-Out)
-            if (isPage) {
-                const mainDocRef = db.collection(config.resultsCollection).doc(dStr)
-                    .collection(config.resultsSubcollection).doc(manifest.category)
-                    .collection(config.computationsSubcollection).doc(name);
-
-                // Fan-out writes: One document per User ID
-                const pageWrites = [];
-                for (const [cid, userData] of Object.entries(result)) {
-                    // Unique document for each user ID
-                    const userDocRef = mainDocRef.collection('pages').doc(cid);
-                    
-                    const payload = (typeof userData === 'object' && userData !== null) 
-                        ? { ...userData, _expireAt: expireAt }
-                        : { value: userData, _expireAt: expireAt };
-
-                    pageWrites.push({ ref: userDocRef, data: payload, options: { merge: false } });
-                }
-
-                if (pageWrites.length > 0) {
-                    await commitBatchInChunks(config, deps, pageWrites, `${name}::PageFanOut`);
-                    runMetrics.io.writes += pageWrites.length;
-                    runMetrics.storage.location = 'FIRESTORE_PAGES';
-                }
-
-                // Write Header Document (Metadata for frontend/indexing)
-                const headerData = {
-                    _isPageMode: true,
-                    _pageCount: isInitialWrite ? pageWrites.length : FieldValue.increment(pageWrites.length),
-                    _lastUpdated: new Date().toISOString(),
-                    _expireAt: expireAt,
-                    _completed: flushMode !== 'INTERMEDIATE'
-                };
-                await mainDocRef.set(headerData, { merge: !isInitialWrite });
-                
-                logger.log('INFO', `[ResultCommitter] ${name}: Wrote ${pageWrites.length} user pages to Firestore.`);
-            }
-
-            // B. ALERT COMPUTATIONS (Single Doc for Triggers)
-            if (isAlert) {
-                // Alerts are written to a single document to trigger the listener
-                const mainDocRef = db.collection(config.resultsCollection).doc(dStr)
-                    .collection(config.resultsSubcollection).doc(manifest.category)
-                    .collection(config.computationsSubcollection).doc(name);
-
-                const alertPayload = {
-                    ...result,
-                    _isAlert: true,
-                    _lastUpdated: new Date().toISOString(),
-                    _expireAt: expireAt
-                };
-
-                await mainDocRef.set(alertPayload);
-                runMetrics.io.writes += 1;
-                runMetrics.storage.location = 'FIRESTORE_ALERT';
-                
-                // Add to triggers list for logging
-                if (flushMode !== 'INTERMEDIATE') {
-                    alertTriggers.push({ date: dStr, computationName: name, documentPath: mainDocRef.path });
-                }
-            }
-
-            // --- 5. FINALIZE ---
-            if (manifest.hash) {
-                successUpdates[name] = {
-                    hash: manifest.hash, simHash, resultHash,
-                    dependencyResultHashes: manifest.dependencyResultHashes || {},
-                    category: manifest.category, composition: manifest.composition, metrics: runMetrics
-                };
-            }
-
-            // Store Schema
-            if (manifest.class.getSchema && flushMode !== 'INTERMEDIATE') {
-                const { class: _cls, ...safeMetadata } = manifest;
-                safeMetadata.ttlDays = ttlDays;
-                schemas.push({ name, category: manifest.category, schema: manifest.class.getSchema(), metadata: safeMetadata });
-            }
-
-        } catch (e) {
-            logger.log('ERROR', `Commit failed for ${name}`, { error: e });
-            failureReport.push({ name, error: { message: e.message, stack: e.stack }, metrics: runMetrics });
-        }
-    }
-
-    if (schemas.length) batchStoreSchemas(deps, config, schemas).catch(() => {});
-    if (!skipStatusWrite && Object.keys(successUpdates).length > 0 && flushMode !== 'INTERMEDIATE') {
-        await updateComputationStatus(dStr, successUpdates, config, deps);
-    }
-    
-    if (alertTriggers.length > 0) {
-        logger.log('INFO', `[ResultCommitter] ${alertTriggers.length} alert computations updated in Firestore.`);
-    }
-
-    return { successUpdates, failureReport };
-}
-
-// --- HELPERS ---
-
-async function writeToBigQuery(result, name, dateContext, category, logger, isAlertComputation = false) {
-    if (process.env.BIGQUERY_ENABLED === 'false') return;
-
-    try {
-        const { ensureComputationResultsTable, insertRowsWithMerge } = require('../../core/utils/bigquery_utils');
-        await ensureComputationResultsTable(logger);
-
-        // Simple metadata extraction
-        const metadata = result.cids && Array.isArray(result.cids) ? { cids: result.cids } : null;
-
-        const row = {
-            date: dateContext,
-            computation_name: name,
-            category: category,
-            result_data: result, // BigQuery handles JSON wrapping
-            metadata: metadata,
-            created_at: new Date().toISOString()
-        };
-
-        const datasetId = process.env.BIGQUERY_DATASET_ID || 'bulltrackers_data';
-        
-        // Always use merge to ensure idempotency (overwrite previous run for same date/calc)
-        await insertRowsWithMerge(datasetId, 'computation_results', [row], ['date', 'computation_name', 'category'], logger);
-
-    } catch (error) {
-        if (logger) logger.log('WARN', `[BigQuery] Write failed for ${name}: ${error.message}`);
-        // Do not throw; we don't want to crash the computation pipeline if metrics fail
-    }
-}
-
-async function batchFetchSimHashes(db, hashes) {
-    if (!hashes || hashes.length === 0) return {};
-    const map = {};
-    const refs = hashes.map(h => db.collection(SIMHASH_REGISTRY_COLLECTION).doc(h));
-    try {
-        const snaps = await db.getAll(...refs);
-        snaps.forEach(snap => { if (snap.exists) map[snap.id] = snap.data().simHash; });
-    } catch (e) {}
-    return map;
-}
-
-async function fetchContracts(db, calcNames) {
-    if (!calcNames || calcNames.length === 0) return {};
-    const map = {};
-    const refs = calcNames.map(name => db.collection(CONTRACTS_COLLECTION).doc(name));
-    try {
-        const snaps = await db.getAll(...refs);
-        snaps.forEach(snap => { if (snap.exists) map[snap.id] = snap.data(); });
-    } catch (e) {}
-    return map;
-}
-
-function calculateExpirationDate(dateStr, ttlDays) {
-    if (!dateStr || !ttlDays || isNaN(Number(ttlDays))) return null;
-    const base = new Date(dateStr);
-    if (isNaN(base.getTime())) return null;
-    base.setDate(base.getDate() + Number(ttlDays));
-    return base;
-}
-
-module.exports = { commitResults };

package/functions/computation-system/persistence/ResultsValidator.js

@@ -1,130 +0,0 @@
-/**
- * @fileoverview HeuristicValidator.js
- * "Grey Box" validation that infers health using statistical analysis and structural sanity checks.
- * UPDATED: Added "Weekend Mode" to allow higher zero/null tolerance on Saturdays/Sundays.
- */
-
-class HeuristicValidator {
-    /**
-     * @param {string} calcName - Name for logging
-     * @param {Object} data - The result data to inspect
-     * @param {string} dateStr - The computation date (YYYY-MM-DD)
-     * @param {Object} [overrides] - Optional central config overrides
-     */
-    static analyze(calcName, data, dateStr, overrides = {}) {
-        // 1. Structure Check
-        if (!data || typeof data !== 'object') return { valid: true }; 
-        
-        const keys = Object.keys(data);
-        const totalItems = keys.length;
-        
-        if (totalItems < 5) return { valid: true };
-
-        // 2. Sampling Configuration
-        const sampleSize = Math.min(totalItems, 100);
-        const step = Math.floor(totalItems / sampleSize);
-        
-        let zeroCount        = 0;
-        let nullCount        = 0;
-        let nanCount         = 0; 
-        let emptyVectorCount = 0; 
-        let analyzedCount    = 0;
-        
-        const numericValues = []; 
-
-        for (let i = 0; i < totalItems; i += step) {
-            const key = keys[i];
-            const val = data[key];
-            if (!val) { 
-                nullCount++;
-                analyzedCount++;
-                continue;
-            }
-            analyzedCount++;
-
-            // --- TYPE A: Object / Complex Result ---
-            if (typeof val === 'object') {
-                const subValues = Object.values(val);
-                
-                const isDeadObject = subValues.every(v => v === 0 || v === null || v === undefined);
-                if (isDeadObject) nullCount++;
-
-                const hasNan = subValues.some(v => typeof v === 'number' && (isNaN(v) || !isFinite(v)));
-                if (hasNan) nanCount++;
-
-                const arrayProps = ['profile', 'history', 'sparkline', 'buckets', 'prices'];
-                for (const prop of arrayProps) { if (Array.isArray(val[prop]) && val[prop].length === 0) { emptyVectorCount++; } }
-
-                const numericProp = subValues.find(v => typeof v === 'number' && v !== 0);
-                if (numericProp !== undefined) numericValues.push(numericProp);
-            } 
-            // --- TYPE B: Scalar / Primitive Result ---
-            if (typeof val === 'number') {
-                if (isNaN(val) || !isFinite(val)) { nanCount++; } 
-                else {
-                    numericValues.push(val); 
-                    if (val === 0) zeroCount++;
-                }
-            }
-        }
-
-        // 3. Weekend Detection & Threshold Resolution
-        let isWeekend = false;
-        if (dateStr) {
-            try {
-                // Force UTC interpretation to align with system dates
-                const safeDate = dateStr.includes('T') ? dateStr : `${dateStr}T00:00:00Z`;
-                const day = new Date(safeDate).getUTCDay();
-                // 0 = Sunday, 6 = Saturday
-                isWeekend = (day === 0 || day === 6);
-            } catch (e) { /* Fallback to standard validation if date is invalid */ }
-        }
-
-        // Default Thresholds
-        let thresholds = {
-            maxZeroPct:     overrides.maxZeroPct     ?? 99, 
-            maxNullPct:     overrides.maxNullPct     ?? 90,
-            maxNanPct:      overrides.maxNanPct      ?? 0,   
-            maxFlatlinePct: overrides.maxFlatlinePct ?? 95 
-        };
-
-        // Apply Weekend Overrides if applicable
-        if (isWeekend && overrides.weekend) {
-            thresholds = { ...thresholds, ...overrides.weekend };
-        }
-
-        // 4. Calculate Stats
-        const zeroPct = (zeroCount / analyzedCount) * 100;
-        const nullPct = (nullCount / analyzedCount) * 100;
-        const nanPct  = (nanCount  / analyzedCount) * 100;
-        
-        // 5. Variance / Flatline Analysis
-        let isFlatline = false;
-        if (numericValues.length > 5) {
-            const first          = numericValues[0];
-            const identicalCount = numericValues.filter(v => Math.abs(v - first) < 0.000001).length;
-            const flatlinePct    = (identicalCount / numericValues.length) * 100;
-            
-            if (flatlinePct > thresholds.maxFlatlinePct && Math.abs(first) > 0.0001) { isFlatline = true; }
-        }
-
-        // 6. Evaluations
-        // Note: We include the applied thresholds in the error message for clarity
-        if (nanPct  > thresholds.maxNanPct)  { return { valid: false, reason: `Mathematical Error: ${nanPct.toFixed(1)}% of sampled results contain NaN (Limit: ${thresholds.maxNanPct}%).` }; }
-        if (zeroPct > thresholds.maxZeroPct) { return { valid: false, reason: `Data Integrity:     ${zeroPct.toFixed(1)}% of results are 0 (Limit: ${thresholds.maxZeroPct}%${isWeekend ? ' [Weekend Mode]' : ''}).` }; }
-        if (nullPct > thresholds.maxNullPct) { return { valid: false, reason: `Data Integrity:     ${nullPct.toFixed(1)}% of results are Empty/Null (Limit: ${thresholds.maxNullPct}%${isWeekend ? ' [Weekend Mode]' : ''}).` }; }
-
-        if (isFlatline) { return { valid: false, reason: `Anomaly: Detected Result Flatline. >${thresholds.maxFlatlinePct}% of outputs are identical (non-zero).` }; }
-        
-        if (calcName.includes('profile') || calcName.includes('distribution')) {
-            const vectorEmptyPct = (emptyVectorCount / analyzedCount) * 100;
-            if (vectorEmptyPct > 90) {
-                return { valid: false, reason: `Data Integrity: ${vectorEmptyPct.toFixed(1)}% of distribution profiles are empty.` };
-            }
-        }
-
-        return { valid: true };
-    }
-}
-
-module.exports = { HeuristicValidator };

package/functions/computation-system/persistence/RunRecorder.js

@@ -1,142 +0,0 @@
-/**
- * @fileoverview Utility for recording computation run attempts (The Audit Logger).
- * UPDATED: Stores 'trigger', 'execution' stats, 'cost' metrics, and 'forensics'.
- * UPDATED: Emits Structured Logs for GCP Observability.
- */
-
-const { FieldValue } = require('../utils/utils'); 
-const os = require('os');
-
-const AUDIT_COLLECTION = 'computation_audit_logs';
-
-function sanitizeErrorKey(message) {
-    if (!message) return 'Unknown_Error';
-    const shortMsg = message.toString().substring(0, 100); 
-    return shortMsg.replace(/[./\[\]*`]/g, '_').trim();
-}
-
-/**
- * Records a run attempt with detailed metrics and aggregated stats.
- */
-async function recordRunAttempt(db, context, status, error = null, detailedMetrics = { durationMs: 0 }, triggerReason = 'Unknown', resourceTier = 'standard') {
-    if (!db || !context) return;
-
-    const { date: targetDate, computation, pass } = context;
-    const now = new Date();
-    const triggerTimestamp = now.getTime();
-    
-    const computationDocRef = db.collection(AUDIT_COLLECTION).doc(computation);
-    const runId     = `${targetDate}_${triggerTimestamp}`;
-    const runDocRef = computationDocRef.collection('history').doc(runId);
-
-    const workerId = process.env.FUNCTION_TARGET || process.env.K_REVISION || os.hostname();
-    
-    let sizeMB = 0;
-    if (detailedMetrics.storage && detailedMetrics.storage.sizeBytes) { sizeMB = Number((detailedMetrics.storage.sizeBytes / (1024 * 1024)).toFixed(4)); }
-
-    const anomalies = detailedMetrics.validation?.anomalies || [];
-    if (error && error.message && error.message.includes('Data Integrity')) { anomalies.push(error.message); }
-
-    const rawExecStats = detailedMetrics.execution || {};
-    const timings = rawExecStats.timings || {};
-
-    const runEntry = {
-        runId:           runId,
-        computationName: computation,
-        pass:            String(pass),
-        workerId:        workerId,
-        targetDate:      targetDate,
-        triggerTime:     now.toISOString(),
-        durationMs:      detailedMetrics.durationMs || 0,
-        status:          status,
-        
-        resourceTier:    resourceTier,
-        peakMemoryMB:    detailedMetrics.peakMemoryMB || 0,
-        
-        firestoreOps: {
-            reads:   detailedMetrics.io?.reads   || 0,
-            writes:  detailedMetrics.io?.writes  || 0,
-            deletes: detailedMetrics.io?.deletes || 0
-        },
-
-        composition: detailedMetrics.composition || null,
-
-        trigger: {
-            reason: triggerReason || 'Unknown', 
-            type: (triggerReason && triggerReason.includes('Layer')) ? 'CASCADE' : ((triggerReason && triggerReason.includes('New')) ? 'INIT' : 'UPDATE')
-        },
-
-        executionStats: {
-            processedUsers: rawExecStats.processedUsers     || 0,
-            skippedUsers:   rawExecStats.skippedUsers       || 0,
-            timings: {
-                setupMs:      Math.round(timings.setup      || 0),
-                streamMs:     Math.round(timings.stream     || 0),
-                processingMs: Math.round(timings.processing || 0)
-            }
-        },
-
-        outputStats: {
-            sizeMB: sizeMB,
-            isSharded: !!detailedMetrics.storage?.isSharded,
-            shardCount:  detailedMetrics.storage?.shardCount || 1,
-            keysWritten: detailedMetrics.storage?.keys       || 0 
-        },
-
-        anomalies: anomalies,
-        _schemaVersion: '2.3'
-    };
-
-    if (error) {
-        runEntry.error = {
-            message: error.message || 'Unknown Error',
-            stage:   error.stage   || 'UNKNOWN',
-            stack:   error.stack    ? error.stack.substring(0, 1000) : null,
-            code:    error.code    || null
-        };
-    }
-
-    // 1. [NEW] Emit Structured Log for GCP Observability
-    // This allows you to query "jsonPayload.event = 'AUDIT_COMPLETE'" in Cloud Logging
-    // independent of Firestore status.
-    console.log(JSON.stringify({
-        event: 'AUDIT_COMPLETE',
-        severity: status === 'SUCCESS' ? 'INFO' : 'ERROR',
-        computation: computation,
-        runId: runId,
-        status: status,
-        metrics: {
-            duration: runEntry.durationMs,
-            memory: runEntry.peakMemoryMB,
-            writes: runEntry.firestoreOps.writes
-        },
-        error: runEntry.error ? runEntry.error.message : null
-    }));
-
-    // 2. Existing Firestore Aggregation Logic
-    const statsUpdate = {
-        lastRunAt: now,
-        lastRunStatus: status,
-        totalRuns: FieldValue.increment(1),
-        totalCostAccumulated: FieldValue.increment(0)
-    };
-
-    if (status === 'SUCCESS') { statsUpdate.successCount = FieldValue.increment(1);
-    } else {                    statsUpdate.failureCount = FieldValue.increment(1);
-        if (error) {
-            const safeKey = sanitizeErrorKey(error.message);
-            statsUpdate[`errorCounts.${safeKey}`] = FieldValue.increment(1);
-        }
-    }
-
-    try {
-        const batch = db.batch();
-        batch.set(runDocRef, runEntry);
-        batch.set(computationDocRef, statsUpdate, { merge: true });
-        await batch.commit();
-    } catch (e) {
-        console.error(`[RunRecorder] ❌ CRITICAL: Failed to write audit log for ${computation}`, e);
-    }
-}
-
-module.exports = { recordRunAttempt };

package/functions/computation-system/persistence/StatusRepository.js

@@ -1,52 +0,0 @@
-/**
- * @fileoverview Manages computation status tracking in Firestore.
- * UPDATED: Supports Schema V2 (Object with Category & Composition) for deep auditing.
- */
-
-async function fetchComputationStatus(dateStr, config, { db }) {
-    if (!dateStr) throw new Error('fetchStatus requires a key'); 
-    const collection = config.computationStatusCollection || 'computation_status';
-    const docRef     = db.collection(collection).doc(dateStr);
-    const snap       = await docRef.get();
-    if (!snap.exists) return {};
-    const rawData    = snap.data();
-    const normalized = {};
-
-    // Normalize V1 (String) to V2 (Object)
-    for (const [name, value] of Object.entries(rawData)) {
-        if (typeof value === 'string') { 
-            normalized[name] = { hash: value, category: null, composition: null }; // Legacy entry
-        } else { 
-            normalized[name] = value; 
-        }
-    }
-
-    return normalized;
-}
-
-async function updateComputationStatus(dateStr, updates, config, { db }) {
-    if (!dateStr) throw new Error('updateStatus requires a key');
-    if (!updates || Object.keys(updates).length === 0) return;
-    
-    const collection = config.computationStatusCollection || 'computation_status';
-    const docRef = db.collection(collection).doc(dateStr);
-    
-    const safeUpdates = {};
-    for (const [key, val] of Object.entries(updates)) {
-        if (typeof val === 'string') { 
-            // Legacy Call Fallback
-            safeUpdates[key] = { hash: val, category: 'unknown', lastUpdated: new Date() };
-        } else { 
-            // V2 Call: val should contain { hash, category, composition }
-            safeUpdates[key] = { 
-                ...val, 
-                lastUpdated: new Date() 
-            }; 
-        }
-    }
-
-    await docRef.set(safeUpdates, { merge: true });
-    return true;
-}
-
-module.exports = { fetchComputationStatus, updateComputationStatus };

package/functions/computation-system/reporter_epoch.js

@@ -1,6 +0,0 @@
-/**
- * FILENAME: computation-system/reporter_epoch.js
- * PURPOSE: Master override for BuildReporter. 
- * Increment this string to force a full re-analysis regardless of code or data stability.
- */
-module.exports = "reporter-epoch-11";