ruvector 0.1.83 → 0.1.85

package/bin/cli.js

@@ -2108,6 +2108,349 @@ embedCmd
     }
   });
 
+embedCmd
+  .command('optimized')
+  .description('Use optimized ONNX embedder with LRU caching')
+  .argument('[text]', 'Text to embed (optional)')
+  .option('--cache-size <n>', 'Embedding cache size', '512')
+  .option('--stats', 'Show cache statistics')
+  .option('--clear-cache', 'Clear all caches')
+  .option('--benchmark', 'Run cache benchmark')
+  .action(async (text, opts) => {
+    try {
+      const { performance } = require('perf_hooks');
+      const { OptimizedOnnxEmbedder } = require('../dist/core/onnx-optimized.js');
+
+      const embedder = new OptimizedOnnxEmbedder({
+        cacheSize: parseInt(opts.cacheSize) || 512,
+        lazyInit: false,
+      });
+
+      await embedder.init();
+
+      if (opts.clearCache) {
+        embedder.clearCache();
+        console.log(chalk.green('✓ Caches cleared'));
+        return;
+      }
+
+      if (opts.benchmark) {
+        console.log(chalk.cyan('\n⚡ Optimized ONNX Cache Benchmark\n'));
+
+        const testTexts = [
+          'Machine learning algorithms optimize model parameters',
+          'Vector databases enable semantic search capabilities',
+          'Neural networks learn hierarchical representations',
+          'Code embeddings capture syntax and semantic patterns',
+          'Transformer models use attention mechanisms',
+        ];
+
+        // Cold benchmark
+        embedder.clearCache();
+        const coldStart = performance.now();
+        for (const t of testTexts) await embedder.embed(t);
+        const coldTime = performance.now() - coldStart;
+
+        // Warm benchmark
+        const warmStart = performance.now();
+        for (let i = 0; i < 100; i++) {
+          for (const t of testTexts) await embedder.embed(t);
+        }
+        const warmTime = performance.now() - warmStart;
+
+        const stats = embedder.getCacheStats();
+
+        console.log(chalk.yellow('Performance:'));
+        console.log(chalk.dim('  Cold (5 unique texts):'), chalk.white(coldTime.toFixed(2) + 'ms'));
+        console.log(chalk.dim('  Warm (500 cached):'), chalk.white(warmTime.toFixed(2) + 'ms'));
+        console.log(chalk.dim('  Cache speedup:'), chalk.green((coldTime / warmTime * 100).toFixed(0) + 'x'));
+        console.log();
+        console.log(chalk.yellow('Cache Stats:'));
+        console.log(chalk.dim('  Hit rate:'), chalk.white((stats.embedding.hitRate * 100).toFixed(1) + '%'));
+        console.log(chalk.dim('  Cache size:'), chalk.white(stats.embedding.size));
+        console.log(chalk.dim('  Total embeds:'), chalk.white(stats.totalEmbeds));
+        console.log();
+        return;
+      }
+
+      if (opts.stats) {
+        const stats = embedder.getCacheStats();
+        console.log(chalk.cyan('\n📊 Optimized ONNX Embedder Stats\n'));
+        console.log(chalk.white('Embedding Cache:'));
+        console.log(chalk.dim('  Size:'), stats.embedding.size);
+        console.log(chalk.dim('  Hits:'), stats.embedding.hits);
+        console.log(chalk.dim('  Misses:'), stats.embedding.misses);
+        console.log(chalk.dim('  Hit Rate:'), (stats.embedding.hitRate * 100).toFixed(1) + '%');
+        console.log();
+        console.log(chalk.white('Performance:'));
+        console.log(chalk.dim('  Avg Time:'), stats.avgTimeMs.toFixed(2) + 'ms');
+        console.log(chalk.dim('  Total Embeds:'), stats.totalEmbeds);
+        console.log();
+        return;
+      }
+
+      if (text) {
+        const start = performance.now();
+        const embedding = await embedder.embed(text);
+        const elapsed = performance.now() - start;
+        const stats = embedder.getCacheStats();
+
+        console.log(chalk.cyan('\n⚡ Optimized ONNX Embedding\n'));
+        console.log(chalk.dim(`Text: "${text.slice(0, 60)}${text.length > 60 ? '...' : ''}"`));
+        console.log(chalk.dim(`Dimension: ${embedding.length}`));
+        console.log(chalk.dim(`Time: ${elapsed.toFixed(2)}ms`));
+        console.log(chalk.dim(`Cache hit rate: ${(stats.embedding.hitRate * 100).toFixed(1)}%`));
+        console.log();
+      } else {
+        console.log(chalk.yellow('Usage: ruvector embed optimized <text>'));
+        console.log(chalk.dim('  --stats       Show cache statistics'));
+        console.log(chalk.dim('  --benchmark   Run cache benchmark'));
+        console.log(chalk.dim('  --clear-cache Clear all caches'));
+        console.log(chalk.dim('  --cache-size  Set cache size (default: 512)'));
+      }
+    } catch (e) {
+      console.error(chalk.red('Error:'), e.message);
+    }
+  });
+
+embedCmd
+  .command('neural')
+  .description('Neural embedding substrate (frontier AI concepts)')
+  .option('--health', 'Show neural substrate health')
+  .option('--consolidate', 'Run memory consolidation (like sleep)')
+  .option('--calibrate', 'Calibrate coherence baseline')
+  .option('--swarm-status', 'Show swarm coordination status')
+  .option('--drift-stats', 'Show semantic drift statistics')
+  .option('--memory-stats', 'Show memory physics statistics')
+  .option('--demo', 'Run interactive neural demo')
+  .option('--dimension <n>', 'Embedding dimension', '384')
+  .action(async (opts) => {
+    try {
+      const { NeuralSubstrate } = require('../dist/core/neural-embeddings.js');
+      const { initOnnxEmbedder, embed } = require('../dist/core/onnx-embedder.js');
+
+      const dimension = parseInt(opts.dimension) || 384;
+      const substrate = new NeuralSubstrate({ dimension });
+
+      if (opts.demo) {
+        console.log(chalk.cyan('\n🧠 Neural Embedding Substrate Demo\n'));
+        console.log(chalk.dim('Frontier AI concepts: drift detection, memory physics, swarm coordination\n'));
+
+        // Initialize ONNX for real embeddings
+        await initOnnxEmbedder();
+
+        console.log(chalk.yellow('1. Semantic Drift Detection'));
+        console.log(chalk.dim('   Observing embeddings and detecting semantic movement...\n'));
+
+        const texts = [
+          'Machine learning optimizes neural networks',
+          'Deep learning uses backpropagation',
+          'AI models learn from data patterns',
+          'Quantum computing is completely different',  // Should trigger drift
+        ];
+
+        for (const text of texts) {
+          const result = await embed(text);
+          const driftEvent = substrate.drift.observe(result.embedding, 'demo');
+          const symbol = driftEvent?.category === 'critical' ? '🚨' :
+                        driftEvent?.category === 'warning' ? '⚠️' : '✓';
+          console.log(chalk.dim(`   ${symbol} "${text.slice(0, 40)}..." → drift: ${driftEvent?.magnitude?.toFixed(3) || '0.000'}`));
+        }
+
+        console.log(chalk.yellow('\n2. Memory Physics (Hippocampal Dynamics)'));
+        console.log(chalk.dim('   Encoding memories with strength, decay, and consolidation...\n'));
+
+        const memories = [
+          { id: 'mem1', text: 'Vector databases store embeddings' },
+          { id: 'mem2', text: 'HNSW enables fast nearest neighbor search' },
+          { id: 'mem3', text: 'Cosine similarity measures semantic closeness' },
+        ];
+
+        for (const mem of memories) {
+          const result = await embed(mem.text);
+          const entry = substrate.memory.encode(mem.id, result.embedding, mem.text);
+          console.log(chalk.dim(`   📝 Encoded "${mem.id}": strength=${entry.strength.toFixed(2)}, interference=${entry.interference.toFixed(2)}`));
+        }
+
+        // Query memory
+        const queryText = 'How do vector databases work?';
+        const queryEmb = await embed(queryText);
+        const recalled = substrate.memory.recall(queryEmb.embedding, 2);
+        console.log(chalk.dim(`\n   🔍 Query: "${queryText}"`));
+        console.log(chalk.dim(`   📚 Recalled: ${recalled.map(m => m.id).join(', ')}`));
+
+        console.log(chalk.yellow('\n3. Agent State Machine (Geometric State)'));
+        console.log(chalk.dim('   Managing agent state as movement through embedding space...\n'));
+
+        // Define mode regions
+        substrate.state.defineMode('research', queryEmb.embedding, 0.5);
+        const codeEmb = await embed('Write code and debug programs');
+        substrate.state.defineMode('coding', codeEmb.embedding, 0.5);
+
+        // Update agent state
+        const agent1State = substrate.state.updateAgent('agent-1', queryEmb.embedding);
+        console.log(chalk.dim(`   🤖 agent-1 mode: ${agent1State.mode}, energy: ${agent1State.energy.toFixed(2)}`));
+
+        const agent2State = substrate.state.updateAgent('agent-2', codeEmb.embedding);
+        console.log(chalk.dim(`   🤖 agent-2 mode: ${agent2State.mode}, energy: ${agent2State.energy.toFixed(2)}`));
+
+        console.log(chalk.yellow('\n4. Swarm Coordination'));
+        console.log(chalk.dim('   Multi-agent coordination through shared embedding geometry...\n'));
+
+        substrate.swarm.register('researcher', queryEmb.embedding, 'research');
+        substrate.swarm.register('coder', codeEmb.embedding, 'development');
+        const reviewEmb = await embed('Review code and check quality');
+        substrate.swarm.register('reviewer', reviewEmb.embedding, 'review');
+
+        const coherence = substrate.swarm.getCoherence();
+        console.log(chalk.dim(`   🌐 Swarm coherence: ${(coherence * 100).toFixed(1)}%`));
+
+        const collaborators = substrate.swarm.findCollaborators('researcher', 2);
+        console.log(chalk.dim(`   🤝 Collaborators for researcher: ${collaborators.map(c => c.id).join(', ')}`));
+
+        console.log(chalk.yellow('\n5. Coherence Monitoring (Safety)'));
+        console.log(chalk.dim('   Detecting degradation, poisoning, misalignment...\n'));
+
+        try {
+          substrate.calibrate();
+          const report = substrate.coherence.report();
+          console.log(chalk.dim(`   📊 Overall coherence: ${(report.overallScore * 100).toFixed(1)}%`));
+          console.log(chalk.dim(`   📊 Stability: ${(report.stabilityScore * 100).toFixed(1)}%`));
+          console.log(chalk.dim(`   📊 Alignment: ${(report.alignmentScore * 100).toFixed(1)}%`));
+        } catch {
+          console.log(chalk.dim('   ℹ️ Need more observations to calibrate coherence'));
+        }
+
+        console.log(chalk.cyan('\n═══════════════════════════════════════════════════════════════'));
+        console.log(chalk.bold('   Neural Substrate: Embeddings as Synthetic Nervous System'));
+        console.log(chalk.cyan('═══════════════════════════════════════════════════════════════\n'));
+
+        console.log(chalk.dim('Components:'));
+        console.log(chalk.dim('  • SemanticDriftDetector - Control signals, reflex triggers'));
+        console.log(chalk.dim('  • MemoryPhysics - Forgetting, interference, consolidation'));
+        console.log(chalk.dim('  • EmbeddingStateMachine - Agent state via geometry'));
+        console.log(chalk.dim('  • SwarmCoordinator - Multi-agent coordination'));
+        console.log(chalk.dim('  • CoherenceMonitor - Safety/alignment detection'));
+        console.log(chalk.dim('  • NeuralSubstrate - Unified nervous system layer'));
+        console.log('');
+        return;
+      }
+
+      if (opts.health) {
+        const health = substrate.health();
+        console.log(chalk.cyan('\n🧠 Neural Substrate Health\n'));
+
+        console.log(chalk.yellow('Drift Detection:'));
+        console.log(chalk.dim(`  Current drift: ${health.driftStats.currentDrift.toFixed(4)}`));
+        console.log(chalk.dim(`  Velocity: ${health.driftStats.velocity.toFixed(4)}/s`));
+        console.log(chalk.dim(`  Critical events: ${health.driftStats.criticalEvents}`));
+        console.log(chalk.dim(`  Warning events: ${health.driftStats.warningEvents}`));
+
+        console.log(chalk.yellow('\nMemory Physics:'));
+        console.log(chalk.dim(`  Total memories: ${health.memoryStats.totalMemories}`));
+        console.log(chalk.dim(`  Avg strength: ${health.memoryStats.avgStrength.toFixed(3)}`));
+        console.log(chalk.dim(`  Avg consolidation: ${health.memoryStats.avgConsolidation.toFixed(3)}`));
+        console.log(chalk.dim(`  Avg interference: ${health.memoryStats.avgInterference.toFixed(3)}`));
+
+        console.log(chalk.yellow('\nSwarm Coordination:'));
+        console.log(chalk.dim(`  Coherence: ${(health.swarmCoherence * 100).toFixed(1)}%`));
+
+        console.log(chalk.yellow('\nCoherence Report:'));
+        console.log(chalk.dim(`  Overall: ${(health.coherenceReport.overallScore * 100).toFixed(1)}%`));
+        console.log(chalk.dim(`  Drift: ${(health.coherenceReport.driftScore * 100).toFixed(1)}%`));
+        console.log(chalk.dim(`  Stability: ${(health.coherenceReport.stabilityScore * 100).toFixed(1)}%`));
+        console.log(chalk.dim(`  Alignment: ${(health.coherenceReport.alignmentScore * 100).toFixed(1)}%`));
+
+        if (health.coherenceReport.anomalies.length > 0) {
+          console.log(chalk.yellow('\nAnomalies:'));
+          for (const a of health.coherenceReport.anomalies) {
+            console.log(chalk.red(`  ⚠️ ${a.type}: ${a.description} (severity: ${a.severity.toFixed(2)})`));
+          }
+        }
+        console.log('');
+        return;
+      }
+
+      if (opts.consolidate) {
+        console.log(chalk.yellow('Running memory consolidation...'));
+        const result = substrate.consolidate();
+        console.log(chalk.green(`✓ Consolidated: ${result.consolidated} memories`));
+        console.log(chalk.dim(`  Forgotten: ${result.forgotten} weak memories`));
+        return;
+      }
+
+      if (opts.calibrate) {
+        try {
+          substrate.calibrate();
+          console.log(chalk.green('✓ Coherence baseline calibrated'));
+        } catch (e) {
+          console.log(chalk.yellow('Need more observations to calibrate'));
+          console.log(chalk.dim('Run --demo first to populate the substrate'));
+        }
+        return;
+      }
+
+      if (opts.driftStats) {
+        const stats = substrate.drift.getStats();
+        console.log(chalk.cyan('\n📊 Semantic Drift Statistics\n'));
+        console.log(chalk.dim(`Current drift: ${stats.currentDrift.toFixed(4)}`));
+        console.log(chalk.dim(`Velocity: ${stats.velocity.toFixed(4)} drift/s`));
+        console.log(chalk.dim(`Critical events: ${stats.criticalEvents}`));
+        console.log(chalk.dim(`Warning events: ${stats.warningEvents}`));
+        console.log(chalk.dim(`History size: ${stats.historySize}`));
+        console.log('');
+        return;
+      }
+
+      if (opts.memoryStats) {
+        const stats = substrate.memory.getStats();
+        console.log(chalk.cyan('\n📊 Memory Physics Statistics\n'));
+        console.log(chalk.dim(`Total memories: ${stats.totalMemories}`));
+        console.log(chalk.dim(`Average strength: ${stats.avgStrength.toFixed(3)}`));
+        console.log(chalk.dim(`Average consolidation: ${stats.avgConsolidation.toFixed(3)}`));
+        console.log(chalk.dim(`Average interference: ${stats.avgInterference.toFixed(3)}`));
+        console.log('');
+        return;
+      }
+
+      if (opts.swarmStatus) {
+        const coherence = substrate.swarm.getCoherence();
+        const clusters = substrate.swarm.detectClusters(0.7);
+        console.log(chalk.cyan('\n📊 Swarm Coordination Status\n'));
+        console.log(chalk.dim(`Coherence: ${(coherence * 100).toFixed(1)}%`));
+        console.log(chalk.dim(`Clusters detected: ${clusters.size}`));
+        for (const [leader, members] of clusters) {
+          console.log(chalk.dim(`  Cluster ${leader}: ${members.join(', ')}`));
+        }
+        console.log('');
+        return;
+      }
+
+      // Default: show help
+      console.log(chalk.cyan('\n🧠 Neural Embedding Substrate\n'));
+      console.log(chalk.dim('Frontier AI concepts treating embeddings as a synthetic nervous system.\n'));
+      console.log(chalk.yellow('Commands:'));
+      console.log(chalk.dim('  --demo          Run interactive neural demo'));
+      console.log(chalk.dim('  --health        Show neural substrate health'));
+      console.log(chalk.dim('  --consolidate   Run memory consolidation (like sleep)'));
+      console.log(chalk.dim('  --calibrate     Calibrate coherence baseline'));
+      console.log(chalk.dim('  --drift-stats   Show semantic drift statistics'));
+      console.log(chalk.dim('  --memory-stats  Show memory physics statistics'));
+      console.log(chalk.dim('  --swarm-status  Show swarm coordination status'));
+      console.log('');
+      console.log(chalk.yellow('Components:'));
+      console.log(chalk.dim('  • SemanticDriftDetector - Embeddings as control signals'));
+      console.log(chalk.dim('  • MemoryPhysics - Hippocampal memory dynamics'));
+      console.log(chalk.dim('  • EmbeddingStateMachine - Agent state via geometry'));
+      console.log(chalk.dim('  • SwarmCoordinator - Multi-agent coordination'));
+      console.log(chalk.dim('  • CoherenceMonitor - Safety/alignment detection'));
+      console.log('');
+    } catch (e) {
+      console.error(chalk.red('Error:'), e.message);
+      if (e.stack) console.error(chalk.dim(e.stack));
+    }
+  });
+
 // =============================================================================
 // Demo Command - Interactive tutorial
 // =============================================================================

