bulltrackers-module 1.0.218 → 1.0.220

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

@@ -0,0 +1,118 @@
+/**
+ * @fileoverview Handles saving computation results with transparent auto-sharding.
+ */
+const { commitBatchInChunks } = require('./FirestoreUtils');
+const { updateComputationStatus } = require('./StatusRepository');
+const { batchStoreSchemas } = require('../utils/schema_capture');
+
+async function commitResults(stateObj, dStr, passName, config, deps, skipStatusWrite = false) {
+    const successUpdates = {};
+    const schemas = [];
+
+    for (const name in stateObj) {
+        const calc = stateObj[name];
+        try {
+            const result = await calc.getResult();
+            if (!result) { 
+                deps.logger.log('INFO', `${name} for ${dStr}: Skipped (Empty Result)`); 
+                continue; 
+            }
+
+            const mainDocRef = deps.db.collection(config.resultsCollection)
+                .doc(dStr)
+                .collection(config.resultsSubcollection)
+                .doc(calc.manifest.category)
+                .collection(config.computationsSubcollection)
+                .doc(name);
+
+            const updates = await prepareAutoShardedWrites(result, mainDocRef, deps.logger);
+
+            if (calc.manifest.class.getSchema) {
+                const { class: _cls, ...safeMetadata } = calc.manifest;
+                schemas.push({ 
+                    name, 
+                    category: calc.manifest.category, 
+                    schema: calc.manifest.class.getSchema(), 
+                    metadata: safeMetadata 
+                });
+            }
+
+            if (updates.length > 0) {
+                await commitBatchInChunks(config, deps, updates, `${name} Results`);
+                successUpdates[name] = calc.manifest.hash || true;
+                const isSharded = updates.some(u => u.data._sharded === true);
+                deps.logger.log('INFO', `${name} for ${dStr}: \u2714 Success (Written ${isSharded ? 'Sharded' : 'Standard'})`);
+            } else {
+                deps.logger.log('INFO', `${name} for ${dStr}: - Empty Data`);
+            }
+        } catch (e) {
+            deps.logger.log('ERROR', `${name} for ${dStr}: \u2716 FAILED Commit: ${e.message}`);
+        }
+    }
+
+    if (schemas.length) batchStoreSchemas(deps, config, schemas).catch(() => {});
+
+    if (!skipStatusWrite && Object.keys(successUpdates).length > 0) {
+        await updateComputationStatus(dStr, successUpdates, config, deps);
+        deps.logger.log('INFO', `[${passName}] Updated status document for ${Object.keys(successUpdates).length} successful computations.`);
+    }
+    return successUpdates;
+}
+
+function calculateFirestoreBytes(value) {
+    if (value === null) return 1;
+    if (value === undefined) return 0;
+    if (typeof value === 'boolean') return 1;
+    if (typeof value === 'number') return 8;
+    if (typeof value === 'string') return Buffer.byteLength(value, 'utf8') + 1;
+    if (value instanceof Date) return 8;
+    if (value.constructor && value.constructor.name === 'DocumentReference') { return Buffer.byteLength(value.path, 'utf8') + 16; }
+    if (Array.isArray(value)) { let sum = 0; for (const item of value) sum += calculateFirestoreBytes(item); return sum; }
+    if (typeof value === 'object') { let sum = 0; for (const k in value) { if (Object.prototype.hasOwnProperty.call(value, k)) { sum += (Buffer.byteLength(k, 'utf8') + 1) + calculateFirestoreBytes(value[k]); } } return sum; }
+    return 0;
+}
+
+async function prepareAutoShardedWrites(result, docRef, logger) {
+    const SAFETY_THRESHOLD_BYTES = 1000 * 1024; // 1MB Limit
+    const OVERHEAD_ALLOWANCE = 20 * 1024;
+    const CHUNK_LIMIT = SAFETY_THRESHOLD_BYTES - OVERHEAD_ALLOWANCE;
+    const totalSize = calculateFirestoreBytes(result);
+    const docPathSize = Buffer.byteLength(docRef.path, 'utf8') + 16;
+
+    if ((totalSize + docPathSize) < CHUNK_LIMIT) { 
+        const data = { ...result, _completed: true, _sharded: false }; 
+        return [{ ref: docRef, data, options: { merge: true } }]; 
+    }
+
+    logger.log('INFO', `[AutoShard] Result size ~${Math.round(totalSize/1024)}KB exceeds limit. Sharding...`);
+    const writes = [];
+    const shardCollection = docRef.collection('_shards');
+    let currentChunk = {};
+    let currentChunkSize = 0;
+    let shardIndex = 0;
+
+    for (const [key, value] of Object.entries(result)) { 
+        if (key.startsWith('_')) continue;
+        const keySize = Buffer.byteLength(key, 'utf8') + 1;         
+        const valueSize = calculateFirestoreBytes(value);
+        const itemSize = keySize + valueSize;
+
+        if (currentChunkSize + itemSize > CHUNK_LIMIT) { 
+            writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } });
+            shardIndex++;
+            currentChunk = {};
+            currentChunkSize = 0;
+        }
+        currentChunk[key] = value;
+        currentChunkSize += itemSize;
+    }
+    if (Object.keys(currentChunk).length > 0) { 
+        writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } }); 
+    }
+    
+    const pointerData = { _completed: true, _sharded: true, _shardCount: shardIndex + 1, _lastUpdated: new Date().toISOString() };
+    writes.push({ ref: docRef, data: pointerData, options: { merge: false } });
+    return writes;
+}
+
+module.exports = { commitResults };

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

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Manages computation status tracking in Firestore.
+ */
+
+async function fetchComputationStatus(dateStr, config, { db }) {
+    if (!key) throw new Error('fetchStatus requires a key'); 
+    const key = dateStr;
+    const collection = config.computationStatusCollection || 'computation_status';
+    const docRef = db.collection(collection).doc(key);
+    const snap = await docRef.get();
+    return snap.exists ? snap.data() : {};
+}
+
+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);
+    await docRef.set(updates, { merge: true });
+    return true;
+}
+
+module.exports = { fetchComputationStatus, updateComputationStatus };

