ruvector 0.2.23 → 0.2.26

package/dist/core/onnx-embedder.d.ts

@@ -0,0 +1,105 @@
+/**
+ * ONNX WASM Embedder - Semantic embeddings for hooks
+ *
+ * Provides real transformer-based embeddings using all-MiniLM-L6-v2
+ * running in pure WASM (no native dependencies).
+ *
+ * Uses bundled ONNX WASM files from src/core/onnx/
+ *
+ * Features:
+ * - 384-dimensional semantic embeddings
+ * - Real semantic understanding (not hash-based)
+ * - Cached model loading (downloads from HuggingFace on first use)
+ * - Batch embedding support
+ * - Optional parallel workers for 3.8x batch speedup
+ */
+declare global {
+    var __ruvector_require: NodeRequire | undefined;
+}
+export interface OnnxEmbedderConfig {
+    modelId?: string;
+    maxLength?: number;
+    normalize?: boolean;
+    cacheDir?: string;
+    /**
+     * Enable parallel workers for batch operations
+     * - 'auto' (default): Enable for long-running processes, skip for CLI
+     * - true: Always enable workers
+     * - false: Never use workers
+     */
+    enableParallel?: boolean | 'auto';
+    /** Number of worker threads (default: CPU cores - 1) */
+    numWorkers?: number;
+    /** Minimum batch size to use parallel processing (default: 4) */
+    parallelThreshold?: number;
+}
+export interface EmbeddingResult {
+    embedding: number[];
+    dimension: number;
+    timeMs: number;
+}
+export interface SimilarityResult {
+    similarity: number;
+    timeMs: number;
+}
+/**
+ * Check if ONNX embedder is available (bundled files exist)
+ */
+export declare function isOnnxAvailable(): boolean;
+/**
+ * Initialize the ONNX embedder (downloads model if needed)
+ */
+export declare function initOnnxEmbedder(config?: OnnxEmbedderConfig): Promise<boolean>;
+/**
+ * Generate embedding for text
+ */
+export declare function embed(text: string): Promise<EmbeddingResult>;
+/**
+ * Generate embeddings for multiple texts
+ * Uses parallel workers automatically for batches >= parallelThreshold
+ */
+export declare function embedBatch(texts: string[]): Promise<EmbeddingResult[]>;
+/**
+ * Calculate cosine similarity between two texts
+ */
+export declare function similarity(text1: string, text2: string): Promise<SimilarityResult>;
+/**
+ * Calculate cosine similarity between two embeddings
+ */
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+/**
+ * Get embedding dimension
+ */
+export declare function getDimension(): number;
+/**
+ * Check if embedder is ready
+ */
+export declare function isReady(): boolean;
+/**
+ * Get embedder stats including SIMD and parallel capabilities
+ */
+export declare function getStats(): {
+    ready: boolean;
+    dimension: number;
+    model: string;
+    simd: boolean;
+    parallel: boolean;
+    parallelWorkers: number;
+    parallelThreshold: number;
+};
+/**
+ * Shutdown parallel workers (call on exit)
+ */
+export declare function shutdown(): Promise<void>;
+export declare class OnnxEmbedder {
+    private config;
+    constructor(config?: OnnxEmbedderConfig);
+    init(): Promise<boolean>;
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+    similarity(text1: string, text2: string): Promise<number>;
+    get dimension(): number;
+    get ready(): boolean;
+}
+export default OnnxEmbedder;
+//# sourceMappingURL=onnx-embedder.d.ts.map

package/dist/core/onnx-embedder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onnx-embedder.d.ts","sourceRoot":"","sources":["../../src/core/onnx-embedder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,kBAAkB,EAAE,WAAW,GAAG,SAAS,CAAC;CACjD;AAuBD,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAClC,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAMD,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAeD;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAOzC;AA6DD;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,GAAE,kBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC,CAkGxF;AAED;;GAEG;AACH,wBAAsB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAiBlE;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAwC5E;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAaxF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAiBjE;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED;;GAEG;AACH,wBAAgB,OAAO,IAAI,OAAO,CAEjC;AAED;;GAEG;AACH,wBAAgB,QAAQ,IAAI;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAUA;AAED;;GAEG;AACH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAM9C;AAGD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAqB;gBAEvB,MAAM,GAAE,kBAAuB;IAIrC,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAIxB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAKtC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IAKhD,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/D,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,KAAK,IAAI,OAAO,CAEnB;CACF;AAED,eAAe,YAAY,CAAC"}

package/dist/core/onnx-embedder.js

