genesis-ai-cli 13.1.0 → 13.3.0

package/dist/src/active-inference/actions.js

@@ -290,17 +290,68 @@ registerAction('verify.ethics', async (context) => {
 });
 /**
  * execute.task: Execute the planned task
+ * v13.1: Closes the autopoietic execution loop by routing through Brain.process()
  */
+let _executeTaskDepth = 0;
+const MAX_EXECUTE_DEPTH = 2; // Prevent infinite recursion (AIF → brain → AIF → brain)
 registerAction('execute.task', async (context) => {
-    return {
-        success: true,
-        action: 'execute.task',
-        data: {
-            taskId: context.taskId,
-            result: null,
-        },
-        duration: 0,
-    };
+    const start = Date.now();
+    // Re-entrancy guard: prevent recursive brain.process() calls
+    if (_executeTaskDepth >= MAX_EXECUTE_DEPTH) {
+        return {
+            success: false,
+            action: 'execute.task',
+            error: `Execution depth limit (${MAX_EXECUTE_DEPTH}) reached — preventing recursion`,
+            duration: Date.now() - start,
+        };
+    }
+    _executeTaskDepth++;
+    try {
+        // Dynamic import to avoid circular dependency (brain → actions → brain)
+        const { getBrainInstance } = await import('../brain/index.js');
+        const brain = getBrainInstance();
+        if (!brain) {
+            return {
+                success: false,
+                action: 'execute.task',
+                error: 'Brain not initialized — cannot execute task',
+                duration: Date.now() - start,
+            };
+        }
+        const goal = context.goal || context.parameters?.goal || '';
+        if (!goal) {
+            return {
+                success: false,
+                action: 'execute.task',
+                error: 'No goal specified for task execution',
+                duration: Date.now() - start,
+            };
+        }
+        // Route through Brain's full processing pipeline (memory → LLM → tools → response)
+        const result = await brain.process(goal);
+        return {
+            success: true,
+            action: 'execute.task',
+            data: {
+                taskId: context.taskId,
+                goal,
+                result,
+                truncated: result.length > 500,
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'execute.task',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+    finally {
+        _executeTaskDepth--;
+    }
 });
 /**
  * execute.cycle: Run a processing cycle

package/dist/src/active-inference/autonomous-loop.js

@@ -575,12 +575,28 @@ class AutonomousLoop {
             const avgS = highSurprise.reduce((s, e) => s + e.surprise, 0) / highSurprise.length;
             console.log(`[AI Loop] Dream: ${highSurprise.length} experiences, avg surprise ${avgS.toFixed(2)}`);
         }
+        // v13.1: Notify FEK to enter dreaming mode (suppresses L2-L4 during consolidation)
+        try {
+            const { getFreeEnergyKernel } = require('../kernel/free-energy-kernel.js');
+            const fek = getFreeEnergyKernel();
+            if (fek?.setMode)
+                fek.setMode('dreaming');
+        }
+        catch { /* FEK may not be available */ }
         // v11.4: Delegate to DreamService for NREM/SWS/REM phases
         // DreamService handles: episodic consolidation, pattern extraction, creative synthesis
         this.dreamService.startDream({ duration: 3000 }).then(session => {
             if (this.config.verbose && session?.results) {
                 console.log(`[AI Loop] Dream complete: ${session.results.memoriesConsolidated} consolidated, ${session.results.patternsExtracted} patterns`);
             }
+            // v13.1: Restore FEK to awake mode after dream
+            try {
+                const { getFreeEnergyKernel } = require('../kernel/free-energy-kernel.js');
+                const fek = getFreeEnergyKernel();
+                if (fek?.setMode)
+                    fek.setMode('awake');
+            }
+            catch { /* non-fatal */ }
         }).catch(() => {
             // Fallback: direct 3× replay if DreamService fails
             for (let iter = 0; iter < 3; iter++) {

package/dist/src/active-inference/economic-integration.d.ts

@@ -190,6 +190,7 @@ export declare class EconomicIntegration {
 export declare function getEconomicIntegration(): EconomicIntegration;
 /**
  * Hook to record LLM costs (call this after each LLM request)
+ * v13.1: Also feeds real costs into EconomicFiber for FEK's leapfrog budget allocation
  */
 export declare function recordLLMCost(provider: string, inputTokens: number, outputTokens: number, model: string): void;
 /**

package/dist/src/active-inference/economic-integration.js

@@ -17,6 +17,7 @@ exports.getEconomicIntegration = getEconomicIntegration;
 exports.recordLLMCost = recordLLMCost;
 exports.recordRevenue = recordRevenue;
 const index_js_1 = require("../economy/index.js");
+const fiber_js_1 = require("../economy/fiber.js");
 // ============================================================================
 // Cost Tracker
 // ============================================================================
@@ -511,9 +512,32 @@ function getEconomicIntegration() {
 }
 /**
  * Hook to record LLM costs (call this after each LLM request)
+ * v13.1: Also feeds real costs into EconomicFiber for FEK's leapfrog budget allocation
  */
 function recordLLMCost(provider, inputTokens, outputTokens, model) {
-    getEconomicIntegration().getCostTracker().recordLLMCost(provider, inputTokens, outputTokens, model);
+    const tracker = getEconomicIntegration().getCostTracker();
+    tracker.recordLLMCost(provider, inputTokens, outputTokens, model);
+    // v13.1: Feed real cost into FEK's EconomicFiber (replaces synthetic $0.001/cycle)
+    // Recompute cost using same pricing as CostTracker
+    const pricing = {
+        'claude-3-opus': { input: 15, output: 75 },
+        'claude-3-sonnet': { input: 3, output: 15 },
+        'claude-3-haiku': { input: 0.25, output: 1.25 },
+        'claude-opus-4': { input: 15, output: 75 },
+        'claude-sonnet-4': { input: 3, output: 15 },
+        'gpt-4o': { input: 2.5, output: 10 },
+        'gpt-4o-mini': { input: 0.15, output: 0.6 },
+        'default': { input: 1, output: 4 },
+    };
+    const rates = pricing[model] || pricing['default'];
+    const realCost = (inputTokens / 1_000_000) * rates.input + (outputTokens / 1_000_000) * rates.output;
+    try {
+        const fiber = (0, fiber_js_1.getEconomicFiber)();
+        fiber.recordCost('llm', realCost, `${provider}:${model}`);
+    }
+    catch {
+        // Fiber may not be initialized yet during startup
+    }
 }
 /**
  * Hook to record revenue (call this when receiving payment)

package/dist/src/active-inference/observations.js

@@ -55,12 +55,26 @@ class ObservationGatherer {
         if (this.realSourcesInitialized)
             return;
         this.realSourcesInitialized = true;
-        // Wire kernel state to process metrics
+        // Wire kernel state to process metrics + FEK total free energy
+        // v13.1: Incorporates FEK's hierarchical free energy as the primary energy signal
         this.getKernelState = () => {
             const mem = process.memoryUsage();
             const heapUsedRatio = mem.heapUsed / mem.heapTotal;
-            // Energy = inverse of resource pressure (more heap used = less energy)
-            const energy = Math.max(0, Math.min(1, 1 - heapUsedRatio));
+            const heapEnergy = Math.max(0, Math.min(1, 1 - heapUsedRatio));
+            // v13.1: Blend with FEK's total free energy (low FE = high energy/viability)
+            let fekEnergy = heapEnergy;
+            try {
+                const { getFreeEnergyKernel } = require('../kernel/free-energy-kernel.js');
+                const fek = getFreeEnergyKernel();
+                if (fek) {
+                    const totalFE = fek.getTotalFE?.() ?? 0;
+                    // Map FE to energy: FE=0 → energy=1.0, FE≥5 → energy=0.0
+                    fekEnergy = Math.max(0, Math.min(1, 1 - totalFE / 5));
+                }
+            }
+            catch { /* FEK may not be initialized */ }
+            // Blend: 30% heap pressure, 70% FEK free energy
+            const energy = 0.3 * heapEnergy + 0.7 * fekEnergy;
             return {
                 energy,
                 state: 'running',

package/dist/src/brain/index.js

@@ -281,6 +281,27 @@ class Brain {
                     data: { mode, prev, kernel: 'fek' },
                     module: 'consciousness',
                 });
+                // v13.1: Close the self-modification loop — when FEK L4 requests
+                // self_improving mode, trigger the DarwinGodel improvement engine
+                if (mode === 'self_improving' && prev !== 'self_improving' && this.darwinGodel) {
+                    import('../active-inference/actions.js').then(({ executeAction }) => {
+                        executeAction('improve.self', {
+                            parameters: { autoApply: false },
+                            beliefs: { viability: 0.5, worldState: 0.5, coupling: 0.5, goalProgress: 0.5 },
+                        }).then((result) => {
+                            this.emit({
+                                type: 'module_exit',
+                                timestamp: new Date(),
+                                data: {
+                                    type: 'fek_self_improvement',
+                                    success: result.success,
+                                    opportunities: result.data?.opportunities?.length || 0,
+                                },
+                                module: 'consciousness',
+                            });
+                        }).catch(() => { });
+                    }).catch(() => { });
+                }
             });
         }
         catch {

package/dist/src/economy/assets/compute-provider.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Decentralized Compute Provider — Akash/Render/io.net
+ *
+ * Deploys Genesis as a compute provider on decentralized networks,
+ * earning revenue by selling idle compute capacity.
+ *
+ * Requirements:
+ *   - Capital: $1,000+ (staking for provider registration)
+ *   - Identity: Wallet only
+ *   - Revenue: $200-$2,000/month depending on hardware
+ *
+ * Networks:
+ *   - Akash Network: General-purpose compute ($0.05-$0.50/hr)
+ *   - Render Network: GPU rendering ($0.20-$2.00/hr)
+ *   - io.net: GPU compute for ML ($0.30-$3.00/hr)
+ *   - Flux: Decentralized cloud ($0.10-$1.00/hr)
+ *
+ * What we sell:
+ *   - Idle CPU cycles during low-activity periods
+ *   - Memory capacity for data processing jobs
+ *   - (Optional) GPU time if available
+ *
+ * Safety:
+ *   - Max 70% CPU utilization for external jobs
+ *   - Pause external work when Genesis needs resources
+ *   - Sandboxed execution (Docker containers)
+ *   - Auto-scale down under load
+ */
+export interface ComputeJob {
+    id: string;
+    network: 'akash' | 'render' | 'ionet' | 'flux';
+    type: 'cpu' | 'gpu' | 'memory' | 'storage';
+    specs: ComputeSpecs;
+    pricePerHour: number;
+    startTime: number;
+    endTime?: number;
+    status: 'pending' | 'running' | 'completed' | 'cancelled' | 'failed';
+    revenue: number;
+    resourceUsage: ResourceUsage;
+}
+export interface ComputeSpecs {
+    cpuCores: number;
+    memoryMB: number;
+    gpuCount: number;
+    storageGB: number;
+    durationHours: number;
+}
+export interface ResourceUsage {
+    cpuPercent: number;
+    memoryPercent: number;
+    gpuPercent: number;
+    networkMbps: number;
+}
+export interface ProviderRegistration {
+    network: string;
+    stakeAmount: number;
+    registered: boolean;
+    registeredAt?: number;
+    providerAddress?: string;
+}
+export interface ComputeProviderStats {
+    totalJobs: number;
+    completedJobs: number;
+    totalRevenue: number;
+    totalUptime: number;
+    averageUtilization: number;
+    activeJobs: number;
+    registeredNetworks: number;
+    totalStaked: number;
+    hourlyRate: number;
+}
+export interface ComputeProviderConfig {
+    maxCpuUtilization: number;
+    maxMemoryUtilization: number;
+    enabledNetworks: string[];
+    minPricePerHour: number;
+    maxConcurrentJobs: number;
+    autoScaleDown: boolean;
+    stakePerNetwork: number;
+}
+export declare class ComputeProvider {
+    private config;
+    private jobs;
+    private registrations;
+    private readonly fiberId;
+    private currentUsage;
+    constructor(config?: Partial<ComputeProviderConfig>);
+    /**
+     * Register as a provider on a decentralized compute network.
+     */
+    register(network: string): Promise<ProviderRegistration>;
+    /**
+     * Accept and start a compute job.
+     */
+    acceptJob(job: Omit<ComputeJob, 'id' | 'startTime' | 'status' | 'revenue' | 'resourceUsage'>): Promise<ComputeJob | null>;
+    /**
+     * Complete a running job and collect payment.
+     */
+    completeJob(jobId: string): Promise<number>;
+    /**
+     * Check for new jobs on registered networks.
+     */
+    checkForJobs(): Promise<ComputeJob[]>;
+    /**
+     * Complete all finished jobs.
+     */
+    harvestCompleted(): Promise<number>;
+    /**
+     * Get current statistics.
+     */
+    getStats(): ComputeProviderStats;
+    /**
+     * Get ROI.
+     */
+    getROI(): number;
+    /**
+     * Check if provider is operational (registered on at least one network).
+     */
+    isOperational(): boolean;
+    private hasCapacity;
+    private getAvailableSpecs;
+    private updateUsage;
+}
+export declare function getComputeProvider(config?: Partial<ComputeProviderConfig>): ComputeProvider;
+export declare function resetComputeProvider(): void;

package/dist/src/economy/assets/compute-provider.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * Decentralized Compute Provider — Akash/Render/io.net
+ *
+ * Deploys Genesis as a compute provider on decentralized networks,
+ * earning revenue by selling idle compute capacity.
+ *
+ * Requirements:
+ *   - Capital: $1,000+ (staking for provider registration)
+ *   - Identity: Wallet only
+ *   - Revenue: $200-$2,000/month depending on hardware
+ *
+ * Networks:
+ *   - Akash Network: General-purpose compute ($0.05-$0.50/hr)
+ *   - Render Network: GPU rendering ($0.20-$2.00/hr)
+ *   - io.net: GPU compute for ML ($0.30-$3.00/hr)
+ *   - Flux: Decentralized cloud ($0.10-$1.00/hr)
+ *
+ * What we sell:
+ *   - Idle CPU cycles during low-activity periods
+ *   - Memory capacity for data processing jobs
+ *   - (Optional) GPU time if available
+ *
+ * Safety:
+ *   - Max 70% CPU utilization for external jobs
+ *   - Pause external work when Genesis needs resources
+ *   - Sandboxed execution (Docker containers)
+ *   - Auto-scale down under load
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComputeProvider = void 0;
+exports.getComputeProvider = getComputeProvider;
+exports.resetComputeProvider = resetComputeProvider;
+const index_js_1 = require("../../mcp/index.js");
+const fiber_js_1 = require("../fiber.js");
+// ============================================================================
+// Compute Provider
+// ============================================================================
+class ComputeProvider {
+    config;
+    jobs = new Map();
+    registrations = new Map();
+    fiberId = 'compute-provider';
+    currentUsage = { cpuPercent: 0, memoryPercent: 0, gpuPercent: 0, networkMbps: 0 };
+    constructor(config) {
+        this.config = {
+            maxCpuUtilization: config?.maxCpuUtilization ?? 0.7,
+            maxMemoryUtilization: config?.maxMemoryUtilization ?? 0.6,
+            enabledNetworks: config?.enabledNetworks ?? ['akash', 'flux'],
+            minPricePerHour: config?.minPricePerHour ?? 0.05,
+            maxConcurrentJobs: config?.maxConcurrentJobs ?? 5,
+            autoScaleDown: config?.autoScaleDown ?? true,
+            stakePerNetwork: config?.stakePerNetwork ?? 500,
+        };
+        (0, fiber_js_1.getEconomicFiber)().registerModule(this.fiberId);
+    }
+    /**
+     * Register as a provider on a decentralized compute network.
+     */
+    async register(network) {
+        const fiber = (0, fiber_js_1.getEconomicFiber)();
+        const existing = this.registrations.get(network);
+        if (existing?.registered)
+            return existing;
+        try {
+            const client = (0, index_js_1.getMCPClient)();
+            const result = await client.call('coinbase', 'register_compute_provider', {
+                network,
+                stake: this.config.stakePerNetwork,
+                specs: this.getAvailableSpecs(),
+            });
+            const reg = {
+                network,
+                stakeAmount: this.config.stakePerNetwork,
+                registered: result.success ?? false,
+                registeredAt: result.success ? Date.now() : undefined,
+                providerAddress: result.data?.address,
+            };
+            if (reg.registered) {
+                fiber.recordCost(this.fiberId, this.config.stakePerNetwork, `stake:${network}`);
+            }
+            this.registrations.set(network, reg);
+            return reg;
+        }
+        catch {
+            const reg = {
+                network,
+                stakeAmount: this.config.stakePerNetwork,
+                registered: false,
+            };
+            this.registrations.set(network, reg);
+            return reg;
+        }
+    }
+    /**
+     * Accept and start a compute job.
+     */
+    async acceptJob(job) {
+        // Check capacity
+        const activeJobs = [...this.jobs.values()].filter(j => j.status === 'running');
+        if (activeJobs.length >= this.config.maxConcurrentJobs)
+            return null;
+        // Check price
+        if (job.pricePerHour < this.config.minPricePerHour)
+            return null;
+        // Check resource availability
+        if (!this.hasCapacity(job.specs))
+            return null;
+        const computeJob = {
+            ...job,
+            id: `job-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            startTime: Date.now(),
+            status: 'running',
+            revenue: 0,
+            resourceUsage: { cpuPercent: 0, memoryPercent: 0, gpuPercent: 0, networkMbps: 0 },
+        };
+        this.jobs.set(computeJob.id, computeJob);
+        this.updateUsage();
+        return computeJob;
+    }
+    /**
+     * Complete a running job and collect payment.
+     */
+    async completeJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job || job.status !== 'running')
+            return 0;
+        const fiber = (0, fiber_js_1.getEconomicFiber)();
+        const hoursRun = (Date.now() - job.startTime) / 3600000;
+        const revenue = hoursRun * job.pricePerHour;
+        job.status = 'completed';
+        job.endTime = Date.now();
+        job.revenue = revenue;
+        fiber.recordRevenue(this.fiberId, revenue, `compute:${job.network}:${job.type}`);
+        this.updateUsage();
+        return revenue;
+    }
+    /**
+     * Check for new jobs on registered networks.
+     */
+    async checkForJobs() {
+        const accepted = [];
+        for (const [network, reg] of this.registrations) {
+            if (!reg.registered)
+                continue;
+            try {
+                const client = (0, index_js_1.getMCPClient)();
+                const result = await client.call('coinbase', 'check_compute_jobs', {
+                    network,
+                    providerAddress: reg.providerAddress,
+                    availableSpecs: this.getAvailableSpecs(),
+                });
+                if (result.success && Array.isArray(result.data?.jobs)) {
+                    for (const j of result.data.jobs) {
+                        const job = await this.acceptJob({
+                            network: network,
+                            type: j.type ?? 'cpu',
+                            specs: {
+                                cpuCores: j.cpuCores ?? 1,
+                                memoryMB: j.memoryMB ?? 512,
+                                gpuCount: j.gpuCount ?? 0,
+                                storageGB: j.storageGB ?? 10,
+                                durationHours: j.durationHours ?? 1,
+                            },
+                            pricePerHour: j.pricePerHour ?? 0.10,
+                        });
+                        if (job)
+                            accepted.push(job);
+                    }
+                }
+            }
+            catch {
+                // Network unavailable
+            }
+        }
+        return accepted;
+    }
+    /**
+     * Complete all finished jobs.
+     */
+    async harvestCompleted() {
+        let totalRevenue = 0;
+        for (const [, job] of this.jobs) {
+            if (job.status !== 'running')
+                continue;
+            const hoursRun = (Date.now() - job.startTime) / 3600000;
+            if (hoursRun >= job.specs.durationHours) {
+                const revenue = await this.completeJob(job.id);
+                totalRevenue += revenue;
+            }
+        }
+        return totalRevenue;
+    }
+    /**
+     * Get current statistics.
+     */
+    getStats() {
+        const completed = [...this.jobs.values()].filter(j => j.status === 'completed');
+        const active = [...this.jobs.values()].filter(j => j.status === 'running');
+        const registered = [...this.registrations.values()].filter(r => r.registered);
+        const totalUptime = completed.reduce((s, j) => {
+            const hours = ((j.endTime ?? Date.now()) - j.startTime) / 3600000;
+            return s + hours;
+        }, 0);
+        return {
+            totalJobs: this.jobs.size,
+            completedJobs: completed.length,
+            totalRevenue: completed.reduce((s, j) => s + j.revenue, 0),
+            totalUptime,
+            averageUtilization: this.currentUsage.cpuPercent,
+            activeJobs: active.length,
+            registeredNetworks: registered.length,
+            totalStaked: registered.reduce((s, r) => s + r.stakeAmount, 0),
+            hourlyRate: totalUptime > 0
+                ? completed.reduce((s, j) => s + j.revenue, 0) / totalUptime
+                : 0,
+        };
+    }
+    /**
+     * Get ROI.
+     */
+    getROI() {
+        const fiber = (0, fiber_js_1.getEconomicFiber)().getFiber(this.fiberId);
+        return fiber?.roi ?? 0;
+    }
+    /**
+     * Check if provider is operational (registered on at least one network).
+     */
+    isOperational() {
+        return [...this.registrations.values()].some(r => r.registered);
+    }
+    // ============================================================================
+    // Private
+    // ============================================================================
+    hasCapacity(specs) {
+        const availCpu = (this.config.maxCpuUtilization - this.currentUsage.cpuPercent) * 100;
+        const availMem = (this.config.maxMemoryUtilization - this.currentUsage.memoryPercent) * 100;
+        return specs.cpuCores <= availCpu / 25 && specs.memoryMB <= (availMem / 100) * 16384;
+    }
+    getAvailableSpecs() {
+        return {
+            cpuCores: Math.floor((this.config.maxCpuUtilization - this.currentUsage.cpuPercent) * 8),
+            memoryMB: Math.floor((this.config.maxMemoryUtilization - this.currentUsage.memoryPercent) * 16384),
+            gpuCount: 0,
+            storageGB: 50,
+            durationHours: 24,
+        };
+    }
+    updateUsage() {
+        const active = [...this.jobs.values()].filter(j => j.status === 'running');
+        const totalCpuDemand = active.reduce((s, j) => s + j.specs.cpuCores * 0.125, 0); // 8 cores = 100%
+        const totalMemDemand = active.reduce((s, j) => s + j.specs.memoryMB / 16384, 0);
+        this.currentUsage = {
+            cpuPercent: Math.min(1, totalCpuDemand),
+            memoryPercent: Math.min(1, totalMemDemand),
+            gpuPercent: 0,
+            networkMbps: active.length * 10,
+        };
+    }
+}
+exports.ComputeProvider = ComputeProvider;
+// ============================================================================
+// Singleton
+// ============================================================================
+let providerInstance = null;
+function getComputeProvider(config) {
+    if (!providerInstance) {
+        providerInstance = new ComputeProvider(config);
+    }
+    return providerInstance;
+}
+function resetComputeProvider() {
+    providerInstance = null;
+}

package/dist/src/economy/assets/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Assets — Passive Revenue Generators
+ *
+ * Capital-deployed assets that earn yield with minimal active management.
+ */
+export { YieldOptimizer, getYieldOptimizer, resetYieldOptimizer } from './yield-optimizer.js';
+export type { YieldPosition, YieldOpportunity, YieldOptimizerStats, YieldOptimizerConfig } from './yield-optimizer.js';
+export { ComputeProvider, getComputeProvider, resetComputeProvider } from './compute-provider.js';
+export type { ComputeJob, ComputeSpecs, ComputeProviderStats, ComputeProviderConfig } from './compute-provider.js';

package/dist/src/economy/assets/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Assets — Passive Revenue Generators
+ *
+ * Capital-deployed assets that earn yield with minimal active management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetComputeProvider = exports.getComputeProvider = exports.ComputeProvider = exports.resetYieldOptimizer = exports.getYieldOptimizer = exports.YieldOptimizer = void 0;
+var yield_optimizer_js_1 = require("./yield-optimizer.js");
+Object.defineProperty(exports, "YieldOptimizer", { enumerable: true, get: function () { return yield_optimizer_js_1.YieldOptimizer; } });
+Object.defineProperty(exports, "getYieldOptimizer", { enumerable: true, get: function () { return yield_optimizer_js_1.getYieldOptimizer; } });
+Object.defineProperty(exports, "resetYieldOptimizer", { enumerable: true, get: function () { return yield_optimizer_js_1.resetYieldOptimizer; } });
+var compute_provider_js_1 = require("./compute-provider.js");
+Object.defineProperty(exports, "ComputeProvider", { enumerable: true, get: function () { return compute_provider_js_1.ComputeProvider; } });
+Object.defineProperty(exports, "getComputeProvider", { enumerable: true, get: function () { return compute_provider_js_1.getComputeProvider; } });
+Object.defineProperty(exports, "resetComputeProvider", { enumerable: true, get: function () { return compute_provider_js_1.resetComputeProvider; } });