@sparkleideas/neural 3.5.2-patch.1

package/src/modes/edge.ts

@@ -0,0 +1,409 @@
+/**
+ * Edge Mode Implementation
+ *
+ * Optimized for resource-constrained environments with:
+ * - <5MB memory footprint
+ * - Minimal latency (<1ms)
+ * - Micro-LoRA (rank-1)
+ * - Aggressive pruning
+ * - Async updates
+ */
+
+import type {
+  SONAModeConfig,
+  ModeOptimizations,
+  Trajectory,
+  Pattern,
+  PatternMatch,
+  LoRAWeights,
+  EWCState,
+} from '../types.js';
+import { BaseModeImplementation } from './base.js';
+
+/**
+ * Edge mode for resource-constrained devices
+ */
+export class EdgeMode extends BaseModeImplementation {
+  readonly mode = 'edge';
+
+  // Minimal pattern storage (compressed)
+  private compressedPatterns: Map<string, CompressedPattern> = new Map();
+
+  // Quantized LoRA weights (int8)
+  private quantizedWeights: Map<string, Int8Array> = new Map();
+  private quantizationScale: number = 1.0;
+
+  // Pending async updates
+  private pendingUpdates: Array<() => Promise<void>> = [];
+  private updateTimer: ReturnType<typeof setTimeout> | null = null;
+
+  // Stats
+  private totalOps = 0;
+  private totalTime = 0;
+
+  async initialize(): Promise<void> {
+    await super.initialize();
+    this.compressedPatterns.clear();
+    this.quantizedWeights.clear();
+    this.pendingUpdates = [];
+  }
+
+  async cleanup(): Promise<void> {
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+    }
+    this.compressedPatterns.clear();
+    this.quantizedWeights.clear();
+    this.pendingUpdates = [];
+    await super.cleanup();
+  }
+
+  /**
+   * Find patterns using compressed embeddings
+   */
+  async findPatterns(
+    embedding: Float32Array,
+    k: number,
+    patterns: Pattern[]
+  ): Promise<PatternMatch[]> {
+    const startTime = performance.now();
+
+    // Compress input embedding for comparison
+    const compressedInput = this.compressEmbedding(embedding);
+
+    // Fast similarity on compressed representations
+    const matches: Array<{ pattern: Pattern; score: number }> = [];
+
+    for (const pattern of patterns) {
+      let compressed = this.compressedPatterns.get(pattern.patternId);
+      if (!compressed) {
+        compressed = this.createCompressedPattern(pattern);
+        this.compressedPatterns.set(pattern.patternId, compressed);
+      }
+
+      // Use compressed similarity (faster but less accurate)
+      const score = this.compressedSimilarity(compressedInput, compressed.embedding);
+      matches.push({ pattern, score });
+    }
+
+    // Quick partial sort
+    matches.sort((a, b) => b.score - a.score);
+    const topK = matches.slice(0, k);
+
+    this.totalOps++;
+    this.totalTime += performance.now() - startTime;
+
+    return topK.map(m => ({
+      pattern: m.pattern,
+      similarity: m.score,
+      confidence: m.score * m.pattern.successRate,
+      latencyMs: 0,
+    }));
+  }
+
+  /**
+   * Lightweight learning with async updates
+   */
+  async learn(
+    trajectories: Trajectory[],
+    config: SONAModeConfig,
+    ewcState: EWCState
+  ): Promise<number> {
+    const startTime = performance.now();
+
+    if (trajectories.length === 0) return 0;
+
+    // Edge mode: only learn from high-quality trajectories
+    const threshold = config.qualityThreshold;
+    const good = trajectories.filter(t => t.qualityScore >= threshold);
+
+    if (good.length === 0) return 0;
+
+    const avgQuality = good.reduce((s, t) => s + t.qualityScore, 0) / good.length;
+
+    // Queue async update for later processing
+    this.queueAsyncUpdate(async () => {
+      await this.performLightweightUpdate(good, config.learningRate);
+    });
+
+    this.totalOps++;
+    this.totalTime += performance.now() - startTime;
+
+    return Math.max(0, avgQuality - 0.5);
+  }
+
+  /**
+   * Apply quantized LoRA
+   */
+  async applyLoRA(
+    input: Float32Array,
+    weights?: LoRAWeights
+  ): Promise<Float32Array> {
+    if (!weights) {
+      return input;
+    }
+
+    const output = new Float32Array(input.length);
+    output.set(input);
+
+    // Quantize weights if not already done
+    for (const module of ['q_proj', 'v_proj']) {
+      const A = weights.A.get(module);
+      const B = weights.B.get(module);
+
+      if (A && B) {
+        const qA = this.getOrQuantize(`A_${module}`, A);
+        const qB = this.getOrQuantize(`B_${module}`, B);
+
+        // Apply quantized LoRA
+        const adapted = this.applyQuantizedLoRA(input, qA, qB);
+        const alpha = 0.05; // Very small blending for edge
+        for (let i = 0; i < output.length; i++) {
+          output[i] = output[i] * (1 - alpha) + adapted[i] * alpha;
+        }
+      }
+    }
+
+    return output;
+  }
+
+  getStats(): Record<string, number> {
+    return {
+      avgLatencyMs: this.totalOps > 0 ? this.totalTime / this.totalOps : 0,
+      compressedPatterns: this.compressedPatterns.size,
+      quantizedWeights: this.quantizedWeights.size,
+      pendingUpdates: this.pendingUpdates.length,
+      memoryEstimateMb: this.estimateMemoryUsage(),
+    };
+  }
+
+  // ========================================================================
+  // Compression utilities
+  // ========================================================================
+
+  /**
+   * Compress embedding to 8-bit representation
+   */
+  private compressEmbedding(embedding: Float32Array): Int8Array {
+    const compressed = new Int8Array(embedding.length);
+    const max = Math.max(...embedding.map(Math.abs));
+    const scale = max > 0 ? 127 / max : 1;
+
+    for (let i = 0; i < embedding.length; i++) {
+      compressed[i] = Math.round(embedding[i] * scale);
+    }
+
+    return compressed;
+  }
+
+  /**
+   * Create compressed pattern representation
+   */
+  private createCompressedPattern(pattern: Pattern): CompressedPattern {
+    return {
+      id: pattern.patternId,
+      embedding: this.compressEmbedding(pattern.embedding),
+      successRate: Math.round(pattern.successRate * 255),
+      usageCount: Math.min(pattern.usageCount, 255),
+    };
+  }
+
+  /**
+   * Fast similarity on compressed embeddings
+   */
+  private compressedSimilarity(a: Int8Array, b: Int8Array): number {
+    if (a.length !== b.length) return 0;
+
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+
+    // Process in chunks of 8 for better cache utilization
+    const len = a.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 * normB);
+    return denom > 0 ? dot / denom : 0;
+  }
+
+  /**
+   * Get or create quantized weights
+   */
+  private getOrQuantize(key: string, weights: Float32Array): Int8Array {
+    let quantized = this.quantizedWeights.get(key);
+    if (!quantized) {
+      quantized = this.quantizeWeights(weights);
+      this.quantizedWeights.set(key, quantized);
+    }
+    return quantized;
+  }
+
+  /**
+   * Quantize float weights to int8
+   */
+  private quantizeWeights(weights: Float32Array): Int8Array {
+    const max = Math.max(...weights.map(Math.abs));
+    this.quantizationScale = max > 0 ? 127 / max : 1;
+
+    const quantized = new Int8Array(weights.length);
+    for (let i = 0; i < weights.length; i++) {
+      quantized[i] = Math.round(weights[i] * this.quantizationScale);
+    }
+
+    return quantized;
+  }
+
+  /**
+   * Apply LoRA with quantized weights
+   */
+  private applyQuantizedLoRA(
+    input: Float32Array,
+    qA: Int8Array,
+    qB: Int8Array
+  ): Float32Array {
+    const dim = input.length;
+    const rank = 1; // Edge mode uses rank-1
+
+    const output = new Float32Array(dim);
+    const dequantScale = 1 / this.quantizationScale;
+
+    // A * input -> intermediate (scalar for rank-1)
+    let intermediate = 0;
+    for (let d = 0; d < dim; d++) {
+      intermediate += (qA[d] * dequantScale) * input[d];
+    }
+
+    // B * intermediate -> output
+    for (let d = 0; d < dim; d++) {
+      output[d] = (qB[d] * dequantScale) * intermediate;
+    }
+
+    return output;
+  }
+
+  // ========================================================================
+  // Async updates
+  // ========================================================================
+
+  /**
+   * Queue an async update
+   */
+  private queueAsyncUpdate(update: () => Promise<void>): void {
+    this.pendingUpdates.push(update);
+
+    // Schedule processing if not already scheduled
+    if (!this.updateTimer) {
+      this.updateTimer = setTimeout(() => {
+        this.processAsyncUpdates();
+      }, 100); // Process updates every 100ms
+    }
+  }
+
+  /**
+   * Process pending async updates
+   */
+  private async processAsyncUpdates(): Promise<void> {
+    this.updateTimer = null;
+
+    const updates = this.pendingUpdates;
+    this.pendingUpdates = [];
+
+    // Process up to 5 updates at a time
+    for (const update of updates.slice(0, 5)) {
+      try {
+        await update();
+      } catch (error) {
+        console.error('Edge mode async update failed:', error);
+      }
+    }
+
+    // Re-queue remaining updates
+    if (updates.length > 5) {
+      this.pendingUpdates = updates.slice(5);
+      this.updateTimer = setTimeout(() => {
+        this.processAsyncUpdates();
+      }, 100);
+    }
+  }
+
+  /**
+   * Perform lightweight parameter update
+   */
+  private async performLightweightUpdate(
+    trajectories: Trajectory[],
+    learningRate: number
+  ): Promise<void> {
+    // Simple exponential moving average update
+    const alpha = learningRate;
+
+    for (const trajectory of trajectories) {
+      if (trajectory.steps.length === 0) continue;
+
+      // Update compressed patterns based on trajectory success
+      const lastStep = trajectory.steps[trajectory.steps.length - 1];
+      const pattern = this.findSimilarCompressedPattern(lastStep.stateAfter);
+
+      if (pattern) {
+        // Update success rate with EMA
+        const newRate = alpha * trajectory.qualityScore + (1 - alpha) * (pattern.successRate / 255);
+        pattern.successRate = Math.round(newRate * 255);
+        pattern.usageCount = Math.min(255, pattern.usageCount + 1);
+      }
+    }
+  }
+
+  /**
+   * Find most similar compressed pattern
+   */
+  private findSimilarCompressedPattern(embedding: Float32Array): CompressedPattern | null {
+    const compressed = this.compressEmbedding(embedding);
+    let best: CompressedPattern | null = null;
+    let bestSim = -1;
+
+    for (const pattern of this.compressedPatterns.values()) {
+      const sim = this.compressedSimilarity(compressed, pattern.embedding);
+      if (sim > bestSim) {
+        bestSim = sim;
+        best = pattern;
+      }
+    }
+
+    return best;
+  }
+
+  /**
+   * Estimate memory usage in MB
+   */
+  private estimateMemoryUsage(): number {
+    let bytes = 0;
+
+    // Compressed patterns
+    for (const pattern of this.compressedPatterns.values()) {
+      bytes += pattern.embedding.byteLength + 8; // embedding + overhead
+    }
+
+    // Quantized weights
+    for (const weights of this.quantizedWeights.values()) {
+      bytes += weights.byteLength;
+    }
+
+    // Pending updates (minimal)
+    bytes += this.pendingUpdates.length * 100;
+
+    return bytes / (1024 * 1024);
+  }
+}
+
+/**
+ * Compressed pattern representation
+ */
+interface CompressedPattern {
+  id: string;
+  embedding: Int8Array;
+  successRate: number; // 0-255
+  usageCount: number; // 0-255
+}

