bulltrackers-module 1.0.732 → 1.0.733

package/functions/computation-system/scripts/UpdateContracts.js

@@ -1,128 +0,0 @@
-/**
- * @fileoverview Discovery Script: UpdateContracts.js
- * Runs offline simulations to "learn" the behavioral contracts of all calculations.
- * Saves these contracts to Firestore for the Runtime Enforcer (ResultCommitter) to use.
- * * USAGE: 
- * node computation-system/scripts/UpdateContracts.js [--calc=CalcName]
- */
-
-const path = require('path');
-const admin = require('firebase-admin');
-
-// Initialize Firebase (Standard Env Check)
-if (!admin.apps.length) {
-    if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
-        admin.initializeApp();
-    } else {
-        // Fallback for local dev if key path isn't set in env
-        console.warn("⚠️ No GOOGLE_APPLICATION_CREDENTIALS. Attempting default init...");
-        admin.initializeApp();
-    }
-}
-
-const db = admin.firestore();
-const { StructuredLogger } = require('../logger/logger');
-const { getManifest } = require('../topology/ManifestLoader');
-const ContractDiscoverer = require('../tools/ContractDiscoverer');
-
-// Load Calculations Package
-let calculationPackage;
-try {
-    // Adjust path if necessary for your local monorepo structure
-    calculationPackage = require('aiden-shared-calculations-unified');
-} catch (e) {
-    console.error("FATAL: Could not load 'aiden-shared-calculations-unified'. Ensure you are in the correct directory or npm link is active.");
-    process.exit(1);
-}
-
-const CONTRACTS_COLLECTION = 'system_contracts';
-
-async function main() {
-    const logger = new StructuredLogger({ enableConsole: true });
-    
-    // 1. Setup Dependencies
-    // The ManifestLoader and Discoverer need a mock dependency object
-    const mockDeps = {
-        db,
-        logger,
-        // Mock specific utils if needed by your calculations during instantiation
-        calculationUtils: {
-            loadInstrumentMappings: async () => ({ instrumentToTicker: {}, tickerToInstrument: {} })
-        }
-    };
-
-    console.log("🚀 Starting Contract Discovery...");
-
-    // 2. Load Manifest
-    const calculations = calculationPackage.calculations;
-    const manifest = getManifest([], calculations, mockDeps);
-    const manifestMap = new Map(manifest.map(c => [c.name, c]));
-
-    console.log(`ℹ️ Loaded manifest with ${manifest.length} calculations.`);
-
-    // 3. Filter Target (Optional CLI Arg)
-    const targetArg = process.argv.find(a => a.startsWith('--calc='));
-    const targetName = targetArg ? targetArg.split('=')[1] : null;
-
-    let calcsToProcess = manifest;
-    if (targetName) {
-        calcsToProcess = manifest.filter(c => c.name.toLowerCase() === targetName.toLowerCase());
-        if (calcsToProcess.length === 0) {
-            console.error(`❌ Calculation '${targetName}' not found.`);
-            process.exit(1);
-        }
-    }
-
-    // 4. Run Discovery Loop
-    let successCount = 0;
-    let skipCount = 0;
-
-    for (const calc of calcsToProcess) {
-        // Skip computations that don't produce data (like aggregators without schema)
-        if (!calc.class.getSchema && !calc.dependencies) {
-            console.log(`⏭️ Skipping ${calc.name} (No schema/outputs to analyze).`);
-            skipCount++;
-            continue;
-        }
-
-        try {
-            // A. Discover Contract via Simulation
-            // We run 50 iterations to get a statistically significant sample
-            const contract = await ContractDiscoverer.generateContract(calc, manifestMap, 50);
-
-            if (contract) {
-                // B. Enrich with Metadata
-                // FIX: Create a NEW object to satisfy Type Checking (avoid mutating the inferred shape)
-                const finalContract = {
-                    ...contract,
-                    lastUpdated: new Date(),
-                    generatedBy: 'UpdateContracts.js',
-                    version: '1.0'
-                };
-
-                // C. Save to Firestore
-                // Use finalContract instead of contract
-                await db.collection(CONTRACTS_COLLECTION).doc(calc.name).set(finalContract);
-                console.log(`✅ [SAVED] Contract for ${calc.name}`);
-                successCount++;
-            } else {
-                console.warn(`⚠️ [EMPTY] No contract generated for ${calc.name} (Insufficient data/samples).`);
-                skipCount++;
-            }
-
-        } catch (err) {
-            console.error(`❌ [ERROR] Failed to generate contract for ${calc.name}:`, err.message);
-        }
-    }
-
-    console.log("\n============================================");
-    console.log(`🎉 Discovery Complete.`);
-    console.log(`   Updated: ${successCount}`);
-    console.log(`   Skipped: ${skipCount}`);
-    console.log("============================================");
-}
-
-main().catch(err => {
-    console.error("FATAL SCRIPT ERROR:", err);
-    process.exit(1);
-});

