agentic-qe 3.7.21 → 3.8.0

package/dist/integrations/ruvector/sona-persistence.js

@@ -63,6 +63,25 @@ export const SONA_PATTERNS_SCHEMA = `
   CREATE INDEX IF NOT EXISTS idx_sona_patterns_confidence ON sona_patterns(confidence DESC);
   CREATE INDEX IF NOT EXISTS idx_sona_patterns_updated ON sona_patterns(updated_at DESC);
 `;
+/**
+ * SONA Fisher matrices table schema - stores EWC++ state per domain
+ */
+export const SONA_FISHER_SCHEMA = `
+  -- SONA Fisher Information Matrices (Task 2.2: EWC++ Persistence)
+  CREATE TABLE IF NOT EXISTS sona_fisher_matrices (
+    domain TEXT PRIMARY KEY,
+    fisher_diagonal BLOB NOT NULL,
+    optimal_params BLOB NOT NULL,
+    base_weights BLOB,
+    dimension INTEGER NOT NULL,
+    task_boundaries INTEGER NOT NULL DEFAULT 0,
+    consolidation_cycles INTEGER NOT NULL DEFAULT 0,
+    request_count INTEGER NOT NULL DEFAULT 0,
+    ewc_lambda REAL NOT NULL DEFAULT 1000.0,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  );
+`;
 /**
  * Default persistent SONA configuration
  */
@@ -140,6 +159,36 @@ export class PersistentSONAEngine {
             if (this.config.loadOnInit) {
                 await this.loadPatterns();
             }
+            // Wire three-loop engine with Fisher persistence when feature flag is on
+            const { isSONAThreeLoopEnabled } = await import('./feature-flags.js');
+            if (isSONAThreeLoopEnabled()) {
+                this.baseEngine.initThreeLoopEngine();
+                // Wire Fisher persistence: consolidation auto-saves to SQLite
+                this.baseEngine.setFisherPersistence((domain, fisher, optimal, base, meta) => {
+                    this.saveFisherMatrix(domain, fisher, optimal, base, meta);
+                }, this.config.domain);
+                // Restore Fisher state from SQLite if available
+                const saved = this.loadFisherMatrix(this.config.domain);
+                if (saved) {
+                    const engine = this.baseEngine.getThreeLoopEngine();
+                    if (engine) {
+                        engine.restoreFisher({
+                            fisherDiagonal: saved.fisherDiagonal,
+                            optimalParams: saved.optimalParams,
+                            baseWeights: saved.baseWeights,
+                            requestCount: saved.requestCount,
+                        });
+                        logger.info('Three-loop engine restored Fisher state from SQLite', {
+                            domain: this.config.domain,
+                            requestCount: saved.requestCount,
+                            taskBoundaries: saved.taskBoundaries,
+                        });
+                    }
+                }
+                logger.info('Three-loop engine initialized with Fisher persistence', {
+                    domain: this.config.domain,
+                });
+            }
             this.initialized = true;
             console.log(`[PersistentSONAEngine] Initialized: domain=${this.config.domain}`);
         }
@@ -160,6 +209,12 @@ export class PersistentSONAEngine {
             console.log('[PersistentSONAEngine] Creating sona_patterns table');
             this.db.exec(SONA_PATTERNS_SCHEMA);
         }
+        // Check if Fisher matrices table exists
+        const fisherTableExists = this.db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='sona_fisher_matrices'`).get();
+        if (!fisherTableExists) {
+            console.log('[PersistentSONAEngine] Creating sona_fisher_matrices table');
+            this.db.exec(SONA_FISHER_SCHEMA);
+        }
     }
     /**
      * Prepare commonly used statements
@@ -245,6 +300,26 @@ export class PersistentSONAEngine {
         DELETE FROM sona_patterns
         WHERE updated_at < datetime('now', '-' || ? || ' days')
       `));