package/src/modes/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * SONA Learning Modes Index
+ *
+ * Exports all learning mode implementations and the common interface.
+ */
+import type { SONAModeConfig, ModeOptimizations, Trajectory, Pattern, PatternMatch, LoRAWeights, EWCState } from '../types.js';
+/**
+ * Common interface for all mode implementations
+ */
+export interface ModeImplementation {
+    /** Mode identifier */
+    readonly mode: string;
+    /** Initialize the mode */
+    initialize(): Promise<void>;
+    /** Cleanup resources */
+    cleanup(): Promise<void>;
+    /** Find similar patterns (k-nearest) */
+    findPatterns(embedding: Float32Array, k: number, patterns: Pattern[]): Promise<PatternMatch[]>;
+    /** Perform a learning step */
+    learn(trajectories: Trajectory[], config: SONAModeConfig, ewcState: EWCState): Promise<number>;
+    /** Apply LoRA adaptations */
+    applyLoRA(input: Float32Array, weights?: LoRAWeights): Promise<Float32Array>;
+    /** Get mode-specific stats */
+    getStats(): Record<string, number>;
+}
+/**
+ * Base class for mode implementations
+ */
+export declare abstract class BaseModeImplementation implements ModeImplementation {
+    abstract readonly mode: string;
+    protected config: SONAModeConfig;
+    protected optimizations: ModeOptimizations;
+    protected isInitialized: boolean;
+    constructor(config: SONAModeConfig, optimizations: ModeOptimizations);
+    initialize(): Promise<void>;
+    cleanup(): Promise<void>;
+    /**
+     * Compute cosine similarity between two vectors (SIMD-optimized)
+     */
+    protected cosineSimilarity(a: Float32Array, b: Float32Array): number;
+    /**
+     * Apply LoRA: output = input + BA * input (simplified)
+     */
+    protected applyLoRATransform(input: Float32Array, A: Float32Array, B: Float32Array, rank: number): Float32Array;
+    abstract findPatterns(embedding: Float32Array, k: number, patterns: Pattern[]): Promise<PatternMatch[]>;
+    abstract learn(trajectories: Trajectory[], config: SONAModeConfig, ewcState: EWCState): Promise<number>;
+    abstract applyLoRA(input: Float32Array, weights?: LoRAWeights): Promise<Float32Array>;
+    abstract getStats(): Record<string, number>;
+}
+export { RealTimeMode } from './real-time.js';
+export { BalancedMode } from './balanced.js';
+export { ResearchMode } from './research.js';
+export { EdgeMode } from './edge.js';
+export { BatchMode } from './batch.js';
+//# sourceMappingURL=index.d.ts.map

