kynjal-cli 4.0.0 → 4.0.1

package/dist/src/ruvector/moe-router.js

@@ -15,68 +15,12 @@
  *
  * @module moe-router
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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 };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 /**
  * Expert names in order (index corresponds to expert slot)
  */
-export var EXPERT_NAMES = [
+export const EXPERT_NAMES = [
     'coder',
     'tester',
     'reviewer',
@@ -89,19 +33,19 @@ export var EXPERT_NAMES = [
 /**
  * Number of experts (fixed at 8)
  */
-export var NUM_EXPERTS = 8;
+export const NUM_EXPERTS = 8;
 /**
  * Input dimension (384 from ONNX MiniLM-L6-v2)
  */
-export var INPUT_DIM = 384;
+export const INPUT_DIM = 384;
 /**
  * Hidden layer dimension
  */
-export var HIDDEN_DIM = 128;
+export const HIDDEN_DIM = 128;
 /**
  * Default configuration
  */
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
     topK: 2,
     learningRate: 0.01,
     temperature: 1.0,
@@ -109,7 +53,7 @@ var DEFAULT_CONFIG = {
     weightsPath: '.swarm/moe-weights.json',
     autoSaveInterval: 50,
     enableNoise: true,
-    noiseStd: 0.1
+    noiseStd: 0.1,
 };
 // ============================================================================
 // Matrix Operations
@@ -118,13 +62,13 @@ var DEFAULT_CONFIG = {
  * Initialize weights using Xavier/Glorot initialization
  */
 function xavierInit(fanIn, fanOut) {
-    var std = Math.sqrt(2.0 / (fanIn + fanOut));
-    var weights = new Float32Array(fanIn * fanOut);
-    for (var i = 0; i < weights.length; i++) {
+    const std = Math.sqrt(2.0 / (fanIn + fanOut));
+    const weights = new Float32Array(fanIn * fanOut);
+    for (let i = 0; i < weights.length; i++) {
         // Box-Muller transform for normal distribution
-        var u1 = Math.random();
-        var u2 = Math.random();
-        var z = Math.sqrt(-2 * Math.log(u1 + 1e-8)) * Math.cos(2 * Math.PI * u2);
+        const u1 = Math.random();
+        const u2 = Math.random();
+        const z = Math.sqrt(-2 * Math.log(u1 + 1e-8)) * Math.cos(2 * Math.PI * u2);
         weights[i] = z * std;
     }
     return weights;
@@ -134,11 +78,11 @@ function xavierInit(fanIn, fanOut) {
  * W is stored row-major: [rows * cols]
  */
 function matmul(W, x, rows, cols, out) {
-    for (var i = 0; i < rows; i++) {
-        var sum = 0;
-        var rowOffset = i * cols;
+    for (let i = 0; i < rows; i++) {
+        let sum = 0;
+        const rowOffset = i * cols;
         // 4x loop unrolling for SIMD-friendly access
-        var j = 0;
+        let j = 0;
         for (; j + 3 < cols; j += 4) {
             sum +=
                 W[rowOffset + j] * x[j] +
@@ -157,7 +101,7 @@ function matmul(W, x, rows, cols, out) {
  * Vector addition: y = x + b
  */
 function addBias(x, b, out) {
-    for (var i = 0; i < x.length; i++) {
+    for (let i = 0; i < x.length; i++) {
         out[i] = x[i] + b[i];
     }
 }
@@ -165,7 +109,7 @@ function addBias(x, b, out) {
  * ReLU activation: y = max(0, x)
  */
 function relu(x, out) {
-    for (var i = 0; i < x.length; i++) {
+    for (let i = 0; i < x.length; i++) {
         out[i] = x[i] > 0 ? x[i] : 0;
     }
 }
@@ -174,20 +118,20 @@ function relu(x, out) {
  */
 function softmax(x, temperature, out) {
     // Find max for numerical stability
-    var maxVal = x[0];
-    for (var i = 1; i < x.length; i++) {
+    let maxVal = x[0];
+    for (let i = 1; i < x.length; i++) {
         if (x[i] > maxVal)
             maxVal = x[i];
     }
     // Compute exp and sum
-    var sum = 0;
-    for (var i = 0; i < x.length; i++) {
+    let sum = 0;
+    for (let i = 0; i < x.length; i++) {
         out[i] = Math.exp((x[i] - maxVal) / temperature);
         sum += out[i];
     }
     // Normalize
-    var invSum = 1.0 / (sum + 1e-8);
-    for (var i = 0; i < x.length; i++) {
+    const invSum = 1.0 / (sum + 1e-8);
+    for (let i = 0; i < x.length; i++) {
         out[i] *= invSum;
     }
 }
@@ -195,8 +139,8 @@ function softmax(x, temperature, out) {
  * Compute entropy of distribution: H = -sum(p * log(p))
  */
 function entropy(p) {
-    var h = 0;
-    for (var i = 0; i < p.length; i++) {
+    let h = 0;
+    for (let i = 0; i < p.length; i++) {
         if (p[i] > 1e-8) {
             h -= p[i] * Math.log(p[i]);
         }
@@ -207,10 +151,10 @@ function entropy(p) {
  * Add Gaussian noise for exploration
  */
 function addNoise(x, std, out) {
-    for (var i = 0; i < x.length; i++) {
-        var u1 = Math.random();
-        var u2 = Math.random();
-        var z = Math.sqrt(-2 * Math.log(u1 + 1e-8)) * Math.cos(2 * Math.PI * u2);
+    for (let i = 0; i < x.length; i++) {
+        const u1 = Math.random();
+        const u2 = Math.random();
+        const z = Math.sqrt(-2 * Math.log(u1 + 1e-8)) * Math.cos(2 * Math.PI * u2);
         out[i] = x[i] + z * std;
     }
 }
@@ -226,18 +170,39 @@ function addNoise(x, std, out) {
  *
  * Uses top-k expert selection with load balancing.
  */
-var MoERouter = /** @class */ (function () {
-    function MoERouter(config) {
-        if (config === void 0) { config = {}; }
-        this.totalRoutings = 0;
-        this.updateCount = 0;
-        this.avgReward = 0;
-        // Cache for last input (for gradient computation)
-        this.lastInput = null;
-        this.lastHiddenActivated = null;
-        this.lastProbs = null;
-        this.lastSelectedExperts = [];
-        this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
+export class MoERouter {
+    config;
+    // Network weights (pre-allocated Float32Arrays)
+    W1; // [HIDDEN_DIM x INPUT_DIM]
+    b1; // [HIDDEN_DIM]
+    W2; // [NUM_EXPERTS x HIDDEN_DIM]
+    b2; // [NUM_EXPERTS]
+    // Intermediate buffers (pre-allocated, no GC pressure)
+    hidden; // [HIDDEN_DIM]
+    hiddenWithBias; // [HIDDEN_DIM]
+    hiddenActivated; // [HIDDEN_DIM]
+    logits; // [NUM_EXPERTS]
+    logitsWithBias; // [NUM_EXPERTS]
+    noisyLogits; // [NUM_EXPERTS]
+    probs; // [NUM_EXPERTS]
+    // Gradient buffers for online learning
+    gradW2; // [NUM_EXPERTS x HIDDEN_DIM]
+    gradb2; // [NUM_EXPERTS]
+    gradW1; // [HIDDEN_DIM x INPUT_DIM]
+    gradb1; // [HIDDEN_DIM]
+    gradHidden; // [HIDDEN_DIM]
+    // Statistics
+    routingCounts; // [NUM_EXPERTS]
+    totalRoutings = 0;
+    updateCount = 0;
+    avgReward = 0;
+    // Cache for last input (for gradient computation)
+    lastInput = null;
+    lastHiddenActivated = null;
+    lastProbs = null;
+    lastSelectedExperts = [];
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
         // Initialize weights
         this.W1 = xavierInit(INPUT_DIM, HIDDEN_DIM);
         this.b1 = new Float32Array(HIDDEN_DIM);
@@ -263,33 +228,23 @@ var MoERouter = /** @class */ (function () {
     /**
      * Initialize router, loading persisted weights if available
      */
-    MoERouter.prototype.initialize = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.loadWeights()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async initialize() {
+        await this.loadWeights();
+    }
     /**
      * Route task to top-k experts based on embedding
      *
      * @param taskEmbedding - 384-dim task embedding from ONNX
      * @returns Routing result with selected experts and weights
      */
-    MoERouter.prototype.route = function (taskEmbedding) {
-        var _this = this;
+    route(taskEmbedding) {
         // Convert to Float32Array if needed
-        var input = taskEmbedding instanceof Float32Array
+        const input = taskEmbedding instanceof Float32Array
             ? taskEmbedding
             : new Float32Array(taskEmbedding);
         // Validate input dimension
         if (input.length !== INPUT_DIM) {
-            throw new Error("Expected embedding dimension " + INPUT_DIM + ", got " + input.length);
+            throw new Error(`Expected embedding dimension ${INPUT_DIM}, got ${input.length}`);
         }
         // Forward pass through gating network
         // Layer 1: Linear + ReLU
@@ -309,14 +264,13 @@ var MoERouter = /** @class */ (function () {
         // Softmax to get probabilities
         softmax(this.noisyLogits, this.config.temperature, this.probs);
         // Select top-k experts
-        var expertIndices = this.selectTopK(this.probs, this.config.topK);
+        const expertIndices = this.selectTopK(this.probs, this.config.topK);
         // Compute load balance loss
-        var loadBalanceLoss = this.computeLoadBalanceLoss();
+        const loadBalanceLoss = this.computeLoadBalanceLoss();
         // Compute entropy
-        var routingEntropy = entropy(this.probs);
+        const routingEntropy = entropy(this.probs);
         // Update statistics
-        for (var _i = 0, expertIndices_1 = expertIndices; _i < expertIndices_1.length; _i++) {
-            var idx = expertIndices_1[_i];
+        for (const idx of expertIndices) {
             this.routingCounts[idx]++;
         }
         this.totalRoutings++;
@@ -326,20 +280,20 @@ var MoERouter = /** @class */ (function () {
         this.lastProbs = new Float32Array(this.probs);
         this.lastSelectedExperts = expertIndices;
         // Build result
-        var totalWeight = expertIndices.reduce(function (sum, idx) { return sum + _this.probs[idx]; }, 0);
-        var experts = expertIndices.map(function (idx) { return ({
+        const totalWeight = expertIndices.reduce((sum, idx) => sum + this.probs[idx], 0);
+        const experts = expertIndices.map((idx) => ({
             name: EXPERT_NAMES[idx],
             index: idx,
-            weight: _this.probs[idx] / (totalWeight + 1e-8),
-            score: _this.probs[idx]
-        }); });
+            weight: this.probs[idx] / (totalWeight + 1e-8), // Normalize weights
+            score: this.probs[idx],
+        }));
         return {
-            experts: experts,
+            experts,
             allScores: Array.from(this.probs),
-            loadBalanceLoss: loadBalanceLoss,
-            entropy: routingEntropy
+            loadBalanceLoss,
+            entropy: routingEntropy,
         };
-    };
+    }
     /**
      * Update expert weights based on reward signal
      *
@@ -349,10 +303,10 @@ var MoERouter = /** @class */ (function () {
      * @param expert - Expert that received the reward
      * @param reward - Reward signal (-1 to 1, positive = good)
      */
-    MoERouter.prototype.updateExpertWeights = function (expert, reward) {
-        var expertIdx = typeof expert === 'number' ? expert : EXPERT_NAMES.indexOf(expert);
+    updateExpertWeights(expert, reward) {
+        const expertIdx = typeof expert === 'number' ? expert : EXPERT_NAMES.indexOf(expert);
         if (expertIdx < 0 || expertIdx >= NUM_EXPERTS) {
-            console.warn("[MoE] Invalid expert: " + expert);
+            console.warn(`[MoE] Invalid expert: ${expert}`);
             return;
         }
         if (!this.lastInput || !this.lastHiddenActivated || !this.lastProbs) {
@@ -360,7 +314,7 @@ var MoERouter = /** @class */ (function () {
             return;
         }
         // Clamp reward to [-1, 1]
-        var clampedReward = Math.max(-1, Math.min(1, reward));
+        const clampedReward = Math.max(-1, Math.min(1, reward));
         // Compute gradients using REINFORCE
         // For softmax: d_log_p_i / d_logit_j = delta_ij - p_j
         // gradient = reward * (1 - p_expert) for selected expert
@@ -372,7 +326,7 @@ var MoERouter = /** @class */ (function () {
         this.gradb1.fill(0);
         this.gradHidden.fill(0);
         // Gradient w.r.t. logits (before softmax)
-        for (var i = 0; i < NUM_EXPERTS; i++) {
+        for (let i = 0; i < NUM_EXPERTS; i++) {
             if (i === expertIdx) {
                 this.gradb2[i] = clampedReward * (1 - this.lastProbs[i]);
             }
@@ -381,22 +335,22 @@ var MoERouter = /** @class */ (function () {
             }
         }
         // Gradient w.r.t. W2: outer product of gradb2 and hiddenActivated
-        for (var i = 0; i < NUM_EXPERTS; i++) {
-            var rowOffset = i * HIDDEN_DIM;
-            for (var j = 0; j < HIDDEN_DIM; j++) {
+        for (let i = 0; i < NUM_EXPERTS; i++) {
+            const rowOffset = i * HIDDEN_DIM;
+            for (let j = 0; j < HIDDEN_DIM; j++) {
                 this.gradW2[rowOffset + j] = this.gradb2[i] * this.lastHiddenActivated[j];
             }
         }
         // Backprop through W2 to get gradient w.r.t. hidden
-        for (var j = 0; j < HIDDEN_DIM; j++) {
-            var sum = 0;
-            for (var i = 0; i < NUM_EXPERTS; i++) {
+        for (let j = 0; j < HIDDEN_DIM; j++) {
+            let sum = 0;
+            for (let i = 0; i < NUM_EXPERTS; i++) {
                 sum += this.gradb2[i] * this.W2[i * HIDDEN_DIM + j];
             }
             this.gradHidden[j] = sum;
         }
         // Backprop through ReLU: gradient is 0 where activation was 0
-        for (var j = 0; j < HIDDEN_DIM; j++) {
+        for (let j = 0; j < HIDDEN_DIM; j++) {
             if (this.lastHiddenActivated[j] <= 0) {
                 this.gradHidden[j] = 0;
             }
@@ -404,24 +358,24 @@ var MoERouter = /** @class */ (function () {
         // Gradient w.r.t. b1
         this.gradb1.set(this.gradHidden);
         // Gradient w.r.t. W1: outer product of gradHidden and input
-        for (var i = 0; i < HIDDEN_DIM; i++) {
-            var rowOffset = i * INPUT_DIM;
-            for (var j = 0; j < INPUT_DIM; j++) {
+        for (let i = 0; i < HIDDEN_DIM; i++) {
+            const rowOffset = i * INPUT_DIM;
+            for (let j = 0; j < INPUT_DIM; j++) {
                 this.gradW1[rowOffset + j] = this.gradHidden[i] * this.lastInput[j];
             }
         }
         // Apply gradients with learning rate
-        var lr = this.config.learningRate;
-        for (var i = 0; i < this.W2.length; i++) {
+        const lr = this.config.learningRate;
+        for (let i = 0; i < this.W2.length; i++) {
             this.W2[i] += lr * this.gradW2[i];
         }
-        for (var i = 0; i < this.b2.length; i++) {
+        for (let i = 0; i < this.b2.length; i++) {
             this.b2[i] += lr * this.gradb2[i];
         }
-        for (var i = 0; i < this.W1.length; i++) {
+        for (let i = 0; i < this.W1.length; i++) {
             this.W1[i] += lr * this.gradW1[i];
         }
-        for (var i = 0; i < this.b1.length; i++) {
+        for (let i = 0; i < this.b1.length; i++) {
             this.b1[i] += lr * this.gradb1[i];
         }
         // Update statistics
@@ -430,44 +384,44 @@ var MoERouter = /** @class */ (function () {
         // Auto-save
         if (this.config.autoSaveInterval > 0 &&
             this.updateCount % this.config.autoSaveInterval === 0) {
-            this.saveWeights()["catch"](function () { }); // Fire and forget
+            this.saveWeights().catch(() => { }); // Fire and forget
         }
-    };
+    }
     /**
      * Get load balance statistics across all experts
      */
-    MoERouter.prototype.getLoadBalance = function () {
-        var counts = {};
-        var utilization = {};
-        var total = this.totalRoutings || 1;
-        var idealUtilization = 1 / NUM_EXPERTS;
-        for (var i = 0; i < NUM_EXPERTS; i++) {
-            var name = EXPERT_NAMES[i];
+    getLoadBalance() {
+        const counts = {};
+        const utilization = {};
+        const total = this.totalRoutings || 1;
+        const idealUtilization = 1 / NUM_EXPERTS;
+        for (let i = 0; i < NUM_EXPERTS; i++) {
+            const name = EXPERT_NAMES[i];
             counts[name] = this.routingCounts[i];
             utilization[name] = this.routingCounts[i] / total;
         }
         // Compute Gini coefficient
-        var gini = this.computeGiniCoefficient();
+        const gini = this.computeGiniCoefficient();
         // Compute coefficient of variation
-        var mean = total / NUM_EXPERTS;
-        var variance = 0;
-        for (var i = 0; i < NUM_EXPERTS; i++) {
+        const mean = total / NUM_EXPERTS;
+        let variance = 0;
+        for (let i = 0; i < NUM_EXPERTS; i++) {
             variance += Math.pow(this.routingCounts[i] - mean, 2);
         }
         variance /= NUM_EXPERTS;
-        var cv = Math.sqrt(variance) / (mean + 1e-8);
+        const cv = Math.sqrt(variance) / (mean + 1e-8);
         return {
-            utilization: utilization,
+            utilization,
             totalRoutings: this.totalRoutings,
             routingCounts: counts,
             giniCoefficient: gini,
-            coefficientOfVariation: cv
+            coefficientOfVariation: cv,
         };
-    };
+    }
     /**
      * Get router statistics
      */
-    MoERouter.prototype.getStats = function () {
+    getStats() {
         return {
             totalRoutings: this.totalRoutings,
             updateCount: this.updateCount,
@@ -475,139 +429,129 @@ var MoERouter = /** @class */ (function () {
             topK: this.config.topK,
             temperature: this.config.temperature,
             learningRate: this.config.learningRate,
-            giniCoefficient: this.computeGiniCoefficient()
+            giniCoefficient: this.computeGiniCoefficient(),
         };
-    };
+    }
     /**
      * Reset all statistics and routing counts
      */
-    MoERouter.prototype.resetStats = function () {
+    resetStats() {
         this.routingCounts.fill(0);
         this.totalRoutings = 0;
         this.updateCount = 0;
         this.avgReward = 0;
-    };
+    }
     /**
      * Load weights from persistence file
      */
-    MoERouter.prototype.loadWeights = function (path) {
-        return __awaiter(this, void 0, Promise, function () {
-            var weightsPath, data, model;
-            return __generator(this, function (_a) {
-                weightsPath = path || this.config.weightsPath;
-                try {
-                    if (!existsSync(weightsPath)) {
-                        return [2 /*return*/, false];
-                    }
-                    data = readFileSync(weightsPath, 'utf-8');
-                    model = JSON.parse(data);
-                    // Validate version
-                    if (!model.version || !model.version.startsWith('1.')) {
-                        console.warn("[MoE] Incompatible model version: " + model.version);
-                        return [2 /*return*/, false];
-                    }
-                    // Load weights
-                    this.W1 = new Float32Array(model.weights.W1.flat());
-                    this.b1 = new Float32Array(model.weights.b1);
-                    this.W2 = new Float32Array(model.weights.W2.flat());
-                    this.b2 = new Float32Array(model.weights.b2);
-                    // Load stats
-                    this.updateCount = model.stats.updateCount || 0;
-                    this.avgReward = model.stats.avgReward || 0;
-                    this.routingCounts = new Float32Array(model.stats.routingCounts || new Array(NUM_EXPERTS).fill(0));
-                    this.totalRoutings = this.routingCounts.reduce(function (a, b) { return a + b; }, 0);
-                    return [2 /*return*/, true];
-                }
-                catch (err) {
-                    console.warn("[MoE] Failed to load weights: " + err);
-                    return [2 /*return*/, false];
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
+    async loadWeights(path) {
+        const weightsPath = path || this.config.weightsPath;
+        try {
+            if (!existsSync(weightsPath)) {
+                return false;
+            }
+            const data = readFileSync(weightsPath, 'utf-8');
+            const model = JSON.parse(data);
+            // Validate version
+            if (!model.version || !model.version.startsWith('1.')) {
+                console.warn(`[MoE] Incompatible model version: ${model.version}`);
+                return false;
+            }
+            // Load weights
+            this.W1 = new Float32Array(model.weights.W1.flat());
+            this.b1 = new Float32Array(model.weights.b1);
+            this.W2 = new Float32Array(model.weights.W2.flat());
+            this.b2 = new Float32Array(model.weights.b2);
+            // Load stats
+            this.updateCount = model.stats.updateCount || 0;
+            this.avgReward = model.stats.avgReward || 0;
+            this.routingCounts = new Float32Array(model.stats.routingCounts || new Array(NUM_EXPERTS).fill(0));
+            this.totalRoutings = this.routingCounts.reduce((a, b) => a + b, 0);
+            return true;
+        }
+        catch (err) {
+            console.warn(`[MoE] Failed to load weights: ${err}`);
+            return false;
+        }
+    }
     /**
      * Save weights to persistence file
      */
-    MoERouter.prototype.saveWeights = function (path) {
-        return __awaiter(this, void 0, Promise, function () {
-            var weightsPath, dir, W1_2d, i, W2_2d, i, model;
-            return __generator(this, function (_a) {
-                weightsPath = path || this.config.weightsPath;
-                try {
-                    dir = dirname(weightsPath);
-                    if (!existsSync(dir)) {
-                        mkdirSync(dir, { recursive: true });
-                    }
-                    W1_2d = [];
-                    for (i = 0; i < HIDDEN_DIM; i++) {
-                        W1_2d.push(Array.from(this.W1.slice(i * INPUT_DIM, (i + 1) * INPUT_DIM)));
-                    }
-                    W2_2d = [];
-                    for (i = 0; i < NUM_EXPERTS; i++) {
-                        W2_2d.push(Array.from(this.W2.slice(i * HIDDEN_DIM, (i + 1) * HIDDEN_DIM)));
-                    }
-                    model = {
-                        version: '1.0.0',
-                        config: {
-                            topK: this.config.topK,
-                            temperature: this.config.temperature,
-                            learningRate: this.config.learningRate,
-                            loadBalanceCoef: this.config.loadBalanceCoef
-                        },
-                        weights: {
-                            W1: W1_2d,
-                            b1: Array.from(this.b1),
-                            W2: W2_2d,
-                            b2: Array.from(this.b2)
-                        },
-                        stats: {
-                            updateCount: this.updateCount,
-                            routingCounts: Array.from(this.routingCounts),
-                            avgReward: this.avgReward
-                        },
-                        metadata: {
-                            savedAt: new Date().toISOString(),
-                            expertNames: __spreadArray([], EXPERT_NAMES, true)
-                        }
-                    };
-                    writeFileSync(weightsPath, JSON.stringify(model, null, 2));
-                    return [2 /*return*/, true];
-                }
-                catch (err) {
-                    console.warn("[MoE] Failed to save weights: " + err);
-                    return [2 /*return*/, false];
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
+    async saveWeights(path) {
+        const weightsPath = path || this.config.weightsPath;
+        try {
+            // Ensure directory exists
+            const dir = dirname(weightsPath);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            // Convert Float32Arrays to nested arrays for JSON
+            const W1_2d = [];
+            for (let i = 0; i < HIDDEN_DIM; i++) {
+                W1_2d.push(Array.from(this.W1.slice(i * INPUT_DIM, (i + 1) * INPUT_DIM)));
+            }
+            const W2_2d = [];
+            for (let i = 0; i < NUM_EXPERTS; i++) {
+                W2_2d.push(Array.from(this.W2.slice(i * HIDDEN_DIM, (i + 1) * HIDDEN_DIM)));
+            }
+            const model = {
+                version: '1.0.0',
+                config: {
+                    topK: this.config.topK,
+                    temperature: this.config.temperature,
+                    learningRate: this.config.learningRate,
+                    loadBalanceCoef: this.config.loadBalanceCoef,
+                },
+                weights: {
+                    W1: W1_2d,
+                    b1: Array.from(this.b1),
+                    W2: W2_2d,
+                    b2: Array.from(this.b2),
+                },
+                stats: {
+                    updateCount: this.updateCount,
+                    routingCounts: Array.from(this.routingCounts),
+                    avgReward: this.avgReward,
+                },
+                metadata: {
+                    savedAt: new Date().toISOString(),
+                    expertNames: [...EXPERT_NAMES],
+                },
+            };
+            writeFileSync(weightsPath, JSON.stringify(model, null, 2));
+            return true;
+        }
+        catch (err) {
+            console.warn(`[MoE] Failed to save weights: ${err}`);
+            return false;
+        }
+    }
     /**
      * Reset weights to random initialization
      */
-    MoERouter.prototype.resetWeights = function () {
+    resetWeights() {
         this.W1 = xavierInit(INPUT_DIM, HIDDEN_DIM);
         this.b1.fill(0);
         this.W2 = xavierInit(HIDDEN_DIM, NUM_EXPERTS);
         this.b2.fill(0);
         this.resetStats();
-    };
+    }
     // ============================================================================
     // Private Methods
     // ============================================================================
     /**
      * Select top-k indices from probabilities
      */
-    MoERouter.prototype.selectTopK = function (probs, k) {
+    selectTopK(probs, k) {
         // Create index-value pairs and sort by value descending
-        var pairs = [];
-        for (var i = 0; i < probs.length; i++) {
+        const pairs = [];
+        for (let i = 0; i < probs.length; i++) {
             pairs.push([i, probs[i]]);
         }
-        pairs.sort(function (a, b) { return b[1] - a[1]; });
+        pairs.sort((a, b) => b[1] - a[1]);
         // Return top-k indices
-        return pairs.slice(0, k).map(function (p) { return p[0]; });
-    };
+        return pairs.slice(0, k).map((p) => p[0]);
+    }
     /**
      * Compute load balance loss for regularization
      *
@@ -616,43 +560,41 @@ var MoERouter = /** @class */ (function () {
      * where f_i = fraction of tokens routed to expert i
      *       P_i = average routing probability to expert i
      */
-    MoERouter.prototype.computeLoadBalanceLoss = function () {
+    computeLoadBalanceLoss() {
         if (this.totalRoutings === 0)
             return 0;
-        var loss = 0;
-        for (var i = 0; i < NUM_EXPERTS; i++) {
-            var fraction = this.routingCounts[i] / this.totalRoutings;
-            var avgProb = this.probs[i]; // Current routing prob
+        let loss = 0;
+        for (let i = 0; i < NUM_EXPERTS; i++) {
+            const fraction = this.routingCounts[i] / this.totalRoutings;
+            const avgProb = this.probs[i]; // Current routing prob
             loss += fraction * avgProb;
         }
         return NUM_EXPERTS * loss * this.config.loadBalanceCoef;
-    };
+    }
     /**
      * Compute Gini coefficient for load distribution
      */
-    MoERouter.prototype.computeGiniCoefficient = function () {
+    computeGiniCoefficient() {
         if (this.totalRoutings === 0)
             return 0;
         // Sort counts
-        var sorted = Array.from(this.routingCounts).sort(function (a, b) { return a - b; });
-        var n = sorted.length;
-        var mean = this.totalRoutings / n;
+        const sorted = Array.from(this.routingCounts).sort((a, b) => a - b);
+        const n = sorted.length;
+        const mean = this.totalRoutings / n;
         // Compute Gini using the formula: G = (2 * sum(i * x_i) - (n+1) * sum(x_i)) / (n * sum(x_i))
-        var weightedSum = 0;
-        for (var i = 0; i < n; i++) {
+        let weightedSum = 0;
+        for (let i = 0; i < n; i++) {
             weightedSum += (i + 1) * sorted[i];
         }
-        var gini = (2 * weightedSum - (n + 1) * this.totalRoutings) /
+        const gini = (2 * weightedSum - (n + 1) * this.totalRoutings) /
             (n * this.totalRoutings + 1e-8);
         return Math.max(0, gini);
-    };
-    return MoERouter;
-}());
-export { MoERouter };
+    }
+}
 // ============================================================================
 // Singleton Instance
 // ============================================================================
-var moeRouterInstance = null;
+let moeRouterInstance = null;
 /**
  * Get singleton MoE router instance
  *
@@ -663,7 +605,7 @@ export function getMoERouter(config) {
     if (!moeRouterInstance) {
         moeRouterInstance = new MoERouter(config);
         // Initialize in background (load weights)
-        moeRouterInstance.initialize()["catch"](function (err) {
+        moeRouterInstance.initialize().catch((err) => {
             console.warn('[MoE] Failed to initialize router:', err);
         });
     }