package/functions/computation-system/services/SnapshotService.js

@@ -1,148 +0,0 @@
-/**
- * @fileoverview Snapshot Service.
- * Creates a complete "Frozen State" of the day's data in GCS.
- * UPDATED: Now snapshots ALL data types (Ratings, Verification, Metadata, etc).
- */
-const zlib = require('zlib');
-const { Storage } = require('@google-cloud/storage');
-const storage = new Storage();
-const dataLoader = require('../utils/data_loader');
-
-async function generateDailySnapshots(dateStr, config, deps) {
-    const { logger } = deps;
-    const bucketName = config.gcsBucketName || 'bulltrackers';
-    const bucket = storage.bucket(bucketName);
-
-    // Quick check: if all main snapshots exist, skip entirely
-    const mainFiles = [
-        `${dateStr}/snapshots/portfolios.json.gz`,
-        `${dateStr}/snapshots/social.json.gz`,
-        `${dateStr}/snapshots/history.jsonl.gz`,
-        `${dateStr}/snapshots/ratings.json.gz`,
-        `${dateStr}/snapshots/rankings.json.gz`
-    ];
-    
-    if (!config.forceSnapshot) {
-        const existenceChecks = await Promise.all(mainFiles.map(path => bucket.file(path).exists()));
-        const allExist = existenceChecks.every(([exists]) => exists);
-        
-        if (allExist) {
-            logger.log('INFO', `[SnapshotService] ⏭️  All snapshots already exist for ${dateStr}, skipping`);
-            return { status: 'SKIPPED', date: dateStr, reason: 'all_exist' };
-        }
-    }
-
-    logger.log('INFO', `[SnapshotService] 📸 Starting Full System Snapshot for ${dateStr}`);
-
-    // parallelize independent fetches
-    await Promise.all([
-        snapshotPortfolios(dateStr, bucket, config, deps),  // Heavy
-        snapshotSocial(dateStr, bucket, config, deps),      // Heavy
-        snapshotHistory(dateStr, bucket, config, deps),     // Heavy (JSONL)
-        snapshotRatings(dateStr, bucket, config, deps),     // Sharded
-        snapshotVerification(dateStr, bucket, config, deps),// Collection Group
-        snapshotRankings(dateStr, bucket, config, deps),    // Single Doc
-        snapshotMetadata(dateStr, bucket, config, deps)     // Small Docs (Insights, Alerts, Watchlist)
-    ]);
-
-    logger.log('INFO', `[SnapshotService] ✅ Full System Snapshot Complete for ${dateStr}`);
-    return { status: 'OK', date: dateStr };
-}
-
-// --- HEAVY DATA HANDLERS (As before) ---
-
-async function snapshotPortfolios(dateStr, bucket, config, deps) {
-    const file = bucket.file(`${dateStr}/snapshots/portfolios.json.gz`);
-    if ((await file.exists())[0] && !config.forceSnapshot) return;
-
-    // Fetch ALL types (PI + SignedIn) to ensure complete context
-    const refs = await dataLoader.getPortfolioPartRefs(config, deps, dateStr, ['ALL']);
-    const data = await dataLoader.loadDataByRefs(config, deps, refs);
-    if (Object.keys(data).length > 0) {
-        await file.save(JSON.stringify(data), { gzip: true });
-        deps.logger.log('INFO', `[Snapshot] Saved ${Object.keys(data).length} portfolios.`);
-    }
-}
-
-async function snapshotSocial(dateStr, bucket, config, deps) {
-    const file = bucket.file(`${dateStr}/snapshots/social.json.gz`);
-    if ((await file.exists())[0] && !config.forceSnapshot) return;
-
-    const data = await dataLoader.loadDailySocialPostInsights(config, deps, dateStr);
-    await file.save(JSON.stringify(data), { gzip: true });
-    deps.logger.log('INFO', `[Snapshot] Saved Social Data.`);
-}
-
-async function snapshotHistory(dateStr, bucket, config, deps) {
-    const file = bucket.file(`${dateStr}/snapshots/history.jsonl.gz`);
-    if ((await file.exists())[0] && !config.forceSnapshot) return;
-
-    const refs = await dataLoader.getHistoryPartRefs(config, deps, dateStr, ['ALL']);
-    const gcsStream = file.createWriteStream({ gzip: true });
-
-    // Stream line-by-line
-    const BATCH_SIZE = 10;
-    for (let i = 0; i < refs.length; i += BATCH_SIZE) {
-        const batchRefs = refs.slice(i, i + BATCH_SIZE);
-        const dataMap = await dataLoader.loadDataByRefs(config, deps, batchRefs);
-        let chunk = '';
-        for (const [uid, h] of Object.entries(dataMap)) chunk += JSON.stringify({ [uid]: h }) + '\n';
-        if (!gcsStream.write(chunk)) await new Promise(r => gcsStream.once('drain', r));
-    }
-    gcsStream.end();
-    await new Promise((resolve, reject) => { gcsStream.on('finish', resolve); gcsStream.on('error', reject); });
-    deps.logger.log('INFO', `[Snapshot] Saved History (JSONL).`);
-}
-
-// --- NEW HANDLERS (The "All Data" Expansion) ---
-
-async function snapshotRatings(dateStr, bucket, config, deps) {
-    const file = bucket.file(`${dateStr}/snapshots/ratings.json.gz`);
-    if ((await file.exists())[0] && !config.forceSnapshot) return;
-
-    // Load RAW ratings from Firestore shards
-    const data = await dataLoader.loadPIRatings(config, deps, dateStr);
-    await file.save(JSON.stringify(data), { gzip: true });
-    deps.logger.log('INFO', `[Snapshot] Saved Ratings for ${Object.keys(data).length} PIs.`);
-}
-
-async function snapshotVerification(dateStr, bucket, config, deps) {
-    const file = bucket.file(`${dateStr}/snapshots/verification.json.gz`);
-    if ((await file.exists())[0] && !config.forceSnapshot) return;
-
-    // Load global verification profiles (expensive scan)
-    const data = await dataLoader.loadVerificationProfiles(config, deps);
-    await file.save(JSON.stringify(data), { gzip: true });
-    deps.logger.log('INFO', `[Snapshot] Saved ${Object.keys(data).length} Verification Profiles.`);
-}
-
-async function snapshotRankings(dateStr, bucket, config, deps) {
-    const file = bucket.file(`${dateStr}/snapshots/rankings.json.gz`);
-    if ((await file.exists())[0] && !config.forceSnapshot) return;
-
-    const data = await dataLoader.loadPopularInvestorRankings(config, deps, dateStr);
-    if (data) await file.save(JSON.stringify(data), { gzip: true });
-    deps.logger.log('INFO', `[Snapshot] Saved Rankings.`);
-}
-
-async function snapshotMetadata(dateStr, bucket, config, deps) {
-    // Bundle small files into one "metadata.json" or keep separate. Separate is safer for loaders.
-    const ops = [
-        { name: 'insights',    fn: () => dataLoader.loadDailyInsights(config, deps, dateStr) },
-        { name: 'page_views',  fn: () => dataLoader.loadPIPageViews(config, deps, dateStr) },
-        { name: 'watchlist',   fn: () => dataLoader.loadWatchlistMembership(config, deps, dateStr) },
-        { name: 'alerts',      fn: () => dataLoader.loadPIAlertHistory(config, deps, dateStr) },
-        { name: 'master_list', fn: () => dataLoader.loadPopularInvestorMasterList(config, deps) } // Not date bound usually, but good to snapshot state
-    ];
-
-    for (const op of ops) {
-        const file = bucket.file(`${dateStr}/snapshots/${op.name}.json.gz`);
-        if ((await file.exists())[0] && !config.forceSnapshot) continue;
-        
-        const data = await op.fn();
-        if (data) await file.save(JSON.stringify(data), { gzip: true });
-    }
-    deps.logger.log('INFO', `[Snapshot] Saved Metadata files.`);
-}
-
-module.exports = { generateDailySnapshots };