+        // Fisher matrix statements (Task 2.2: EWC++ Persistence)
+        this.prepared.set('upsertFisher', this.db.prepare(`
+        INSERT INTO sona_fisher_matrices (
+          domain, fisher_diagonal, optimal_params, base_weights,
+          dimension, task_boundaries, consolidation_cycles,
+          request_count, ewc_lambda, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+        ON CONFLICT(domain) DO UPDATE SET
+          fisher_diagonal = excluded.fisher_diagonal,
+          optimal_params = excluded.optimal_params,
+          base_weights = excluded.base_weights,
+          dimension = excluded.dimension,
+          task_boundaries = excluded.task_boundaries,
+          consolidation_cycles = excluded.consolidation_cycles,
+          request_count = excluded.request_count,
+          ewc_lambda = excluded.ewc_lambda,
+          updated_at = datetime('now')
+      `));
+        this.prepared.set('getFisher', this.db.prepare(`SELECT * FROM sona_fisher_matrices WHERE domain = ?`));
+        this.prepared.set('deleteFisher', this.db.prepare(`DELETE FROM sona_fisher_matrices WHERE domain = ?`));
     }
     /**
      * Load patterns from SQLite into base engine
@@ -644,6 +719,72 @@ export class PersistentSONAEngine {
         console.log(`[PersistentSONAEngine] Closed: domain=${this.config.domain}`);
     }
     // ==========================================================================
+    // Fisher Matrix Persistence (Task 2.2: EWC++)
+    // ==========================================================================
+    /**
+     * Save Fisher Information Matrix and optimal parameters to SQLite.
+     *
+     * Persists the EWC++ state for a domain so it survives across sessions.
+     * This includes the Fisher diagonal, optimal parameters, base weights,
+     * and metadata about task boundaries and consolidation cycles.
+     *
+     * @param domain - Domain identifier for the Fisher state
+     * @param fisherDiagonal - Fisher Information Matrix diagonal
+     * @param optimalParams - Optimal parameters at last task boundary
+     * @param baseWeights - Current base weights (optional)
+     * @param metadata - Additional metadata (task boundaries, cycles, etc.)
+     */
+    saveFisherMatrix(domain, fisherDiagonal, optimalParams, baseWeights, metadata) {
+        this.ensureInitialized();
+        const stmt = this.prepared.get('upsertFisher');
+        if (!stmt)
+            throw new Error('Fisher upsert statement not prepared');
+        const fisherBuf = this.float32ToBuffer(fisherDiagonal);
+        const optimalBuf = this.float32ToBuffer(optimalParams);
+        const baseBuf = baseWeights ? this.float32ToBuffer(baseWeights) : null;
+        stmt.run(domain, fisherBuf, optimalBuf, baseBuf, fisherDiagonal.length, metadata?.taskBoundaries ?? 0, metadata?.consolidationCycles ?? 0, metadata?.requestCount ?? 0, metadata?.ewcLambda ?? 1000.0);
+        logger.info('Fisher matrix saved', { domain, dimension: fisherDiagonal.length });
+    }
+    /**
+     * Load Fisher Information Matrix and optimal parameters from SQLite.
+     *
+     * @param domain - Domain identifier to load Fisher state for
+     * @returns Fisher state or null if not found
+     */
+    loadFisherMatrix(domain) {
+        this.ensureInitialized();
+        const stmt = this.prepared.get('getFisher');
+        if (!stmt)
+            throw new Error('Fisher get statement not prepared');
+        const row = stmt.get(domain);
+        if (!row)
+            return null;
+        return {
+            fisherDiagonal: this.bufferToFloat32(row.fisher_diagonal),
+            optimalParams: this.bufferToFloat32(row.optimal_params),
+            baseWeights: row.base_weights ? this.bufferToFloat32(row.base_weights) : null,
+            dimension: row.dimension,
+            taskBoundaries: row.task_boundaries,
+            consolidationCycles: row.consolidation_cycles,
+            requestCount: row.request_count,
+            ewcLambda: row.ewc_lambda,
+        };
+    }
+    /**
+     * Delete Fisher matrix for a domain.
+     *
+     * @param domain - Domain identifier
+     * @returns true if a row was deleted
+     */
+    deleteFisherMatrix(domain) {
+        this.ensureInitialized();
+        const stmt = this.prepared.get('deleteFisher');
+        if (!stmt)
+            throw new Error('Fisher delete statement not prepared');
+        const result = stmt.run(domain);
+        return result.changes > 0;
+    }
+    // ==========================================================================
     // Server Integration
     // ==========================================================================
     /**
@@ -849,6 +990,27 @@ export class PersistentSONAEngine {
         }
         return arr;
     }
+    /**
+     * Convert Float32Array to Buffer (for Fisher matrix persistence)
+     */
+    float32ToBuffer(arr) {
+        const buffer = Buffer.alloc(arr.length * 4);
+        for (let i = 0; i < arr.length; i++) {
+            buffer.writeFloatLE(arr[i], i * 4);
+        }
+        return buffer;
+    }
+    /**
+     * Convert Buffer to Float32Array (for Fisher matrix loading)
+     */
+    bufferToFloat32(buffer) {
+        const count = buffer.length / 4;
+        const arr = new Float32Array(count);
+        for (let i = 0; i < count; i++) {
+            arr[i] = buffer.readFloatLE(i * 4);
+        }
+        return arr;
+    }
 }
 // ============================================================================
 // Factory Functions

