@ruvector/ruvllm 4.0.1 → 4.2.0

package/dist/esm/sona.js

@@ -0,0 +1,556 @@
+/**
+ * SONA (Self-Optimizing Neural Architecture) Learning System
+ *
+ * Provides adaptive learning capabilities with trajectory tracking,
+ * pattern recognition, and memory protection (EWC++).
+ */
+import { LoraAdapter } from './lora.js';
+/** Embedding dimension used by the coordinator's hash embedder and micro-LoRA. */
+const MICRO_LORA_DIM = 64;
+/** Micro-LoRA rank: SONA's instant loop uses a tiny adapter (rank 1-2) by design. */
+const MICRO_LORA_RANK = 2;
+/**
+ * Default SONA configuration
+ */
+const DEFAULT_SONA_CONFIG = {
+    instantLoopEnabled: true,
+    backgroundLoopEnabled: true,
+    loraLearningRate: 0.001,
+    loraRank: 8,
+    ewcLambda: 2000,
+    maxTrajectorySize: 1000,
+    patternThreshold: 0.85,
+};
+/**
+ * Trajectory Builder for tracking query execution paths
+ *
+ * @example
+ * ```typescript
+ * const builder = new TrajectoryBuilder();
+ *
+ * builder.startStep('query', 'What is AI?');
+ * // ... processing ...
+ * builder.endStep('AI is artificial intelligence', 0.95);
+ *
+ * builder.startStep('memory', 'searching context');
+ * builder.endStep('found 3 relevant documents', 0.88);
+ *
+ * const trajectory = builder.complete('success');
+ * ```
+ */
+export class TrajectoryBuilder {
+    constructor() {
+        this.steps = [];
+        this.currentStep = null;
+        this.stepStart = 0;
+        this.id = `traj-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.startTime = Date.now();
+    }
+    /**
+     * Start a new step in the trajectory
+     */
+    startStep(type, input) {
+        if (this.currentStep) {
+            // Auto-complete previous step
+            this.endStep('', 0);
+        }
+        this.stepStart = Date.now();
+        this.currentStep = {
+            type,
+            input,
+        };
+        return this;
+    }
+    /**
+     * End current step with output
+     */
+    endStep(output, confidence) {
+        if (!this.currentStep) {
+            return this;
+        }
+        this.steps.push({
+            type: this.currentStep.type,
+            input: this.currentStep.input,
+            output,
+            durationMs: Date.now() - this.stepStart,
+            confidence,
+        });
+        this.currentStep = null;
+        return this;
+    }
+    /**
+     * Complete trajectory with final outcome
+     */
+    complete(outcome) {
+        // Complete any pending step
+        if (this.currentStep) {
+            this.endStep('incomplete', 0);
+        }
+        return {
+            id: this.id,
+            steps: this.steps,
+            outcome,
+            durationMs: Date.now() - this.startTime,
+        };
+    }
+    /**
+     * Get current trajectory ID
+     */
+    getId() {
+        return this.id;
+    }
+}
+/**
+ * ReasoningBank - Pattern storage and retrieval
+ *
+ * Stores learned patterns from successful interactions and
+ * enables pattern-based reasoning shortcuts.
+ *
+ * OPTIMIZED: Uses Float64Array for embeddings and partial sorting
+ */
+export class ReasoningBank {
+    constructor(threshold = 0.85) {
+        this.patterns = new Map();
+        this.embeddings = new Map();
+        this.embeddingNorms = new Map(); // Pre-computed norms
+        // Reusable arrays for findSimilar to avoid allocations
+        this._similarityResults = [];
+        this.threshold = threshold;
+    }
+    /**
+     * Store a new pattern
+     */
+    store(type, embedding, metadata) {
+        const id = `pat-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const pattern = {
+            id,
+            type,
+            embedding,
+            successRate: 1.0,
+            useCount: 0,
+            lastUsed: new Date(),
+        };
+        this.patterns.set(id, pattern);
+        // Store as typed array for faster similarity computation
+        const typedEmb = new Float64Array(embedding);
+        this.embeddings.set(id, typedEmb);
+        // Pre-compute and cache the norm
+        let norm = 0;
+        for (let i = 0; i < typedEmb.length; i++) {
+            norm += typedEmb[i] * typedEmb[i];
+        }
+        this.embeddingNorms.set(id, Math.sqrt(norm));
+        return id;
+    }
+    /**
+     * Find similar patterns
+     * OPTIMIZED: Uses typed arrays, pre-computed norms, and partial sorting
+     */
+    findSimilar(embedding, k = 5) {
+        // Pre-compute query norm
+        let queryNorm = 0;
+        const queryLen = embedding.length;
+        for (let i = 0; i < queryLen; i++) {
+            queryNorm += embedding[i] * embedding[i];
+        }
+        queryNorm = Math.sqrt(queryNorm);
+        if (queryNorm === 0)
+            return [];
+        // Reuse array to avoid allocations
+        this._similarityResults.length = 0;
+        for (const [id, patEmb] of this.embeddings) {
+            const patNorm = this.embeddingNorms.get(id) || 0;
+            if (patNorm === 0)
+                continue;
+            // Fast dot product
+            let dot = 0;
+            const minLen = Math.min(queryLen, patEmb.length);
+            // Unrolled loop
+            let i = 0;
+            for (; i + 3 < minLen; i += 4) {
+                dot += embedding[i] * patEmb[i] +
+                    embedding[i + 1] * patEmb[i + 1] +
+                    embedding[i + 2] * patEmb[i + 2] +
+                    embedding[i + 3] * patEmb[i + 3];
+            }
+            for (; i < minLen; i++) {
+                dot += embedding[i] * patEmb[i];
+            }
+            const score = dot / (queryNorm * patNorm);
+            if (score >= this.threshold) {
+                this._similarityResults.push({ id, score });
+            }
+        }
+        // Partial sort for top-k (faster than full sort for large arrays)
+        if (this._similarityResults.length <= k) {
+            this._similarityResults.sort((a, b) => b.score - a.score);
+        }
+        else {
+            // Quick partial sort for top k
+            this.partialSort(this._similarityResults, k);
+        }
+        const topK = this._similarityResults.slice(0, k);
+        return topK
+            .map(s => this.patterns.get(s.id))
+            .filter((p) => p !== undefined);
+    }
+    /**
+     * Partial sort to get top k elements (faster than full sort)
+     */
+    partialSort(arr, k) {
+        // Simple selection for small k
+        for (let i = 0; i < k && i < arr.length; i++) {
+            let maxIdx = i;
+            for (let j = i + 1; j < arr.length; j++) {
+                if (arr[j].score > arr[maxIdx].score) {
+                    maxIdx = j;
+                }
+            }
+            if (maxIdx !== i) {
+                const temp = arr[i];
+                arr[i] = arr[maxIdx];
+                arr[maxIdx] = temp;
+            }
+        }
+    }
+    /**
+     * Record pattern usage (success or failure)
+     */
+    recordUsage(patternId, success) {
+        const pattern = this.patterns.get(patternId);
+        if (!pattern)
+            return;
+        pattern.useCount++;
+        pattern.lastUsed = new Date();
+        // Update success rate with exponential moving average
+        const alpha = 0.1;
+        const outcome = success ? 1.0 : 0.0;
+        pattern.successRate = alpha * outcome + (1 - alpha) * pattern.successRate;
+    }
+    /**
+     * Get pattern by ID
+     */
+    get(patternId) {
+        return this.patterns.get(patternId);
+    }
+    /**
+     * Get all patterns of a type
+     */
+    getByType(type) {
+        return Array.from(this.patterns.values()).filter(p => p.type === type);
+    }
+    /**
+     * Prune low-performing patterns
+     */
+    prune(minSuccessRate = 0.3, minUseCount = 5) {
+        let pruned = 0;
+        for (const [id, pattern] of this.patterns) {
+            if (pattern.useCount >= minUseCount && pattern.successRate < minSuccessRate) {
+                this.patterns.delete(id);
+                this.embeddings.delete(id);
+                this.embeddingNorms.delete(id);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    /**
+     * Get statistics
+     */
+    stats() {
+        const patterns = Array.from(this.patterns.values());
+        const byType = {};
+        let totalSuccess = 0;
+        for (const p of patterns) {
+            totalSuccess += p.successRate;
+            byType[p.type] = (byType[p.type] || 0) + 1;
+        }
+        return {
+            totalPatterns: patterns.length,
+            avgSuccessRate: patterns.length > 0 ? totalSuccess / patterns.length : 0,
+            byType,
+        };
+    }
+    cosineSimilarity(a, b) {
+        let dot = 0, normA = 0, normB = 0;
+        const len = Math.min(a.length, b.length);
+        for (let i = 0; i < len; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denom = Math.sqrt(normA) * Math.sqrt(normB);
+        return denom > 0 ? dot / denom : 0;
+    }
+}
+/**
+ * EWC++ (Elastic Weight Consolidation) Manager
+ *
+ * Prevents catastrophic forgetting by protecting important weights.
+ * This is a simplified JS implementation of the concept.
+ *
+ * OPTIMIZED: Uses Float64Array for 5-10x faster penalty computation
+ */
+export class EwcManager {
+    constructor(lambda = 2000) {
+        this.tasksLearned = 0;
+        this.fisherDiagonal = new Map();
+        this.optimalWeights = new Map();
+        // Pre-allocated buffer for penalty computation
+        this._penaltyBuffer = null;
+        this.lambda = lambda;
+    }
+    /**
+     * Register a new task (after successful learning)
+     */
+    registerTask(taskId, weights) {
+        // Store optimal weights for this task using typed arrays
+        const optimalArr = new Float64Array(weights.length);
+        const fisherArr = new Float64Array(weights.length);
+        for (let i = 0; i < weights.length; i++) {
+            optimalArr[i] = weights[i];
+            fisherArr[i] = Math.abs(weights[i]) * this.lambda;
+        }
+        this.optimalWeights.set(taskId, optimalArr);
+        this.fisherDiagonal.set(taskId, fisherArr);
+        this.tasksLearned++;
+    }
+    /**
+     * Compute EWC penalty for weight update
+     * OPTIMIZED: Uses typed arrays and minimizes allocations
+     */
+    computePenalty(currentWeights) {
+        let penalty = 0;
+        const len = currentWeights.length;
+        for (const [taskId, optimal] of this.optimalWeights) {
+            const fisher = this.fisherDiagonal.get(taskId);
+            if (!fisher)
+                continue;
+            const minLen = Math.min(len, optimal.length);
+            // Unrolled loop for better performance
+            let i = 0;
+            for (; i + 3 < minLen; i += 4) {
+                const diff0 = currentWeights[i] - optimal[i];
+                const diff1 = currentWeights[i + 1] - optimal[i + 1];
+                const diff2 = currentWeights[i + 2] - optimal[i + 2];
+                const diff3 = currentWeights[i + 3] - optimal[i + 3];
+                penalty += fisher[i] * diff0 * diff0 +
+                    fisher[i + 1] * diff1 * diff1 +
+                    fisher[i + 2] * diff2 * diff2 +
+                    fisher[i + 3] * diff3 * diff3;
+            }
+            // Handle remaining elements
+            for (; i < minLen; i++) {
+                const diff = currentWeights[i] - optimal[i];
+                penalty += fisher[i] * diff * diff;
+            }
+        }
+        return penalty * 0.5;
+    }
+    /**
+     * Get EWC statistics
+     */
+    stats() {
+        return {
+            tasksLearned: this.tasksLearned,
+            fisherComputed: this.fisherDiagonal.size > 0,
+            protectionStrength: this.lambda,
+            forgettingRate: this.estimateForgettingRate(),
+        };
+    }
+    estimateForgettingRate() {
+        // Simplified estimation based on number of tasks
+        return Math.max(0, 1 - Math.exp(-this.tasksLearned * 0.1));
+    }
+}
+/**
+ * SONA Learning Coordinator
+ *
+ * Orchestrates the learning loops and components.
+ */
+export class SonaCoordinator {
+    constructor(config) {
+        this.trajectoryBuffer = [];
+        this.signalBuffer = [];
+        this.microLoraUpdates = 0;
+        this.config = { ...DEFAULT_SONA_CONFIG, ...config };
+        this.reasoningBank = new ReasoningBank(this.config.patternThreshold);
+        this.ewcManager = new EwcManager(this.config.ewcLambda);
+        this.microLora = new LoraAdapter({ rank: MICRO_LORA_RANK }, MICRO_LORA_DIM, MICRO_LORA_DIM);
+    }
+    /**
+     * Record a learning signal
+     *
+     * Every signal drives the instant loop: quality above 0.5 reinforces the
+     * signal's direction in the micro-LoRA, quality below 0.5 unlearns it
+     * (previously only quality >= 0.8 was processed, so negative feedback
+     * never adapted anything).
+     */
+    recordSignal(signal) {
+        this.signalBuffer.push(signal);
+        // Instant loop - immediate learning
+        if (this.config.instantLoopEnabled) {
+            this.processInstantLearning(signal);
+        }
+    }
+    /**
+     * Record a completed trajectory
+     */
+    recordTrajectory(trajectory) {
+        this.trajectoryBuffer.push(trajectory);
+        // Maintain buffer size
+        while (this.trajectoryBuffer.length > this.config.maxTrajectorySize) {
+            this.trajectoryBuffer.shift();
+        }
+        // Extract patterns from successful trajectories
+        if (trajectory.outcome === 'success') {
+            this.extractPatterns(trajectory);
+        }
+    }
+    /**
+     * Run background learning loop
+     */
+    runBackgroundLoop() {
+        if (!this.config.backgroundLoopEnabled) {
+            return { patternsLearned: 0, trajectoriesProcessed: 0 };
+        }
+        let patternsLearned = 0;
+        const trajectoriesProcessed = this.trajectoryBuffer.length;
+        // Process accumulated trajectories
+        for (const traj of this.trajectoryBuffer) {
+            if (traj.outcome === 'success' || traj.outcome === 'partial') {
+                patternsLearned += this.extractPatterns(traj);
+            }
+        }
+        // Prune low-performing patterns
+        this.reasoningBank.prune();
+        // Clear processed trajectories
+        this.trajectoryBuffer = [];
+        return { patternsLearned, trajectoriesProcessed };
+    }
+    /**
+     * Get reasoning bank for pattern queries
+     */
+    getReasoningBank() {
+        return this.reasoningBank;
+    }
+    /**
+     * Get EWC manager
+     */
+    getEwcManager() {
+        return this.ewcManager;
+    }
+    /**
+     * Get statistics
+     */
+    stats() {
+        return {
+            signalsReceived: this.signalBuffer.length,
+            trajectoriesBuffered: this.trajectoryBuffer.length,
+            patterns: this.reasoningBank.stats(),
+            ewc: this.ewcManager.stats(),
+            microLora: {
+                updates: this.microLoraUpdates,
+                deltaNorm: this.microLoraDeltaNorm(),
+            },
+        };
+    }
+    /**
+     * Apply the micro-LoRA transformation learned from feedback.
+     *
+     * Input is truncated/zero-padded to the adapter dimension; the residual
+     * connection means an untrained adapter returns the input unchanged.
+     */
+    applyMicroLora(input) {
+        return this.microLora.forward(input.slice(0, MICRO_LORA_DIM));
+    }
+    /**
+     * Frobenius norm of the micro-LoRA weight delta (scaling * A @ B).
+     *
+     * 0 means no adaptation has occurred (LoRA B is zero-initialized, so the
+     * delta is exactly zero until the first feedback update). Consumers can
+     * surface this directly (e.g. a statusline "delta LoRA" field) — see #553.
+     */
+    microLoraDeltaNorm() {
+        const { loraA, loraB, scaling } = this.microLora.getWeights();
+        const rank = loraB.length;
+        let sumSq = 0;
+        for (let i = 0; i < loraA.length; i++) {
+            for (let j = 0; j < MICRO_LORA_DIM; j++) {
+                let d = 0;
+                for (let r = 0; r < rank; r++) {
+                    d += loraA[i][r] * loraB[r][j];
+                }
+                sumSq += scaling * d * (scaling * d);
+            }
+        }
+        return Math.sqrt(sumSq);
+    }
+    /**
+     * Instant-loop learning: a single feedback signal produces a real
+     * micro-LoRA weight update (fixes #553 — this was a no-op stub, so
+     * learn-from-feedback never changed any weight).
+     *
+     * REINFORCE-style with a fixed 0.5 baseline: reward = quality - 0.5.
+     * The gradient pushes the adapter output toward the signal's embedding
+     * direction for positive reward and away from it for negative reward
+     * (backward() applies `weights -= lr * grad`, hence the negated sign).
+     */
+    processInstantLearning(signal) {
+        const reward = signal.quality - 0.5;
+        if (reward === 0)
+            return;
+        const input = this.createEmbedding(signal.correction ?? `${signal.requestId}:${signal.type}`);
+        const gradOutput = input.map(x => -reward * x);
+        this.microLora.backward(input, gradOutput, this.config.loraLearningRate);
+        this.microLoraUpdates++;
+    }
+    extractPatterns(trajectory) {
+        let extracted = 0;
+        for (const step of trajectory.steps) {
+            if (step.confidence >= this.config.patternThreshold) {
+                // Create embedding from step (simplified)
+                const embedding = this.createEmbedding(step.input + step.output);
+                // Determine pattern type
+                const type = this.stepTypeToPatternType(step.type);
+                // Store if not too similar to existing
+                const similar = this.reasoningBank.findSimilar(embedding, 1);
+                if (similar.length === 0) {
+                    this.reasoningBank.store(type, embedding);
+                    extracted++;
+                }
+            }
+        }
+        return extracted;
+    }
+    stepTypeToPatternType(stepType) {
+        switch (stepType) {
+            case 'query':
+            case 'generate':
+                return 'query_response';
+            case 'route':
+                return 'routing';
+            case 'memory':
+                return 'context_retrieval';
+            case 'feedback':
+                return 'correction';
+            default:
+                return 'query_response';
+        }
+    }
+    createEmbedding(text) {
+        // Simplified hash-based embedding (real impl uses model)
+        const dim = 64;
+        const embedding = new Array(dim).fill(0);
+        for (let i = 0; i < text.length; i++) {
+            const idx = (text.charCodeAt(i) * (i + 1)) % dim;
+            embedding[idx] += 0.1;
+        }
+        // Normalize
+        const norm = Math.sqrt(embedding.reduce((s, x) => s + x * x, 0)) || 1;
+        return embedding.map(x => x / norm);
+    }
+}
+// Export all SONA components
+export { DEFAULT_SONA_CONFIG, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sona.js","sourceRoot":"","sources":["../../src/sona.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC,kFAAkF;AAClF,MAAM,cAAc,GAAG,EAAE,CAAC;AAC1B,qFAAqF;AACrF,MAAM,eAAe,GAAG,CAAC,CAAC;AAE1B;;GAEG;AACH,MAAM,mBAAmB,GAAyB;IAChD,kBAAkB,EAAE,IAAI;IACxB,qBAAqB,EAAE,IAAI;IAC3B,gBAAgB,EAAE,KAAK;IACvB,QAAQ,EAAE,CAAC;IACX,SAAS,EAAE,IAAI;IACf,iBAAiB,EAAE,IAAI;IACvB,gBAAgB,EAAE,IAAI;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,iBAAiB;IAO5B;QALQ,UAAK,GAAqB,EAAE,CAAC;QAC7B,gBAAW,GAAmC,IAAI,CAAC;QACnD,cAAS,GAAW,CAAC,CAAC;QAI5B,IAAI,CAAC,EAAE,GAAG,QAAQ,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QACzE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,IAA4B,EAAE,KAAa;QACnD,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,8BAA8B;YAC9B,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QACtB,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC5B,IAAI,CAAC,WAAW,GAAG;YACjB,IAAI;YACJ,KAAK;SACN,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,MAAc,EAAE,UAAkB;QACxC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YACd,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,IAAK;YAC5B,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,KAAM;YAC9B,MAAM;YACN,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS;YACvC,UAAU;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,OAA0B;QACjC,4BAA4B;QAC5B,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;QAChC,CAAC;QAED,OAAO;YACL,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,OAAO;YACP,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS;SACxC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,aAAa;IAQxB,YAAY,SAAS,GAAG,IAAI;QAPpB,aAAQ,GAAgC,IAAI,GAAG,EAAE,CAAC;QAClD,eAAU,GAA8B,IAAI,GAAG,EAAE,CAAC;QAClD,mBAAc,GAAwB,IAAI,GAAG,EAAE,CAAC,CAAC,qBAAqB;QAE9E,uDAAuD;QAC/C,uBAAkB,GAAyC,EAAE,CAAC;QAGpE,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,KAAK,CACH,IAAiB,EACjB,SAAoB,EACpB,QAAkC;QAElC,MAAM,EAAE,GAAG,OAAO,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QAEzE,MAAM,OAAO,GAAmB;YAC9B,EAAE;YACF,IAAI;YACJ,SAAS;YACT,WAAW,EAAE,GAAG;YAChB,QAAQ,EAAE,CAAC;YACX,QAAQ,EAAE,IAAI,IAAI,EAAE;SACrB,CAAC;QAEF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAE/B,yDAAyD;QACzD,MAAM,QAAQ,GAAG,IAAI,YAAY,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QAElC,iCAAiC;QACjC,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QACpC,CAAC;QACD,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAE7C,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,SAAoB,EAAE,CAAC,GAAG,CAAC;QACrC,yBAAyB;QACzB,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC;QAClC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;YAClC,SAAS,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QAC3C,CAAC;QACD,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAEjC,IAAI,SAAS,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QAE/B,mCAAmC;QACnC,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC;QAEnC,KAAK,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;YACjD,IAAI,OAAO,KAAK,CAAC;gBAAE,SAAS;YAE5B,mBAAmB;YACnB,IAAI,GAAG,GAAG,CAAC,CAAC;YACZ,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YAEjD,gBAAgB;YAChB,IAAI,CAAC,GAAG,CAAC,CAAC;YACV,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC9B,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;oBACxB,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;oBAChC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;oBAChC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC1C,CAAC;YACD,OAAO,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACvB,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YAClC,CAAC;YAED,MAAM,KAAK,GAAG,GAAG,GAAG,CAAC,SAAS,GAAG,OAAO,CAAC,CAAC;YAE1C,IAAI,KAAK,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;gBAC5B,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;QAED,kEAAkE;QAClE,IAAI,IAAI,CAAC,kBAAkB,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YACxC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;QAC5D,CAAC;aAAM,CAAC;YACN,+BAA+B;YAC/B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC;QAC/C,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAEjD,OAAO,IAAI;aACR,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;aACjC,MAAM,CAAC,CAAC,CAAC,EAAuB,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;IACzD,CAAC;IAED;;OAEG;IACK,WAAW,CAAC,GAAyC,EAAE,CAAS;QACtE,+BAA+B;QAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7C,IAAI,MAAM,GAAG,CAAC,CAAC;YACf,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACxC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC;oBACrC,MAAM,GAAG,CAAC,CAAC;gBACb,CAAC;YACH,CAAC;YACD,IAAI,MAAM,KAAK,CAAC,EAAE,CAAC;gBACjB,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;gBACpB,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;gBACrB,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;YACrB,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,WAAW,CAAC,SAAiB,EAAE,OAAgB;QAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO;YAAE,OAAO;QAErB,OAAO,CAAC,QAAQ,EAAE,CAAC;QACnB,OAAO,CAAC,QAAQ,GAAG,IAAI,IAAI,EAAE,CAAC;QAE9B,sDAAsD;QACtD,MAAM,KAAK,GAAG,GAAG,CAAC;QAClB,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;QACpC,OAAO,CAAC,WAAW,GAAG,KAAK,GAAG,OAAO,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;IAC5E,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,SAAiB;QACnB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,IAAiB;QACzB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IACzE,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc,GAAG,GAAG,EAAE,WAAW,GAAG,CAAC;QACzC,IAAI,MAAM,GAAG,CAAC,CAAC;QAEf,KAAK,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC1C,IAAI,OAAO,CAAC,QAAQ,IAAI,WAAW,IAAI,OAAO,CAAC,WAAW,GAAG,cAAc,EAAE,CAAC;gBAC5E,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBACzB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAC3B,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAC/B,MAAM,EAAE,CAAC;YACX,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,KAAK;QACH,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;QACpD,MAAM,MAAM,GAA2B,EAAE,CAAC;QAE1C,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;YACzB,YAAY,IAAI,CAAC,CAAC,WAAW,CAAC;YAC9B,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QAC7C,CAAC;QAED,OAAO;YACL,aAAa,EAAE,QAAQ,CAAC,MAAM;YAC9B,cAAc,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YACxE,MAAM;SACP,CAAC;IACJ,CAAC;IAEO,gBAAgB,CAAC,CAAY,EAAE,CAAY;QACjD,IAAI,GAAG,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC;QAClC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;QAEzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7B,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACnB,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACrB,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACvB,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClD,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACrC,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,UAAU;IAQrB,YAAY,MAAM,GAAG,IAAI;QANjB,iBAAY,GAAW,CAAC,CAAC;QACzB,mBAAc,GAA8B,IAAI,GAAG,EAAE,CAAC;QACtD,mBAAc,GAA8B,IAAI,GAAG,EAAE,CAAC;QAC9D,+CAA+C;QACvC,mBAAc,GAAwB,IAAI,CAAC;QAGjD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,MAAc,EAAE,OAAiB;QAC5C,yDAAyD;QACzD,MAAM,UAAU,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACpD,MAAM,SAAS,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAEnD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC3B,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QACpD,CAAC;QAED,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAC5C,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,cAAc,CAAC,cAAwB;QACrC,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,MAAM,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC;QAElC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACpD,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC/C,IAAI,CAAC,MAAM;gBAAE,SAAS;YAEtB,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;YAE7C,uCAAuC;YACvC,IAAI,CAAC,GAAG,CAAC,CAAC;YACV,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC9B,MAAM,KAAK,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC7C,MAAM,KAAK,GAAG,cAAc,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBACrD,MAAM,KAAK,GAAG,cAAc,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBACrD,MAAM,KAAK,GAAG,cAAc,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBACrD,OAAO,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,KAAK;oBACzB,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,KAAK;oBAC7B,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,KAAK;oBAC7B,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;YAC3C,CAAC;YACD,4BAA4B;YAC5B,OAAO,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACvB,MAAM,IAAI,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC5C,OAAO,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;YACrC,CAAC;QACH,CAAC;QAED,OAAO,OAAO,GAAG,GAAG,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,KAAK;QACH,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,cAAc,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI,GAAG,CAAC;YAC5C,kBAAkB,EAAE,IAAI,CAAC,MAAM;YAC/B,cAAc,EAAE,IAAI,CAAC,sBAAsB,EAAE;SAC9C,CAAC;IACJ,CAAC;IAEO,sBAAsB;QAC5B,iDAAiD;QACjD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,CAAC,CAAC;IAC7D,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,eAAe;IAS1B,YAAY,MAAmB;QAPvB,qBAAgB,GAAsB,EAAE,CAAC;QAGzC,iBAAY,GAAqB,EAAE,CAAC;QAEpC,qBAAgB,GAAG,CAAC,CAAC;QAG3B,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAAC;QACpD,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACrE,IAAI,CAAC,UAAU,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACxD,IAAI,CAAC,SAAS,GAAG,IAAI,WAAW,CAC9B,EAAE,IAAI,EAAE,eAAe,EAAE,EACzB,cAAc,EACd,cAAc,CACf,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,YAAY,CAAC,MAAsB;QACjC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAE/B,oCAAoC;QACpC,IAAI,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE,CAAC;YACnC,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,UAA2B;QAC1C,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAEvC,uBAAuB;QACvB,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;YACpE,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;QAChC,CAAC;QAED,gDAAgD;QAChD,IAAI,UAAU,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YACrC,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;OAEG;IACH,iBAAiB;QACf,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC;YACvC,OAAO,EAAE,eAAe,EAAE,CAAC,EAAE,qBAAqB,EAAE,CAAC,EAAE,CAAC;QAC1D,CAAC;QAED,IAAI,eAAe,GAAG,CAAC,CAAC;QACxB,MAAM,qBAAqB,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC;QAE3D,mCAAmC;QACnC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACzC,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC7D,eAAe,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;YAChD,CAAC;QACH,CAAC;QAED,gCAAgC;QAChC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAE3B,+BAA+B;QAC/B,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;QAE3B,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,aAAa;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;OAEG;IACH,KAAK;QAOH,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM;YACzC,oBAAoB,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM;YAClD,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE;YACpC,GAAG,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE;YAC5B,SAAS,EAAE;gBACT,OAAO,EAAE,IAAI,CAAC,gBAAgB;gBAC9B,SAAS,EAAE,IAAI,CAAC,kBAAkB,EAAE;aACrC;SACF,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,KAAe;QAC5B,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;OAMG;IACH,kBAAkB;QAChB,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;QAC9D,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC;QAC1B,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,EAAE,CAAC,EAAE,EAAE,CAAC;gBACxC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC9B,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACjC,CAAC;gBACD,KAAK,IAAI,OAAO,GAAG,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;;;;;OASG;IACK,sBAAsB,CAAC,MAAsB;QACnD,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,GAAG,GAAG,CAAC;QACpC,IAAI,MAAM,KAAK,CAAC;YAAE,OAAO;QAEzB,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAChC,MAAM,CAAC,UAAU,IAAI,GAAG,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,IAAI,EAAE,CAC1D,CAAC;QACF,MAAM,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC/C,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACzE,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAEO,eAAe,CAAC,UAA2B;QACjD,IAAI,SAAS,GAAG,CAAC,CAAC;QAElB,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,KAAK,EAAE,CAAC;YACpC,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;gBACpD,0CAA0C;gBAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;gBAEjE,yBAAyB;gBACzB,MAAM,IAAI,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAEnD,uCAAuC;gBACvC,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;gBAC7D,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBACzB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;oBAC1C,SAAS,EAAE,CAAC;gBACd,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,qBAAqB,CAAC,QAAgC;QAC5D,QAAQ,QAAQ,EAAE,CAAC;YACjB,KAAK,OAAO,CAAC;YACb,KAAK,UAAU;gBACb,OAAO,gBAAgB,CAAC;YAC1B,KAAK,OAAO;gBACV,OAAO,SAAS,CAAC;YACnB,KAAK,QAAQ;gBACX,OAAO,mBAAmB,CAAC;YAC7B,KAAK,UAAU;gBACb,OAAO,YAAY,CAAC;YACtB;gBACE,OAAO,gBAAgB,CAAC;QAC5B,CAAC;IACH,CAAC;IAEO,eAAe,CAAC,IAAY;QAClC,yDAAyD;QACzD,MAAM,GAAG,GAAG,EAAE,CAAC;QACf,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAEzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;YACjD,SAAS,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC;QACxB,CAAC;QAED,YAAY;QACZ,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACtE,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACtC,CAAC;CACF;AAED,6BAA6B;AAC7B,OAAO,EACL,mBAAmB,GACpB,CAAC","sourcesContent":["/**\n * SONA (Self-Optimizing Neural Architecture) Learning System\n *\n * Provides adaptive learning capabilities with trajectory tracking,\n * pattern recognition, and memory protection (EWC++).\n */\n\nimport {\n  SonaConfig,\n  LearningSignal,\n  QueryTrajectory,\n  TrajectoryStep,\n  TrajectoryOutcome,\n  LearnedPattern,\n  PatternType,\n  EwcStats,\n  LoRAConfig,\n  Embedding,\n} from './types';\nimport { LoraAdapter } from './lora';\n\n/** Embedding dimension used by the coordinator's hash embedder and micro-LoRA. */\nconst MICRO_LORA_DIM = 64;\n/** Micro-LoRA rank: SONA's instant loop uses a tiny adapter (rank 1-2) by design. */\nconst MICRO_LORA_RANK = 2;\n\n/**\n * Default SONA configuration\n */\nconst DEFAULT_SONA_CONFIG: Required<SonaConfig> = {\n  instantLoopEnabled: true,\n  backgroundLoopEnabled: true,\n  loraLearningRate: 0.001,\n  loraRank: 8,\n  ewcLambda: 2000,\n  maxTrajectorySize: 1000,\n  patternThreshold: 0.85,\n};\n\n/**\n * Trajectory Builder for tracking query execution paths\n *\n * @example\n * ```typescript\n * const builder = new TrajectoryBuilder();\n *\n * builder.startStep('query', 'What is AI?');\n * // ... processing ...\n * builder.endStep('AI is artificial intelligence', 0.95);\n *\n * builder.startStep('memory', 'searching context');\n * builder.endStep('found 3 relevant documents', 0.88);\n *\n * const trajectory = builder.complete('success');\n * ```\n */\nexport class TrajectoryBuilder {\n  private id: string;\n  private steps: TrajectoryStep[] = [];\n  private currentStep: Partial<TrajectoryStep> | null = null;\n  private stepStart: number = 0;\n  private startTime: number;\n\n  constructor() {\n    this.id = `traj-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n    this.startTime = Date.now();\n  }\n\n  /**\n   * Start a new step in the trajectory\n   */\n  startStep(type: TrajectoryStep['type'], input: string): this {\n    if (this.currentStep) {\n      // Auto-complete previous step\n      this.endStep('', 0);\n    }\n\n    this.stepStart = Date.now();\n    this.currentStep = {\n      type,\n      input,\n    };\n\n    return this;\n  }\n\n  /**\n   * End current step with output\n   */\n  endStep(output: string, confidence: number): this {\n    if (!this.currentStep) {\n      return this;\n    }\n\n    this.steps.push({\n      type: this.currentStep.type!,\n      input: this.currentStep.input!,\n      output,\n      durationMs: Date.now() - this.stepStart,\n      confidence,\n    });\n\n    this.currentStep = null;\n    return this;\n  }\n\n  /**\n   * Complete trajectory with final outcome\n   */\n  complete(outcome: TrajectoryOutcome): QueryTrajectory {\n    // Complete any pending step\n    if (this.currentStep) {\n      this.endStep('incomplete', 0);\n    }\n\n    return {\n      id: this.id,\n      steps: this.steps,\n      outcome,\n      durationMs: Date.now() - this.startTime,\n    };\n  }\n\n  /**\n   * Get current trajectory ID\n   */\n  getId(): string {\n    return this.id;\n  }\n}\n\n/**\n * ReasoningBank - Pattern storage and retrieval\n *\n * Stores learned patterns from successful interactions and\n * enables pattern-based reasoning shortcuts.\n *\n * OPTIMIZED: Uses Float64Array for embeddings and partial sorting\n */\nexport class ReasoningBank {\n  private patterns: Map<string, LearnedPattern> = new Map();\n  private embeddings: Map<string, Float64Array> = new Map();\n  private embeddingNorms: Map<string, number> = new Map(); // Pre-computed norms\n  private threshold: number;\n  // Reusable arrays for findSimilar to avoid allocations\n  private _similarityResults: Array<{ id: string; score: number }> = [];\n\n  constructor(threshold = 0.85) {\n    this.threshold = threshold;\n  }\n\n  /**\n   * Store a new pattern\n   */\n  store(\n    type: PatternType,\n    embedding: Embedding,\n    metadata?: Record<string, unknown>\n  ): string {\n    const id = `pat-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n\n    const pattern: LearnedPattern = {\n      id,\n      type,\n      embedding,\n      successRate: 1.0,\n      useCount: 0,\n      lastUsed: new Date(),\n    };\n\n    this.patterns.set(id, pattern);\n\n    // Store as typed array for faster similarity computation\n    const typedEmb = new Float64Array(embedding);\n    this.embeddings.set(id, typedEmb);\n\n    // Pre-compute and cache the norm\n    let norm = 0;\n    for (let i = 0; i < typedEmb.length; i++) {\n      norm += typedEmb[i] * typedEmb[i];\n    }\n    this.embeddingNorms.set(id, Math.sqrt(norm));\n\n    return id;\n  }\n\n  /**\n   * Find similar patterns\n   * OPTIMIZED: Uses typed arrays, pre-computed norms, and partial sorting\n   */\n  findSimilar(embedding: Embedding, k = 5): LearnedPattern[] {\n    // Pre-compute query norm\n    let queryNorm = 0;\n    const queryLen = embedding.length;\n    for (let i = 0; i < queryLen; i++) {\n      queryNorm += embedding[i] * embedding[i];\n    }\n    queryNorm = Math.sqrt(queryNorm);\n\n    if (queryNorm === 0) return [];\n\n    // Reuse array to avoid allocations\n    this._similarityResults.length = 0;\n\n    for (const [id, patEmb] of this.embeddings) {\n      const patNorm = this.embeddingNorms.get(id) || 0;\n      if (patNorm === 0) continue;\n\n      // Fast dot product\n      let dot = 0;\n      const minLen = Math.min(queryLen, patEmb.length);\n\n      // Unrolled loop\n      let i = 0;\n      for (; i + 3 < minLen; i += 4) {\n        dot += embedding[i] * patEmb[i] +\n               embedding[i + 1] * patEmb[i + 1] +\n               embedding[i + 2] * patEmb[i + 2] +\n               embedding[i + 3] * patEmb[i + 3];\n      }\n      for (; i < minLen; i++) {\n        dot += embedding[i] * patEmb[i];\n      }\n\n      const score = dot / (queryNorm * patNorm);\n\n      if (score >= this.threshold) {\n        this._similarityResults.push({ id, score });\n      }\n    }\n\n    // Partial sort for top-k (faster than full sort for large arrays)\n    if (this._similarityResults.length <= k) {\n      this._similarityResults.sort((a, b) => b.score - a.score);\n    } else {\n      // Quick partial sort for top k\n      this.partialSort(this._similarityResults, k);\n    }\n\n    const topK = this._similarityResults.slice(0, k);\n\n    return topK\n      .map(s => this.patterns.get(s.id))\n      .filter((p): p is LearnedPattern => p !== undefined);\n  }\n\n  /**\n   * Partial sort to get top k elements (faster than full sort)\n   */\n  private partialSort(arr: Array<{ id: string; score: number }>, k: number): void {\n    // Simple selection for small k\n    for (let i = 0; i < k && i < arr.length; i++) {\n      let maxIdx = i;\n      for (let j = i + 1; j < arr.length; j++) {\n        if (arr[j].score > arr[maxIdx].score) {\n          maxIdx = j;\n        }\n      }\n      if (maxIdx !== i) {\n        const temp = arr[i];\n        arr[i] = arr[maxIdx];\n        arr[maxIdx] = temp;\n      }\n    }\n  }\n\n  /**\n   * Record pattern usage (success or failure)\n   */\n  recordUsage(patternId: string, success: boolean): void {\n    const pattern = this.patterns.get(patternId);\n    if (!pattern) return;\n\n    pattern.useCount++;\n    pattern.lastUsed = new Date();\n\n    // Update success rate with exponential moving average\n    const alpha = 0.1;\n    const outcome = success ? 1.0 : 0.0;\n    pattern.successRate = alpha * outcome + (1 - alpha) * pattern.successRate;\n  }\n\n  /**\n   * Get pattern by ID\n   */\n  get(patternId: string): LearnedPattern | undefined {\n    return this.patterns.get(patternId);\n  }\n\n  /**\n   * Get all patterns of a type\n   */\n  getByType(type: PatternType): LearnedPattern[] {\n    return Array.from(this.patterns.values()).filter(p => p.type === type);\n  }\n\n  /**\n   * Prune low-performing patterns\n   */\n  prune(minSuccessRate = 0.3, minUseCount = 5): number {\n    let pruned = 0;\n\n    for (const [id, pattern] of this.patterns) {\n      if (pattern.useCount >= minUseCount && pattern.successRate < minSuccessRate) {\n        this.patterns.delete(id);\n        this.embeddings.delete(id);\n        this.embeddingNorms.delete(id);\n        pruned++;\n      }\n    }\n\n    return pruned;\n  }\n\n  /**\n   * Get statistics\n   */\n  stats(): { totalPatterns: number; avgSuccessRate: number; byType: Record<string, number> } {\n    const patterns = Array.from(this.patterns.values());\n    const byType: Record<string, number> = {};\n\n    let totalSuccess = 0;\n    for (const p of patterns) {\n      totalSuccess += p.successRate;\n      byType[p.type] = (byType[p.type] || 0) + 1;\n    }\n\n    return {\n      totalPatterns: patterns.length,\n      avgSuccessRate: patterns.length > 0 ? totalSuccess / patterns.length : 0,\n      byType,\n    };\n  }\n\n  private cosineSimilarity(a: Embedding, b: Embedding): number {\n    let dot = 0, normA = 0, normB = 0;\n    const len = Math.min(a.length, b.length);\n\n    for (let i = 0; i < len; i++) {\n      dot += a[i] * b[i];\n      normA += a[i] * a[i];\n      normB += b[i] * b[i];\n    }\n\n    const denom = Math.sqrt(normA) * Math.sqrt(normB);\n    return denom > 0 ? dot / denom : 0;\n  }\n}\n\n/**\n * EWC++ (Elastic Weight Consolidation) Manager\n *\n * Prevents catastrophic forgetting by protecting important weights.\n * This is a simplified JS implementation of the concept.\n *\n * OPTIMIZED: Uses Float64Array for 5-10x faster penalty computation\n */\nexport class EwcManager {\n  private lambda: number;\n  private tasksLearned: number = 0;\n  private fisherDiagonal: Map<string, Float64Array> = new Map();\n  private optimalWeights: Map<string, Float64Array> = new Map();\n  // Pre-allocated buffer for penalty computation\n  private _penaltyBuffer: Float64Array | null = null;\n\n  constructor(lambda = 2000) {\n    this.lambda = lambda;\n  }\n\n  /**\n   * Register a new task (after successful learning)\n   */\n  registerTask(taskId: string, weights: number[]): void {\n    // Store optimal weights for this task using typed arrays\n    const optimalArr = new Float64Array(weights.length);\n    const fisherArr = new Float64Array(weights.length);\n\n    for (let i = 0; i < weights.length; i++) {\n      optimalArr[i] = weights[i];\n      fisherArr[i] = Math.abs(weights[i]) * this.lambda;\n    }\n\n    this.optimalWeights.set(taskId, optimalArr);\n    this.fisherDiagonal.set(taskId, fisherArr);\n    this.tasksLearned++;\n  }\n\n  /**\n   * Compute EWC penalty for weight update\n   * OPTIMIZED: Uses typed arrays and minimizes allocations\n   */\n  computePenalty(currentWeights: number[]): number {\n    let penalty = 0;\n    const len = currentWeights.length;\n\n    for (const [taskId, optimal] of this.optimalWeights) {\n      const fisher = this.fisherDiagonal.get(taskId);\n      if (!fisher) continue;\n\n      const minLen = Math.min(len, optimal.length);\n\n      // Unrolled loop for better performance\n      let i = 0;\n      for (; i + 3 < minLen; i += 4) {\n        const diff0 = currentWeights[i] - optimal[i];\n        const diff1 = currentWeights[i + 1] - optimal[i + 1];\n        const diff2 = currentWeights[i + 2] - optimal[i + 2];\n        const diff3 = currentWeights[i + 3] - optimal[i + 3];\n        penalty += fisher[i] * diff0 * diff0 +\n                   fisher[i + 1] * diff1 * diff1 +\n                   fisher[i + 2] * diff2 * diff2 +\n                   fisher[i + 3] * diff3 * diff3;\n      }\n      // Handle remaining elements\n      for (; i < minLen; i++) {\n        const diff = currentWeights[i] - optimal[i];\n        penalty += fisher[i] * diff * diff;\n      }\n    }\n\n    return penalty * 0.5;\n  }\n\n  /**\n   * Get EWC statistics\n   */\n  stats(): EwcStats {\n    return {\n      tasksLearned: this.tasksLearned,\n      fisherComputed: this.fisherDiagonal.size > 0,\n      protectionStrength: this.lambda,\n      forgettingRate: this.estimateForgettingRate(),\n    };\n  }\n\n  private estimateForgettingRate(): number {\n    // Simplified estimation based on number of tasks\n    return Math.max(0, 1 - Math.exp(-this.tasksLearned * 0.1));\n  }\n}\n\n/**\n * SONA Learning Coordinator\n *\n * Orchestrates the learning loops and components.\n */\nexport class SonaCoordinator {\n  private config: Required<SonaConfig>;\n  private trajectoryBuffer: QueryTrajectory[] = [];\n  private reasoningBank: ReasoningBank;\n  private ewcManager: EwcManager;\n  private signalBuffer: LearningSignal[] = [];\n  private microLora: LoraAdapter;\n  private microLoraUpdates = 0;\n\n  constructor(config?: SonaConfig) {\n    this.config = { ...DEFAULT_SONA_CONFIG, ...config };\n    this.reasoningBank = new ReasoningBank(this.config.patternThreshold);\n    this.ewcManager = new EwcManager(this.config.ewcLambda);\n    this.microLora = new LoraAdapter(\n      { rank: MICRO_LORA_RANK },\n      MICRO_LORA_DIM,\n      MICRO_LORA_DIM\n    );\n  }\n\n  /**\n   * Record a learning signal\n   *\n   * Every signal drives the instant loop: quality above 0.5 reinforces the\n   * signal's direction in the micro-LoRA, quality below 0.5 unlearns it\n   * (previously only quality >= 0.8 was processed, so negative feedback\n   * never adapted anything).\n   */\n  recordSignal(signal: LearningSignal): void {\n    this.signalBuffer.push(signal);\n\n    // Instant loop - immediate learning\n    if (this.config.instantLoopEnabled) {\n      this.processInstantLearning(signal);\n    }\n  }\n\n  /**\n   * Record a completed trajectory\n   */\n  recordTrajectory(trajectory: QueryTrajectory): void {\n    this.trajectoryBuffer.push(trajectory);\n\n    // Maintain buffer size\n    while (this.trajectoryBuffer.length > this.config.maxTrajectorySize) {\n      this.trajectoryBuffer.shift();\n    }\n\n    // Extract patterns from successful trajectories\n    if (trajectory.outcome === 'success') {\n      this.extractPatterns(trajectory);\n    }\n  }\n\n  /**\n   * Run background learning loop\n   */\n  runBackgroundLoop(): { patternsLearned: number; trajectoriesProcessed: number } {\n    if (!this.config.backgroundLoopEnabled) {\n      return { patternsLearned: 0, trajectoriesProcessed: 0 };\n    }\n\n    let patternsLearned = 0;\n    const trajectoriesProcessed = this.trajectoryBuffer.length;\n\n    // Process accumulated trajectories\n    for (const traj of this.trajectoryBuffer) {\n      if (traj.outcome === 'success' || traj.outcome === 'partial') {\n        patternsLearned += this.extractPatterns(traj);\n      }\n    }\n\n    // Prune low-performing patterns\n    this.reasoningBank.prune();\n\n    // Clear processed trajectories\n    this.trajectoryBuffer = [];\n\n    return { patternsLearned, trajectoriesProcessed };\n  }\n\n  /**\n   * Get reasoning bank for pattern queries\n   */\n  getReasoningBank(): ReasoningBank {\n    return this.reasoningBank;\n  }\n\n  /**\n   * Get EWC manager\n   */\n  getEwcManager(): EwcManager {\n    return this.ewcManager;\n  }\n\n  /**\n   * Get statistics\n   */\n  stats(): {\n    signalsReceived: number;\n    trajectoriesBuffered: number;\n    patterns: ReturnType<ReasoningBank['stats']>;\n    ewc: EwcStats;\n    microLora: { updates: number; deltaNorm: number };\n  } {\n    return {\n      signalsReceived: this.signalBuffer.length,\n      trajectoriesBuffered: this.trajectoryBuffer.length,\n      patterns: this.reasoningBank.stats(),\n      ewc: this.ewcManager.stats(),\n      microLora: {\n        updates: this.microLoraUpdates,\n        deltaNorm: this.microLoraDeltaNorm(),\n      },\n    };\n  }\n\n  /**\n   * Apply the micro-LoRA transformation learned from feedback.\n   *\n   * Input is truncated/zero-padded to the adapter dimension; the residual\n   * connection means an untrained adapter returns the input unchanged.\n   */\n  applyMicroLora(input: number[]): number[] {\n    return this.microLora.forward(input.slice(0, MICRO_LORA_DIM));\n  }\n\n  /**\n   * Frobenius norm of the micro-LoRA weight delta (scaling * A @ B).\n   *\n   * 0 means no adaptation has occurred (LoRA B is zero-initialized, so the\n   * delta is exactly zero until the first feedback update). Consumers can\n   * surface this directly (e.g. a statusline \"delta LoRA\" field) — see #553.\n   */\n  microLoraDeltaNorm(): number {\n    const { loraA, loraB, scaling } = this.microLora.getWeights();\n    const rank = loraB.length;\n    let sumSq = 0;\n    for (let i = 0; i < loraA.length; i++) {\n      for (let j = 0; j < MICRO_LORA_DIM; j++) {\n        let d = 0;\n        for (let r = 0; r < rank; r++) {\n          d += loraA[i][r] * loraB[r][j];\n        }\n        sumSq += scaling * d * (scaling * d);\n      }\n    }\n    return Math.sqrt(sumSq);\n  }\n\n  /**\n   * Instant-loop learning: a single feedback signal produces a real\n   * micro-LoRA weight update (fixes #553 — this was a no-op stub, so\n   * learn-from-feedback never changed any weight).\n   *\n   * REINFORCE-style with a fixed 0.5 baseline: reward = quality - 0.5.\n   * The gradient pushes the adapter output toward the signal's embedding\n   * direction for positive reward and away from it for negative reward\n   * (backward() applies `weights -= lr * grad`, hence the negated sign).\n   */\n  private processInstantLearning(signal: LearningSignal): void {\n    const reward = signal.quality - 0.5;\n    if (reward === 0) return;\n\n    const input = this.createEmbedding(\n      signal.correction ?? `${signal.requestId}:${signal.type}`\n    );\n    const gradOutput = input.map(x => -reward * x);\n    this.microLora.backward(input, gradOutput, this.config.loraLearningRate);\n    this.microLoraUpdates++;\n  }\n\n  private extractPatterns(trajectory: QueryTrajectory): number {\n    let extracted = 0;\n\n    for (const step of trajectory.steps) {\n      if (step.confidence >= this.config.patternThreshold) {\n        // Create embedding from step (simplified)\n        const embedding = this.createEmbedding(step.input + step.output);\n\n        // Determine pattern type\n        const type = this.stepTypeToPatternType(step.type);\n\n        // Store if not too similar to existing\n        const similar = this.reasoningBank.findSimilar(embedding, 1);\n        if (similar.length === 0) {\n          this.reasoningBank.store(type, embedding);\n          extracted++;\n        }\n      }\n    }\n\n    return extracted;\n  }\n\n  private stepTypeToPatternType(stepType: TrajectoryStep['type']): PatternType {\n    switch (stepType) {\n      case 'query':\n      case 'generate':\n        return 'query_response';\n      case 'route':\n        return 'routing';\n      case 'memory':\n        return 'context_retrieval';\n      case 'feedback':\n        return 'correction';\n      default:\n        return 'query_response';\n    }\n  }\n\n  private createEmbedding(text: string): Embedding {\n    // Simplified hash-based embedding (real impl uses model)\n    const dim = 64;\n    const embedding = new Array(dim).fill(0);\n\n    for (let i = 0; i < text.length; i++) {\n      const idx = (text.charCodeAt(i) * (i + 1)) % dim;\n      embedding[idx] += 0.1;\n    }\n\n    // Normalize\n    const norm = Math.sqrt(embedding.reduce((s, x) => s + x * x, 0)) || 1;\n    return embedding.map(x => x / norm);\n  }\n}\n\n// Export all SONA components\nexport {\n  DEFAULT_SONA_CONFIG,\n};\n"]}