package/dist/core/index.d.ts

@@ -10,6 +10,7 @@ export * from './agentdb-fast';
 export * from './sona-wrapper';
 export * from './intelligence-engine';
 export * from './onnx-embedder';
+export * from './onnx-optimized';
 export * from './parallel-intelligence';
 export * from './parallel-workers';
 export * from './router-wrapper';
@@ -22,6 +23,7 @@ export * from './graph-algorithms';
 export * from './tensor-compress';
 export * from './learning-engine';
 export * from './adaptive-embedder';
+export * from './neural-embeddings';
 export * from '../analysis';
 export { default as gnnWrapper } from './gnn-wrapper';
 export { default as attentionFallbacks } from './attention-fallbacks';
@@ -29,6 +31,7 @@ export { default as agentdbFast } from './agentdb-fast';
 export { default as Sona } from './sona-wrapper';
 export { default as IntelligenceEngine } from './intelligence-engine';
 export { default as OnnxEmbedder } from './onnx-embedder';
+export { default as OptimizedOnnxEmbedder } from './onnx-optimized';
 export { default as ParallelIntelligence } from './parallel-intelligence';
 export { default as ExtendedWorkerPool } from './parallel-workers';
 export { default as SemanticRouter } from './router-wrapper';
@@ -39,4 +42,5 @@ export { CodeParser as ASTParser } from './ast-parser';
 export { default as TensorCompress } from './tensor-compress';
 export { default as LearningEngine } from './learning-engine';
 export { default as AdaptiveEmbedder } from './adaptive-embedder';