package/functions/computation-system/simulation/Fabricator.js

@@ -1,285 +0,0 @@
-/**
- * @fileoverview Generates deterministic mock contexts for Simulation Hashing.
- * STRICTLY ALIGNED WITH SCHEMA.MD (Production V2 Schemas).
- * UPGRADED: Supports Iteration (Seed Rotation) and Volume Scaling for Arrays.
- */
-const SeededRandom = require('./SeededRandom');
-const { ContextFactory } = require('../context/ContextFactory');
-
-const FAKE_SECTORS = ['Technology', 'Healthcare', 'Financials', 'Energy', 'Crypto', 'Consumer Discretionary'];
-const FAKE_TICKERS = ['AAPL', 'GOOGL', 'MSFT', 'TSLA', 'AMZN', 'BTC', 'ETH', 'NVDA', 'META', 'AMD'];
-const FAKE_TOPICS  = ['AI', 'Earnings', 'Fed', 'Crypto', 'Macro'];
-
-class Fabricator {
-    constructor(calcName) {
-        this.baseSeed = calcName;
-        // Primary RNG for high-level structure
-        this.rng = new SeededRandom(calcName);
-    }
-
-    /**
-     * Generates a context for a specific user iteration.
-     * @param {number} iteration - The index of the user in the batch (0, 1, 2...).
-     */
-    async generateContext(calcManifest, dependenciesManifest, iteration = 0) {
-        // [CRITICAL] Rotate the RNG state based on iteration so User 1 != User 2
-        this.rng = new SeededRandom(`${this.baseSeed}_ITER_${iteration}`);
-
-        const FIXED_DATE = '2025-01-01'; // Fixed simulation date
-
-        // 1. Generate Root Data
-        const user = this._generateUser(calcManifest.userType, iteration);
-        const insights = this._generateInsights(FIXED_DATE);
-        
-        // 2. Generate Mock Dependencies (The "Schema Faking" Part)
-        const computed = {};
-        if (calcManifest.dependencies) {
-            for (const depName of calcManifest.dependencies) {
-                const depEntry = dependenciesManifest.get(depName);
-                if (depEntry && depEntry.class && depEntry.class.getSchema) {
-                    const schema = depEntry.class.getSchema();
-                    // [VOLUME UPGRADE] Dependencies usually represent aggregate data.
-                    computed[depName] = this._fakeFromSchema(schema, true); 
-                } else {
-                    computed[depName] = {};
-                }
-            }
-        }
-        
-        return ContextFactory.buildPerUserContext({
-            userId: user.id,
-            userType: user.type,
-            dateStr: FIXED_DATE,
-            todayPortfolio: user.portfolio.today,
-            yesterdayPortfolio: user.portfolio.yesterday,
-            todayHistory: user.history.today,
-            yesterdayHistory: user.history.yesterday,
-            metadata: calcManifest,
-            mappings: {
-                instrumentToTicker: this._generateMappings(),
-                instrumentToSector: this._generateSectorMappings()
-            },
-            insights: { today: insights },
-            socialData: { today: this._generateSocial(FIXED_DATE) },
-            computedDependencies: computed,
-            config: {},
-            deps: { logger: { log: () => {} } } 
-        });
-    }
-
-    // --- Schema Faker Logic (Unchanged) ---
-    _fakeFromSchema(schema, isHighVolume = false) {
-        if (!schema) return {};
-        if (schema.type === 'object') {
-            const obj = {};
-            if (schema.properties) {
-                for (const [key, propSchema] of Object.entries(schema.properties)) {
-                    obj[key] = this._fakeFromSchema(propSchema, isHighVolume);
-                }
-            }
-            if (schema.patternProperties) {
-                const count = isHighVolume ? this.rng.range(20, 50) : 3;
-                const propSchema = Object.values(schema.patternProperties)[0];
-                for (let i = 0; i < count; i++) {
-                    // Use deterministic ticker keys for stability
-                    const key = `${this.rng.choice(FAKE_TICKERS)}`; 
-                    // Note: In real scenarios tickers are unique, so we might need a suffix if count > tickers.length
-                    const safeKey = count > FAKE_TICKERS.length ? `${key}_${i}` : key;
-                    obj[safeKey] = this._fakeFromSchema(propSchema, isHighVolume);
-                }
-            }
-            return obj;
-        }
-        if (schema.type === 'array') {
-            const min = isHighVolume ? 50 : 1;
-            const max = isHighVolume ? 150 : 5;
-            const len = this.rng.range(min, max);
-            return Array.from({ length: len }, () => this._fakeFromSchema(schema.items, isHighVolume));
-        }
-        if (schema.type === 'number') return parseFloat(this.rng.next().toFixed(4)) * 100;
-        if (schema.type === 'string') return "SIMULATED_STRING";
-        if (schema.type === 'boolean') return this.rng.bool();
-        return null;
-    }
-
-    // --- PROD ALIGNED GENERATORS ---
-    
-    _generateUser(type, iteration) {
-        const userId = 1000000 + iteration; // Numeric ID to match Schema
-        const isSpeculator = (type === 'speculator');
-        
-        return {
-            id: String(userId),
-            type: type || 'all',
-            portfolio: {
-                today: isSpeculator     ? this._genSpecPortfolio(userId) : this._genNormalPortfolio(userId),
-                yesterday: isSpeculator ? this._genSpecPortfolio(userId) : this._genNormalPortfolio(userId)
-            },
-            history: {
-                today:     { PublicHistoryPositions: this._genHistoryTrades(userId) },
-                yesterday: { PublicHistoryPositions: this._genHistoryTrades(userId) }
-            }
-        };
-    }
-
-    // Schema 2: Speculator User Portfolio
-    _genSpecPortfolio(userId) {
-        const invested = this.rng.range(5000, 50000);
-        const netProfit = this.rng.range(-20, 30);
-        const equity = invested * (1 + (netProfit / 100));
-
-        return {
-            AverageOpen: this.rng.range(100, 3000),
-            Equity: parseFloat(equity.toFixed(4)),
-            Invested: parseFloat(invested.toFixed(4)),
-            NetProfit: parseFloat(netProfit.toFixed(4)),
-            PublicPositions: Array.from({ length: this.rng.range(2, 10) }, (_, i) => {
-                const openRate = this.rng.range(50, 500);
-                const isBuy = this.rng.bool();
-                return {
-                    Amount: parseFloat(this.rng.range(100, 1000).toFixed(4)),
-                    CID: userId,
-                    CurrentRate: parseFloat((openRate * (1 + (this.rng.next() - 0.5) * 0.1)).toFixed(2)),
-                    InstrumentID: 100 + (i % 20),
-                    IsBuy: isBuy,
-                    IsTslEnabled: this.rng.bool(0.1),
-                    Leverage: this.rng.choice([1, 2, 5, 10, 20]),
-                    MirrorID: 0,
-                    NetProfit: parseFloat(this.rng.range(-50, 50).toFixed(4)),
-                    OpenDateTime: '2024-12-01T10:00:00Z',
-                    OpenRate: parseFloat(openRate.toFixed(2)),
-                    ParentPositionID: 0,
-                    PipDifference: this.rng.range(-100, 100),
-                    PositionID: 3000000000 + i,
-                    StopLossRate: 0.01,
-                    TakeProfitRate: 0
-                };
-            })
-        };
-    }
-
-    // Schema 1: Normal User Portfolio
-    _genNormalPortfolio(userId) {
-        const positions = Array.from({ length: this.rng.range(3, 12) }, (_, i) => ({
-            Direction: "Buy",
-            InstrumentID: 100 + (i % 20),
-            Invested: parseFloat(this.rng.range(5, 20).toFixed(4)), // Percent
-            NetProfit: parseFloat(this.rng.range(-30, 40).toFixed(4)),
-            Value: parseFloat(this.rng.range(5, 25).toFixed(4)) // Percent (Invested + PnL approx)
-        }));
-
-        // [CRITICAL] DataExtractor.getPortfolioDailyPnl uses AggregatedPositionsByInstrumentTypeID
-        // We must generate this aggregation or PnL calcs return 0.
-        const aggByType = positions.map(p => ({
-            Direction: p.Direction,
-            InstrumentTypeID: 5, // Stock
-            Invested: p.Invested,
-            NetProfit: p.NetProfit,
-            Value: p.Value
-        }));
-
-        return {
-            AggregatedMirrors: [],
-            AggregatedPositions: positions,
-            AggregatedPositionsByInstrumentTypeID: aggByType, // Required for PnL
-            AggregatedPositionsByStockIndustryID: [],
-            CreditByRealizedEquity: 0,
-            CreditByUnrealizedEquity: 0
-        };
-    }
-
-    // Schema 3: Trade History
-    _genHistoryTrades(userId) {
-        return Array.from({ length: this.rng.range(5, 30) }, (_, i) => ({
-            PositionID: 4000000000 + i,
-            CID: userId,
-            OpenDateTime: '2024-12-01T10:00:00Z',
-            OpenRate: 100.50,
-            InstrumentID: 100 + (i % 20),
-            IsBuy: this.rng.bool(),
-            MirrorID: 0,
-            ParentPositionID: 0,
-            CloseDateTime: '2024-12-02T10:00:00Z',
-            CloseRate: 110.20,
-            CloseReason: this.rng.choice([1, 5, 0]), // 1=SL, 5=TP, 0=Manual
-            ParentCID: userId,
-            NetProfit: parseFloat(this.rng.range(-50, 50).toFixed(4)),
-            Leverage: this.rng.choice([1, 2, 5])
-        }));
-    }
-
-    // Schema 5: Insights
-    // [CRITICAL FIX] Must return object { fetchedAt, insights: [] }, not just array.
-    _generateInsights(dateStr) { 
-        const insightsArray = Array.from({ length: 50 }, (_, i) => ({
-            instrumentId: 100 + i,
-            total: this.rng.range(100, 50000), // Total owners
-            percentage: this.rng.next() * 0.05, // % of brokerage
-            growth: parseFloat((this.rng.next() * 10 - 5).toFixed(4)),
-            buy: this.rng.range(20, 95),
-            sell: 0, // Will calculate below
-            prevBuy: this.rng.range(20, 95),
-            prevSell: 0
-        }));
-
-        // Fix sell/prevSell math
-        insightsArray.forEach(i => {
-            i.sell = 100 - i.buy;
-            i.prevSell = 100 - i.prevBuy;
-        });
-
-        return {
-            fetchedAt: `${dateStr}T12:00:00Z`,
-            insights: insightsArray
-        };
-    }
-    
-    // Schema 4: Social Post Data
-    // Returns Map: { "postId": { ... } }
-    _generateSocial(dateStr) { 
-        const posts = {};
-        const count = this.rng.range(5, 20);
-        
-        for(let i=0; i<count; i++) {
-            const id = `post_${i}_${this.rng.next().toString(36).substring(7)}`;
-            const ticker = this.rng.choice(FAKE_TICKERS);
-            
-            posts[id] = {
-                commentCount: this.rng.range(0, 50),
-                createdAt: `${dateStr}T09:00:00Z`,
-                fetchedAt: `${dateStr}T10:00:00Z`,
-                fullText: `$${ticker} is looking bullish today!`,
-                language: 'en-gb',
-                likeCount: this.rng.range(0, 200),
-                postOwnerId: String(this.rng.range(100000, 999999)),
-                sentiment: {
-                    overallSentiment: this.rng.choice(['Bullish', 'Bearish', 'Neutral']),
-                    topics: [this.rng.choice(FAKE_TOPICS)]
-                },
-                textSnippet: `$${ticker} is looking...`,
-                tickers: [ticker]
-            };
-        }
-        return posts;
-    }
-    
-    _generateMappings() {
-        const map = {};
-        // Map ID 100-150 to FAKE_TICKERS deterministically
-        for(let i=0; i<50; i++) {
-            // cycle through tickers
-            map[100+i] = FAKE_TICKERS[i % FAKE_TICKERS.length];
-        }
-        return map;
-    }
-    
-    _generateSectorMappings() {
-        const map = {};
-        for(let i=0; i<50; i++) {
-            map[100+i] = FAKE_SECTORS[i % FAKE_SECTORS.length];
-        }
-        return map;
-    }
-}
-
-module.exports = Fabricator;

