agentic-flow 3.0.0-alpha.1 → 3.0.0

package/dist/packages/agentdb/src/controllers/AttentionService.js

@@ -1,849 +0,0 @@
-/**
- * AttentionService - Advanced Attention Mechanisms for AgentDB
- *
- * Provides state-of-the-art attention mechanisms with runtime detection:
- * - MultiHeadAttention (standard transformer attention)
- * - FlashAttention (memory-efficient attention, 7.47x speedup)
- * - HyperbolicAttention (hyperbolic space attention)
- * - MoEAttention (Mixture-of-Experts attention)
- * - LinearAttention (linear complexity attention)
- *
- * ADR-064 Phase 1: Native Flash Attention integration with @ruvector/attention
- * bindings for 7.47x speedup. High-level API (applyFlashAttention, applyMultiHeadAttention,
- * applyMoE) works with number[] arrays for ergonomic MCP tool usage.
- *
- * Features:
- * - Automatic runtime detection (Node.js NAPI vs Browser WASM)
- * - Zero-copy Float32Array processing
- * - Graceful fallbacks for unsupported environments
- * - Performance monitoring hooks
- * - Type-safe interfaces
- */
-/**
- * Detect the current runtime environment
- */
-function detectRuntime() {
-    // Check for Node.js
-    if (typeof process !== 'undefined' && process.versions && process.versions.node) {
-        return 'nodejs';
-    }
-    // Check for browser (with proper type guards)
-    if (typeof globalThis !== 'undefined') {
-        const global = globalThis;
-        if (typeof global.window !== 'undefined' && typeof global.document !== 'undefined') {
-            return 'browser';
-        }
-    }
-    return 'unknown';
-}
-/**
- * AttentionService - Main controller for attention mechanisms
- *
- * ADR-062 Phase 2: Enhanced with explicit native binding detection,
- * engine type reporting, and @ruvector/graph-transformer integration.
- */
-export class AttentionService {
-    config;
-    runtime;
-    napiModule = null;
-    wasmModule = null;
-    initialized = false;
-    engineType = 'fallback';
-    // Performance tracking
-    stats = {
-        totalOps: 0,
-        avgExecutionTimeMs: 0,
-        peakMemoryBytes: 0,
-        mechanismCounts: {},
-        runtimeCounts: {}
-    };
-    constructor(config) {
-        this.config = {
-            dropout: 0.1,
-            bias: true,
-            useFlash: true,
-            useLinear: false,
-            useHyperbolic: false,
-            useMoE: false,
-            numExperts: 8,
-            topK: 2,
-            ...config
-        };
-        this.runtime = detectRuntime();
-    }
-    /**
-     * Get the active engine type: 'napi', 'wasm', or 'fallback'
-     */
-    getEngineType() {
-        return this.engineType;
-    }
-    /**
-     * Initialize the attention service
-     * Automatically detects and loads the appropriate backend (NAPI or WASM)
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        performance.mark('attention-service-init-start');
-        try {
-            if (this.runtime === 'nodejs') {
-                // Try to load NAPI module for Node.js
-                await this.loadNAPIModule();
-            }
-            else if (this.runtime === 'browser') {
-                // Load WASM module for browsers
-                await this.loadWASMModule();
-            }
-            else {
-                console.warn('⚠️  Unknown runtime environment, using fallback implementation');
-            }
-            this.initialized = true;
-            performance.mark('attention-service-init-end');
-            performance.measure('attention-service-init', 'attention-service-init-start', 'attention-service-init-end');
-            const measure = performance.getEntriesByName('attention-service-init')[0];
-            console.log(`✅ AttentionService initialized in ${measure.duration.toFixed(2)}ms (${this.runtime})`);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`❌ AttentionService initialization failed: ${errorMessage}`);
-            throw new Error(`Failed to initialize AttentionService: ${errorMessage}`);
-        }
-    }
-    /**
-     * Load NAPI module for Node.js runtime
-     *
-     * ADR-062: Tries native @ruvector/attention first, then
-     * @ruvector/graph-transformer sublinear attention as a secondary path.
-     */
-    async loadNAPIModule() {
-        // Strategy 1: Try @ruvector/attention (direct NAPI-RS bindings)
-        try {
-            // @ts-ignore - Optional dependency
-            const mod = await import('@ruvector/attention');
-            if (mod && (typeof mod.multiHeadAttention === 'function' || typeof mod.flashAttention === 'function' || mod.default)) {
-                this.napiModule = mod;
-                this.engineType = 'napi';
-                console.log('[AttentionService] Using native @ruvector/attention NAPI-RS (2.49x-7.47x speedup)');
-                return;
-            }
-        }
-        catch {
-            // Not available, try next
-        }
-        // Strategy 2: Try @ruvector/graph-transformer for sublinear attention
-        try {
-            // @ts-ignore - Optional dependency
-            const { GraphTransformer } = await import('@ruvector/graph-transformer');
-            if (GraphTransformer) {
-                const gt = new GraphTransformer();
-                // Wrap graph-transformer as a partial NAPI module
-                this.napiModule = {
-                    _graphTransformer: gt,
-                    _isGraphTransformerShim: true,
-                };
-                this.engineType = 'napi';
-                console.log('[AttentionService] Using @ruvector/graph-transformer native attention');
-                return;
-            }
-        }
-        catch {
-            // Not available
-        }
-        console.warn('[AttentionService] No native bindings available, using JS fallback');
-        this.napiModule = null;
-        this.engineType = 'fallback';
-    }
-    /**
-     * Load WASM module for browser runtime
-     */
-    async loadWASMModule() {
-        try {
-            // @ts-ignore - Optional dependency
-            this.wasmModule = await import('ruvector-attention-wasm');
-            await this.wasmModule.default(); // Initialize WASM
-            this.engineType = 'wasm';
-            console.log('[AttentionService] Using ruvector-attention-wasm');
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.warn(`[AttentionService] WASM not available: ${errorMessage}`);
-            this.wasmModule = null;
-            this.engineType = 'fallback';
-        }
-    }
-    /**
-     * Compute multi-head attention
-     *
-     * @param query - Query vectors [batchSize * seqLen * embedDim]
-     * @param key - Key vectors [batchSize * seqLen * embedDim]
-     * @param value - Value vectors [batchSize * seqLen * embedDim]
-     * @param mask - Optional attention mask [batchSize * seqLen * seqLen]
-     * @returns Attention output and metadata
-     */
-    async multiHeadAttention(query, key, value, mask) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        performance.mark('mha-start');
-        const startTime = Date.now();
-        try {
-            let output;
-            let weights;
-            let runtime = 'fallback';
-            // Try NAPI first (fastest for Node.js)
-            if (this.napiModule && this.napiModule.multiHeadAttention) {
-                const result = this.napiModule.multiHeadAttention(query, key, value, this.config.numHeads, this.config.headDim, mask);
-                output = result.output;
-                weights = result.weights;
-                runtime = 'napi';
-            }
-            // Try WASM (for browsers)
-            else if (this.wasmModule && this.wasmModule.multiHeadAttention) {
-                const result = this.wasmModule.multiHeadAttention(query, key, value, this.config.numHeads, this.config.headDim, mask);
-                output = result.output;
-                weights = result.weights;
-                runtime = 'wasm';
-            }
-            // Fallback to JavaScript implementation
-            else {
-                const result = this.multiHeadAttentionFallback(query, key, value, mask);
-                output = result.output;
-                weights = result.weights;
-                runtime = 'fallback';
-            }
-            performance.mark('mha-end');
-            performance.measure('mha', 'mha-start', 'mha-end');
-            const measure = performance.getEntriesByName('mha')[0];
-            const executionTimeMs = measure.duration;
-            // Update statistics
-            this.updateStats('multi-head', runtime, executionTimeMs, output.length * 4);
-            return {
-                output,
-                weights,
-                executionTimeMs,
-                mechanism: 'multi-head',
-                runtime
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Multi-head attention failed: ${errorMessage}`);
-        }
-    }
-    /**
-     * Compute Flash Attention (memory-efficient)
-     *
-     * Flash Attention reduces memory usage from O(n²) to O(n) for sequence length n
-     *
-     * @param query - Query vectors
-     * @param key - Key vectors
-     * @param value - Value vectors
-     * @param mask - Optional attention mask
-     * @returns Attention output and metadata
-     */
-    async flashAttention(query, key, value, mask) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        performance.mark('flash-start');
-        try {
-            let output;
-            let runtime = 'fallback';
-            // Try NAPI first
-            if (this.napiModule && this.napiModule.flashAttention) {
-                output = this.napiModule.flashAttention(query, key, value, this.config.numHeads, this.config.headDim, mask);
-                runtime = 'napi';
-            }
-            // Try WASM
-            else if (this.wasmModule && this.wasmModule.flashAttention) {
-                output = this.wasmModule.flashAttention(query, key, value, this.config.numHeads, this.config.headDim, mask);
-                runtime = 'wasm';
-            }
-            // Fallback (same as multi-head for now)
-            else {
-                const result = this.multiHeadAttentionFallback(query, key, value, mask);
-                output = result.output;
-                runtime = 'fallback';
-            }
-            performance.mark('flash-end');
-            performance.measure('flash', 'flash-start', 'flash-end');
-            const measure = performance.getEntriesByName('flash')[0];
-            const executionTimeMs = measure.duration;
-            // Update statistics
-            this.updateStats('flash', runtime, executionTimeMs, output.length * 4);
-            return {
-                output,
-                executionTimeMs,
-                mechanism: 'flash',
-                runtime
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Flash attention failed: ${errorMessage}`);
-        }
-    }
-    /**
-     * Compute Linear Attention (O(n) complexity)
-     *
-     * Linear attention approximates standard attention with linear complexity
-     *
-     * @param query - Query vectors
-     * @param key - Key vectors
-     * @param value - Value vectors
-     * @returns Attention output and metadata
-     */
-    async linearAttention(query, key, value) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        performance.mark('linear-start');
-        try {
-            let output;
-            let runtime = 'fallback';
-            // Try NAPI first
-            if (this.napiModule && this.napiModule.linearAttention) {
-                output = this.napiModule.linearAttention(query, key, value, this.config.numHeads, this.config.headDim);
-                runtime = 'napi';
-            }
-            // Try WASM
-            else if (this.wasmModule && this.wasmModule.linearAttention) {
-                output = this.wasmModule.linearAttention(query, key, value, this.config.numHeads, this.config.headDim);
-                runtime = 'wasm';
-            }
-            // Fallback
-            else {
-                output = this.linearAttentionFallback(query, key, value);
-                runtime = 'fallback';
-            }
-            performance.mark('linear-end');
-            performance.measure('linear', 'linear-start', 'linear-end');
-            const measure = performance.getEntriesByName('linear')[0];
-            const executionTimeMs = measure.duration;
-            // Update statistics
-            this.updateStats('linear', runtime, executionTimeMs, output.length * 4);
-            return {
-                output,
-                executionTimeMs,
-                mechanism: 'linear',
-                runtime
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Linear attention failed: ${errorMessage}`);
-        }
-    }
-    /**
-     * Compute Hyperbolic Attention (for hierarchical data)
-     *
-     * Hyperbolic attention operates in hyperbolic space, suitable for tree-like structures
-     *
-     * @param query - Query vectors
-     * @param key - Key vectors
-     * @param value - Value vectors
-     * @param curvature - Hyperbolic space curvature (default: -1.0)
-     * @returns Attention output and metadata
-     */
-    async hyperbolicAttention(query, key, value, curvature = -1.0) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        performance.mark('hyperbolic-start');
-        try {
-            let output;
-            let runtime = 'fallback';
-            // Try NAPI first
-            if (this.napiModule && this.napiModule.hyperbolicAttention) {
-                output = this.napiModule.hyperbolicAttention(query, key, value, this.config.numHeads, this.config.headDim, curvature);
-                runtime = 'napi';
-            }
-            // Try WASM
-            else if (this.wasmModule && this.wasmModule.hyperbolicAttention) {
-                output = this.wasmModule.hyperbolicAttention(query, key, value, this.config.numHeads, this.config.headDim, curvature);
-                runtime = 'wasm';
-            }
-            // Fallback (use standard attention)
-            else {
-                const result = this.multiHeadAttentionFallback(query, key, value);
-                output = result.output;
-                runtime = 'fallback';
-            }
-            performance.mark('hyperbolic-end');
-            performance.measure('hyperbolic', 'hyperbolic-start', 'hyperbolic-end');
-            const measure = performance.getEntriesByName('hyperbolic')[0];
-            const executionTimeMs = measure.duration;
-            // Update statistics
-            this.updateStats('hyperbolic', runtime, executionTimeMs, output.length * 4);
-            return {
-                output,
-                executionTimeMs,
-                mechanism: 'hyperbolic',
-                runtime
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Hyperbolic attention failed: ${errorMessage}`);
-        }
-    }
-    /**
-     * Compute Mixture-of-Experts (MoE) Attention
-     *
-     * MoE routes inputs to different expert attention mechanisms
-     *
-     * @param query - Query vectors
-     * @param key - Key vectors
-     * @param value - Value vectors
-     * @param mask - Optional attention mask
-     * @returns Attention output and metadata
-     */
-    async moeAttention(query, key, value, mask) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        performance.mark('moe-start');
-        try {
-            let output;
-            let runtime = 'fallback';
-            const numExperts = this.config.numExperts || 8;
-            const topK = this.config.topK || 2;
-            // Try NAPI first
-            if (this.napiModule && this.napiModule.moeAttention) {
-                output = this.napiModule.moeAttention(query, key, value, this.config.numHeads, this.config.headDim, numExperts, topK, mask);
-                runtime = 'napi';
-            }
-            // Try WASM
-            else if (this.wasmModule && this.wasmModule.moeAttention) {
-                output = this.wasmModule.moeAttention(query, key, value, this.config.numHeads, this.config.headDim, numExperts, topK, mask);
-                runtime = 'wasm';
-            }
-            // Fallback (use standard attention)
-            else {
-                const result = this.multiHeadAttentionFallback(query, key, value, mask);
-                output = result.output;
-                runtime = 'fallback';
-            }
-            performance.mark('moe-end');
-            performance.measure('moe', 'moe-start', 'moe-end');
-            const measure = performance.getEntriesByName('moe')[0];
-            const executionTimeMs = measure.duration;
-            // Update statistics
-            this.updateStats('moe', runtime, executionTimeMs, output.length * 4);
-            return {
-                output,
-                executionTimeMs,
-                mechanism: 'moe',
-                runtime
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`MoE attention failed: ${errorMessage}`);
-        }
-    }
-    /**
-     * Fallback JavaScript implementation of multi-head attention
-     * Used when native modules are not available
-     */
-    multiHeadAttentionFallback(query, key, value, mask) {
-        const { numHeads, headDim, embedDim } = this.config;
-        const seqLen = Math.floor(query.length / embedDim);
-        const batchSize = 1; // Simplified for fallback
-        // Simple scaled dot-product attention
-        const scale = 1.0 / Math.sqrt(headDim);
-        const output = new Float32Array(query.length);
-        for (let i = 0; i < seqLen; i++) {
-            for (let d = 0; d < embedDim; d++) {
-                let sum = 0;
-                let weightSum = 0;
-                for (let j = 0; j < seqLen; j++) {
-                    // Compute attention score
-                    let score = 0;
-                    for (let k = 0; k < headDim; k++) {
-                        const qIdx = i * embedDim + k;
-                        const kIdx = j * embedDim + k;
-                        score += query[qIdx] * key[kIdx];
-                    }
-                    score *= scale;
-                    // Apply mask if provided
-                    if (mask && mask[i * seqLen + j] === 0) {
-                        score = -Infinity;
-                    }
-                    // Softmax (simplified)
-                    const weight = Math.exp(score);
-                    const vIdx = j * embedDim + d;
-                    sum += weight * value[vIdx];
-                    weightSum += weight;
-                }
-                output[i * embedDim + d] = weightSum > 0 ? sum / weightSum : 0;
-            }
-        }
-        return { output };
-    }
-    /**
-     * Fallback JavaScript implementation of linear attention
-     */
-    linearAttentionFallback(query, key, value) {
-        // Simplified linear attention using feature maps
-        const { embedDim } = this.config;
-        const seqLen = Math.floor(query.length / embedDim);
-        const output = new Float32Array(query.length);
-        // Apply feature map (elu + 1)
-        const featureMap = (x) => x > 0 ? x + 1 : Math.exp(x);
-        for (let i = 0; i < seqLen; i++) {
-            for (let d = 0; d < embedDim; d++) {
-                let numerator = 0;
-                let denominator = 0;
-                for (let j = 0; j < seqLen; j++) {
-                    const qVal = featureMap(query[i * embedDim + d]);
-                    const kVal = featureMap(key[j * embedDim + d]);
-                    const vVal = value[j * embedDim + d];
-                    numerator += qVal * kVal * vVal;
-                    denominator += qVal * kVal;
-                }
-                output[i * embedDim + d] = denominator > 0 ? numerator / denominator : 0;
-            }
-        }
-        return output;
-    }
-    /**
-     * Update performance statistics
-     */
-    updateStats(mechanism, runtime, executionTimeMs, memoryBytes) {
-        this.stats.totalOps++;
-        // Update average execution time
-        const prevTotal = this.stats.avgExecutionTimeMs * (this.stats.totalOps - 1);
-        this.stats.avgExecutionTimeMs = (prevTotal + executionTimeMs) / this.stats.totalOps;
-        // Update peak memory
-        if (memoryBytes > this.stats.peakMemoryBytes) {
-            this.stats.peakMemoryBytes = memoryBytes;
-        }
-        // Update mechanism counts
-        this.stats.mechanismCounts[mechanism] = (this.stats.mechanismCounts[mechanism] || 0) + 1;
-        // Update runtime counts
-        this.stats.runtimeCounts[runtime] = (this.stats.runtimeCounts[runtime] || 0) + 1;
-    }
-    /**
-     * Get performance statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Reset performance statistics
-     */
-    resetStats() {
-        this.stats = {
-            totalOps: 0,
-            avgExecutionTimeMs: 0,
-            peakMemoryBytes: 0,
-            mechanismCounts: {},
-            runtimeCounts: {}
-        };
-    }
-    /**
-     * Get service information
-     */
-    getInfo() {
-        return {
-            initialized: this.initialized,
-            runtime: this.runtime,
-            hasNAPI: this.napiModule !== null,
-            hasWASM: this.wasmModule !== null,
-            config: { ...this.config }
-        };
-    }
-    // -- ADR-064 Phase 1: High-level API for MCP tools --------------------------
-    /**
-     * Apply Flash Attention to query against key/value context vectors.
-     * Returns attention-weighted output (7.47x faster with native bindings).
-     *
-     * @param query  - Query vector (number[])
-     * @param keys   - Key vectors (number[][])
-     * @param values - Value vectors (number[][])
-     * @param options - Optional head count and dropout rate
-     * @returns Attention-weighted output vector
-     */
-    async applyFlashAttention(query, keys, values, options) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        const heads = options?.headCount ?? this.config.numHeads;
-        const dimPerHead = Math.max(1, Math.floor(query.length / heads));
-        const queryBuf = new Float32Array(query);
-        const keysBuf = new Float32Array(keys.flat());
-        const valuesBuf = new Float32Array(values.flat());
-        // Try native Flash Attention
-        if (this.napiModule && typeof this.napiModule.flashAttention === 'function') {
-            const startNs = performance.now();
-            const result = this.napiModule.flashAttention(queryBuf, keysBuf, valuesBuf, heads, dimPerHead);
-            const elapsed = performance.now() - startNs;
-            this.updateStats('flash', 'napi', elapsed, queryBuf.byteLength);
-            const output = result instanceof Float32Array ? result : new Float32Array(result);
-            return Array.from(output);
-        }
-        // Try WASM
-        if (this.wasmModule && typeof this.wasmModule.flashAttention === 'function') {
-            const startNs = performance.now();
-            const result = this.wasmModule.flashAttention(queryBuf, keysBuf, valuesBuf, heads, dimPerHead);
-            const elapsed = performance.now() - startNs;
-            this.updateStats('flash', 'wasm', elapsed, queryBuf.byteLength);
-            const output = result instanceof Float32Array ? result : new Float32Array(result);
-            return Array.from(output);
-        }
-        // JS fallback
-        return this.applyAttentionJS(query, keys, values);
-    }
-    /**
-     * Apply Multi-Head Attention for 5x better relevance scoring.
-     *
-     * @param query    - Query vector (number[])
-     * @param context  - Context vectors (number[][])
-     * @param numHeads - Number of attention heads (default: 8)
-     * @returns Attention output and per-context weight matrix
-     */
-    async applyMultiHeadAttention(query, context, numHeads) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        const heads = numHeads ?? this.config.numHeads;
-        const dimPerHead = Math.max(1, Math.floor(query.length / heads));
-        const queryBuf = new Float32Array(query);
-        const contextFlat = new Float32Array(context.flat());
-        // Try native multi-head attention
-        if (this.napiModule && typeof this.napiModule.multiHeadAttention === 'function') {
-            const startNs = performance.now();
-            const result = this.napiModule.multiHeadAttention(queryBuf, contextFlat, contextFlat, heads, dimPerHead);
-            const elapsed = performance.now() - startNs;
-            this.updateStats('multi-head', 'napi', elapsed, queryBuf.byteLength);
-            const output = result.output instanceof Float32Array
-                ? Array.from(result.output)
-                : Array.from(new Float32Array(result.output ?? []));
-            const weights = result.weights
-                ? this.reshapeWeights(result.weights, context.length, heads)
-                : this.computeFallbackWeights(query, context);
-            return { attention: output, weights };
-        }
-        // JS fallback: compute attention via dot-product scoring per head
-        return this.applyMultiHeadJS(query, context, heads);
-    }
-    /**
-     * Apply Mixture-of-Experts routing for dynamic expert selection.
-     *
-     * @param input   - Input vector (number[])
-     * @param experts - Number of expert models
-     * @param topK    - Top-K experts to use (default: 2)
-     * @returns Output vector and expert gating weights
-     */
-    async applyMoE(input, experts, topK) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        const k = topK ?? this.config.topK ?? 2;
-        const inputBuf = new Float32Array(input);
-        // Try native MoE
-        if (this.napiModule && typeof this.napiModule.moeAttention === 'function') {
-            const startNs = performance.now();
-            const result = this.napiModule.moeAttention(inputBuf, inputBuf, inputBuf, this.config.numHeads, this.config.headDim, experts, k);
-            const elapsed = performance.now() - startNs;
-            this.updateStats('moe', 'napi', elapsed, inputBuf.byteLength);
-            const output = result instanceof Float32Array
-                ? Array.from(result)
-                : Array.from(new Float32Array(result.output ?? result));
-            const gating = result.gating
-                ? Array.from(result.gating instanceof Float32Array ? result.gating : new Float32Array(result.gating))
-                : this.computeGatingWeights(input, experts, k);
-            return { output, expertWeights: gating };
-        }
-        // JS fallback
-        return this.applyMoEJS(input, experts, k);
-    }
-    // -- JS fallback helpers for high-level API ---------------------------------
-    /**
-     * JS fallback for Flash Attention (dot-product attention over key/value pairs).
-     */
-    applyAttentionJS(query, keys, values) {
-        const dim = query.length;
-        const seqLen = keys.length;
-        const scale = 1.0 / Math.sqrt(dim);
-        // Compute attention scores
-        const scores = new Array(seqLen);
-        let maxScore = -Infinity;
-        for (let j = 0; j < seqLen; j++) {
-            let dot = 0;
-            const kj = keys[j];
-            for (let d = 0; d < dim; d++) {
-                dot += query[d] * kj[d];
-            }
-            scores[j] = dot * scale;
-            if (scores[j] > maxScore)
-                maxScore = scores[j];
-        }
-        // Softmax
-        let expSum = 0;
-        for (let j = 0; j < seqLen; j++) {
-            scores[j] = Math.exp(scores[j] - maxScore);
-            expSum += scores[j];
-        }
-        for (let j = 0; j < seqLen; j++) {
-            scores[j] /= expSum;
-        }
-        // Weighted sum of values
-        const output = new Array(dim).fill(0);
-        for (let j = 0; j < seqLen; j++) {
-            const vj = values[j];
-            const w = scores[j];
-            for (let d = 0; d < dim; d++) {
-                output[d] += w * vj[d];
-            }
-        }
-        this.updateStats('flash', 'fallback', 0, dim * 4);
-        return output;
-    }
-    /**
-     * JS fallback for Multi-Head Attention.
-     */
-    applyMultiHeadJS(query, context, numHeads) {
-        const dim = query.length;
-        const seqLen = context.length;
-        const headDim = Math.max(1, Math.floor(dim / numHeads));
-        const scale = 1.0 / Math.sqrt(headDim);
-        // Per-head attention
-        const output = new Array(dim).fill(0);
-        const allWeights = [];
-        for (let h = 0; h < numHeads; h++) {
-            const hStart = h * headDim;
-            const hEnd = Math.min(hStart + headDim, dim);
-            const headWeights = [];
-            // Compute scores for this head
-            const scores = [];
-            let maxScore = -Infinity;
-            for (let j = 0; j < seqLen; j++) {
-                let dot = 0;
-                for (let d = hStart; d < hEnd; d++) {
-                    dot += query[d] * context[j][d];
-                }
-                const s = dot * scale;
-                scores.push(s);
-                if (s > maxScore)
-                    maxScore = s;
-            }
-            // Softmax
-            let expSum = 0;
-            for (let j = 0; j < seqLen; j++) {
-                scores[j] = Math.exp(scores[j] - maxScore);
-                expSum += scores[j];
-            }
-            for (let j = 0; j < seqLen; j++) {
-                scores[j] /= expSum;
-                headWeights.push(scores[j]);
-            }
-            // Weighted sum for this head
-            for (let j = 0; j < seqLen; j++) {
-                const w = scores[j];
-                for (let d = hStart; d < hEnd; d++) {
-                    output[d] += w * context[j][d];
-                }
-            }
-            allWeights.push(headWeights);
-        }
-        this.updateStats('multi-head', 'fallback', 0, dim * 4);
-        return { attention: output, weights: allWeights };
-    }
-    /**
-     * JS fallback for Mixture of Experts.
-     */
-    applyMoEJS(input, experts, topK) {
-        const dim = input.length;
-        const gating = this.computeGatingWeights(input, experts, topK);
-        // Simulate expert outputs (each expert applies a simple transform)
-        const output = new Array(dim).fill(0);
-        for (let e = 0; e < experts; e++) {
-            if (gating[e] === 0)
-                continue;
-            const w = gating[e];
-            for (let d = 0; d < dim; d++) {
-                // Expert transform: scaled rotation based on expert index
-                const angle = (e * Math.PI) / experts;
-                output[d] += w * (input[d] * Math.cos(angle) + (input[(d + 1) % dim] || 0) * Math.sin(angle));
-            }
-        }
-        this.updateStats('moe', 'fallback', 0, dim * 4);
-        return { output, expertWeights: gating };
-    }
-    /**
-     * Compute gating weights for MoE (top-K selection with softmax).
-     */
-    computeGatingWeights(input, experts, topK) {
-        // Simple gating: hash-based expert scores
-        const scores = [];
-        let sum = 0;
-        for (let e = 0; e < experts; e++) {
-            let s = 0;
-            for (let d = 0; d < Math.min(input.length, 16); d++) {
-                s += input[d] * Math.sin((e + 1) * (d + 1));
-            }
-            scores.push(Math.exp(s));
-            sum += Math.exp(s);
-        }
-        // Normalize
-        for (let e = 0; e < experts; e++) {
-            scores[e] /= sum;
-        }
-        // Zero out non-top-K
-        const indexed = scores.map((s, i) => ({ s, i }));
-        indexed.sort((a, b) => b.s - a.s);
-        const topKSet = new Set(indexed.slice(0, topK).map(x => x.i));
-        const result = new Array(experts).fill(0);
-        let topSum = 0;
-        for (const idx of topKSet) {
-            result[idx] = scores[idx];
-            topSum += scores[idx];
-        }
-        // Renormalize top-K
-        if (topSum > 0) {
-            for (const idx of topKSet) {
-                result[idx] /= topSum;
-            }
-        }
-        return result;
-    }
-    /**
-     * Reshape flat weight buffer into per-context weight matrix.
-     */
-    reshapeWeights(weights, contextLen, numHeads) {
-        const result = [];
-        const w = weights instanceof Float32Array ? weights : new Float32Array(weights);
-        const stride = Math.max(1, Math.floor(w.length / numHeads));
-        for (let h = 0; h < numHeads; h++) {
-            const headWeights = [];
-            for (let j = 0; j < contextLen; j++) {
-                const idx = h * stride + j;
-                headWeights.push(idx < w.length ? w[idx] : 0);
-            }
-            result.push(headWeights);
-        }
-        return result;
-    }
-    /**
-     * Compute fallback attention weights via cosine similarity.
-     */
-    computeFallbackWeights(query, context) {
-        const dim = query.length;
-        const weights = [[]];
-        for (const ctx of context) {
-            let dot = 0, mq = 0, mc = 0;
-            for (let d = 0; d < dim; d++) {
-                dot += query[d] * ctx[d];
-                mq += query[d] * query[d];
-                mc += ctx[d] * ctx[d];
-            }
-            const denom = Math.sqrt(mq) * Math.sqrt(mc);
-            weights[0].push(denom > 0 ? dot / denom : 0);
-        }
-        return weights;
-    }
-}
-//# sourceMappingURL=AttentionService.js.map