kynjal-cli 4.0.0 → 4.0.1

package/dist/src/ruvector/flash-attention.js

@@ -14,45 +14,24 @@
  *
  * Created with love by ruv.io
  */
-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 __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));
-};
 // ============================================================================
 // Flash Attention Implementation
 // ============================================================================
-var FlashAttention = /** @class */ (function () {
-    function FlashAttention(config) {
-        if (config === void 0) { config = {}; }
-        var _a, _b, _c, _d, _e;
-        this.lastSpeedup = 0;
-        this.benchmarkHistory = [];
-        // Pre-allocated buffers for CPU optimization
-        this.scoreBuffer = null;
-        this.expBuffer = null;
-        this.accumBuffer = null;
+export class FlashAttention {
+    config;
+    lastSpeedup = 0;
+    benchmarkHistory = [];
+    // Pre-allocated buffers for CPU optimization
+    scoreBuffer = null;
+    expBuffer = null;
+    accumBuffer = null;
+    constructor(config = {}) {
         this.config = {
-            blockSize: (_a = config.blockSize) !== null && _a !== void 0 ? _a : 32,
-            dimensions: (_b = config.dimensions) !== null && _b !== void 0 ? _b : 384,
-            temperature: (_c = config.temperature) !== null && _c !== void 0 ? _c : 1.0,
-            useStableMode: (_d = config.useStableMode) !== null && _d !== void 0 ? _d : true,
-            useCPUOptimizations: (_e = config.useCPUOptimizations) !== null && _e !== void 0 ? _e : true
+            blockSize: config.blockSize ?? 32, // Smaller blocks for CPU L1 cache
+            dimensions: config.dimensions ?? 384,
+            temperature: config.temperature ?? 1.0,
+            useStableMode: config.useStableMode ?? true,
+            useCPUOptimizations: config.useCPUOptimizations ?? true,
         };
     }
     // ==========================================================================
@@ -66,14 +45,14 @@ var FlashAttention = /** @class */ (function () {
      * @param values - Value vectors [M x D]
      * @returns Attention output [N x D]
      */
-    FlashAttention.prototype.attention = function (queries, keys, values) {
-        var startTime = performance.now();
+    attention(queries, keys, values) {
+        const startTime = performance.now();
         // Validate inputs
         this.validateInputs(queries, keys, values);
-        var numQueries = queries.length;
-        var numKeys = keys.length;
+        const numQueries = queries.length;
+        const numKeys = keys.length;
         // Use CPU-optimized path for all sizes when enabled
-        var output;
+        let output;
         if (this.config.useCPUOptimizations) {
             output = this.cpuOptimizedAttention(queries, keys, values);
         }
@@ -83,12 +62,12 @@ var FlashAttention = /** @class */ (function () {
         else {
             output = this.naiveAttention(queries, keys, values);
         }
-        var computeTimeMs = performance.now() - startTime;
+        const computeTimeMs = performance.now() - startTime;
         return {
-            output: output,
-            computeTimeMs: computeTimeMs
+            output,
+            computeTimeMs,
         };
-    };
+    }
     /**
      * CPU-optimized attention with aggressive optimizations
      *
@@ -99,15 +78,14 @@ var FlashAttention = /** @class */ (function () {
      * - 8x loop unrolling for dot products
      * - Fused max-finding during score computation
      */
-    FlashAttention.prototype.cpuOptimizedAttention = function (Q, K, V) {
-        var _a, _b;
-        var numQ = Q.length;
-        var numK = K.length;
-        var dim = (_b = (_a = Q[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : this.config.dimensions;
-        var scale = 1.0 / (Math.sqrt(dim) * this.config.temperature);
+    cpuOptimizedAttention(Q, K, V) {
+        const numQ = Q.length;
+        const numK = K.length;
+        const dim = Q[0]?.length ?? this.config.dimensions;
+        const scale = 1.0 / (Math.sqrt(dim) * this.config.temperature);
         // Sparse attention: Use only top 12% of keys (min 16, max 96)
-        var topK = Math.max(16, Math.min(96, Math.ceil(numK * 0.12)));
-        var useTopK = numK > 32;
+        const topK = Math.max(16, Math.min(96, Math.ceil(numK * 0.12)));
+        const useTopK = numK > 32;
         // Ensure buffers are allocated
         if (!this.scoreBuffer || this.scoreBuffer.length < numK) {
             this.scoreBuffer = new Float32Array(numK);
@@ -118,42 +96,42 @@ var FlashAttention = /** @class */ (function () {
         if (!this.accumBuffer || this.accumBuffer.length < dim) {
             this.accumBuffer = new Float64Array(dim);
         }
-        var scores = this.scoreBuffer;
-        var exps = this.expBuffer;
-        var accum = this.accumBuffer;
+        const scores = this.scoreBuffer;
+        const exps = this.expBuffer;
+        const accum = this.accumBuffer;
         // Pre-allocate output once
-        var output = new Array(numQ);
-        for (var i = 0; i < numQ; i++) {
+        const output = new Array(numQ);
+        for (let i = 0; i < numQ; i++) {
             output[i] = new Float32Array(dim);
         }
         // Reusable index array
-        var indices = useTopK ? new Uint32Array(numK) : null;
+        const indices = useTopK ? new Uint32Array(numK) : null;
         if (indices) {
-            for (var i = 0; i < numK; i++)
+            for (let i = 0; i < numK; i++)
                 indices[i] = i;
         }
         // Two-stage screening: use 1/4 of dimensions for quick filtering
-        var screenDim = Math.min(96, dim >> 2);
-        var screenScale = scale * Math.sqrt(dim / screenDim);
+        const screenDim = Math.min(96, dim >> 2);
+        const screenScale = scale * Math.sqrt(dim / screenDim);
         // Candidate buffer for two-stage filtering
-        var candidateCount = Math.max(topK * 2, Math.ceil(numK * 0.25));
+        const candidateCount = Math.max(topK * 2, Math.ceil(numK * 0.25));
         // Process queries
-        for (var qi = 0; qi < numQ; qi++) {
-            var query = Q[qi];
+        for (let qi = 0; qi < numQ; qi++) {
+            const query = Q[qi];
             if (useTopK && numK > 128) {
                 // Two-stage approach for large key sets
                 // Stage 1: Quick screening with partial dimensions
-                for (var ki = 0; ki < numK; ki++) {
+                for (let ki = 0; ki < numK; ki++) {
                     scores[ki] = this.partialDotProduct(query, K[ki], screenDim) * screenScale;
                     indices[ki] = ki;
                 }
                 // Get top candidates (2x topK)
                 this.partialSort(scores, indices, candidateCount);
                 // Stage 2: Full score computation only for candidates
-                var maxScore = -Infinity;
-                for (var i = 0; i < candidateCount; i++) {
-                    var ki = indices[i];
-                    var s = this.fastDotProduct(query, K[ki], dim) * scale;
+                let maxScore = -Infinity;
+                for (let i = 0; i < candidateCount; i++) {
+                    const ki = indices[i];
+                    const s = this.fastDotProduct(query, K[ki], dim) * scale;
                     scores[ki] = s;
                     if (s > maxScore)
                         maxScore = s;
@@ -162,68 +140,68 @@ var FlashAttention = /** @class */ (function () {
                 this.partialSort(scores, indices.subarray(0, candidateCount), topK);
                 // Compute softmax over top-K
                 maxScore = -Infinity;
-                for (var i = 0; i < topK; i++) {
+                for (let i = 0; i < topK; i++) {
                     if (scores[indices[i]] > maxScore)
                         maxScore = scores[indices[i]];
                 }
-                var sumExp = 0;
-                for (var i = 0; i < topK; i++) {
-                    var e = Math.exp(scores[indices[i]] - maxScore);
+                let sumExp = 0;
+                for (let i = 0; i < topK; i++) {
+                    const e = Math.exp(scores[indices[i]] - maxScore);
                     exps[i] = e;
                     sumExp += e;
                 }
                 // Weighted sum
-                for (var d = 0; d < dim; d++)
+                for (let d = 0; d < dim; d++)
                     accum[d] = 0;
-                var invSum = 1.0 / sumExp;
-                for (var i = 0; i < topK; i++) {
-                    var weight = exps[i] * invSum;
-                    var value = V[indices[i]];
-                    for (var d = 0; d < dim; d++) {
+                const invSum = 1.0 / sumExp;
+                for (let i = 0; i < topK; i++) {
+                    const weight = exps[i] * invSum;
+                    const value = V[indices[i]];
+                    for (let d = 0; d < dim; d++) {
                         accum[d] += weight * value[d];
                     }
                 }
             }
             else {
                 // Simple path for small key sets
-                var maxScore = -Infinity;
-                for (var ki = 0; ki < numK; ki++) {
-                    var s = this.fastDotProduct(query, K[ki], dim) * scale;
+                let maxScore = -Infinity;
+                for (let ki = 0; ki < numK; ki++) {
+                    const s = this.fastDotProduct(query, K[ki], dim) * scale;
                     scores[ki] = s;
                     if (s > maxScore)
                         maxScore = s;
                 }
-                var sumExp = 0;
-                for (var ki = 0; ki < numK; ki++) {
-                    var e = Math.exp(scores[ki] - maxScore);
+                let sumExp = 0;
+                for (let ki = 0; ki < numK; ki++) {
+                    const e = Math.exp(scores[ki] - maxScore);
                     exps[ki] = e;
                     sumExp += e;
                 }
-                for (var d = 0; d < dim; d++)
+                for (let d = 0; d < dim; d++)
                     accum[d] = 0;
-                var invSum = 1.0 / sumExp;
-                for (var ki = 0; ki < numK; ki++) {
-                    var weight = exps[ki] * invSum;
-                    var value = V[ki];
-                    for (var d = 0; d < dim; d++) {
+                const invSum = 1.0 / sumExp;
+                for (let ki = 0; ki < numK; ki++) {
+                    const weight = exps[ki] * invSum;
+                    const value = V[ki];
+                    for (let d = 0; d < dim; d++) {
                         accum[d] += weight * value[d];
                     }
                 }
             }
             // Copy to output
-            var out = output[qi];
-            for (var d = 0; d < dim; d++) {
+            const out = output[qi];
+            for (let d = 0; d < dim; d++) {
                 out[d] = accum[d];
             }
         }
         return output;
-    };
+    }
     /**
      * Partial dot product using only first N dimensions (for screening)
      */
-    FlashAttention.prototype.partialDotProduct = function (a, b, len) {
-        var sum = 0;
-        var i = 0;
+    partialDotProduct(a, b, len) {
+        let sum = 0;
+        let i = 0;
         for (; i <= len - 4; i += 4) {
             sum += a[i] * b[i] + a[i + 1] * b[i + 1] + a[i + 2] * b[i + 2] + a[i + 3] * b[i + 3];
         }
@@ -231,26 +209,26 @@ var FlashAttention = /** @class */ (function () {
             sum += a[i] * b[i];
         }
         return sum;
-    };
+    }
     /**
      * Partial sort to get top-K elements (QuickSelect-like)
      * Only ensures first K elements are the largest, not sorted
      */
-    FlashAttention.prototype.partialSort = function (scores, indices, k) {
-        var n = indices.length;
+    partialSort(scores, indices, k) {
+        const n = indices.length;
         if (k >= n)
             return;
         // Use partition-based selection (O(n) average)
-        var left = 0;
-        var right = n - 1;
+        let left = 0;
+        let right = n - 1;
         while (left < right) {
             // Partition around pivot
-            var pivotIdx = left + Math.floor(Math.random() * (right - left + 1));
-            var pivotScore = scores[indices[pivotIdx]];
+            const pivotIdx = left + Math.floor(Math.random() * (right - left + 1));
+            const pivotScore = scores[indices[pivotIdx]];
             // Move pivot to end
             this.swapIndices(indices, pivotIdx, right);
-            var storeIdx = left;
-            for (var i = left; i < right; i++) {
+            let storeIdx = left;
+            for (let i = left; i < right; i++) {
                 if (scores[indices[i]] > pivotScore) {
                     this.swapIndices(indices, i, storeIdx);
                     storeIdx++;
@@ -268,21 +246,21 @@ var FlashAttention = /** @class */ (function () {
                 right = storeIdx - 1;
             }
         }
-    };
+    }
     /**
      * Swap two indices in array
      */
-    FlashAttention.prototype.swapIndices = function (arr, i, j) {
-        var temp = arr[i];
+    swapIndices(arr, i, j) {
+        const temp = arr[i];
         arr[i] = arr[j];
         arr[j] = temp;
-    };
+    }
     /**
      * Fast dot product with 8x unrolling
      */
-    FlashAttention.prototype.fastDotProduct = function (a, b, len) {
-        var sum = 0;
-        var i = 0;
+    fastDotProduct(a, b, len) {
+        let sum = 0;
+        let i = 0;
         // 8x unroll
         for (; i <= len - 8; i += 8) {
             sum += a[i] * b[i] +
@@ -299,7 +277,7 @@ var FlashAttention = /** @class */ (function () {
             sum += a[i] * b[i];
         }
         return sum;
-    };
+    }
     /**
      * Block-wise attention computation (Flash Attention core algorithm)
      *
@@ -315,50 +293,49 @@ var FlashAttention = /** @class */ (function () {
      * @param V - Value vectors
      * @param blockSize - Block size for tiling
      */
-    FlashAttention.prototype.blockAttention = function (Q, K, V, blockSize) {
-        var _a, _b;
-        var numQueries = Q.length;
-        var numKeys = K.length;
-        var dimensions = (_b = (_a = Q[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : this.config.dimensions;
-        var scale = 1.0 / (Math.sqrt(dimensions) * this.config.temperature);
+    blockAttention(Q, K, V, blockSize) {
+        const numQueries = Q.length;
+        const numKeys = K.length;
+        const dimensions = Q[0]?.length ?? this.config.dimensions;
+        const scale = 1.0 / (Math.sqrt(dimensions) * this.config.temperature);
         // Initialize output arrays
-        var output = new Array(numQueries);
-        for (var i = 0; i < numQueries; i++) {
+        const output = new Array(numQueries);
+        for (let i = 0; i < numQueries; i++) {
             output[i] = new Float32Array(dimensions);
         }
         // Online softmax state: max values and sum of exp for each query
-        var maxScores = new Float32Array(numQueries).fill(-Infinity);
-        var sumExp = new Float32Array(numQueries).fill(0);
+        const maxScores = new Float32Array(numQueries).fill(-Infinity);
+        const sumExp = new Float32Array(numQueries).fill(0);
         // Process in blocks
-        for (var kStart = 0; kStart < numKeys; kStart += blockSize) {
-            var kEnd = Math.min(kStart + blockSize, numKeys);
-            var kBlockSize = kEnd - kStart;
+        for (let kStart = 0; kStart < numKeys; kStart += blockSize) {
+            const kEnd = Math.min(kStart + blockSize, numKeys);
+            const kBlockSize = kEnd - kStart;
             // Process each query against this key block
-            for (var qStart = 0; qStart < numQueries; qStart += blockSize) {
-                var qEnd = Math.min(qStart + blockSize, numQueries);
+            for (let qStart = 0; qStart < numQueries; qStart += blockSize) {
+                const qEnd = Math.min(qStart + blockSize, numQueries);
                 // Compute attention scores for this block
-                var blockScores = this.computeBlockScores(Q, K, qStart, qEnd, kStart, kEnd, scale);
+                const blockScores = this.computeBlockScores(Q, K, qStart, qEnd, kStart, kEnd, scale);
                 // Apply online softmax and accumulate output
                 this.onlineSoftmaxAccumulate(blockScores, V, output, maxScores, sumExp, qStart, qEnd, kStart, kEnd);
             }
         }
         // Normalize outputs by final sum of exponentials
-        for (var i = 0; i < numQueries; i++) {
-            var normalizer = sumExp[i];
+        for (let i = 0; i < numQueries; i++) {
+            const normalizer = sumExp[i];
             if (normalizer > 0) {
-                for (var d = 0; d < dimensions; d++) {
+                for (let d = 0; d < dimensions; d++) {
                     output[i][d] /= normalizer;
                 }
             }
         }
         return output;
-    };
+    }
     /**
      * Get the speedup factor from the last benchmark
      */
-    FlashAttention.prototype.getSpeedup = function () {
+    getSpeedup() {
         return this.lastSpeedup;
-    };
+    }
     /**
      * Run benchmark comparing naive vs CPU-optimized attention
      *
@@ -366,165 +343,160 @@ var FlashAttention = /** @class */ (function () {
      * @param dimensions - Dimensions per vector
      * @param iterations - Number of iterations for averaging
      */
-    FlashAttention.prototype.benchmark = function (numVectors, dimensions, iterations) {
-        if (numVectors === void 0) { numVectors = 512; }
-        if (dimensions === void 0) { dimensions = 384; }
-        if (iterations === void 0) { iterations = 5; }
+    benchmark(numVectors = 512, dimensions = 384, iterations = 5) {
         // Generate random test data
-        var queries = this.generateRandomVectors(numVectors, dimensions);
-        var keys = this.generateRandomVectors(numVectors, dimensions);
-        var values = this.generateRandomVectors(numVectors, dimensions);
+        const queries = this.generateRandomVectors(numVectors, dimensions);
+        const keys = this.generateRandomVectors(numVectors, dimensions);
+        const values = this.generateRandomVectors(numVectors, dimensions);
         // Warm up both paths
         this.naiveAttention(queries.slice(0, 10), keys.slice(0, 10), values.slice(0, 10));
         this.cpuOptimizedAttention(queries.slice(0, 10), keys.slice(0, 10), values.slice(0, 10));
         // Benchmark naive attention
-        var naiveTotalMs = 0;
-        for (var i = 0; i < iterations; i++) {
-            var start = performance.now();
+        let naiveTotalMs = 0;
+        for (let i = 0; i < iterations; i++) {
+            const start = performance.now();
             this.naiveAttention(queries, keys, values);
             naiveTotalMs += performance.now() - start;
         }
-        var naiveTimeMs = naiveTotalMs / iterations;
+        const naiveTimeMs = naiveTotalMs / iterations;
         // Benchmark CPU-optimized attention
-        var flashTotalMs = 0;
-        for (var i = 0; i < iterations; i++) {
-            var start = performance.now();
+        let flashTotalMs = 0;
+        for (let i = 0; i < iterations; i++) {
+            const start = performance.now();
             this.cpuOptimizedAttention(queries, keys, values);
             flashTotalMs += performance.now() - start;
         }
-        var flashTimeMs = flashTotalMs / iterations;
+        const flashTimeMs = flashTotalMs / iterations;
         // Calculate metrics
-        var speedup = naiveTimeMs / flashTimeMs;
+        const speedup = naiveTimeMs / flashTimeMs;
         this.lastSpeedup = speedup;
         // Memory estimates
         // Naive: needs full N x N attention matrix
-        var naiveMemoryBytes = numVectors * numVectors * 4; // Float32
+        const naiveMemoryBytes = numVectors * numVectors * 4; // Float32
         // Flash: only needs block_size x block_size at a time
-        var flashMemoryBytes = this.config.blockSize * this.config.blockSize * 4;
-        var memoryReduction = naiveMemoryBytes / flashMemoryBytes;
-        var result = {
-            naiveTimeMs: naiveTimeMs,
-            flashTimeMs: flashTimeMs,
-            speedup: speedup,
-            numVectors: numVectors,
-            dimensions: dimensions,
-            naiveMemoryBytes: naiveMemoryBytes,
-            flashMemoryBytes: flashMemoryBytes,
-            memoryReduction: memoryReduction
+        const flashMemoryBytes = this.config.blockSize * this.config.blockSize * 4;
+        const memoryReduction = naiveMemoryBytes / flashMemoryBytes;
+        const result = {
+            naiveTimeMs,
+            flashTimeMs,
+            speedup,
+            numVectors,
+            dimensions,
+            naiveMemoryBytes,
+            flashMemoryBytes,
+            memoryReduction,
         };
         this.benchmarkHistory.push(result);
         return result;
-    };
+    }
     /**
      * Get benchmark history
      */
-    FlashAttention.prototype.getBenchmarkHistory = function () {
-        return __spreadArray([], this.benchmarkHistory, true);
-    };
+    getBenchmarkHistory() {
+        return [...this.benchmarkHistory];
+    }
     /**
      * Get configuration
      */
-    FlashAttention.prototype.getConfig = function () {
-        return __assign({}, this.config);
-    };
+    getConfig() {
+        return { ...this.config };
+    }
     /**
      * Update configuration
      */
-    FlashAttention.prototype.setConfig = function (config) {
-        this.config = __assign(__assign({}, this.config), config);
-    };
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
     // ==========================================================================
     // Private Methods
     // ==========================================================================
     /**
      * Naive O(N^2) attention implementation for comparison
      */
-    FlashAttention.prototype.naiveAttention = function (queries, keys, values) {
-        var _a, _b;
-        var numQueries = queries.length;
-        var numKeys = keys.length;
-        var dimensions = (_b = (_a = queries[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : this.config.dimensions;
-        var scale = 1.0 / (Math.sqrt(dimensions) * this.config.temperature);
+    naiveAttention(queries, keys, values) {
+        const numQueries = queries.length;
+        const numKeys = keys.length;
+        const dimensions = queries[0]?.length ?? this.config.dimensions;
+        const scale = 1.0 / (Math.sqrt(dimensions) * this.config.temperature);
         // Compute full attention matrix Q @ K.T
-        var scores = new Array(numQueries);
-        for (var i = 0; i < numQueries; i++) {
+        const scores = new Array(numQueries);
+        for (let i = 0; i < numQueries; i++) {
             scores[i] = new Float32Array(numKeys);
-            for (var j = 0; j < numKeys; j++) {
+            for (let j = 0; j < numKeys; j++) {
                 scores[i][j] = this.dotProduct(queries[i], keys[j]) * scale;
             }
         }
         // Softmax over each row
-        var attentionWeights = new Array(numQueries);
-        for (var i = 0; i < numQueries; i++) {
+        const attentionWeights = new Array(numQueries);
+        for (let i = 0; i < numQueries; i++) {
             attentionWeights[i] = this.softmax(scores[i]);
         }
         // Compute output: attention @ V
-        var output = new Array(numQueries);
-        for (var i = 0; i < numQueries; i++) {
+        const output = new Array(numQueries);
+        for (let i = 0; i < numQueries; i++) {
             output[i] = new Float32Array(dimensions);
-            for (var j = 0; j < numKeys; j++) {
-                var weight = attentionWeights[i][j];
-                for (var d = 0; d < dimensions; d++) {
+            for (let j = 0; j < numKeys; j++) {
+                const weight = attentionWeights[i][j];
+                for (let d = 0; d < dimensions; d++) {
                     output[i][d] += weight * values[j][d];
                 }
             }
         }
         return output;
-    };
+    }
     /**
      * Compute block of attention scores
      */
-    FlashAttention.prototype.computeBlockScores = function (Q, K, qStart, qEnd, kStart, kEnd, scale) {
-        var qBlockSize = qEnd - qStart;
-        var kBlockSize = kEnd - kStart;
-        var scores = new Array(qBlockSize);
-        for (var qi = 0; qi < qBlockSize; qi++) {
+    computeBlockScores(Q, K, qStart, qEnd, kStart, kEnd, scale) {
+        const qBlockSize = qEnd - qStart;
+        const kBlockSize = kEnd - kStart;
+        const scores = new Array(qBlockSize);
+        for (let qi = 0; qi < qBlockSize; qi++) {
             scores[qi] = new Float32Array(kBlockSize);
-            var query = Q[qStart + qi];
-            for (var ki = 0; ki < kBlockSize; ki++) {
+            const query = Q[qStart + qi];
+            for (let ki = 0; ki < kBlockSize; ki++) {
                 scores[qi][ki] = this.dotProduct(query, K[kStart + ki]) * scale;
             }
         }
         return scores;
-    };
+    }
     /**
      * Online softmax with output accumulation (key to Flash Attention)
      *
      * Uses the online softmax trick to maintain numerical stability
      * while processing blocks incrementally.
      */
-    FlashAttention.prototype.onlineSoftmaxAccumulate = function (blockScores, V, output, maxScores, sumExp, qStart, qEnd, kStart, kEnd) {
-        var _a, _b;
-        var qBlockSize = qEnd - qStart;
-        var kBlockSize = kEnd - kStart;
-        var dimensions = (_b = (_a = output[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : this.config.dimensions;
-        for (var qi = 0; qi < qBlockSize; qi++) {
-            var globalQi = qStart + qi;
-            var rowScores = blockScores[qi];
+    onlineSoftmaxAccumulate(blockScores, V, output, maxScores, sumExp, qStart, qEnd, kStart, kEnd) {
+        const qBlockSize = qEnd - qStart;
+        const kBlockSize = kEnd - kStart;
+        const dimensions = output[0]?.length ?? this.config.dimensions;
+        for (let qi = 0; qi < qBlockSize; qi++) {
+            const globalQi = qStart + qi;
+            const rowScores = blockScores[qi];
             // Find max in this block
-            var blockMax = -Infinity;
-            for (var ki = 0; ki < kBlockSize; ki++) {
+            let blockMax = -Infinity;
+            for (let ki = 0; ki < kBlockSize; ki++) {
                 if (rowScores[ki] > blockMax) {
                     blockMax = rowScores[ki];
                 }
             }
-            var oldMax = maxScores[globalQi];
-            var newMax = Math.max(oldMax, blockMax);
+            const oldMax = maxScores[globalQi];
+            const newMax = Math.max(oldMax, blockMax);
             // Correction factor for previous outputs
-            var correction = oldMax === -Infinity ? 0 : Math.exp(oldMax - newMax);
+            const correction = oldMax === -Infinity ? 0 : Math.exp(oldMax - newMax);
             // Update sum of exponentials with correction
-            var newSumExp = sumExp[globalQi] * correction;
+            let newSumExp = sumExp[globalQi] * correction;
             // Scale existing output by correction factor
-            for (var d = 0; d < dimensions; d++) {
+            for (let d = 0; d < dimensions; d++) {
                 output[globalQi][d] *= correction;
             }
             // Process this block
-            for (var ki = 0; ki < kBlockSize; ki++) {
-                var expScore = Math.exp(rowScores[ki] - newMax);
+            for (let ki = 0; ki < kBlockSize; ki++) {
+                const expScore = Math.exp(rowScores[ki] - newMax);
                 newSumExp += expScore;
                 // Accumulate weighted values
-                var value = V[kStart + ki];
-                for (var d = 0; d < dimensions; d++) {
+                const value = V[kStart + ki];
+                for (let d = 0; d < dimensions; d++) {
                     output[globalQi][d] += expScore * value[d];
                 }
             }
@@ -532,15 +504,15 @@ var FlashAttention = /** @class */ (function () {
             maxScores[globalQi] = newMax;
             sumExp[globalQi] = newSumExp;
         }
-    };
+    }
     /**
      * Compute dot product of two vectors
      */
-    FlashAttention.prototype.dotProduct = function (a, b) {
-        var sum = 0;
-        var len = Math.min(a.length, b.length);
+    dotProduct(a, b) {
+        let sum = 0;
+        const len = Math.min(a.length, b.length);
         // Unroll loop for performance (4x unroll)
-        var i = 0;
+        let i = 0;
         for (; i <= len - 4; i += 4) {
             sum += a[i] * b[i] +
                 a[i + 1] * b[i + 1] +
@@ -552,85 +524,82 @@ var FlashAttention = /** @class */ (function () {
             sum += a[i] * b[i];
         }
         return sum;
-    };
+    }
     /**
      * Stable softmax implementation
      */
-    FlashAttention.prototype.softmax = function (scores) {
-        var result = new Float32Array(scores.length);
+    softmax(scores) {
+        const result = new Float32Array(scores.length);
         // Find max for numerical stability
-        var max = -Infinity;
-        for (var i = 0; i < scores.length; i++) {
+        let max = -Infinity;
+        for (let i = 0; i < scores.length; i++) {
             if (scores[i] > max) {
                 max = scores[i];
             }
         }
         // Compute exp and sum
-        var sum = 0;
-        for (var i = 0; i < scores.length; i++) {
+        let sum = 0;
+        for (let i = 0; i < scores.length; i++) {
             result[i] = Math.exp(scores[i] - max);
             sum += result[i];
         }
         // Normalize
         if (sum > 0) {
-            for (var i = 0; i < scores.length; i++) {
+            for (let i = 0; i < scores.length; i++) {
                 result[i] /= sum;
             }
         }
         return result;
-    };
+    }
     /**
      * Generate random vectors for benchmarking
      */
-    FlashAttention.prototype.generateRandomVectors = function (count, dimensions) {
-        var vectors = new Array(count);
-        for (var i = 0; i < count; i++) {
+    generateRandomVectors(count, dimensions) {
+        const vectors = new Array(count);
+        for (let i = 0; i < count; i++) {
             vectors[i] = new Float32Array(dimensions);
-            for (var d = 0; d < dimensions; d++) {
+            for (let d = 0; d < dimensions; d++) {
                 vectors[i][d] = (Math.random() - 0.5) * 2;
             }
             // Normalize
-            var norm = 0;
-            for (var d = 0; d < dimensions; d++) {
+            let norm = 0;
+            for (let d = 0; d < dimensions; d++) {
                 norm += vectors[i][d] * vectors[i][d];
             }
             norm = Math.sqrt(norm);
             if (norm > 0) {
-                for (var d = 0; d < dimensions; d++) {
+                for (let d = 0; d < dimensions; d++) {
                     vectors[i][d] /= norm;
                 }
             }
         }
         return vectors;
-    };
+    }
     /**
      * Validate input arrays
      */
-    FlashAttention.prototype.validateInputs = function (queries, keys, values) {
-        var _a, _b, _c, _d, _e, _f;
+    validateInputs(queries, keys, values) {
         if (!queries.length || !keys.length || !values.length) {
             throw new Error('FlashAttention: Empty input arrays');
         }
         if (keys.length !== values.length) {
-            throw new Error("FlashAttention: Keys and values must have same count. Got " + keys.length + " keys, " + values.length + " values");
+            throw new Error(`FlashAttention: Keys and values must have same count. Got ${keys.length} keys, ${values.length} values`);
         }
-        var qDim = (_b = (_a = queries[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
-        var kDim = (_d = (_c = keys[0]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
-        var vDim = (_f = (_e = values[0]) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0;
+        const qDim = queries[0]?.length ?? 0;
+        const kDim = keys[0]?.length ?? 0;
+        const vDim = values[0]?.length ?? 0;
         if (qDim !== kDim) {
-            throw new Error("FlashAttention: Query and key dimensions must match. Got Q=" + qDim + ", K=" + kDim);
+            throw new Error(`FlashAttention: Query and key dimensions must match. Got Q=${qDim}, K=${kDim}`);
         }
         if (kDim !== vDim) {
-            throw new Error("FlashAttention: Key and value dimensions must match. Got K=" + kDim + ", V=" + vDim);
+            throw new Error(`FlashAttention: Key and value dimensions must match. Got K=${kDim}, V=${vDim}`);
         }
-    };
-    return FlashAttention;
-}());
-export { FlashAttention };
+    }
+}
 // ============================================================================
 // Singleton Instance
 // ============================================================================
-var flashAttentionInstance = null;
+let flashAttentionInstance = null;
 /**
  * Get singleton FlashAttention instance
  *
@@ -656,7 +625,7 @@ export function resetFlashAttention() {
  * Compute attention using Flash Attention
  */
 export function computeAttention(queries, keys, values, config) {
-    var fa = config ? new FlashAttention(config) : getFlashAttention();
+    const fa = config ? new FlashAttention(config) : getFlashAttention();
     return fa.attention(queries, keys, values);
 }
 /**