package/functions/computation-system/simulation/SeededRandom.js

@@ -1,41 +0,0 @@
-/**
- * @fileoverview Deterministic Pseudo-Random Number Generator (LCG).
- * Ensures that for a given seed, the sequence of numbers is identical across runs.
- */
-class SeededRandom {
-    constructor(seedString) {
-        this.state = this._stringToSeed(seedString);
-    }
-
-    _stringToSeed(str) {
-        let h = 2166136261 >>> 0;
-        for (let i = 0; i < str.length; i++) {
-            h = Math.imul(h ^ str.charCodeAt(i), 16777619);
-        }
-        return h >>> 0;
-    }
-
-    /** Returns a float between 0 and 1 */
-    next() {
-        this.state = (Math.imul(48271, this.state) % 2147483647);
-        return (this.state - 1) / 2147483646;
-    }
-
-    /** Returns an integer between min and max (inclusive) */
-    range(min, max) {
-        return Math.floor(this.next() * (max - min + 1)) + min;
-    }
-
-    /** Returns a random element from an array */
-    choice(arr) {
-        if (!arr || arr.length === 0) return null;
-        return arr[this.range(0, arr.length - 1)];
-    }
-
-    /** Returns a boolean based on probability */
-    bool(probability = 0.5) {
-        return this.next() < probability;
-    }
-}
-
-module.exports = SeededRandom;