package/functions/computation-system/topology/HashManager.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Manages code versioning, hashing, and legacy mappings.
+ */
+const crypto = require('crypto');
+
+// Legacy Keys Mapping (Ensures backward compatibility)
+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',
+    Psychometrics: 'psychometrics',
+    CognitiveBiases: 'bias',
+    SkillAttribution: 'skill',
+    ExecutionAnalytics: 'execution',
+    AdaptiveAnalytics: 'adaptive'
+};
+
+function generateCodeHash(codeString) {
+    if (!codeString) return 'unknown';
+    let clean = codeString.replace(/\/\/.*$/gm, '');
+    clean = clean.replace(/\/\*[\s\S]*?\*\//g, '');
+    clean = clean.replace(/\s+/g, '');
+    return crypto.createHash('sha256').update(clean).digest('hex');
+}
+
+module.exports = { LEGACY_MAPPING, generateCodeHash };

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

@@ -19,12 +19,34 @@ function generateCodeHash(codeString) {
     return crypto.createHash('sha256').update(clean).digest('hex');
 }
 
+/**
+ * Executes a function with exponential backoff retry logic.
+ * @param {Function} fn - Async function to execute
+ * @param {string} operationName - Label for logging
+ * @param {number} maxRetries - Max attempts (default 3)
+ */
+async function withRetry(fn, operationName, maxRetries = 3) {
+    let attempt = 0;
+    while (attempt < maxRetries) {
+        try {
+            return await fn();
+        } catch (error) {
+            attempt++;
+            console.warn(`[Retry] ${operationName} failed (Attempt ${attempt}/${maxRetries}): ${error.message}`);
+            if (attempt >= maxRetries) throw error;
+            // Exponential backoff: 1s, 2s, 4s...
+            await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, attempt - 1)));
+        }
+    }
+}
+
 /** * Stage 2: Commit a batch of writes in chunks 
  * FIXED: Now respects write.options (e.g. { merge: false }) to allow overwrites/deletes.
  */
 async function commitBatchInChunks(config, deps, writes, operationName) {
-    const { db, logger, calculationUtils } = deps;
-    const { withRetry } = calculationUtils;
+    const { db, logger } = deps;
+    // Use the local withRetry if not provided in deps
+    const retryFn = (deps.calculationUtils && deps.calculationUtils.withRetry) ? deps.calculationUtils.withRetry : withRetry;
 
     if (!writes || !writes.length) {
         logger.log('WARN', `[${operationName}] No writes to commit.`);
@@ -42,7 +64,7 @@ async function commitBatchInChunks(config, deps, writes, operationName) {
     const commitAndReset = async () => {
         if (currentOpsCount > 0) {
             try {
-                await withRetry(
+                await retryFn(
                     () => currentBatch.commit(),
                     `${operationName} (Chunk ${batchIndex})`
                 );
@@ -94,8 +116,7 @@ function getExpectedDateStrings(startDate, endDate) {
 
 /** Stage 4: Get the earliest date in a *flat* collection where doc IDs are dates. */
 async function getFirstDateFromSimpleCollection(config, deps, collectionName) {
-    const { db, logger, calculationUtils } = deps;
-    const { withRetry } = calculationUtils;
+    const { db, logger } = deps;
     try {
         if (!collectionName) { logger.log('WARN', `[Core Utils] Collection name not provided for simple date query.`); return null; }
         const query = db.collection(collectionName).where(FieldPath.documentId(), '>=', '2000-01-01').orderBy(FieldPath.documentId(), 'asc').limit(1);
@@ -107,8 +128,7 @@ async function getFirstDateFromSimpleCollection(config, deps, collectionName) {
 
 /** Stage 4: Get the earliest date in a sharded collection */
 async function getFirstDateFromCollection(config, deps, collectionName) {
-    const { db, logger, calculationUtils } = deps;
-    const { withRetry } = calculationUtils;
+    const { db, logger } = deps;
     let earliestDate = null;
     try {
         if (!collectionName) { logger.log('WARN', `[Core Utils] Collection name not provided for sharded date query.`); return null; }
@@ -165,8 +185,7 @@ async function getEarliestDataDates(config, deps) {
 }
 
 async function getFirstDateFromPriceCollection(config, deps) {
-    const { db, logger, calculationUtils } = deps;
-    const { withRetry } = calculationUtils;
+    const { db, logger } = deps;
     const collection = config.priceCollection || 'asset_prices';
     try {
         const snapshot = await withRetry(() => db.collection(collection).limit(10).get(), `GetPriceShards(${collection})`);
@@ -184,4 +203,13 @@ async function getFirstDateFromPriceCollection(config, deps) {
     } catch (e) { logger.log('ERROR', `Failed to get earliest price date from ${collection}`, { errorMessage: e.message }); return null; }
 }
 
-module.exports = { FieldValue, FieldPath, normalizeName, commitBatchInChunks, getExpectedDateStrings, getEarliestDataDates, generateCodeHash };
+module.exports = { 
+    FieldValue, 
+    FieldPath, 
+    normalizeName, 
+    commitBatchInChunks, 
+    getExpectedDateStrings, 
+    getEarliestDataDates, 
+    generateCodeHash,
+    withRetry // Exported here
+};

package/index.js

@@ -43,14 +43,19 @@ const taskEngine = {
     handleUpdate: require('./functions/task-engine/helpers/update_helpers').handleUpdate
 };
 
-// --- NEW IMPORT ---
-const { build: buildManifestFunc } = require('./functions/computation-system/helpers/computation_manifest_builder');
+// --- UPDATED IMPORT: Point to the new Context Domain ---
+const { build: buildManifestFunc } = require('./functions/computation-system/context/ManifestBuilder');
 
 // Computation System
 const computationSystem = {
-    runComputationPass: require('./functions/computation-system/helpers/computation_pass_runner').runComputationPass,
+    // UPDATED: Point to the new Workflow Orchestrator
+    runComputationPass: require('./functions/computation-system/WorkflowOrchestrator').runComputationPass,
+    
+    // These helpers wrap the Orchestrator, so they stay, but we updated their internals (see below)
     dispatchComputationPass: require('./functions/computation-system/helpers/computation_dispatcher').dispatchComputationPass,
     handleComputationTask: require('./functions/computation-system/helpers/computation_worker').handleComputationTask,
+    
+    // Utils
     dataLoader: require('./functions/computation-system/utils/data_loader'),
     computationUtils: require('./functions/computation-system/utils/utils'),
     buildManifest: buildManifestFunc

package/package.json

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

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

@@ -1,291 +0,0 @@
-/**
- * @fileoverview
- * Dynamic Manifest Builder (v6 - Merkle Tree Dependency Hashing)
- *
- * KEY FEATURES:
- * 1. Smart Layer Hashing: Detects used layers (Math, Extractors) to avoid stale helper code.
- * 2. Cascading Invalidation (Merkle Hashing): 
- * The final hash of a computation is derived from:
- * [Own Code] + [Layer States] + [Hashes of all Dependencies]
- * * This guarantees that if Calculation A is updated, Calculation B (which depends on A)
- * will automatically generate a new hash, forcing the system to re-run it.
- */
-
-const { generateCodeHash } = require('../utils/utils');
-
-// 1. Import Layers directly to generate their "State Hashes"
-const MathematicsLayer = require('../layers/mathematics');
-const ExtractorsLayer  = require('../layers/extractors');
-const ProfilingLayer   = require('../layers/profiling');
-const ValidatorsLayer  = require('../layers/validators');
-
-/* --------------------------------------------------
- * 1. Layer Hash Generation
- * -------------------------------------------------- */
-
-function generateLayerHash(layerExports, layerName) {
-    const keys = Object.keys(layerExports).sort(); 
-    let combinedSource = `LAYER:${layerName}`;
-
-    for (const key of keys) {
-        const item = layerExports[key];
-        if (typeof item === 'function')                       { combinedSource += item.toString();
-        } else if (typeof item === 'object' && item !== null) { combinedSource += JSON.stringify(item);
-        } else                                                { combinedSource += String(item); }
-    }
-    return generateCodeHash(combinedSource);
-}
-
-// Pre-compute layer hashes at startup
-const LAYER_HASHES = {
-    'mathematics': generateLayerHash(MathematicsLayer, 'mathematics'),
-    'extractors':  generateLayerHash(ExtractorsLayer,  'extractors'),
-    'profiling':   generateLayerHash(ProfilingLayer,   'profiling'),
-    'validators':  generateLayerHash(ValidatorsLayer,  'validators')
-};
-
-// Map code patterns to Layer dependencies
-const LAYER_TRIGGERS = {
-    'mathematics': [
-        'math.compute', 'MathPrimitives',
-        'math.signals', 'SignalPrimitives', 'signals.',
-        'math.aggregate', 'Aggregators',
-        'math.timeseries', 'TimeSeries', 'timeSeries.',
-        'math.distribution', 'DistributionAnalytics', 'distribution.',
-        'math.financial', 'FinancialEngineering'
-    ],
-    'extractors': [
-        'math.extract', 'DataExtractor',
-        'math.history', 'HistoryExtractor',
-        'math.prices', 'priceExtractor',
-        'math.insights', 'InsightsExtractor', 'insights.',
-        'math.tradeSeries', 'TradeSeriesBuilder'
-    ],
-    'profiling': [
-        'math.profiling', 'SCHEMAS',
-        'math.classifier', 'UserClassifier',
-        'math.psychometrics', 'Psychometrics',
-        'math.bias', 'CognitiveBiases',
-        'math.skill', 'SkillAttribution'
-    ],
-    'validators': [
-        'math.validate', 'Validators'
-    ]
-};
-
-/* --------------------------------------------------
- * Pretty Console Helpers
- * -------------------------------------------------- */
-const log = {
-    info:    (msg)   =>   console.log('ℹ︎ ' + msg),
-    step:    (msg)   =>   console.log('› ' + msg),
-    warn:    (msg)   =>   console.warn('⚠︎ ' + msg),
-    success: (msg)   =>   console.log('✔︎ ' + msg),
-    error:   (msg)   =>   console.error('✖ ' + msg),
-    fatal:   (msg)   => { console.error('✖ FATAL ✖ ' + msg); console.error('✖ FATAL ✖ Manifest build FAILED.'); },
-    divider: (label) => { const line = ''.padEnd(60, '─'); console.log(`\n${line}\n${label}\n${line}\n`); },
-};
-
-/* --------------------------------------------------
- * Helper Utilities
- * -------------------------------------------------- */
-
-const normalizeName = (name) => { if (typeof name !== 'string') return name; return name.trim().replace(/,$/, '').replace(/_/g, '-').toLowerCase(); };
-
-function suggestClosest(name, candidates, n = 3) {
-    const levenshtein = (a = '', b = '') => {
-        const m = a.length, n = b.length;
-        if (!m) return n; if (!n) return m;
-        const dp = Array.from({ length: m + 1 }, (_, i) => Array(n + 1).fill(i));
-        for (let j = 0; j <= n; j++) dp[0][j] = j;
-        for (let i = 1; i <= m; i++)
-        for (let j = 1; j <= n; j++)
-        dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : Math.min(dp[i - 1][j - 1], dp[i][j - 1], dp[i - 1][j]) + 1;
-        return dp[m][n];
-    };
-    const scores = candidates.map(c => [c, levenshtein(name, c)]);
-    scores.sort((a, b)              => a[1] - b[1]);
-    return scores.slice(0, n).map(s => s[0]);
-}
-
-function getDependencySet(endpoints, adjacencyList) {
-    const required = new Set(endpoints);
-    const queue    = [...endpoints];
-    while (queue.length > 0) { const calcName = queue.shift(); const dependencies = adjacencyList.get(calcName);
-    if (dependencies) { for (const dep of dependencies) { if (!required.has(dep)) { required.add(dep); queue.push(dep); } } } }
-    return required;
-}
-
-/* --------------------------------------------------
- * Core Manifest Builder
- * -------------------------------------------------- */
-
-function buildManifest(productLinesToRun = [], calculations) {
-    log.divider('Building Dynamic Manifest (Merkle Hashing)');
-    log.info(`Target Product Lines: [${productLinesToRun.join(', ')}]`);
-    
-    const manifestMap      = new Map();
-    const adjacency        = new Map(); 
-    const reverseAdjacency = new Map(); 
-    const inDegree         = new Map();
-    let hasFatalError      = false;
-    
-    /* ---------------- 1. Load All Calculations (Phase 1: Intrinsic Hash) ---------------- */
-    log.step('Loading and validating all calculation classes…');
-
-    function processCalc(Class, name, folderName) {
-        if (!Class || typeof Class !== 'function') return;
-        const normalizedName = normalizeName(name);
-        
-        if (typeof Class.getMetadata     !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getMetadata().`);     hasFatalError = true; return; }
-        if (typeof Class.getDependencies !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getDependencies().`); hasFatalError = true;return; }
-        
-        const metadata     = Class.getMetadata();
-        const dependencies = Class.getDependencies().map(normalizeName);
-        
-        const codeStr = Class.toString();
-        if (metadata.isHistorical === true && !codeStr.includes('yesterday') && !codeStr.includes('previousComputed')) { 
-            log.warn(`Calculation "${normalizedName}" marked 'isHistorical' but no 'previousComputed' state reference found.`); 
-        }
-
-        let finalCategory = folderName === 'core' && metadata.category ? metadata.category : folderName;
-
-        // --- PHASE 1: INTRINSIC HASH (Code + Layers) ---
-        // We do NOT include dependencies yet.
-        let compositeHashString = generateCodeHash(codeStr); 
-        const usedLayers = [];
-
-        // Check for specific layer usage
-        for (const [layerName, triggers] of Object.entries(LAYER_TRIGGERS)) {
-            if (triggers.some(trigger => codeStr.includes(trigger))) { compositeHashString += LAYER_HASHES[layerName];  usedLayers.push(layerName); }
-        }
-
-        // Safe Mode Fallback
-        let isSafeMode = false;
-        if (usedLayers.length === 0) {
-            isSafeMode = true;
-            Object.values(LAYER_HASHES).forEach(h => compositeHashString += h);
-        }
-
-        const baseHash = generateCodeHash(compositeHashString);
-
-        const manifestEntry = {
-            name: normalizedName,
-            class: Class,
-            category: finalCategory,     
-            sourcePackage: folderName,   
-            type: metadata.type,
-            isHistorical: metadata.isHistorical, 
-            rootDataDependencies: metadata.rootDataDependencies || [],
-            userType: metadata.userType,
-            dependencies: dependencies,
-            pass: 0,
-            hash: baseHash,
-            debugUsedLayers: isSafeMode ? ['ALL (Safe Mode)'] : usedLayers
-        };
-        
-        manifestMap.set(normalizedName, manifestEntry);
-        adjacency.set(normalizedName, dependencies);
-        inDegree.set(normalizedName, dependencies.length);
-        dependencies.forEach(dep => { if (!reverseAdjacency.has(dep)) reverseAdjacency.set(dep, []); reverseAdjacency.get(dep).push(normalizedName); }); 
-    }
-    
-    if (!calculations || typeof calculations !== 'object') {
-        throw new Error('Manifest build failed: Invalid calculations object.');
-    }
-
-    for (const folderName in calculations) {
-        if (folderName === 'legacy') continue;
-        const group = calculations[folderName];
-        for (const key in group) {
-            const entry = group[key];
-            if (typeof entry === 'function') { processCalc(entry, key, folderName);  } 
-        } 
-    }
-
-    if (hasFatalError) { throw new Error('Manifest build failed due to missing static methods.'); }
-    log.success(`Loaded ${manifestMap.size} calculations.`);
-
-    /* ---------------- 2. Validate Dependency Links ---------------- */
-    const allNames = new Set(manifestMap.keys());
-    let invalidLinks = false;
-    for (const [name, entry] of manifestMap) {
-        for (const dep of entry.dependencies) {
-            if (!allNames.has(dep)) {
-                invalidLinks = true;
-                const guesses = suggestClosest(dep, Array.from(allNames));
-                log.error(`${name} depends on unknown calculation "${dep}". Did you mean: ${guesses.join(', ')}?`);
-            }
-            if (dep === name) {
-                invalidLinks = true;
-                log.error(`${name} has a circular dependency on *itself*!`);
-            }
-        }
-    }
-    if (invalidLinks) { throw new Error('Manifest validation failed.'); }
-
-    /* ---------------- 3. Filter for Product Lines ---------------- */
-    const productLineEndpoints = [];
-    for (const [name, entry] of manifestMap.entries()) {  if (productLinesToRun.includes(entry.category)) { productLineEndpoints.push(name); }  }
-    for (const [name, entry] of manifestMap.entries()) {  if (entry.sourcePackage === 'core') { productLineEndpoints.push(name); }  }
-
-    const requiredCalcs = getDependencySet(productLineEndpoints, adjacency);
-    log.info(`Filtered down to ${requiredCalcs.size} active calculations.`);
-
-    const filteredManifestMap      = new Map();
-    const filteredInDegree         = new Map();
-    const filteredReverseAdjacency = new Map();
-
-    for (const name of requiredCalcs) { filteredManifestMap.set(name, manifestMap.get(name)); filteredInDegree.set(name, inDegree.get(name));
-    const consumers = (reverseAdjacency.get(name) || []).filter(consumer => requiredCalcs.has(consumer)); filteredReverseAdjacency.set(name, consumers); }
-
-    /* ---------------- 4. Topological Sort ---------------- */
-    const sortedManifest = [];
-    const queue          = [];
-    let maxPass          = 0;
-
-    for (const [name, degree] of filteredInDegree) { if (degree === 0) { queue.push(name); filteredManifestMap.get(name).pass = 1; maxPass = 1; } }
-    queue.sort();
-    while (queue.length) {
-        const currentName = queue.shift();
-        const currentEntry = filteredManifestMap.get(currentName);
-        sortedManifest.push(currentEntry);
-        
-        for (const neighborName of (filteredReverseAdjacency.get(currentName) || [])) { const newDegree = filteredInDegree.get(neighborName) - 1; filteredInDegree.set(neighborName, newDegree);
-            const neighborEntry = filteredManifestMap.get(neighborName);
-            if (neighborEntry.pass <= currentEntry.pass) { neighborEntry.pass = currentEntry.pass + 1; if (neighborEntry.pass > maxPass) maxPass = neighborEntry.pass; }
-            if (newDegree === 0) { queue.push(neighborName); } }
-        queue.sort(); }
-
-    if (sortedManifest.length !== filteredManifestMap.size) {
-        throw new Error('Circular dependency detected. Manifest build failed.'); }
-
-    /* ---------------- 5. Phase 2: Cascading Dependency Hashing ---------------- */
-    log.step('Computing Cascading Merkle Hashes...');
-
-    for (const entry of sortedManifest) {
-        // Start with the intrinsic hash (Code + Layers)
-        let dependencySignature = entry.hash;
-
-        if (entry.dependencies && entry.dependencies.length > 0) {
-            const depHashes = entry.dependencies.map(depName => { const depEntry = filteredManifestMap.get(depName); if (!depEntry) return '';  return depEntry.hash; }).join('|'); 
-            dependencySignature += `|DEPS:${depHashes}`;
-        }
-        // Generate the Final Smart Hash
-        entry.hash = generateCodeHash(dependencySignature);
-    }
-
-    log.success(`Total passes required: ${maxPass}`);
-    return sortedManifest;
-}
-
-function build(productLinesToRun, calculations) {
-    try {
-        return buildManifest(productLinesToRun, calculations);
-    } catch (error) { 
-        log.error(error.message); 
-        return null; 
-    }
-}
-
-module.exports = { build };