package/src/modes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,OAAO,EACP,YAAY,EACZ,WAAW,EACX,QAAQ,EACT,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sBAAsB;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,0BAA0B;IAC1B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B,wBAAwB;IACxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB,wCAAwC;IACxC,YAAY,CACV,SAAS,EAAE,YAAY,EACvB,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAE3B,8BAA8B;IAC9B,KAAK,CACH,YAAY,EAAE,UAAU,EAAE,EAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,MAAM,CAAC,CAAC;IAEnB,6BAA6B;IAC7B,SAAS,CACP,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,YAAY,CAAC,CAAC;IAEzB,8BAA8B;IAC9B,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,8BAAsB,sBAAuB,YAAW,kBAAkB;IACxE,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAE/B,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;IACjC,SAAS,CAAC,aAAa,EAAE,iBAAiB,CAAC;IAC3C,SAAS,CAAC,aAAa,UAAS;gBAEpB,MAAM,EAAE,cAAc,EAAE,aAAa,EAAE,iBAAiB;IAK9D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,MAAM;IA4BpE;;OAEG;IACH,SAAS,CAAC,kBAAkB,CAC1B,KAAK,EAAE,YAAY,EACnB,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,EACf,IAAI,EAAE,MAAM,GACX,YAAY;IA6Bf,QAAQ,CAAC,YAAY,CACnB,SAAS,EAAE,YAAY,EACvB,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,CAAC,YAAY,EAAE,CAAC;IAE1B,QAAQ,CAAC,KAAK,CACZ,YAAY,EAAE,UAAU,EAAE,EAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,MAAM,CAAC;IAElB,QAAQ,CAAC,SAAS,CAChB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,YAAY,CAAC;IAExB,QAAQ,CAAC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAC5C;AAGD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/src/modes/index.js