package/dist/integrations/ruvector/sona-three-loop.d.ts

@@ -0,0 +1,392 @@
+/**
+ * SONA Three-Loop Coordination Engine
+ *
+ * Implements the three-loop architecture for continuous neural adaptation:
+ *
+ * 1. **Instant Loop** - Per-request MicroLoRA adaptation (<100us)
+ *    Applies rank-1 weight updates for real-time personalization.
+ *
+ * 2. **Background Loop** - Periodic consolidation (every N requests)
+ *    Merges instant adaptations into base model, runs EWC++ to prevent
+ *    catastrophic forgetting, and updates the Fisher Information Matrix.
+ *
+ * 3. **Coordination Loop** - Cross-agent state synchronization
+ *    Shares learned patterns across agent instances and manages
+ *    domain-specific adaptation state.
+ *
+ * @module integrations/ruvector/sona-three-loop
+ */
+/**
+ * Minimal interface for @ruvector/sona SonaEngine (NAPI).
+ * Used for optional delegation when the native engine is injected.
+ */
+interface INativeSonaEngine {
+    applyMicroLora(features: number[]): number[];
+    forceLearn(): string;
+    tick(): string | null;
+    beginTrajectory(stateEmbedding: number[]): number;
+    addTrajectoryStep(trajectoryId: number, actionEmbedding: number[], attentionWeights: number[], reward: number): void;
+    endTrajectory(trajectoryId: number, quality: number): void;
+}
+/** Reset WASM loader state (for testing) */
+export declare function resetWasmLoraLoader(): void;
+/** Result from an instant MicroLoRA adaptation */
+export interface AdaptationResult {
+    /** Adapted output weights */
+    adaptedWeights: Float32Array;
+    /** Time taken in microseconds */
+    latencyUs: number;
+    /** Whether the adaptation was applied (vs skipped) */
+    applied: boolean;
+    /** Adaptation magnitude (L2 norm of delta) */
+    magnitude: number;
+    /** Request counter at time of adaptation */
+    requestIndex: number;
+}
+/** Result from a background consolidation cycle */
+export interface ConsolidationResult {
+    /** Whether consolidation was performed */
+    consolidated: boolean;
+    /** Number of instant adaptations merged */
+    adaptationsMerged: number;
+    /** EWC++ regularization loss before consolidation */
+    ewcLossBefore: number;
+    /** EWC++ regularization loss after consolidation */
+    ewcLossAfter: number;
+    /** Whether a new task boundary was detected */
+    taskBoundaryDetected: boolean;
+    /** Duration of consolidation in milliseconds */
+    durationMs: number;
+}
+/** Peer state for cross-agent synchronization */
+export interface PeerState {
+    /** Unique peer identifier */
+    peerId: string;
+    /** Domain the peer operates in */
+    domain: string;
+    /** Peer's current adaptation vector */
+    adaptationVector: Float32Array;
+    /** Peer's Fisher diagonal (importance weights) */
+    fisherDiagonal: Float32Array;
+    /** Number of requests processed by peer */
+    requestCount: number;
+    /** Timestamp of last update */
+    lastUpdateMs: number;
+}
+/** EWC++ metrics for monitoring */
+export interface EWCMetrics {
+    /** Current EWC++ regularization loss */
+    regularizationLoss: number;
+    /** Number of task boundaries detected */
+    taskBoundariesDetected: number;
+    /** Fisher Information Matrix trace (sum of diagonal) */
+    fisherTrace: number;
+    /** Average Fisher diagonal value */
+    avgFisherImportance: number;
+    /** Maximum Fisher diagonal value */
+    maxFisherImportance: number;
+    /** Number of parameters protected above threshold */
+    protectedParams: number;
+    /** Total consolidation cycles completed */
+    consolidationCycles: number;
+    /** EWC lambda (regularization strength) */
+    lambda: number;
+}
+/** Configuration for the three-loop engine */
+export interface ThreeLoopConfig {
+    /** Dimension of the adaptation/weight space */
+    dimension: number;
+    /** MicroLoRA learning rate for instant adaptations */
+    microLoraLr: number;
+    /** Number of requests between background consolidation cycles */
+    consolidationInterval: number;
+    /** EWC++ regularization strength (lambda) */
+    ewcLambda: number;
+    /** Z-score threshold for task boundary detection */
+    taskBoundaryZScoreThreshold: number;
+    /** Decay factor for blending old/new Fisher estimates */
+    fisherDecay: number;
+    /** Number of gradient samples for Fisher estimation */
+    fisherSampleSize: number;
+    /** Importance threshold below which params are not protected */
+    importanceThreshold: number;
+}
+/** Default three-loop configuration */
+export declare const DEFAULT_THREE_LOOP_CONFIG: ThreeLoopConfig;
+/**
+ * Micro-Linear Adaptation (element-wise) for per-request weight updates.
+ *
+ * Applies W' = W + alpha * features element-wise.
+ * Not a true rank-1 outer product LoRA — for that, use native @ruvector/sona.
+ *
+ * This is intentionally lightweight for real-time use (<100us).
+ */
+export declare class MicroLoRA {
+    /** Current rank-1 adaptation delta accumulated across requests */
+    adaptationVector: Float32Array;
+    /** Base weights (updated by background consolidation) */
+    baseWeights: Float32Array;
+    /** Learning rate for instant adaptation */
+    private readonly lr;
+    /** Count of adaptations applied since last consolidation */
+    private adaptationCount;
+    constructor(dimension: number, lr?: number);
+    /**
+     * Apply rank-1 instant adaptation to produce adapted weights.
+     *
+     * @param features - Input features for the current request
+     * @returns Adapted weights = baseWeights + adaptationVector + lr * features
+     */
+    adapt(features: number[]): Float32Array;
+    /**
+     * Merge accumulated adaptations into base weights and reset delta.
+     * Called by the background loop during consolidation.
+     *
+     * @returns Number of adaptations that were merged
+     */
+    consolidate(): number;
+    /** Get the number of adaptations since last consolidation */
+    getAdaptationCount(): number;
+    /** Get the current effective weights (base + delta) */
+    getEffectiveWeights(): Float32Array;
+    /** Get the L2 norm of the adaptation delta */
+    getAdaptationMagnitude(): number;
+    /** Reset adaptation state without affecting base weights */
+    resetAdaptation(): void;
+}
+/**
+ * EWC++ for preventing catastrophic forgetting across task boundaries.
+ *
+ * Maintains a diagonal Fisher Information Matrix that captures parameter
+ * importance. When a new task boundary is detected (via gradient z-score),
+ * the Fisher matrix is updated using online blending:
+ *   F_new = decay * F_old + (1 - decay) * F_current
+ *
+ * The EWC loss penalizes deviation from optimal parameters:
+ *   L_EWC = (lambda/2) * sum(F_i * (theta_i - theta*_i)^2)
+ */
+export declare class EWCPlusPlus {
+    /** Diagonal Fisher Information Matrix (importance weights) */
+    fisherMatrix: Float32Array;
+    /** Optimal parameters at last task boundary */
+    optimalParams: Float32Array;
+    /** Regularization strength */
+    private readonly lambda;
+    /** Decay for blending old/new Fisher estimates */
+    private readonly fisherDecay;
+    /** Z-score threshold for task boundary detection */
+    private readonly zScoreThreshold;
+    /** Importance threshold for parameter protection */
+    private readonly importanceThreshold;
+    /** Running statistics for gradient magnitudes */
+    private gradientHistory;
+    private gradientMean;
+    private gradientVariance;
+    /** Number of task boundaries detected */
+    private taskBoundaryCount;
+    /** Number of consolidation cycles */
+    private consolidationCount;
+    constructor(dimension: number, lambda?: number, fisherDecay?: number, zScoreThreshold?: number, importanceThreshold?: number);
+    /**
+     * Detect whether a task boundary has occurred based on the z-score
+     * of the gradient magnitude change.
+     *
+     * A sudden spike in gradient magnitude signals a distribution shift,
+     * indicating we have moved to a new task.
+     *
+     * @param gradients - Current gradient vector
+     * @returns true if a task boundary is detected
+     */
+    detectTaskBoundary(gradients: Float32Array): boolean;
+    /**
+     * Compute EWC++ regularization loss for current parameters.
+     *
+     * L_EWC = (lambda/2) * sum(F_i * (theta_i - theta*_i)^2)
+     *
+     * @param currentParams - Current model parameters
+     * @returns Scalar regularization loss
+     */
+    computeLoss(currentParams: Float32Array): number;
+    /**
+     * Update the Fisher Information Matrix using online EWC++ blending.
+     *
+     * F_new = decay * F_old + (1 - decay) * F_sample
+     *
+     * The sample Fisher is approximated from squared gradients.
+     *
+     * Gradient samples should be outcome-weighted (REINFORCE-style), not raw
+     * request features. Call recordOutcome() to generate proper gradient proxies.
+     *
+     * @param gradientSamples - Array of gradient vectors to estimate Fisher
+     * @param currentParams - Current parameters to snapshot as optimal
+     */
+    updateFisher(gradientSamples: Float32Array[], currentParams: Float32Array): void;
+    /** Get metrics for monitoring */
+    getMetrics(): EWCMetrics;
+    /** Get the number of task boundaries detected */
+    getTaskBoundaryCount(): number;
+    /** Get the Fisher diagonal as a copy */
+    getFisherDiagonal(): Float32Array;
+    /** Get the optimal parameters as a copy */
+    getOptimalParams(): Float32Array;
+    /** Load Fisher matrix from persisted data */
+    loadFisher(fisher: Float32Array, optimal: Float32Array): void;
+    /** Update running gradient statistics (Welford's algorithm) */
+    private updateGradientStats;
+}
+/**
+ * Three-loop coordination engine for SONA neural adaptation.
+ *
+ * Combines MicroLoRA instant adaptation, EWC++ background consolidation,
+ * and cross-agent coordination into a unified engine.
+ */
+export declare class SONAThreeLoopEngine {
+    private readonly config;
+    private readonly microLora;
+    private readonly ewc;
+    private readonly nativeEngine;
+    private wasmLora;
+    private requestCount;
+    private lastConsolidationRequest;
+    private peerStates;
+    private gradientBuffer;
+    private lastFeatures;
+    constructor(config?: Partial<ThreeLoopConfig>, nativeEngine?: INativeSonaEngine | null);
+    /**
+     * Perform instant per-request MicroLoRA adaptation.
+     *
+     * This is the hot path and must complete in <100us.
+     * When a native @ruvector/sona engine is available, delegates to the
+     * Rust implementation for true rank-1 LoRA. Otherwise falls back to
+     * the TypeScript element-wise approximation.
+     *
+     * @param requestFeatures - Feature vector for the current request
+     * @returns Adaptation result with adapted weights and timing
+     */
+    instantAdapt(requestFeatures: number[]): AdaptationResult;
+    /**
+     * Record the outcome of a request for REINFORCE-style gradient estimation.
+     * Must be called after instantAdapt() with the reward signal.
+     *
+     * Computes gradient proxy: reward * last_features (REINFORCE estimator)
+     * This is what gets buffered for Fisher estimation, NOT raw features.
+     *
+     * @param reward - Scalar reward (e.g., 1.0 for success, -1.0 for failure, 0.0 for neutral)
+     * @param requestIndex - The requestIndex from the AdaptationResult (for matching)
+     */
+    recordOutcome(reward: number, requestIndex?: number): void;
+    /**
+     * Run background consolidation cycle.
+     *
+     * This merges accumulated MicroLoRA adaptations into base weights,
+     * checks for task boundaries, and runs EWC++ if a boundary is detected.
+     * When a native @ruvector/sona engine is available, also triggers
+     * native background learning via forceLearn() and tick().
+     * Should be called periodically (every N requests via shouldConsolidate()).
+     *
+     * @returns Consolidation result with metrics
+     */
+    backgroundConsolidate(): ConsolidationResult;
+    /**
+     * Check if background consolidation is due.
+     */
+    shouldConsolidate(): boolean;
+    /**
+     * Synchronize state with peer agents.
+     *
+     * Merges peer adaptation vectors using Fisher-weighted averaging:
+     * For each parameter, the peer with higher Fisher importance has
+     * more influence on the merged value.
+     *
+     * @param peerStates - Array of peer states to synchronize with
+     */
+    syncWithPeers(peerStates: PeerState[]): void;
+    /**
+     * Get our current state for sharing with peers.
+     */
+    getLocalPeerState(peerId: string, domain: string): PeerState;
+    /**
+     * Get EWC++ metrics for monitoring and diagnostics.
+     */
+    getEWCMetrics(): EWCMetrics;
+    /**
+     * Get the Fisher diagonal for persistence.
+     */
+    getFisherDiagonal(): Float32Array;
+    /**
+     * Get the optimal parameters for persistence.
+     */
+    getOptimalParams(): Float32Array;
+    /**
+     * Load persisted Fisher matrix and optimal parameters.
+     */
+    loadFisher(fisher: Float32Array, optimalParams: Float32Array): void;
+    /**
+     * Get the current base weights from MicroLoRA.
+     */
+    getBaseWeights(): Float32Array;
+    /**
+     * Set base weights (e.g., from persistence).
+     */
+    setBaseWeights(weights: Float32Array): void;
+    /**
+     * Get the effective weights (base + adaptation delta).
+     */
+    getEffectiveWeights(): Float32Array;
+    /** Get the total number of requests processed */
+    getRequestCount(): number;
+    /** Get the engine configuration */
+    getConfig(): ThreeLoopConfig;
+    /** Get the connected peer states */
+    getPeerStates(): Map<string, PeerState>;
+    /** Get direct access to internal MicroLoRA (for testing) */
+    getMicroLoRA(): MicroLoRA;
+    /** Get direct access to internal EWC++ (for testing) */
+    getEWC(): EWCPlusPlus;
+    /**
+     * Apply EWC++ regularization to pull weights toward optimal.
+     *
+     * For parameters with high Fisher importance, nudge the current
+     * weights back toward the optimal values to prevent forgetting.
+     */
+    private applyEWCRegularization;
+    /**
+     * Persist Fisher matrix, optimal parameters, and base weights to SQLite
+     * via PersistentSONAEngine.saveFisherMatrix().
+     *
+     * Call this after backgroundConsolidate() to ensure EWC++ state survives
+     * across sessions. Typically called at session end or after N consolidations.
+     *
+     * @param persistFn - Callback that receives data and writes to SQLite.
+     *   Typically `(domain, fisher, optimal, base, meta) => persistentEngine.saveFisherMatrix(...)`.
+     * @param domain - Domain identifier for the Fisher state
+     */
+    persistFisher(persistFn: (domain: string, fisherDiagonal: Float32Array, optimalParams: Float32Array, baseWeights: Float32Array, metadata: {
+        taskBoundaries: number;
+        consolidationCycles: number;
+        requestCount: number;
+        ewcLambda: number;
+    }) => void, domain: string): void;
+    /**
+     * Restore Fisher matrix, optimal parameters, and base weights from SQLite.
+     *
+     * Call this on engine startup to restore EWC++ state from a previous session.
+     *
+     * @param data - Persisted data from PersistentSONAEngine.loadFisherMatrix()
+     */
+    restoreFisher(data: {
+        fisherDiagonal: Float32Array;
+        optimalParams: Float32Array;
+        baseWeights: Float32Array | null;
+        requestCount: number;
+    }): void;
+}
+/**
+ * Create a SONA Three-Loop Engine with the given configuration.
+ *
+ * @param config - Optional three-loop configuration overrides
+ * @param nativeEngine - Optional @ruvector/sona SonaEngine for native delegation
+ */
+export declare function createSONAThreeLoopEngine(config?: Partial<ThreeLoopConfig>, nativeEngine?: INativeSonaEngine | null): SONAThreeLoopEngine;
+export {};
+//# sourceMappingURL=sona-three-loop.d.ts.map