@ruvector/ruvllm 2.4.1 → 2.5.1

package/dist/esm/intelligence.js

@@ -0,0 +1,188 @@
+/**
+ * External Intelligence Providers for SONA Learning (ADR-043)
+ *
+ * TypeScript bindings for the IntelligenceProvider trait, enabling
+ * external systems to feed quality signals into RuvLLM's learning loops.
+ *
+ * @example
+ * ```typescript
+ * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';
+ *
+ * const loader = new IntelligenceLoader();
+ * loader.registerProvider(new FileSignalProvider('./signals.json'));
+ *
+ * const { signals, errors } = loader.loadAllSignals();
+ * console.log(`Loaded ${signals.length} signals`);
+ * ```
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/** Maximum signal file size (10 MiB) */
+const MAX_SIGNAL_FILE_SIZE = 10 * 1024 * 1024;
+/** Maximum number of signals per file */
+const MAX_SIGNALS_PER_FILE = 10000;
+/** Valid outcome values */
+const VALID_OUTCOMES = new Set(['success', 'partial_success', 'failure']);
+/** Valid human verdict values */
+const VALID_VERDICTS = new Set(['approved', 'rejected']);
+function asOptionalNumber(val) {
+    if (val === undefined || val === null)
+        return undefined;
+    const n = Number(val);
+    return Number.isFinite(n) && n >= 0 && n <= 1 ? n : undefined;
+}
+function validateOutcome(val) {
+    const s = String(val ?? 'failure');
+    return VALID_OUTCOMES.has(s) ? s : 'failure';
+}
+function validateVerdict(val) {
+    if (val === undefined || val === null)
+        return undefined;
+    const s = String(val);
+    return VALID_VERDICTS.has(s) ? s : undefined;
+}
+function validateScore(val) {
+    const n = Number(val ?? 0);
+    if (!Number.isFinite(n) || n < 0 || n > 1)
+        return 0;
+    return n;
+}
+function mapQualityFactors(raw) {
+    return {
+        acceptanceCriteriaMet: asOptionalNumber(raw.acceptance_criteria_met),
+        testsPassing: asOptionalNumber(raw.tests_passing),
+        noRegressions: asOptionalNumber(raw.no_regressions),
+        lintClean: asOptionalNumber(raw.lint_clean),
+        typeCheckClean: asOptionalNumber(raw.type_check_clean),
+        followsPatterns: asOptionalNumber(raw.follows_patterns),
+        contextRelevance: asOptionalNumber(raw.context_relevance),
+        reasoningCoherence: asOptionalNumber(raw.reasoning_coherence),
+        executionEfficiency: asOptionalNumber(raw.execution_efficiency),
+    };
+}
+/**
+ * Built-in file-based intelligence provider.
+ *
+ * Reads quality signals from a JSON file. This is the default provider
+ * for non-Rust integrations that write signal files.
+ */
+export class FileSignalProvider {
+    constructor(filePath) {
+        this.filePath = path.resolve(filePath);
+    }
+    name() {
+        return 'file-signals';
+    }
+    loadSignals() {
+        if (!fs.existsSync(this.filePath)) {
+            return [];
+        }
+        // Check file size before reading (prevent OOM)
+        const stat = fs.statSync(this.filePath);
+        if (stat.size > MAX_SIGNAL_FILE_SIZE) {
+            throw new Error(`Signal file exceeds max size (${stat.size} bytes, limit ${MAX_SIGNAL_FILE_SIZE})`);
+        }
+        const raw = fs.readFileSync(this.filePath, 'utf-8');
+        const data = JSON.parse(raw);
+        if (!Array.isArray(data)) {
+            return [];
+        }
+        // Check signal count
+        if (data.length > MAX_SIGNALS_PER_FILE) {
+            throw new Error(`Signal file contains ${data.length} signals, max is ${MAX_SIGNALS_PER_FILE}`);
+        }
+        return data.map((item) => {
+            const qfRaw = (item.quality_factors ?? item.qualityFactors);
+            return {
+                id: String(item.id ?? ''),
+                taskDescription: String(item.task_description ?? item.taskDescription ?? ''),
+                outcome: validateOutcome(item.outcome),
+                qualityScore: validateScore(item.quality_score ?? item.qualityScore),
+                humanVerdict: validateVerdict(item.human_verdict ?? item.humanVerdict),
+                qualityFactors: qfRaw ? mapQualityFactors(qfRaw) : undefined,
+                completedAt: String(item.completed_at ?? item.completedAt ?? new Date().toISOString()),
+            };
+        });
+    }
+    qualityWeights() {
+        try {
+            const weightsPath = path.join(path.dirname(this.filePath), 'quality-weights.json');
+            if (!fs.existsSync(weightsPath))
+                return undefined;
+            const raw = fs.readFileSync(weightsPath, 'utf-8');
+            const data = JSON.parse(raw);
+            return {
+                taskCompletion: Number(data.task_completion ?? data.taskCompletion ?? 0.5),
+                codeQuality: Number(data.code_quality ?? data.codeQuality ?? 0.3),
+                process: Number(data.process ?? 0.2),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+/**
+ * Aggregates quality signals from multiple registered providers.
+ *
+ * If no providers are registered, loadAllSignals returns empty arrays
+ * with zero overhead.
+ */
+export class IntelligenceLoader {
+    constructor() {
+        this.providers = [];
+    }
+    /** Register an external intelligence provider */
+    registerProvider(provider) {
+        this.providers.push(provider);
+    }
+    /** Returns the number of registered providers */
+    get providerCount() {
+        return this.providers.length;
+    }
+    /** Returns the names of all registered providers */
+    get providerNames() {
+        return this.providers.map(p => p.name());
+    }
+    /**
+     * Load signals from all registered providers.
+     *
+     * Non-fatal: if a provider fails, its error is captured but
+     * other providers continue loading.
+     */
+    loadAllSignals() {
+        const signals = [];
+        const errors = [];
+        for (const provider of this.providers) {
+            try {
+                const providerSignals = provider.loadSignals();
+                signals.push(...providerSignals);
+            }
+            catch (e) {
+                errors.push({
+                    providerName: provider.name(),
+                    message: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        return { signals, errors };
+    }
+    /** Load signals grouped by provider with weight overrides */
+    loadGrouped() {
+        return this.providers.map(provider => {
+            let providerSignals = [];
+            try {
+                providerSignals = provider.loadSignals();
+            }
+            catch {
+                // Non-fatal
+            }
+            return {
+                providerName: provider.name(),
+                signals: providerSignals,
+                weights: provider.qualityWeights?.(),
+            };
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intelligence.js","sourceRoot":"","sources":["../../src/intelligence.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * External Intelligence Providers for SONA Learning (ADR-043)\n *\n * TypeScript bindings for the IntelligenceProvider trait, enabling\n * external systems to feed quality signals into RuvLLM's learning loops.\n *\n * @example\n * ```typescript\n * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';\n *\n * const loader = new IntelligenceLoader();\n * loader.registerProvider(new FileSignalProvider('./signals.json'));\n *\n * const { signals, errors } = loader.loadAllSignals();\n * console.log(`Loaded ${signals.length} signals`);\n * ```\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n/** Maximum signal file size (10 MiB) */\nconst MAX_SIGNAL_FILE_SIZE = 10 * 1024 * 1024;\n\n/** Maximum number of signals per file */\nconst MAX_SIGNALS_PER_FILE = 10_000;\n\n/** Valid outcome values */\nconst VALID_OUTCOMES = new Set(['success', 'partial_success', 'failure']);\n\n/** Valid human verdict values */\nconst VALID_VERDICTS = new Set(['approved', 'rejected']);\n\n/**\n * A quality signal from an external system.\n *\n * Represents one completed task with quality assessment data\n * that can feed into SONA trajectories, the embedding classifier,\n * and model router calibration.\n */\nexport interface QualitySignal {\n  /** Unique identifier for this signal */\n  id: string;\n  /** Human-readable task description (used for embedding generation) */\n  taskDescription: string;\n  /** Execution outcome */\n  outcome: 'success' | 'partial_success' | 'failure';\n  /** Composite quality score (0.0 - 1.0) */\n  qualityScore: number;\n  /** Optional human verdict */\n  humanVerdict?: 'approved' | 'rejected';\n  /** Optional structured quality factors for detailed analysis */\n  qualityFactors?: QualityFactors;\n  /** ISO 8601 timestamp of task completion */\n  completedAt: string;\n}\n\n/**\n * Granular quality factor breakdown.\n *\n * Not all providers will have all factors. Undefined fields mean\n * \"not assessed\" (distinct from 0.0, which means \"assessed as zero\").\n */\nexport interface QualityFactors {\n  acceptanceCriteriaMet?: number;\n  testsPassing?: number;\n  noRegressions?: number;\n  lintClean?: number;\n  typeCheckClean?: number;\n  followsPatterns?: number;\n  contextRelevance?: number;\n  reasoningCoherence?: number;\n  executionEfficiency?: number;\n}\n\n/**\n * Quality weight overrides from a provider.\n *\n * Weights should sum to approximately 1.0.\n */\nexport interface ProviderQualityWeights {\n  taskCompletion: number;\n  codeQuality: number;\n  process: number;\n}\n\n/**\n * Error from a single provider during batch loading.\n */\nexport interface ProviderError {\n  providerName: string;\n  message: string;\n}\n\n/**\n * Result from a single provider during grouped loading.\n */\nexport interface ProviderResult {\n  providerName: string;\n  signals: QualitySignal[];\n  weights?: ProviderQualityWeights;\n}\n\n/**\n * Interface for external systems that supply quality signals to RuvLLM.\n *\n * Implement this interface and register with IntelligenceLoader.\n */\nexport interface IntelligenceProvider {\n  /** Human-readable name for this provider */\n  name(): string;\n  /** Load quality signals from this provider's data source */\n  loadSignals(): QualitySignal[];\n  /** Optional quality weight overrides */\n  qualityWeights?(): ProviderQualityWeights | undefined;\n}\n\nfunction asOptionalNumber(val: unknown): number | undefined {\n  if (val === undefined || val === null) return undefined;\n  const n = Number(val);\n  return Number.isFinite(n) && n >= 0 && n <= 1 ? n : undefined;\n}\n\nfunction validateOutcome(val: unknown): QualitySignal['outcome'] {\n  const s = String(val ?? 'failure');\n  return VALID_OUTCOMES.has(s) ? s as QualitySignal['outcome'] : 'failure';\n}\n\nfunction validateVerdict(val: unknown): QualitySignal['humanVerdict'] | undefined {\n  if (val === undefined || val === null) return undefined;\n  const s = String(val);\n  return VALID_VERDICTS.has(s) ? s as QualitySignal['humanVerdict'] : undefined;\n}\n\nfunction validateScore(val: unknown): number {\n  const n = Number(val ?? 0);\n  if (!Number.isFinite(n) || n < 0 || n > 1) return 0;\n  return n;\n}\n\nfunction mapQualityFactors(raw: Record<string, unknown>): QualityFactors {\n  return {\n    acceptanceCriteriaMet: asOptionalNumber(raw.acceptance_criteria_met),\n    testsPassing: asOptionalNumber(raw.tests_passing),\n    noRegressions: asOptionalNumber(raw.no_regressions),\n    lintClean: asOptionalNumber(raw.lint_clean),\n    typeCheckClean: asOptionalNumber(raw.type_check_clean),\n    followsPatterns: asOptionalNumber(raw.follows_patterns),\n    contextRelevance: asOptionalNumber(raw.context_relevance),\n    reasoningCoherence: asOptionalNumber(raw.reasoning_coherence),\n    executionEfficiency: asOptionalNumber(raw.execution_efficiency),\n  };\n}\n\n/**\n * Built-in file-based intelligence provider.\n *\n * Reads quality signals from a JSON file. This is the default provider\n * for non-Rust integrations that write signal files.\n */\nexport class FileSignalProvider implements IntelligenceProvider {\n  private readonly filePath: string;\n\n  constructor(filePath: string) {\n    this.filePath = path.resolve(filePath);\n  }\n\n  name(): string {\n    return 'file-signals';\n  }\n\n  loadSignals(): QualitySignal[] {\n    if (!fs.existsSync(this.filePath)) {\n      return [];\n    }\n\n    // Check file size before reading (prevent OOM)\n    const stat = fs.statSync(this.filePath);\n    if (stat.size > MAX_SIGNAL_FILE_SIZE) {\n      throw new Error(\n        `Signal file exceeds max size (${stat.size} bytes, limit ${MAX_SIGNAL_FILE_SIZE})`\n      );\n    }\n\n    const raw = fs.readFileSync(this.filePath, 'utf-8');\n    const data: unknown = JSON.parse(raw);\n    if (!Array.isArray(data)) {\n      return [];\n    }\n\n    // Check signal count\n    if (data.length > MAX_SIGNALS_PER_FILE) {\n      throw new Error(\n        `Signal file contains ${data.length} signals, max is ${MAX_SIGNALS_PER_FILE}`\n      );\n    }\n\n    return data.map((item: Record<string, unknown>) => {\n      const qfRaw = (item.quality_factors ?? item.qualityFactors) as Record<string, unknown> | undefined;\n      return {\n        id: String(item.id ?? ''),\n        taskDescription: String(item.task_description ?? item.taskDescription ?? ''),\n        outcome: validateOutcome(item.outcome),\n        qualityScore: validateScore(item.quality_score ?? item.qualityScore),\n        humanVerdict: validateVerdict(item.human_verdict ?? item.humanVerdict),\n        qualityFactors: qfRaw ? mapQualityFactors(qfRaw) : undefined,\n        completedAt: String(item.completed_at ?? item.completedAt ?? new Date().toISOString()),\n      };\n    });\n  }\n\n  qualityWeights(): ProviderQualityWeights | undefined {\n    try {\n      const weightsPath = path.join(path.dirname(this.filePath), 'quality-weights.json');\n      if (!fs.existsSync(weightsPath)) return undefined;\n      const raw = fs.readFileSync(weightsPath, 'utf-8');\n      const data = JSON.parse(raw) as Record<string, unknown>;\n      return {\n        taskCompletion: Number(data.task_completion ?? data.taskCompletion ?? 0.5),\n        codeQuality: Number(data.code_quality ?? data.codeQuality ?? 0.3),\n        process: Number(data.process ?? 0.2),\n      };\n    } catch {\n      return undefined;\n    }\n  }\n}\n\n/**\n * Aggregates quality signals from multiple registered providers.\n *\n * If no providers are registered, loadAllSignals returns empty arrays\n * with zero overhead.\n */\nexport class IntelligenceLoader {\n  private providers: IntelligenceProvider[] = [];\n\n  /** Register an external intelligence provider */\n  registerProvider(provider: IntelligenceProvider): void {\n    this.providers.push(provider);\n  }\n\n  /** Returns the number of registered providers */\n  get providerCount(): number {\n    return this.providers.length;\n  }\n\n  /** Returns the names of all registered providers */\n  get providerNames(): string[] {\n    return this.providers.map(p => p.name());\n  }\n\n  /**\n   * Load signals from all registered providers.\n   *\n   * Non-fatal: if a provider fails, its error is captured but\n   * other providers continue loading.\n   */\n  loadAllSignals(): { signals: QualitySignal[]; errors: ProviderError[] } {\n    const signals: QualitySignal[] = [];\n    const errors: ProviderError[] = [];\n\n    for (const provider of this.providers) {\n      try {\n        const providerSignals = provider.loadSignals();\n        signals.push(...providerSignals);\n      } catch (e) {\n        errors.push({\n          providerName: provider.name(),\n          message: e instanceof Error ? e.message : String(e),\n        });\n      }\n    }\n\n    return { signals, errors };\n  }\n\n  /** Load signals grouped by provider with weight overrides */\n  loadGrouped(): ProviderResult[] {\n    return this.providers.map(provider => {\n      let providerSignals: QualitySignal[] = [];\n      try {\n        providerSignals = provider.loadSignals();\n      } catch {\n        // Non-fatal\n      }\n      return {\n        providerName: provider.name(),\n        signals: providerSignals,\n        weights: provider.qualityWeights?.(),\n      };\n    });\n  }\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ruvector/ruvllm",
-  "version": "2.4.1",
-  "description": "Self-learning LLM orchestration with SONA adaptive learning, HNSW memory, RLM recursive retrieval, FastGRNN routing, and SIMD inference",
+  "version": "2.5.1",
+  "description": "Self-learning LLM orchestration with SONA adaptive learning, HNSW memory, FastGRNN routing, and SIMD inference",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/cjs/index.d.ts",
@@ -74,8 +74,6 @@
   "keywords": [
     "ruvllm",
     "llm",
-    "rlm",
-    "retrieval-language-model",
     "self-learning",
     "adaptive-learning",
     "sona",
@@ -94,9 +92,7 @@
     "deep-learning",
     "napi",
     "rust",
-    "ruvector",
-    "rag",
-    "contrastive-learning"
+    "ruvector"
   ],
   "author": "rUv Team <team@ruv.io>",
   "license": "MIT OR Apache-2.0",

package/scripts/training/validation-results.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-01-21T14:48:06.797Z",
+  "timestamp": "2026-01-21T00:21:04.044Z",
   "totalAccuracy": 100,
   "results": {
     "claude-flow": {

package/dist/cjs/rlm/controller.d.ts

@@ -1,245 +0,0 @@
-/**
- * RLM Controller - Recursive Retrieval Language Model
- *
- * Implements a recursive retrieval-augmented generation system that:
- * 1. Breaks down complex queries into sub-queries
- * 2. Retrieves relevant memory spans for each query
- * 3. Synthesizes coherent answers from retrieved context
- * 4. Optionally reflects on and refines answers
- *
- * @example Basic Usage
- * ```typescript
- * import { RlmController } from '@ruvector/ruvllm';
- *
- * const rlm = new RlmController({
- *   maxDepth: 3,
- *   retrievalTopK: 10,
- *   enableCache: true,
- * });
- *
- * // Add knowledge to memory
- * await rlm.addMemory('Machine learning is a subset of AI that enables systems to learn from data.');
- * await rlm.addMemory('Deep learning uses neural networks with many layers.');
- *
- * // Query with recursive retrieval
- * const answer = await rlm.query('Explain the relationship between ML and deep learning');
- * console.log(answer.text);
- * console.log('Sources:', answer.sources.length);
- * console.log('Confidence:', answer.confidence);
- * ```
- *
- * @example Streaming
- * ```typescript
- * const rlm = new RlmController();
- *
- * for await (const event of rlm.queryStream('What is AI?')) {
- *   if (event.type === 'token') {
- *     process.stdout.write(event.text);
- *   } else {
- *     console.log('\n\nDone! Quality:', event.answer.qualityScore);
- *   }
- * }
- * ```
- *
- * @example With Reflection
- * ```typescript
- * const rlm = new RlmController({
- *   enableReflection: true,
- *   maxReflectionIterations: 2,
- *   minQualityScore: 0.8,
- * });
- *
- * const answer = await rlm.query('Complex multi-part question...');
- * // Answer will be iteratively refined until quality >= 0.8
- * ```
- */
-import { RlmConfig, RlmAnswer, MemorySpan, StreamToken } from './types';
-import { RuvLLM } from '../engine';
-/**
- * RlmController - Recursive Retrieval Language Model Controller
- *
- * Orchestrates retrieval-augmented generation with recursive sub-query
- * decomposition, memory search, and optional self-reflection.
- */
-export declare class RlmController {
-    private config;
-    private cache;
-    private engine;
-    private memoryIdCounter;
-    /**
-     * Create a new RLM controller
-     *
-     * @param config - Configuration options
-     * @param engine - Optional RuvLLM engine instance (creates new if not provided)
-     *
-     * @example
-     * ```typescript
-     * // With default config
-     * const rlm = new RlmController();
-     *
-     * // With custom config
-     * const rlm = new RlmController({
-     *   maxDepth: 5,
-     *   enableReflection: true,
-     * });
-     *
-     * // With existing engine
-     * const engine = new RuvLLM({ learningEnabled: true });
-     * const rlm = new RlmController({}, engine);
-     * ```
-     */
-    constructor(config?: RlmConfig, engine?: RuvLLM);
-    /**
-     * Query the RLM with recursive retrieval
-     *
-     * @param input - The query string
-     * @returns Promise resolving to the answer with sources and metadata
-     *
-     * @example
-     * ```typescript
-     * const answer = await rlm.query('What is the capital of France?');
-     * console.log(answer.text); // "The capital of France is Paris..."
-     * console.log(answer.confidence); // 0.95
-     * console.log(answer.sources); // [{ id: '...', text: '...', similarityScore: 0.92 }]
-     * ```
-     */
-    query(input: string): Promise<RlmAnswer>;
-    /**
-     * Query with streaming response
-     *
-     * @param input - The query string
-     * @yields StreamToken events (either partial tokens or final answer)
-     *
-     * @example
-     * ```typescript
-     * for await (const event of rlm.queryStream('Explain quantum computing')) {
-     *   if (event.type === 'token') {
-     *     // Partial token received
-     *     process.stdout.write(event.text);
-     *   } else {
-     *     // Generation complete
-     *     console.log('\n\nSources:', event.answer.sources.length);
-     *   }
-     * }
-     * ```
-     */
-    queryStream(input: string): AsyncGenerator<StreamToken>;
-    /**
-     * Add content to memory for retrieval
-     *
-     * @param text - The text content to store
-     * @param metadata - Optional metadata to associate with the memory
-     * @returns Promise resolving to the memory span ID
-     *
-     * @example
-     * ```typescript
-     * const id1 = await rlm.addMemory(
-     *   'TypeScript is a typed superset of JavaScript.',
-     *   { source: 'documentation', category: 'programming' }
-     * );
-     *
-     * const id2 = await rlm.addMemory(
-     *   'React is a JavaScript library for building UIs.'
-     * );
-     * ```
-     */
-    addMemory(text: string, metadata?: Record<string, unknown>): Promise<string>;
-    /**
-     * Search memory for relevant spans
-     *
-     * @param query - The search query
-     * @param topK - Number of results to return (default: config.retrievalTopK)
-     * @returns Promise resolving to array of memory spans
-     *
-     * @example
-     * ```typescript
-     * const spans = await rlm.searchMemory('JavaScript frameworks', 5);
-     * for (const span of spans) {
-     *   console.log(`[${span.similarityScore.toFixed(2)}] ${span.text}`);
-     * }
-     * ```
-     */
-    searchMemory(query: string, topK?: number): Promise<MemorySpan[]>;
-    /**
-     * Clear the response cache
-     *
-     * @example
-     * ```typescript
-     * rlm.clearCache();
-     * console.log('Cache cleared');
-     * ```
-     */
-    clearCache(): void;
-    /**
-     * Get current cache statistics
-     *
-     * @returns Object with cache size and hit rate info
-     */
-    getCacheStats(): {
-        size: number;
-        entries: number;
-    };
-    /**
-     * Update configuration at runtime
-     *
-     * @param config - Partial configuration to merge
-     */
-    updateConfig(config: Partial<RlmConfig>): void;
-    /**
-     * Get current configuration
-     */
-    getConfig(): Required<RlmConfig>;
-    /**
-     * Generate sub-queries for complex questions
-     */
-    private generateSubQueries;
-    /**
-     * Decompose a complex query into simpler parts
-     */
-    private decomposeQuery;
-    /**
-     * Build context string from sources and sub-queries
-     */
-    private buildContext;
-    /**
-     * Build the full prompt with context
-     */
-    private buildPrompt;
-    /**
-     * Get generation config based on RLM settings
-     */
-    private getGenerationConfig;
-    /**
-     * Estimate token usage
-     */
-    private estimateTokenUsage;
-    /**
-     * Calculate quality score based on sources and confidence
-     */
-    private calculateQualityScore;
-    /**
-     * Apply self-reflection to improve answer
-     */
-    private applyReflection;
-    /**
-     * Get cached answer if valid
-     */
-    private getCached;
-    /**
-     * Set cache entry
-     */
-    private setCache;
-    /**
-     * Simple hash function for cache keys
-     */
-    private hashQuery;
-    /**
-     * Prune expired cache entries
-     */
-    private pruneCache;
-    /**
-     * Utility delay function for streaming simulation
-     */
-    private delay;
-}
-//# sourceMappingURL=controller.d.ts.map

package/dist/cjs/rlm/controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/rlm/controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EACL,SAAS,EACT,SAAS,EACT,UAAU,EAGV,WAAW,EAGZ,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAkBnC;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,eAAe,CAAS;IAEhC;;;;;;;;;;;;;;;;;;;;;OAqBG;gBACS,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM;IAO/C;;;;;;;;;;;;;OAaG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAsD9C;;;;;;;;;;;;;;;;;;OAkBG;IACI,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,WAAW,CAAC;IA2D9D;;;;;;;;;;;;;;;;;;OAkBG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAMlF;;;;;;;;;;;;;;OAcG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAavE;;;;;;;;OAQG;IACH,UAAU,IAAI,IAAI;IAIlB;;;;OAIG;IACH,aAAa,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAOlD;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;IAI9C;;OAEG;IACH,SAAS,IAAI,QAAQ,CAAC,SAAS,CAAC;IAQhC;;OAEG;YACW,kBAAkB;IAkChC;;OAEG;IACH,OAAO,CAAC,cAAc;IAyBtB;;OAEG;IACH,OAAO,CAAC,YAAY;IAuBpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAY7B;;OAEG;YACW,eAAe;IA0D7B;;OAEG;IACH,OAAO,CAAC,SAAS;IAiBjB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAchB;;OAEG;IACH,OAAO,CAAC,SAAS;IAUjB;;OAEG;IACH,OAAO,CAAC,UAAU;IA0BlB;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd"}