@@ -0,0 +1,83 @@
+/**
+ * SONA Learning Modes Index
+ *
+ * Exports all learning mode implementations and the common interface.
+ */
+/**
+ * Base class for mode implementations
+ */
+export class BaseModeImplementation {
+    config;
+    optimizations;
+    isInitialized = false;
+    constructor(config, optimizations) {
+        this.config = config;
+        this.optimizations = optimizations;
+    }
+    async initialize() {
+        this.isInitialized = true;
+    }
+    async cleanup() {
+        this.isInitialized = false;
+    }
+    /**
+     * Compute cosine similarity between two vectors (SIMD-optimized)
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        // Process 4 elements at a time for SIMD-like behavior
+        const len = a.length;
+        const simdLen = len - (len % 4);
+        for (let i = 0; i < simdLen; i += 4) {
+            dotProduct += a[i] * b[i] + a[i + 1] * b[i + 1] + a[i + 2] * b[i + 2] + a[i + 3] * b[i + 3];
+            normA += a[i] * a[i] + a[i + 1] * a[i + 1] + a[i + 2] * a[i + 2] + a[i + 3] * a[i + 3];
+            normB += b[i] * b[i] + b[i + 1] * b[i + 1] + b[i + 2] * b[i + 2] + b[i + 3] * b[i + 3];
+        }
+        // Handle remaining elements
+        for (let i = simdLen; i < len; i++) {
+            dotProduct += 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 ? dotProduct / denom : 0;
+    }
+    /**
+     * Apply LoRA: output = input + BA * input (simplified)
+     */
+    applyLoRATransform(input, A, B, rank) {
+        const dim = input.length;
+        const output = new Float32Array(dim);
+        // Copy input to output
+        output.set(input);
+        // Compute A * input -> intermediate (rank dimensions)
+        const intermediate = new Float32Array(rank);
+        for (let r = 0; r < rank; r++) {
+            let sum = 0;
+            for (let d = 0; d < dim; d++) {
+                sum += A[d * rank + r] * input[d];
+            }
+            intermediate[r] = sum;
+        }
+        // Compute B * intermediate -> delta (dim dimensions)
+        for (let d = 0; d < dim; d++) {
+            let sum = 0;
+            for (let r = 0; r < rank; r++) {
+                sum += B[r * dim + d] * intermediate[r];
+            }
+            output[d] += sum;
+        }
+        return output;
+    }
+}
+// Export mode implementations
+export { RealTimeMode } from './real-time.js';
+export { BalancedMode } from './balanced.js';
+export { ResearchMode } from './research.js';
+export { EdgeMode } from './edge.js';
+export { BatchMode } from './batch.js';
+//# sourceMappingURL=index.js.map