+export { default as NeuralSubstrate } from './neural-embeddings';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,aAAa,CAAC;AAG5B,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAGrD,OAAO,EAAE,UAAU,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AAGvD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,aAAa,CAAC;AAG5B,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAGrD,OAAO,EAAE,UAAU,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AAGvD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/core/index.js

@@ -23,13 +23,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptiveEmbedder = exports.LearningEngine = exports.TensorCompress = exports.ASTParser = exports.CodeParser = exports.RuvectorCluster = exports.CodeGraph = exports.SemanticRouter = exports.ExtendedWorkerPool = exports.ParallelIntelligence = exports.OnnxEmbedder = exports.IntelligenceEngine = exports.Sona = exports.agentdbFast = exports.attentionFallbacks = exports.gnnWrapper = void 0;
+exports.NeuralSubstrate = exports.AdaptiveEmbedder = exports.LearningEngine = exports.TensorCompress = exports.ASTParser = exports.CodeParser = exports.RuvectorCluster = exports.CodeGraph = exports.SemanticRouter = exports.ExtendedWorkerPool = exports.ParallelIntelligence = exports.OptimizedOnnxEmbedder = exports.OnnxEmbedder = exports.IntelligenceEngine = exports.Sona = exports.agentdbFast = exports.attentionFallbacks = exports.gnnWrapper = void 0;
 __exportStar(require("./gnn-wrapper"), exports);
 __exportStar(require("./attention-fallbacks"), exports);
 __exportStar(require("./agentdb-fast"), exports);
 __exportStar(require("./sona-wrapper"), exports);
 __exportStar(require("./intelligence-engine"), exports);
 __exportStar(require("./onnx-embedder"), exports);
