kynjal-cli 3.1.3 → 4.0.0

package/dist/src/services/ruvector-training.js

@@ -13,122 +13,376 @@
  *
  * Created with ❤️ by ruv.io
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+/**
+ * ESM/CJS interop helper — handles `.default` for CJS modules.
+ * Uses `'default' in mod` check which is safer than `mod.default || mod`.
+ */
+function importWithInterop(packageName) {
+    return __awaiter(this, void 0, Promise, function () {
+        var mod;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, import(packageName)];
+                case 1:
+                    mod = _a.sent();
+                    return [2 /*return*/, ('default' in mod) ? mod["default"] : mod];
+            }
+        });
+    });
+}
 // Lazy-loaded WASM modules
-let microLoRA = null;
-let scopedLoRA = null;
-let trajectoryBuffer = null;
-let flashAttention = null;
-let moeAttention = null;
-let hyperbolicAttention = null;
-let optimizer = null;
-let contrastiveLoss = null;
-let curriculum = null;
-let hardMiner = null;
+var microLoRA = null;
+var scopedLoRA = null;
+var trajectoryBuffer = null;
+var flashAttention = null;
+var moeAttention = null;
+var hyperbolicAttention = null;
+var optimizer = null;
+var contrastiveLoss = null;
+var curriculum = null;
+var hardMiner = null;
 // SONA engine (optional enhancement)
-let sonaEngine = null;
-let sonaAvailable = false;
+var sonaEngine = null;
+var sonaAvailable = false;
 // Training state
-let initialized = false;
-let totalAdaptations = 0;
-let totalForwards = 0;
-let totalSonaLearns = 0;
-let totalSonaSearches = 0;
-let lastBenchmark = null;
+var initialized = false;
+var totalAdaptations = 0;
+var totalForwards = 0;
+var totalSonaLearns = 0;
+var totalSonaSearches = 0;
+var lastBenchmark = null;
+// Backend tracking
+var activeBackend = 'js-fallback';
 /**
- * Initialize the RuVector training system
+ * Get which backend is active for training
  */