package/src/modes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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"}

package/src/modes/index.ts

@@ -0,0 +1,16 @@
+/**
+ * SONA Learning Modes Index
+ *
+ * Exports all learning mode implementations and the common interface.
+ */
+
+// Re-export base types and class (defined separately to avoid circular deps)
+export type { ModeImplementation } from './base.js';
+export { BaseModeImplementation } from './base.js';
+
+// Export mode implementations
+export { RealTimeMode } from './real-time.js';
+export { BalancedMode } from './balanced.js';
+export { ResearchMode } from './research.js';
+export { EdgeMode } from './edge.js';
+export { BatchMode } from './batch.js';

package/src/modes/real-time.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Real-Time Mode Implementation
+ *
+ * Optimized for sub-millisecond adaptation with:
+ * - 2200 ops/sec target
+ * - <0.5ms latency
+ * - Micro-LoRA (rank-2)
+ * - SIMD vectorization
+ * - Aggressive caching
+ */
+import type { SONAModeConfig, Trajectory, Pattern, PatternMatch, LoRAWeights, EWCState } from '../types.js';
+import { BaseModeImplementation } from './index.js';
+/**
+ * Real-Time mode for sub-millisecond adaptation
+ */
+export declare class RealTimeMode extends BaseModeImplementation {
+    readonly mode = "real-time";
+    private patternCache;
+    private cacheHits;
+    private cacheMisses;
+    private patternEmbeddings;
+    private patternIds;
+    private totalPatternMatches;
+    private totalPatternTime;
+    private totalLearnTime;
+    private learnIterations;
+    initialize(): Promise<void>;
+    cleanup(): Promise<void>;
+    /**
+     * Find patterns using cached similarity search
+     * Target: <1ms for k=3
+     */
+    findPatterns(embedding: Float32Array, k: number, patterns: Pattern[]): Promise<PatternMatch[]>;
+    /**
+     * Fast learning using Micro-LoRA updates
+     * Target: <10ms per batch
+     */
+    learn(trajectories: Trajectory[], config: SONAModeConfig, ewcState: EWCState): Promise<number>;
+    /**
+     * Apply LoRA with minimal overhead
+     * Target: <0.05ms
+     */
+    applyLoRA(input: Float32Array, weights?: LoRAWeights): Promise<Float32Array>;
+    getStats(): Record<string, number>;
+    /**
+     * Compute cache key from embedding
+     */
+    private computeCacheKey;
+    /**
+     * Update pattern index for fast similarity search
+     */
+    private updatePatternIndex;
+    /**
+     * Partial sort to get top-k elements (faster than full sort)
+     */
+    private partialSort;
+}
+//# sourceMappingURL=real-time.d.ts.map