+__exportStar(require("./onnx-optimized"), exports);
 __exportStar(require("./parallel-intelligence"), exports);
 __exportStar(require("./parallel-workers"), exports);
 __exportStar(require("./router-wrapper"), exports);
@@ -42,6 +43,7 @@ __exportStar(require("./graph-algorithms"), exports);
 __exportStar(require("./tensor-compress"), exports);
 __exportStar(require("./learning-engine"), exports);
 __exportStar(require("./adaptive-embedder"), exports);
+__exportStar(require("./neural-embeddings"), exports);
 // Analysis module (consolidated security, complexity, patterns)
 __exportStar(require("../analysis"), exports);
 // Re-export default objects for convenience
@@ -57,6 +59,8 @@ var intelligence_engine_1 = require("./intelligence-engine");
 Object.defineProperty(exports, "IntelligenceEngine", { enumerable: true, get: function () { return __importDefault(intelligence_engine_1).default; } });
 var onnx_embedder_1 = require("./onnx-embedder");
 Object.defineProperty(exports, "OnnxEmbedder", { enumerable: true, get: function () { return __importDefault(onnx_embedder_1).default; } });
+var onnx_optimized_1 = require("./onnx-optimized");
+Object.defineProperty(exports, "OptimizedOnnxEmbedder", { enumerable: true, get: function () { return __importDefault(onnx_optimized_1).default; } });
 var parallel_intelligence_1 = require("./parallel-intelligence");
 Object.defineProperty(exports, "ParallelIntelligence", { enumerable: true, get: function () { return __importDefault(parallel_intelligence_1).default; } });
 var parallel_workers_1 = require("./parallel-workers");
@@ -79,3 +83,5 @@ var learning_engine_1 = require("./learning-engine");
 Object.defineProperty(exports, "LearningEngine", { enumerable: true, get: function () { return __importDefault(learning_engine_1).default; } });
 var adaptive_embedder_1 = require("./adaptive-embedder");
 Object.defineProperty(exports, "AdaptiveEmbedder", { enumerable: true, get: function () { return __importDefault(adaptive_embedder_1).default; } });
+var neural_embeddings_1 = require("./neural-embeddings");
+Object.defineProperty(exports, "NeuralSubstrate", { enumerable: true, get: function () { return __importDefault(neural_embeddings_1).default; } });