-export async function initializeTraining(config = {}) {
-    const features = [];
-    const dim = Math.min(config.dim || 256, 256); // Max 256 for WASM
-    const lr = config.learningRate || 0.01;
-    const alpha = config.alpha || 0.1;
-    try {
-        // Initialize MicroLoRA with direct WASM loading (Node.js compatible)
-        const fs = await import('fs');
-        const { createRequire } = await import('module');
-        const require = createRequire(import.meta.url);
-        // Load WASM file directly instead of using fetch
-        const wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
-        const wasmBuffer = fs.readFileSync(wasmPath);
-        const learningWasm = await import('@ruvector/learning-wasm');
-        learningWasm.initSync({ module: wasmBuffer });
-        microLoRA = new learningWasm.WasmMicroLoRA(dim, alpha, lr);
-        features.push(`MicroLoRA (${dim}-dim, <1μs adaptation)`);
-        // Initialize ScopedLoRA for per-operator learning
-        scopedLoRA = new learningWasm.WasmScopedLoRA(dim, alpha, lr);
-        scopedLoRA.set_category_fallback(true);
-        features.push('ScopedLoRA (17 operators)');
-        // Initialize trajectory buffer
-        trajectoryBuffer = new learningWasm.WasmTrajectoryBuffer(config.trajectoryCapacity || 10000, dim);
-        features.push('TrajectoryBuffer');
-        // Initialize attention mechanisms
-        const attention = await import('@ruvector/attention');
-        if (config.useFlashAttention !== false) {
-            flashAttention = new attention.FlashAttention(dim, 64);
-            features.push('FlashAttention');
+export function getActiveBackend() {
+    return activeBackend;
+}
+/**
+ * Pure-JS fallback implementations for when WASM is unavailable.
+ * These provide the same API surface with basic linear algebra.
+ */
+var JsMicroLoRA = /** @class */ (function () {
+    function JsMicroLoRA(dim, alpha, lr) {
+        this._adaptCount = 0n;
+        this._forwardCount = 0n;
+        this._deltaNorm = 0;
+        this.RANK = 2;
+        this._dim = dim;
+        this._alpha = alpha;
+        this._lr = lr;
+        this._A = new Float32Array(this.RANK * dim);
+        this._B = new Float32Array(dim * this.RANK);
+        // Xavier initialization
+        var scale = Math.sqrt(2 / (dim + this.RANK));
+        for (var i = 0; i < this._A.length; i++)
+            this._A[i] = (Math.random() - 0.5) * scale;
+        for (var i = 0; i < this._B.length; i++)
+            this._B[i] = (Math.random() - 0.5) * scale;
+    }
+    JsMicroLoRA.prototype.adapt_array = function (gradient) {
+        // Simple gradient update on low-rank matrices
+        var norm = 0;
+        for (var i = 0; i < Math.min(gradient.length, this._A.length); i++) {
+            var delta = -this._lr * gradient[i % gradient.length] * this._alpha;
+            this._A[i] += delta;
+            norm += delta * delta;
         }
-        if (config.useMoE) {
-            moeAttention = attention.MoEAttention.simple(dim, 8, 2);
-            features.push('MoE (8 experts, top-2)');
+        this._deltaNorm = Math.sqrt(norm);
+        this._adaptCount++;
+    };
+    JsMicroLoRA.prototype.adapt_count = function () { return this._adaptCount; };
+    JsMicroLoRA.prototype.param_count = function () { return this._A.length + this._B.length; };
+    JsMicroLoRA.prototype.forward_array = function (input) {
+        var output = new Float32Array(this._dim);
+        // y = x + alpha * B @ A @ x  (simplified low-rank)
+        for (var i = 0; i < this._dim; i++) {
+            output[i] = input[i];
+            var sum = 0;
+            for (var r = 0; r < this.RANK; r++) {
+                var dot = 0;
+                for (var j = 0; j < this._dim; j++) {
+                    dot += this._A[r * this._dim + j] * input[j];
+                }
+                sum += this._B[i * this.RANK + r] * dot;
+            }
+            output[i] += this._alpha * sum;
         }
-        if (config.useHyperbolic) {
-            hyperbolicAttention = new attention.HyperbolicAttention(dim, 1.0);
-            features.push('HyperbolicAttention');
+        this._forwardCount++;
+        return output;
+    };
+    JsMicroLoRA.prototype.forward_count = function () { return this._forwardCount; };
+    JsMicroLoRA.prototype.adapt_with_reward = function (improvement) {
+        var scale = improvement * this._lr * this._alpha;
+        var norm = 0;
+        for (var i = 0; i < this._A.length; i++) {
+            var delta = scale * (Math.random() - 0.5);
+            this._A[i] += delta;
+            norm += delta * delta;
         }
-        // Initialize optimizer and loss
-        optimizer = new attention.AdamWOptimizer(lr, 0.9, 0.999, 1e-8, 0.01);
-        features.push('AdamW Optimizer');
-        contrastiveLoss = new attention.InfoNceLoss(0.07);
-        features.push('InfoNCE Loss');
-        // Curriculum scheduler
-        if (config.totalSteps) {
-            curriculum = new attention.CurriculumScheduler(config.totalSteps, config.warmupSteps || Math.floor(config.totalSteps * 0.1));
-            features.push('Curriculum Learning');
+        this._deltaNorm = Math.sqrt(norm);
+        this._adaptCount++;
+    };
+    JsMicroLoRA.prototype.delta_norm = function () { return this._deltaNorm; };
+    JsMicroLoRA.prototype.dim = function () { return this._dim; };
+    JsMicroLoRA.prototype.reset = function () {
+        this._A.fill(0);
+        this._B.fill(0);
+        this._adaptCount = 0n;
+        this._forwardCount = 0n;
+        this._deltaNorm = 0;
+    };
+    JsMicroLoRA.prototype.free = function () { };
+    return JsMicroLoRA;
+}());
+var JsScopedLoRA = /** @class */ (function () {
+    function JsScopedLoRA(dim, alpha, lr) {
+        this.adapters = new Map();
+        this._fallback = false;
+        this._dim = dim;
+        this._alpha = alpha;
+        this._lr = lr;
+    }
+    JsScopedLoRA.prototype.getAdapter = function (opType) {
+        if (!this.adapters.has(opType)) {
+            if (this._fallback && opType > 0 && this.adapters.has(0)) {
+                return this.adapters.get(0);
+            }
+            this.adapters.set(opType, new JsMicroLoRA(this._dim, this._alpha, this._lr));
         }
-        // Hard negative mining - use string for MiningStrategy enum due to NAPI binding quirk
-        try {
-            // @ts-expect-error - MiningStrategy enum binding expects string not enum value
-            hardMiner = new attention.HardNegativeMiner(5, 'semi_hard');
-            features.push('Hard Negative Mining');
+        return this.adapters.get(opType);
+    };
+    JsScopedLoRA.prototype.adapt_array = function (opType, gradient) { this.getAdapter(opType).adapt_array(gradient); };
+    JsScopedLoRA.prototype.adapt_count = function (opType) { return this.getAdapter(opType).adapt_count(); };
+    JsScopedLoRA.prototype.forward_array = function (opType, input) { return this.getAdapter(opType).forward_array(input); };
+    JsScopedLoRA.prototype.forward_count = function (opType) { return this.getAdapter(opType).forward_count(); };
+    JsScopedLoRA.prototype.adapt_with_reward = function (opType, improvement) { this.getAdapter(opType).adapt_with_reward(improvement); };
+    JsScopedLoRA.prototype.delta_norm = function (opType) { return this.getAdapter(opType).delta_norm(); };
+    JsScopedLoRA.prototype.set_category_fallback = function (enabled) { this._fallback = enabled; };
+    JsScopedLoRA.prototype.total_adapt_count = function () {
+        var total = 0n;
+        for (var _i = 0, _a = this.adapters.values(); _i < _a.length; _i++) {
+            var a = _a[_i];
+            total += a.adapt_count();
         }
-        catch {
-            // Mining not available, continue without it
+        return total;
+    };
+    JsScopedLoRA.prototype.total_forward_count = function () {
+        var total = 0n;
+        for (var _i = 0, _a = this.adapters.values(); _i < _a.length; _i++) {
+            var a = _a[_i];
+            total += a.forward_count();
         }
-        // Initialize SONA (optional, backward compatible)
-        if (config.useSona !== false) {
-            try {
-                const sona = await import('@ruvector/sona');
-                const sonaRank = config.sonaRank || 4;
-                // SonaEngine constructor: (dim, rank, alpha, learningRate) - TypeScript types are wrong
-                // @ts-expect-error - SonaEngine accepts 4 positional args but types say 1
-                sonaEngine = new sona.SonaEngine(dim, sonaRank, alpha, lr);
-                sonaAvailable = true;
-                features.push(`SONA (${dim}-dim, rank-${sonaRank}, 624k learn/s)`);
-            }
-            catch (sonaError) {
-                // SONA not available, continue without it (backward compatible)
-                sonaAvailable = false;
-                // Only log if explicitly requested
-                if (config.useSona === true) {
-                    console.warn('SONA requested but not available:', sonaError);
-                }
+        return total;
+    };
+    JsScopedLoRA.prototype.reset_all = function () { this.adapters.clear(); };
+    JsScopedLoRA.prototype.reset_scope = function (opType) { this.adapters["delete"](opType); };
+    JsScopedLoRA.prototype.free = function () { this.adapters.clear(); };
+    return JsScopedLoRA;
+}());
+var JsTrajectoryBuffer = /** @class */ (function () {
+    function JsTrajectoryBuffer(capacity, _dim) {
+        this.entries = [];
+        this.capacity = capacity;
+    }
+    JsTrajectoryBuffer.prototype.record = function (_embedding, _opType, _attType, executionMs, baselineMs) {
+        var improvement = baselineMs > 0 ? (baselineMs - executionMs) / baselineMs : 0;
+        if (this.entries.length >= this.capacity)
+            this.entries.shift();
+        this.entries.push({ improvement: improvement });
+    };
+    JsTrajectoryBuffer.prototype.is_empty = function () { return this.entries.length === 0; };
+    JsTrajectoryBuffer.prototype.total_count = function () { return BigInt(this.entries.length); };
+    JsTrajectoryBuffer.prototype.success_rate = function () {
+        if (this.entries.length === 0)
+            return 0;
+        return this.entries.filter(function (e) { return e.improvement > 0; }).length / this.entries.length;
+    };
+    JsTrajectoryBuffer.prototype.mean_improvement = function () {
+        if (this.entries.length === 0)
+            return 0;
+        return this.entries.reduce(function (s, e) { return s + e.improvement; }, 0) / this.entries.length;
+    };
+    JsTrajectoryBuffer.prototype.best_improvement = function () {
+        if (this.entries.length === 0)
+            return 0;
+        return Math.max.apply(Math, this.entries.map(function (e) { return e.improvement; }));
+    };
+    JsTrajectoryBuffer.prototype.high_quality_count = function (threshold) {
+        return this.entries.filter(function (e) { return e.improvement > threshold; }).length;
+    };
+    JsTrajectoryBuffer.prototype.variance = function () {
+        if (this.entries.length < 2)
+            return 0;
+        var mean = this.mean_improvement();
+        return this.entries.reduce(function (s, e) { return s + Math.pow((e.improvement - mean), 2); }, 0) / (this.entries.length - 1);
+    };
+    JsTrajectoryBuffer.prototype.reset = function () { this.entries = []; };
+    JsTrajectoryBuffer.prototype.free = function () { this.entries = []; };
+    return JsTrajectoryBuffer;
+}());
+/**
+ * Initialize the RuVector training system.
+ * Attempts to load @ruvector/learning-wasm for WASM-accelerated training.
+ * Falls back to a pure-JS implementation if WASM is unavailable.
+ */
+export function initializeTraining(config) {
+    if (config === void 0) { config = {}; }
+    return __awaiter(this, void 0, Promise, function () {
+        var features, dim, lr, alpha, wasmLoaded, fs, createRequire, require, wasmPath, wasmBuffer, learningWasm, wasmError_1, reason, attention, attentionError_1, reason, sona, sonaRank, sonaError_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    features = [];
+                    dim = Math.min(config.dim || 256, 256);
+                    lr = config.learningRate || 0.01;
+                    alpha = config.alpha || 0.1;
+                    wasmLoaded = false;
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 5, , 6]);
+                    return [4 /*yield*/, import('fs')];
+                case 2:
+                    fs = _a.sent();
+                    return [4 /*yield*/, import('module')];
+                case 3:
+                    createRequire = (_a.sent()).createRequire;
+                    require = createRequire(import.meta.url);
+                    wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
+                    wasmBuffer = fs.readFileSync(wasmPath);
+                    return [4 /*yield*/, import('@ruvector/learning-wasm')];
+                case 4:
+                    learningWasm = _a.sent();
+                    learningWasm.initSync({ module: wasmBuffer });
+                    microLoRA = new learningWasm.WasmMicroLoRA(dim, alpha, lr);
+                    features.push("MicroLoRA/WASM (" + dim + "-dim, <1\u03BCs adaptation)");
+                    scopedLoRA = new learningWasm.WasmScopedLoRA(dim, alpha, lr);
+                    scopedLoRA.set_category_fallback(true);
+                    features.push('ScopedLoRA/WASM (17 operators)');
+                    trajectoryBuffer = new learningWasm.WasmTrajectoryBuffer(config.trajectoryCapacity || 10000, dim);
+                    features.push('TrajectoryBuffer/WASM');
+                    activeBackend = 'wasm';
+                    wasmLoaded = true;
+                    return [3 /*break*/, 6];
+                case 5:
+                    wasmError_1 = _a.sent();
+                    reason = wasmError_1 instanceof Error ? wasmError_1.message : String(wasmError_1);
+                    console.warn("[ruvector] WASM backend unavailable (" + reason + "), using JS fallback");
+                    microLoRA = new JsMicroLoRA(dim, alpha, lr);
+                    features.push("MicroLoRA/JS (" + dim + "-dim, JS fallback)");
+                    scopedLoRA = new JsScopedLoRA(dim, alpha, lr);
+                    scopedLoRA.set_category_fallback(true);
+                    features.push('ScopedLoRA/JS (17 operators)');
+                    trajectoryBuffer = new JsTrajectoryBuffer(config.trajectoryCapacity || 10000, dim);
+                    features.push('TrajectoryBuffer/JS');
+                    activeBackend = 'js-fallback';
+                    return [3 /*break*/, 6];
+                case 6:
+                    _a.trys.push([6, 8, , 9]);
+                    return [4 /*yield*/, importWithInterop('@ruvector/attention')];
+                case 7:
+                    attention = _a.sent();
+                    if (config.useFlashAttention !== false) {
+                        flashAttention = new attention.FlashAttention(dim, 64);
+                        features.push('FlashAttention');
+                    }
+                    if (config.useMoE) {
+                        moeAttention = attention.MoEAttention.simple(dim, 8, 2);
+                        features.push('MoE (8 experts, top-2)');
+                    }
+                    if (config.useHyperbolic) {
+                        hyperbolicAttention = new attention.HyperbolicAttention(dim, 1.0);
+                        features.push('HyperbolicAttention');
+                    }
+                    optimizer = new attention.AdamWOptimizer(lr, 0.9, 0.999, 1e-8, 0.01);
+                    features.push('AdamW Optimizer');
+                    contrastiveLoss = new attention.InfoNceLoss(0.07);
+                    features.push('InfoNCE Loss');
+                    if (config.totalSteps) {
+                        curriculum = new attention.CurriculumScheduler(config.totalSteps, config.warmupSteps || Math.floor(config.totalSteps * 0.1));
+                        features.push('Curriculum Learning');
+                    }
+                    try {
+                        hardMiner = new attention.HardNegativeMiner(5, 'semi_hard');
+                        features.push('Hard Negative Mining');
+                    }
+                    catch (_b) {
+                        // Mining not available, continue without it
+                    }
+                    return [3 /*break*/, 9];
+                case 8:
+                    attentionError_1 = _a.sent();
+                    reason = attentionError_1 instanceof Error ? attentionError_1.message : String(attentionError_1);
+                    console.warn("[ruvector] @ruvector/attention unavailable (" + reason + "), attention features disabled");
+                    return [3 /*break*/, 9];
+                case 9:
+                    if (!(config.useSona !== false)) return [3 /*break*/, 13];
+                    _a.label = 10;
+                case 10:
+                    _a.trys.push([10, 12, , 13]);
+                    return [4 /*yield*/, importWithInterop('@ruvector/sona')];
+                case 11:
+                    sona = _a.sent();
+                    sonaRank = config.sonaRank || 4;
+                    sonaEngine = new sona.SonaEngine(dim, sonaRank, alpha, lr);
+                    sonaAvailable = true;
+                    features.push("SONA (" + dim + "-dim, rank-" + sonaRank + ", 624k learn/s)");
+                    return [3 /*break*/, 13];
+                case 12:
+                    sonaError_1 = _a.sent();
+                    sonaAvailable = false;
+                    if (config.useSona === true) {
+                        console.warn('SONA requested but not available:', sonaError_1);
+                    }
+                    return [3 /*break*/, 13];
+                case 13:
+                    initialized = true;
+                    return [2 /*return*/, { success: true, features: features, backend: activeBackend }];
             }
-        }
-        initialized = true;
-        return { success: true, features };
-    }
-    catch (error) {
-        return {
-            success: false,
-            features,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
+        });
+    });
 }
 /**
  * Operator types for scoped LoRA (0-16)
  */
-export const OperatorType = {
+export var OperatorType = {
     GENERAL: 0,
     ATTENTION: 1,
     MLP: 2,
@@ -145,30 +399,34 @@ export const OperatorType = {
     OPTIMIZATION: 13,
     SECURITY: 14,
     TESTING: 15,
-    DEBUGGING: 16,
+    DEBUGGING: 16
 };
 /**
  * Train a pattern with MicroLoRA
  */
-export async function trainPattern(embedding, gradient, operatorType) {
-    if (!initialized || !microLoRA) {
-        throw new Error('Training system not initialized');
-    }
-    // Use scoped LoRA if operator type specified
-    if (operatorType !== undefined && scopedLoRA) {
-        scopedLoRA.adapt_array(operatorType, gradient);
-        return {
-            deltaNorm: scopedLoRA.delta_norm(operatorType),
-            adaptCount: scopedLoRA.adapt_count(operatorType),
-        };
-    }
-    // Standard MicroLoRA adaptation
-    microLoRA.adapt_array(gradient);
-    totalAdaptations++;
-    return {
-        deltaNorm: microLoRA.delta_norm(),
-        adaptCount: microLoRA.adapt_count(),
-    };
+export function trainPattern(embedding, gradient, operatorType) {
+    return __awaiter(this, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            if (!initialized || !microLoRA) {
+                throw new Error('Training system not initialized');
+            }
+            // Use scoped LoRA if operator type specified
+            if (operatorType !== undefined && scopedLoRA) {
+                scopedLoRA.adapt_array(operatorType, gradient);
+                return [2 /*return*/, {
+                        deltaNorm: scopedLoRA.delta_norm(operatorType),
+                        adaptCount: scopedLoRA.adapt_count(operatorType)
+                    }];
+            }
+            // Standard MicroLoRA adaptation
+            microLoRA.adapt_array(gradient);
+            totalAdaptations++;
+            return [2 /*return*/, {
+                    deltaNorm: microLoRA.delta_norm(),
+                    adaptCount: microLoRA.adapt_count()
+                }];
+        });
+    });
 }
 /**
  * Forward pass through LoRA
@@ -220,7 +478,7 @@ export function getTrajectoryStats() {
         bestImprovement: trajectoryBuffer.best_improvement(),
         totalCount: trajectoryBuffer.total_count(),
         highQualityCount: trajectoryBuffer.high_quality_count(0.1),
-        variance: trajectoryBuffer.variance(),
+        variance: trajectoryBuffer.variance()
     };
 }
 /**
@@ -257,9 +515,9 @@ export function computeContrastiveLoss(anchor, positives, negatives) {
     if (!contrastiveLoss) {
         throw new Error('Contrastive loss not initialized');
     }
-    const loss = contrastiveLoss.compute(anchor, positives, negatives);
-    const gradient = contrastiveLoss.backward(anchor, positives, negatives);
-    return { loss, gradient };
+    var loss = contrastiveLoss.compute(anchor, positives, negatives);
+    var gradient = contrastiveLoss.backward(anchor, positives, negatives);
+    return { loss: loss, gradient: gradient };
 }
 /**
  * Optimizer step
@@ -291,10 +549,19 @@ export function mineHardNegatives(anchor, candidates) {
 /**
  * Benchmark the training system
  */
-export async function benchmarkTraining(dim, iterations) {
-    const attention = await import('@ruvector/attention');
-    lastBenchmark = attention.benchmarkAttention(dim || 256, 100, iterations || 1000);
-    return lastBenchmark;
+export function benchmarkTraining(dim, iterations) {
+    return __awaiter(this, void 0, Promise, function () {
+        var attention;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, importWithInterop('@ruvector/attention')];
+                case 1:
+                    attention = _a.sent();
+                    lastBenchmark = attention.benchmarkAttention(dim || 256, 100, iterations || 1000);
+                    return [2 /*return*/, lastBenchmark !== null && lastBenchmark !== void 0 ? lastBenchmark : []];
+            }
+        });
+    });
 }
 // ============================================
 // SONA Functions (v2 enhancement, optional)
@@ -320,12 +587,13 @@ export function sonaForceLearn(embedding, reward) {
  * Search for similar patterns with SONA (16.7μs, 60k searches/s)
  * Returns the k most similar patterns from the pattern bank
  */
-export function sonaFindPatterns(embedding, k = 5) {
+export function sonaFindPatterns(embedding, k) {
+    if (k === void 0) { k = 5; }
     if (!sonaEngine) {
         throw new Error('SONA not initialized. Call initializeTraining with useSona: true');
     }
     // SONA requires Array, not Float32Array
-    const embeddingArray = Array.from(embedding);
+    var embeddingArray = Array.from(embedding);
     totalSonaSearches++;
     return sonaEngine.findPatterns(embeddingArray, k);
 }
@@ -349,27 +617,27 @@ export function getSonaStats() {
             enabled: false,
             stats: null,
             totalLearns: totalSonaLearns,
-            totalSearches: totalSonaSearches,
+            totalSearches: totalSonaSearches
         };
     }
     try {
-        const statsJson = sonaEngine.getStats();
-        const stats = JSON.parse(statsJson);
+        var statsJson = sonaEngine.getStats();
+        var stats = JSON.parse(statsJson);
         return {
             available: true,
             enabled: sonaEngine.isEnabled(),
-            stats,
+            stats: stats,
             totalLearns: totalSonaLearns,
-            totalSearches: totalSonaSearches,
+            totalSearches: totalSonaSearches
         };
     }
-    catch {
+    catch (_a) {
         return {
             available: true,
             enabled: false,
             stats: null,
             totalLearns: totalSonaLearns,
-            totalSearches: totalSonaSearches,
+            totalSearches: totalSonaSearches
         };
     }
 }
@@ -395,23 +663,24 @@ export function sonaFlush() {
  * Get training statistics
  */
 export function getTrainingStats() {
-    const stats = {
-        initialized,
-        totalAdaptations,
-        totalForwards,
+    var stats = {
+        initialized: initialized,
+        backend: activeBackend,
+        totalAdaptations: totalAdaptations,
+        totalForwards: totalForwards
     };
     if (microLoRA) {
         stats.microLoraStats = {
             paramCount: microLoRA.param_count(),
             adaptCount: microLoRA.adapt_count(),
             forwardCount: microLoRA.forward_count(),
-            deltaNorm: microLoRA.delta_norm(),
+            deltaNorm: microLoRA.delta_norm()
         };
     }
     if (scopedLoRA) {
         stats.scopedLoraStats = {
             totalAdaptCount: scopedLoRA.total_adapt_count(),
-            totalForwardCount: scopedLoRA.total_forward_count(),
+            totalForwardCount: scopedLoRA.total_forward_count()
         };
     }
     if (trajectoryBuffer && !trajectoryBuffer.is_empty()) {
@@ -444,6 +713,7 @@ export function resetTraining() {
     totalForwards = 0;
     totalSonaLearns = 0;
     totalSonaSearches = 0;
+    activeBackend = 'js-fallback';
 }
 /**
  * Export trained weights
@@ -456,7 +726,7 @@ export function exportWeights() {
         dim: microLoRA.dim(),
         deltaNorm: microLoRA.delta_norm(),
         adaptCount: microLoRA.adapt_count(),
-        trajectoryStats: getTrajectoryStats(),
+        trajectoryStats: getTrajectoryStats()
     };
 }
 /**