package/functions/computation-system/simulation/SimRunner.js

@@ -1,51 +0,0 @@
-/**
- * @fileoverview Runner for Behavioral Hashing (SimHash).
- * Executes a calculation against a fabricated, deterministic context.
- */
-const Fabricator = require('./Fabricator');
-const { generateDataHash } = require('../utils/utils');
-
-class SimRunner {
-    /**
-     * Runs the simulation for a specific calculation.
-     * @param {Object} calcManifest - The manifest entry for the calculation.
-     * @param {Map} fullManifestMap - Map of all manifests (to look up dependencies).
-     * @returns {Promise<string>} The SimHash (SHA256 of the output).
-     */
-    static async run(calcManifest, fullManifestMap) {
-        try {
-            const fabricator = new Fabricator(calcManifest.name);
-            
-            // 1. Generate Deterministic Context
-            const context = await fabricator.generateContext(calcManifest, fullManifestMap);
-            
-            // 2. Instantiate
-            const instance = new calcManifest.class();
-            
-            // 3. Process
-            await instance.process(context);
-            
-            // 4. Get Result
-            // Note: If the calculation uses internal state buffering (like `results` property),
-            // getResult() usually returns that.
-            let result = null;
-            if (instance.getResult) {
-                result = await instance.getResult();
-            } else {
-                result = instance.result || instance.results || {};
-            }
-
-            // 5. Sanitize & Hash
-            // We strip any non-deterministic keys if they leak (like timestamps generated inside process)
-            // But ideally, the context mocking prevents this.
-            return generateDataHash(result);
-
-        } catch (e) {
-            console.error(`[SimRunner] Simulation failed for ${calcManifest.name}:`, e);
-            // If simulation crashes, we return a hash of the error to safely trigger a re-run
-            return generateDataHash({ error: e.message });
-        }
-    }
-}
-
-module.exports = SimRunner;

package/functions/computation-system/system_epoch.js

@@ -1,2 +0,0 @@
-// Change this string to force a global re-computation
-module.exports = "v2.0-epoch-8";