kynjal-cli 4.0.0 → 4.0.1

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

@@ -13,82 +13,37 @@
  *
  * 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];
-            }
-        });
-    });
+async function importWithInterop(packageName) {
+    const mod = await import(packageName);
+    return ('default' in mod) ? mod.default : mod;
 }
 // Lazy-loaded WASM modules
-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;
+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;
 // SONA engine (optional enhancement)
-var sonaEngine = null;
-var sonaAvailable = false;
+let sonaEngine = null;
+let sonaAvailable = false;
 // Training state
-var initialized = false;
-var totalAdaptations = 0;
-var totalForwards = 0;
-var totalSonaLearns = 0;
-var totalSonaSearches = 0;
-var lastBenchmark = null;
+let initialized = false;
+let totalAdaptations = 0;
+let totalForwards = 0;
+let totalSonaLearns = 0;
+let totalSonaSearches = 0;
+let lastBenchmark = null;
 // Backend tracking
-var activeBackend = 'js-fallback';
+let activeBackend = 'js-fallback';
 /**
  * Get which backend is active for training
  */
@@ -99,46 +54,51 @@ export function getActiveBackend() {
  * 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;
+class JsMicroLoRA {
+    _dim;
+    _alpha;
+    _lr;
+    _adaptCount = 0n;
+    _forwardCount = 0n;
+    _deltaNorm = 0;
+    _A; // Low-rank A (rank x dim)
+    _B; // Low-rank B (dim x rank)
+    RANK = 2;
+    constructor(dim, alpha, lr) {
         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++)
+        const scale = Math.sqrt(2 / (dim + this.RANK));
+        for (let i = 0; i < this._A.length; i++)
             this._A[i] = (Math.random() - 0.5) * scale;
-        for (var i = 0; i < this._B.length; i++)
+        for (let i = 0; i < this._B.length; i++)
             this._B[i] = (Math.random() - 0.5) * scale;
     }
-    JsMicroLoRA.prototype.adapt_array = function (gradient) {
+    adapt_array(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;
+        let norm = 0;
+        for (let i = 0; i < Math.min(gradient.length, this._A.length); i++) {
+            const delta = -this._lr * gradient[i % gradient.length] * this._alpha;
             this._A[i] += delta;
             norm += delta * delta;
         }
         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);
+    }
+    adapt_count() { return this._adaptCount; }
+    param_count() { return this._A.length + this._B.length; }
+    forward_array(input) {
+        const output = new Float32Array(this._dim);
         // y = x + alpha * B @ A @ x  (simplified low-rank)
-        for (var i = 0; i < this._dim; i++) {
+        for (let 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++) {
+            let sum = 0;
+            for (let r = 0; r < this.RANK; r++) {
+                let dot = 0;
+                for (let j = 0; j < this._dim; j++) {
                     dot += this._A[r * this._dim + j] * input[j];
                 }
                 sum += this._B[i * this.RANK + r] * dot;
@@ -147,40 +107,42 @@ var JsMicroLoRA = /** @class */ (function () {
         }
         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);
+    }
+    forward_count() { return this._forwardCount; }
+    adapt_with_reward(improvement) {
+        const scale = improvement * this._lr * this._alpha;
+        let norm = 0;
+        for (let i = 0; i < this._A.length; i++) {
+            const delta = scale * (Math.random() - 0.5);
             this._A[i] += delta;
             norm += delta * delta;
         }
         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 () {
+    }
+    delta_norm() { return this._deltaNorm; }
+    dim() { return this._dim; }
+    reset() {
         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;
+    }
+    free() { }
+}
+class JsScopedLoRA {
+    adapters = new Map();
+    _dim;
+    _alpha;
+    _lr;
+    _fallback = false;
+    constructor(dim, alpha, lr) {
         this._dim = dim;
         this._alpha = alpha;
         this._lr = lr;
     }
-    JsScopedLoRA.prototype.getAdapter = function (opType) {
+    getAdapter(opType) {
         if (!this.adapters.has(opType)) {
             if (this._fallback && opType > 0 && this.adapters.has(0)) {
                 return this.adapters.get(0);
@@ -188,201 +150,173 @@ var JsScopedLoRA = /** @class */ (function () {
             this.adapters.set(opType, new JsMicroLoRA(this._dim, this._alpha, this._lr));
         }
         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];
+    }
+    adapt_array(opType, gradient) { this.getAdapter(opType).adapt_array(gradient); }
+    adapt_count(opType) { return this.getAdapter(opType).adapt_count(); }
+    forward_array(opType, input) { return this.getAdapter(opType).forward_array(input); }
+    forward_count(opType) { return this.getAdapter(opType).forward_count(); }
+    adapt_with_reward(opType, improvement) { this.getAdapter(opType).adapt_with_reward(improvement); }
+    delta_norm(opType) { return this.getAdapter(opType).delta_norm(); }
+    set_category_fallback(enabled) { this._fallback = enabled; }
+    total_adapt_count() {
+        let total = 0n;
+        for (const a of this.adapters.values())
             total += a.adapt_count();
-        }
         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_forward_count() {
+        let total = 0n;
+        for (const a of this.adapters.values())
             total += a.forward_count();
-        }
         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 = [];
+    }
+    reset_all() { this.adapters.clear(); }
+    reset_scope(opType) { this.adapters.delete(opType); }
+    free() { this.adapters.clear(); }
+}
+class JsTrajectoryBuffer {
+    entries = [];
+    capacity;
+    constructor(capacity, _dim) {
         this.capacity = capacity;
     }
-    JsTrajectoryBuffer.prototype.record = function (_embedding, _opType, _attType, executionMs, baselineMs) {
-        var improvement = baselineMs > 0 ? (baselineMs - executionMs) / baselineMs : 0;
+    record(_embedding, _opType, _attType, executionMs, baselineMs) {
+        const 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 () {
+        this.entries.push({ improvement });
+    }
+    is_empty() { return this.entries.length === 0; }
+    total_count() { return BigInt(this.entries.length); }
+    success_rate() {
         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 () {
+        return this.entries.filter(e => e.improvement > 0).length / this.entries.length;
+    }
+    mean_improvement() {
         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 () {
+        return this.entries.reduce((s, e) => s + e.improvement, 0) / this.entries.length;
+    }
+    best_improvement() {
         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 () {
+        return Math.max(...this.entries.map(e => e.improvement));
+    }
+    high_quality_count(threshold) {
+        return this.entries.filter(e => e.improvement > threshold).length;
+    }
+    variance() {
         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;
-}());
+        const mean = this.mean_improvement();
+        return this.entries.reduce((s, e) => s + (e.improvement - mean) ** 2, 0) / (this.entries.length - 1);
+    }
+    reset() { this.entries = []; }
+    free() { this.entries = []; }
+}
 /**
  * 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 }];
+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;
+    // --- Attempt WASM backend first ---
+    let wasmLoaded = false;
+    try {
+        const fs = await import('fs');
+        const { createRequire } = await import('module');
+        const require = createRequire(import.meta.url);
+        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/WASM (${dim}-dim, <1μs 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;
+    }
+    catch (wasmError) {
+        // WASM not available - fall back to JS implementation
+        const reason = wasmError instanceof Error ? wasmError.message : String(wasmError);
+        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';
+    }
+    // --- Attention mechanisms (optional, independent of WASM) ---
+    try {
+        const attention = await importWithInterop('@ruvector/attention');
+        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 {
+            // Mining not available, continue without it
+        }
+    }
+    catch (attentionError) {
+        // @ruvector/attention not available - attention features skipped
+        const reason = attentionError instanceof Error ? attentionError.message : String(attentionError);
+        console.warn(`[ruvector] @ruvector/attention unavailable (${reason}), attention features disabled`);
+    }
+    // --- SONA (optional, backward compatible) ---
+    if (config.useSona !== false) {
+        try {
+            const sona = await importWithInterop('@ruvector/sona');
+            const sonaRank = config.sonaRank || 4;
+            sonaEngine = new sona.SonaEngine(dim, sonaRank, alpha, lr);
+            sonaAvailable = true;
+            features.push(`SONA (${dim}-dim, rank-${sonaRank}, 624k learn/s)`);
+        }
+        catch (sonaError) {
+            sonaAvailable = false;
+            if (config.useSona === true) {
+                console.warn('SONA requested but not available:', sonaError);
             }
-        });
-    });
+        }
+    }
+    initialized = true;
+    return { success: true, features, backend: activeBackend };
 }
 /**
  * Operator types for scoped LoRA (0-16)
  */
-export var OperatorType = {
+export const OperatorType = {
     GENERAL: 0,
     ATTENTION: 1,
     MLP: 2,
@@ -399,34 +333,30 @@ export var OperatorType = {
     OPTIMIZATION: 13,
     SECURITY: 14,
     TESTING: 15,
-    DEBUGGING: 16
+    DEBUGGING: 16,
 };
 /**
  * Train a pattern with MicroLoRA
  */
-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()
-                }];
-        });
-    });
+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(),
+    };
 }
 /**
  * Forward pass through LoRA
@@ -478,7 +408,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(),
     };
 }
 /**
@@ -515,9 +445,9 @@ export function computeContrastiveLoss(anchor, positives, negatives) {
     if (!contrastiveLoss) {
         throw new Error('Contrastive loss not initialized');
     }
-    var loss = contrastiveLoss.compute(anchor, positives, negatives);
-    var gradient = contrastiveLoss.backward(anchor, positives, negatives);
-    return { loss: loss, gradient: gradient };
+    const loss = contrastiveLoss.compute(anchor, positives, negatives);
+    const gradient = contrastiveLoss.backward(anchor, positives, negatives);
+    return { loss, gradient };
 }
 /**
  * Optimizer step
@@ -549,19 +479,10 @@ export function mineHardNegatives(anchor, candidates) {
 /**
  * Benchmark the training system
  */
-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 : []];
-            }
-        });
-    });
+export async function benchmarkTraining(dim, iterations) {
+    const attention = await importWithInterop('@ruvector/attention');
+    lastBenchmark = attention.benchmarkAttention(dim || 256, 100, iterations || 1000);
+    return lastBenchmark ?? [];
 }
 // ============================================
 // SONA Functions (v2 enhancement, optional)