@@ -0,0 +1,414 @@
+"use strict";
+/**
+ * ONNX WASM Embedder - Semantic embeddings for hooks
+ *
+ * Provides real transformer-based embeddings using all-MiniLM-L6-v2
+ * running in pure WASM (no native dependencies).
+ *
+ * Uses bundled ONNX WASM files from src/core/onnx/
+ *
+ * Features:
+ * - 384-dimensional semantic embeddings
+ * - Real semantic understanding (not hash-based)
+ * - Cached model loading (downloads from HuggingFace on first use)
+ * - Batch embedding support
+ * - Optional parallel workers for 3.8x batch speedup
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnnxEmbedder = void 0;
+exports.isOnnxAvailable = isOnnxAvailable;
+exports.initOnnxEmbedder = initOnnxEmbedder;
+exports.embed = embed;
+exports.embedBatch = embedBatch;
+exports.similarity = similarity;
+exports.cosineSimilarity = cosineSimilarity;
+exports.getDimension = getDimension;
+exports.isReady = isReady;
+exports.getStats = getStats;
+exports.shutdown = shutdown;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const url_1 = require("url");
+const module_1 = require("module");
+// Set up ESM-compatible require for WASM module (fixes Windows/ESM compatibility)
+// The WASM bindings use module.require for Node.js crypto, this provides a fallback
+if (typeof globalThis !== 'undefined' && !globalThis.__ruvector_require) {
+    try {
+        // In ESM context, use createRequire with __filename
+        globalThis.__ruvector_require = (0, module_1.createRequire)(__filename);
+    }
+    catch {
+        // Fallback: require should be available in CommonJS
+        try {
+            globalThis.__ruvector_require = require;
+        }
+        catch {
+            // Neither available - WASM will fall back to crypto.getRandomValues
+        }
+    }
+}
+// Force native dynamic import (avoids TypeScript transpiling to require)
+// eslint-disable-next-line @typescript-eslint/no-implied-eval
+const dynamicImport = new Function('specifier', 'return import(specifier)');
+// Capability detection
+let simdAvailable = false;
+let parallelAvailable = false;
+// Lazy-loaded module state
+let wasmModule = null;
+let embedder = null;
+let parallelEmbedder = null;
+let loadError = null;
+let loadPromise = null;
+let isInitialized = false;
+let parallelEnabled = false;
+let parallelThreshold = 4;
+// Default model
+const DEFAULT_MODEL = 'all-MiniLM-L6-v2';
+/**
+ * Check if ONNX embedder is available (bundled files exist)
+ */
+function isOnnxAvailable() {
+    try {
+        const pkgPath = path.join(__dirname, 'onnx', 'pkg', 'ruvector_onnx_embeddings_wasm.js');
+        return fs.existsSync(pkgPath);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if parallel workers are available (npm package installed)
+ */
+async function detectParallelAvailable() {
+    try {
+        await dynamicImport('ruvector-onnx-embeddings-wasm/parallel');
+        parallelAvailable = true;
+        return true;
+    }
+    catch {
+        parallelAvailable = false;
+        return false;
+    }
+}
+/**
+ * Check if SIMD is available (from WASM module)
+ */
+function detectSimd() {
+    try {
+        if (wasmModule && typeof wasmModule.simd_available === 'function') {
+            simdAvailable = wasmModule.simd_available();
+            return simdAvailable;
+        }
+    }
+    catch { }
+    return false;
+}
+/**
+ * Try to load ParallelEmbedder from npm package (optional)
+ */
+async function tryInitParallel(config) {
+    // Skip if explicitly disabled
+    if (config.enableParallel === false)
+        return false;
+    // For 'auto' or true, try to initialize
+    try {
+        const parallelModule = await dynamicImport('ruvector-onnx-embeddings-wasm/parallel');
+        const { ParallelEmbedder } = parallelModule;
+        parallelEmbedder = new ParallelEmbedder({
+            numWorkers: config.numWorkers,
+        });
+        await parallelEmbedder.init(config.modelId || DEFAULT_MODEL);
+        parallelThreshold = config.parallelThreshold || 4;
+        parallelEnabled = true;
+        parallelAvailable = true;
+        console.error(`Parallel embedder ready: ${parallelEmbedder.numWorkers} workers, SIMD: ${simdAvailable}`);
+        return true;
+    }
+    catch (e) {
+        parallelAvailable = false;
+        if (config.enableParallel === true) {
+            // Only warn if explicitly requested
+            console.error(`Parallel embedder not available: ${e.message}`);
+        }
+        return false;
+    }
+}
+/**
+ * Initialize the ONNX embedder (downloads model if needed)
+ */
+async function initOnnxEmbedder(config = {}) {
+    if (isInitialized)
+        return true;
+    if (loadError)
+        throw loadError;
+    if (loadPromise) {
+        await loadPromise;
+        return isInitialized;
+    }
+    loadPromise = (async () => {
+        try {
+            // Paths to bundled ONNX files
+            const bgJsPath = path.join(__dirname, 'onnx', 'pkg', 'ruvector_onnx_embeddings_wasm_bg.js');
+            const wasmPath = path.join(__dirname, 'onnx', 'pkg', 'ruvector_onnx_embeddings_wasm_bg.wasm');
+            const loaderPath = path.join(__dirname, 'onnx', 'loader.js');
+            if (!fs.existsSync(bgJsPath) || !fs.existsSync(wasmPath)) {
+                throw new Error('ONNX WASM files not bundled. The onnx/ directory is missing.');
+            }
+            // Load the bg.js module directly (avoids the ESM `import * as wasm from "*.wasm"`
+            // in the main .js shim which requires --experimental-wasm-modules on Node 18-24).
+            const bgUrl = (0, url_1.pathToFileURL)(bgJsPath).href;
+            const loaderUrl = (0, url_1.pathToFileURL)(loaderPath).href;
+            wasmModule = await dynamicImport(bgUrl);
+            // Instantiate the .wasm bytes via WebAssembly API (no --experimental-wasm-modules needed).
+            const wasmBytes = fs.readFileSync(wasmPath);
+            const wasmResult = await WebAssembly.instantiate(wasmBytes, { './ruvector_onnx_embeddings_wasm_bg.js': wasmModule });
+            const wasmExports = wasmResult.instance.exports;
+            if (typeof wasmModule.__wbg_set_wasm === 'function') {
+                wasmModule.__wbg_set_wasm(wasmExports);
+            }
+            if (typeof wasmExports.__wbindgen_start === 'function') {
+                wasmExports.__wbindgen_start();
+            }
+            const loaderModule = await dynamicImport(loaderUrl);
+            const { ModelLoader } = loaderModule;
+            // Create model loader with caching
+            const modelLoader = new ModelLoader({
+                cache: true,
+                cacheDir: config.cacheDir || path.join(process.env.HOME || '/tmp', '.ruvector', 'models'),
+            });
+            // Load model (downloads from HuggingFace on first use)
+            const modelId = config.modelId || DEFAULT_MODEL;
+            console.error(`Loading ONNX model: ${modelId}...`);
+            const { modelBytes, tokenizerJson, config: modelConfig } = await modelLoader.loadModel(modelId);
+            // Create embedder with config
+            const embedderConfig = new wasmModule.WasmEmbedderConfig()
+                .setMaxLength(config.maxLength || modelConfig.maxLength || 256)
+                .setNormalize(config.normalize !== false)
+                .setPooling(0); // Mean pooling
+            embedder = wasmModule.WasmEmbedder.withConfig(modelBytes, tokenizerJson, embedderConfig);
+            // Detect SIMD capability
+            detectSimd();
+            console.error(`ONNX embedder ready: ${embedder.dimension()}d, SIMD: ${simdAvailable}`);
+            isInitialized = true;
+            // Determine if we should use parallel workers
+            // - true: always enable
+            // - false: never enable
+            // - 'auto'/undefined: enable for long-running processes (MCP, servers), skip for CLI
+            let shouldTryParallel = false;
+            if (config.enableParallel === true) {
+                shouldTryParallel = true;
+            }
+            else if (config.enableParallel === false) {
+                shouldTryParallel = false;
+            }
+            else {
+                // Auto-detect: check if running as CLI hook or long-running process
+                const isCLI = process.argv[1]?.includes('cli.js') ||
+                    process.argv[1]?.includes('bin/ruvector') ||
+                    process.env.RUVECTOR_CLI === '1';
+                const isMCP = process.env.MCP_SERVER === '1' ||
+                    process.argv.some(a => a.includes('mcp'));
+                const forceParallel = process.env.RUVECTOR_PARALLEL === '1';
+                // Enable parallel for MCP/servers or if explicitly requested, skip for CLI
+                shouldTryParallel = forceParallel || (isMCP && !isCLI);
+            }
+            if (shouldTryParallel) {
+                await tryInitParallel(config);
+            }
+        }
+        catch (e) {
+            loadError = new Error(`Failed to initialize ONNX embedder: ${e.message}`);
+            throw loadError;
+        }
+    })();
+    await loadPromise;
+    return isInitialized;
+}
+/**
+ * Generate embedding for text
+ */
+async function embed(text) {
+    if (!isInitialized) {
+        await initOnnxEmbedder();
+    }
+    if (!embedder) {
+        throw new Error('ONNX embedder not initialized');
+    }
+    const start = performance.now();
+    const embedding = embedder.embedOne(text);
+    const timeMs = performance.now() - start;
+    return {
+        embedding: Array.from(embedding),
+        dimension: embedding.length,
+        timeMs,
+    };
+}
+/**
+ * Generate embeddings for multiple texts
+ * Uses parallel workers automatically for batches >= parallelThreshold
+ */
+async function embedBatch(texts) {
+    if (!isInitialized) {
+        await initOnnxEmbedder();
+    }
+    if (!embedder) {
+        throw new Error('ONNX embedder not initialized');
+    }
+    const start = performance.now();
+    // Use parallel workers for large batches
+    if (parallelEnabled && parallelEmbedder && texts.length >= parallelThreshold) {
+        const batchResults = await parallelEmbedder.embedBatch(texts);
+        const totalTime = performance.now() - start;
+        const dimension = parallelEmbedder.dimension || 384;
+        return batchResults.map((emb) => ({
+            embedding: Array.from(emb),
+            dimension,
+            timeMs: totalTime / texts.length,
+        }));
+    }
+    // Sequential fallback
+    const batchEmbeddings = embedder.embedBatch(texts);
+    const totalTime = performance.now() - start;
+    const dimension = embedder.dimension();
+    const results = [];
+    for (let i = 0; i < texts.length; i++) {
+        const embedding = batchEmbeddings.slice(i * dimension, (i + 1) * dimension);
+        results.push({
+            embedding: Array.from(embedding),
+            dimension,
+            timeMs: totalTime / texts.length,
+        });
+    }
+    return results;
+}
+/**
+ * Calculate cosine similarity between two texts
+ */
+async function similarity(text1, text2) {
+    if (!isInitialized) {
+        await initOnnxEmbedder();
+    }
+    if (!embedder) {
+        throw new Error('ONNX embedder not initialized');
+    }
+    const start = performance.now();
+    const sim = embedder.similarity(text1, text2);
+    const timeMs = performance.now() - start;
+    return { similarity: sim, timeMs };
+}
+/**
+ * Calculate cosine similarity between two embeddings
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Embeddings must have same dimension');
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    return magnitude === 0 ? 0 : dotProduct / magnitude;
+}
+/**
+ * Get embedding dimension
+ */
+function getDimension() {
+    return embedder ? embedder.dimension() : 384;
+}
+/**
+ * Check if embedder is ready
+ */
+function isReady() {
+    return isInitialized;
+}
+/**
+ * Get embedder stats including SIMD and parallel capabilities
+ */
+function getStats() {
+    return {
+        ready: isInitialized,
+        dimension: embedder ? embedder.dimension() : 384,
+        model: DEFAULT_MODEL,
+        simd: simdAvailable,
+        parallel: parallelEnabled,
+        parallelWorkers: parallelEmbedder?.numWorkers || 0,
+        parallelThreshold,
+    };
+}
+/**
+ * Shutdown parallel workers (call on exit)
+ */
+async function shutdown() {
+    if (parallelEmbedder) {
+        await parallelEmbedder.shutdown();
+        parallelEmbedder = null;
+        parallelEnabled = false;
+    }
+}
+// Export class wrapper for compatibility
+class OnnxEmbedder {
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async init() {
+        return initOnnxEmbedder(this.config);
+    }
+    async embed(text) {
+        const result = await embed(text);
+        return result.embedding;
+    }
+    async embedBatch(texts) {
+        const results = await embedBatch(texts);
+        return results.map(r => r.embedding);
+    }
+    async similarity(text1, text2) {
+        const result = await similarity(text1, text2);
+        return result.similarity;
+    }
+    get dimension() {
+        return getDimension();
+    }
+    get ready() {
+        return isReady();
+    }
+}
+exports.OnnxEmbedder = OnnxEmbedder;
+exports.default = OnnxEmbedder;

package/dist/core/onnx-optimized.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Optimized ONNX Embedder for RuVector
+ *
+ * Performance optimizations:
+ * 1. TOKENIZER CACHING - Cache tokenization results (~10-20ms savings per repeat)
+ * 2. EMBEDDING LRU CACHE - Full embedding cache with configurable size
+ * 3. QUANTIZED MODELS - INT8/FP16 models for 2-4x speedup
+ * 4. LAZY INITIALIZATION - Defer model loading until first use
+ * 5. DYNAMIC BATCHING - Optimize batch sizes based on input
+ * 6. MEMORY OPTIMIZATION - Float32Array for all operations
+ *
+ * Usage:
+ *   const embedder = new OptimizedOnnxEmbedder({ cacheSize: 1000 });
+ *   await embedder.init();
+ *   const embedding = await embedder.embed("Hello world");
+ */
+export interface OptimizedOnnxConfig {
+    /** Model to use (default: 'all-MiniLM-L6-v2') */
+    modelId?: string;
+    /** Use quantized model if available (default: true) */
+    useQuantized?: boolean;
+    /** Quantization type: 'fp16' | 'int8' | 'dynamic' */
+    quantization?: 'fp16' | 'int8' | 'dynamic' | 'none';
+    /** Max input length (default: 256) */
+    maxLength?: number;
+    /** Embedding cache size (default: 512) */
+    cacheSize?: number;
+    /** Tokenizer cache size (default: 256) */
+    tokenizerCacheSize?: number;
+    /** Enable lazy initialization (default: true) */
+    lazyInit?: boolean;
+    /** Batch size for dynamic batching (default: 32) */
+    batchSize?: number;
+    /** Minimum texts to trigger batching (default: 4) */
+    batchThreshold?: number;
+}
+export declare class OptimizedOnnxEmbedder {
+    private config;
+    private wasmModule;
+    private embedder;
+    private initialized;
+    private initPromise;
+    private embeddingCache;
+    private tokenizerCache;
+    private totalEmbeds;
+    private totalTimeMs;
+    private dimension;
+    constructor(config?: OptimizedOnnxConfig);
+    /**
+     * Initialize the embedder (loads model)
+     */
+    init(): Promise<void>;
+    private doInit;
+    /**
+     * Embed a single text with caching
+     */
+    embed(text: string): Promise<Float32Array>;
+    /**
+     * Embed multiple texts with batching and caching
+     */
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    /**
+     * Calculate similarity between two texts
+     */
+    similarity(text1: string, text2: string): Promise<number>;
+    /**
+     * Fast cosine similarity with loop unrolling
+     */
+    cosineSimilarity(a: Float32Array, b: Float32Array): number;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        embedding: {
+            hits: number;
+            misses: number;
+            hitRate: number;
+            size: number;
+        };
+        tokenizer: {
+            hits: number;
+            misses: number;
+            hitRate: number;
+            size: number;
+        };
+        avgTimeMs: number;
+        totalEmbeds: number;
+    };
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Get embedding dimension
+     */
+    getDimension(): number;
+    /**
+     * Check if initialized
+     */
+    isReady(): boolean;
+    /**
+     * Get configuration
+     */
+    getConfig(): Required<OptimizedOnnxConfig>;
+}
+export declare function getOptimizedOnnxEmbedder(config?: OptimizedOnnxConfig): OptimizedOnnxEmbedder;
+export declare function initOptimizedOnnx(config?: OptimizedOnnxConfig): Promise<OptimizedOnnxEmbedder>;
+export default OptimizedOnnxEmbedder;
+//# sourceMappingURL=onnx-optimized.d.ts.map

package/dist/core/onnx-optimized.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onnx-optimized.d.ts","sourceRoot":"","sources":["../../src/core/onnx-optimized.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAcH,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IACpD,sCAAsC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,iDAAiD;IACjD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AA0HD,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAA8B;IAGjD,OAAO,CAAC,cAAc,CAAiC;IACvD,OAAO,CAAC,cAAc,CAAwB;IAG9C,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,SAAS,CAAO;gBAEZ,MAAM,GAAE,mBAAwB;IAiB5C;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAWb,MAAM;IA8EpB;;OAEG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAiChD;;OAEG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAmD1D;;OAEG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/D;;OAEG;IACH,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,MAAM;IAmB1D;;OAEG;IACH,aAAa,IAAI;QACf,SAAS,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;QAC3E,SAAS,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;QAC3E,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;KACrB;IASD;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,SAAS,IAAI,QAAQ,CAAC,mBAAmB,CAAC;CAG3C;AAQD,wBAAgB,wBAAwB,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,qBAAqB,CAK5F;AAED,wBAAsB,iBAAiB,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAIpG;AAED,eAAe,qBAAqB,CAAC"}