package/src/modes/real-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"real-time.d.ts","sourceRoot":"","sources":["real-time.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,cAAc,EAEd,UAAU,EACV,OAAO,EACP,YAAY,EACZ,WAAW,EACX,QAAQ,EACT,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD;;GAEG;AACH,qBAAa,YAAa,SAAQ,sBAAsB;IACtD,QAAQ,CAAC,IAAI,eAAe;IAG5B,OAAO,CAAC,YAAY,CAA0C;IAC9D,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,WAAW,CAAK;IAGxB,OAAO,CAAC,iBAAiB,CAAsB;IAC/C,OAAO,CAAC,UAAU,CAAgB;IAGlC,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,eAAe,CAAK;IAEtB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B;;;OAGG;IACG,YAAY,CAChB,SAAS,EAAE,YAAY,EACvB,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,CAAC,YAAY,EAAE,CAAC;IAqD1B;;;OAGG;IACG,KAAK,CACT,YAAY,EAAE,UAAU,EAAE,EAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,MAAM,CAAC;IAyBlB;;;OAGG;IACG,SAAS,CACb,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,YAAY,CAAC;IA8BxB,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAgBlC;;OAEG;IACH,OAAO,CAAC,eAAe;IASvB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;OAEG;IACH,OAAO,CAAC,WAAW;CA4BpB"}