@@ -587,13 +508,12 @@ 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) {
-    if (k === void 0) { k = 5; }
+export function sonaFindPatterns(embedding, k = 5) {
     if (!sonaEngine) {
         throw new Error('SONA not initialized. Call initializeTraining with useSona: true');
     }
     // SONA requires Array, not Float32Array
-    var embeddingArray = Array.from(embedding);
+    const embeddingArray = Array.from(embedding);
     totalSonaSearches++;
     return sonaEngine.findPatterns(embeddingArray, k);
 }
@@ -617,27 +537,27 @@ export function getSonaStats() {
             enabled: false,
             stats: null,
             totalLearns: totalSonaLearns,
-            totalSearches: totalSonaSearches
+            totalSearches: totalSonaSearches,
         };
     }
     try {
-        var statsJson = sonaEngine.getStats();
-        var stats = JSON.parse(statsJson);
+        const statsJson = sonaEngine.getStats();
+        const stats = JSON.parse(statsJson);
         return {
             available: true,
             enabled: sonaEngine.isEnabled(),
-            stats: stats,
+            stats,
             totalLearns: totalSonaLearns,
-            totalSearches: totalSonaSearches
+            totalSearches: totalSonaSearches,
         };
     }
-    catch (_a) {
+    catch {
         return {
             available: true,
             enabled: false,
             stats: null,
             totalLearns: totalSonaLearns,
-            totalSearches: totalSonaSearches
+            totalSearches: totalSonaSearches,
         };
     }
 }
@@ -663,24 +583,24 @@ export function sonaFlush() {
  * Get training statistics
  */
 export function getTrainingStats() {
-    var stats = {
-        initialized: initialized,
+    const stats = {
+        initialized,
         backend: activeBackend,
-        totalAdaptations: totalAdaptations,
-        totalForwards: totalForwards
+        totalAdaptations,
+        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()) {
@@ -726,7 +646,7 @@ export function exportWeights() {
         dim: microLoRA.dim(),
         deltaNorm: microLoRA.delta_norm(),
         adaptCount: microLoRA.adapt_count(),
-        trajectoryStats: getTrajectoryStats()
+        trajectoryStats: getTrajectoryStats(),
     };
 }
 /**