ruvector 0.2.25 → 0.2.27

package/dist/core/onnx/bundled-parallel.mjs

@@ -0,0 +1,164 @@
+/**
+ * Bundled-WASM parallel embedder (issue #523 SOTA).
+ *
+ * A self-contained worker_threads pool — NO external dependency — that shards
+ * batches of text across CPU cores, each worker running the bundled ONNX WASM
+ * embedder over the SAME model bytes (shared via SharedArrayBuffer) and config.
+ * Output vectors are identical to the single-thread path (cosine-equivalent),
+ * so this is a pure throughput optimization with no quality change.
+ *
+ * Drop-in shape compatible with the optional `ruvector-onnx-embeddings-wasm/parallel`
+ * package: { numWorkers, dimension, init(), embedBatch(texts) -> number[][], shutdown() }.
+ */
+import { Worker } from 'node:worker_threads';
+import * as os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export class ParallelEmbedder {
+  /**
+   * @param {object} opts
+   * @param {Uint8Array} opts.modelBytes  raw ONNX model bytes (loaded once by caller)
+   * @param {string}     opts.tokenizerJson
+   * @param {number}     [opts.maxLength=256]
+   * @param {number}     [opts.dimension=384]
+   * @param {number}     [opts.numWorkers]  defaults to min(cpus-2, 16), >=2
+   */
+  constructor(opts = {}) {
+    this.numWorkers = opts.numWorkers || Math.max(2, Math.min((os.cpus().length || 4) - 2, 16));
+    this.dimension = opts.dimension || 384;
+    this._modelBytes = opts.modelBytes;
+    this._tokenizerJson = opts.tokenizerJson;
+    this._maxLength = opts.maxLength || 256;
+    this._requestTimeoutMs = opts.requestTimeoutMs ?? 30000;
+    this._workers = [];
+    this._pending = new Map();   // id -> { resolve, reject, worker, timer }
+    this._seq = 0;
+    this._shuttingDown = false;
+  }
+
+  async init() {
+    if (!this._modelBytes || !this._tokenizerJson) {
+      throw new Error('ParallelEmbedder requires modelBytes and tokenizerJson');
+    }
+    // Share model bytes across all workers via a single SharedArrayBuffer.
+    const sab = new SharedArrayBuffer(this._modelBytes.length);
+    new Uint8Array(sab).set(this._modelBytes);
+
+    const workerUrl = new URL('./embed-worker.mjs', import.meta.url);
+    const readies = [];
+
+    for (let i = 0; i < this.numWorkers; i++) {
+      const w = new Worker(workerUrl, {
+        workerData: { modelSab: sab, tokenizerJson: this._tokenizerJson, maxLength: this._maxLength },
+      });
+      w.on('message', (m) => this._onMessage(m));
+      // If a worker dies (uncaught error or unexpected exit), fail every request
+      // currently routed to it instead of letting those promises hang forever.
+      w.on('error', (e) => this._failWorker(w, e instanceof Error ? e : new Error(String(e))));
+      w.on('exit', (code) => {
+        if (!this._shuttingDown && code !== 0) {
+          this._failWorker(w, new Error(`embed worker exited unexpectedly (code ${code})`));
+        }
+      });
+      this._workers.push(w);
+      readies.push(new Promise((resolve, reject) => {
+        const onReady = (m) => {
+          if (m.type === 'ready') { cleanup(); resolve(); }
+          else if (m.type === 'init-error') { cleanup(); reject(new Error('worker init failed: ' + m.error)); }
+        };
+        const onErr = (e) => { cleanup(); reject(e); };
+        const cleanup = () => { w.off('message', onReady); w.off('error', onErr); };
+        w.on('message', onReady);
+        w.once('error', onErr);
+      }));
+    }
+
+    await Promise.all(readies);
+    // Drop the main-thread reference; the SAB keeps the shared copy alive.
+    this._modelBytes = null;
+  }
+
+  _settle(id, fn) {
+    const p = this._pending.get(id);
+    if (!p) return;
+    this._pending.delete(id);
+    if (p.timer) clearTimeout(p.timer);
+    fn(p);
+  }
+
+  _onMessage(m) {
+    if (m.type !== 'result' && m.type !== 'error') return;
+    this._settle(m.id, (p) => {
+      if (m.type === 'error') p.reject(new Error(m.error));
+      else p.resolve({ dim: m.dim, count: m.count, flat: new Float32Array(m.buffer) });
+    });
+  }
+
+  /** Reject every in-flight request routed to a dead worker. */
+  _failWorker(worker, err) {
+    for (const [id, p] of this._pending) {
+      if (p.worker === worker) this._settle(id, () => p.reject(err));
+    }
+  }
+
+  _send(worker, texts) {
+    const id = ++this._seq;
+    return new Promise((resolve, reject) => {
+      const entry = { resolve, reject, worker, timer: null };
+      if (this._requestTimeoutMs > 0) {
+        entry.timer = setTimeout(() => {
+          this._settle(id, () =>
+            reject(new Error(`embed request timed out after ${this._requestTimeoutMs}ms`)));
+        }, this._requestTimeoutMs);
+        // Don't keep the event loop alive solely for this timer.
+        if (typeof entry.timer.unref === 'function') entry.timer.unref();
+      }
+      this._pending.set(id, entry);
+      worker.postMessage({ type: 'embed', id, texts });
+    });
+  }
+
+  /**
+   * Embed many texts, sharded across workers. Returns number[][] in input order.
+   */
+  async embedBatch(texts) {
+    if (!texts || texts.length === 0) return [];
+    const n = this._workers.length;
+    const shard = Math.ceil(texts.length / n);
+    const tasks = [];
+    const starts = [];
+    for (let i = 0; i < n; i++) {
+      const start = i * shard;
+      if (start >= texts.length) break;
+      const end = Math.min(texts.length, start + shard);
+      starts.push(start);
+      tasks.push(this._send(this._workers[i], texts.slice(start, end)));
+    }
+    const results = await Promise.all(tasks);
+    const out = new Array(texts.length);
+    for (let r = 0; r < results.length; r++) {
+      const { dim, count, flat } = results[r];
+      const start = starts[r];
+      for (let j = 0; j < count; j++) {
+        out[start + j] = Array.from(flat.subarray(j * dim, (j + 1) * dim));
+      }
+    }
+    return out;
+  }
+
+  async shutdown() {
+    this._shuttingDown = true;
+    // Reject anything still in flight so callers don't hang on shutdown.
+    for (const [id, p] of this._pending) {
+      this._settle(id, () => p.reject(new Error('ParallelEmbedder shut down')));
+    }
+    const ws = this._workers;
+    this._workers = [];
+    await Promise.all(ws.map((w) => w.terminate()));
+  }
+}
+
+export default ParallelEmbedder;

package/dist/core/onnx/embed-worker.mjs

@@ -0,0 +1,67 @@
+/**
+ * Worker-thread entry for the bundled-WASM parallel embedder (issue #523 SOTA).
+ *
+ * Each worker loads its own instance of the bundled ONNX WASM embedder from the
+ * SAME model bytes (shared via SharedArrayBuffer — no per-worker download) and
+ * the SAME config, so the vectors it produces are identical to the single-thread
+ * path (cosine-equivalent by construction).
+ *
+ * Protocol:
+ *   workerData: { modelSab: SharedArrayBuffer, tokenizerJson: string, maxLength: number }
+ *   → posts { type: 'ready' } once the WASM embedder is constructed
+ *   message { type: 'embed', id, texts: string[] }
+ *   → posts { type: 'result', id, dim, count, buffer } (Float32Array buffer, transferred)
+ *   errors → { type: 'error', id, error }
+ */
+import { parentPort, workerData } from 'node:worker_threads';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let embedder = null;
+
+async function init() {
+  const bgJsPath = path.join(__dirname, 'pkg', 'ruvector_onnx_embeddings_wasm_bg.js');
+  const wasmPath = path.join(__dirname, 'pkg', 'ruvector_onnx_embeddings_wasm_bg.wasm');
+
+  const wasmModule = await import(pathToFileURL(bgJsPath).href);
+  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();
+
+  // Reconstruct model bytes from the shared buffer (zero-copy view, then handed
+  // to wasm-bindgen which copies into WASM linear memory).
+  const modelBytes = new Uint8Array(workerData.modelSab);
+
+  const cfg = new wasmModule.WasmEmbedderConfig()
+    .setMaxLength(workerData.maxLength || 256)
+    .setNormalize(true)
+    .setPooling(0); // Mean pooling — matches the single-thread path.
+
+  embedder = wasmModule.WasmEmbedder.withConfig(modelBytes, workerData.tokenizerJson, cfg);
+}
+
+parentPort.on('message', (msg) => {
+  if (msg.type !== 'embed') return;
+  try {
+    const dim = embedder.dimension();
+    const flat = embedder.embedBatch(msg.texts); // length = texts.length * dim
+    const arr = Float32Array.from(flat);
+    parentPort.postMessage(
+      { type: 'result', id: msg.id, dim, count: msg.texts.length, buffer: arr.buffer },
+      [arr.buffer],
+    );
+  } catch (e) {
+    parentPort.postMessage({ type: 'error', id: msg.id, error: e?.message || String(e) });
+  }
+});
+
+init()
+  .then(() => parentPort.postMessage({ type: 'ready' }))
+  .catch((e) => parentPort.postMessage({ type: 'init-error', error: e?.message || String(e) }));

package/dist/core/onnx/loader.js

@@ -0,0 +1,434 @@
+/**
+ * Model Loader for RuVector ONNX Embeddings WASM
+ *
+ * Provides easy loading of pre-trained models from HuggingFace Hub
+ */
+
+/**
+ * Pre-configured models with their HuggingFace URLs
+ */
+export const MODELS = {
+    // Sentence Transformers - Small & Fast
+    'all-MiniLM-L6-v2': {
+        name: 'all-MiniLM-L6-v2',
+        dimension: 384,
+        maxLength: 256,
+        size: '23MB',
+        description: 'Fast, general-purpose embeddings',
+        model: 'https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/onnx/model.onnx',
+        tokenizer: 'https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/tokenizer.json',
+    },
+    'all-MiniLM-L12-v2': {
+        name: 'all-MiniLM-L12-v2',
+        dimension: 384,
+        maxLength: 256,
+        size: '33MB',
+        description: 'Better quality, balanced speed',
+        model: 'https://huggingface.co/sentence-transformers/all-MiniLM-L12-v2/resolve/main/onnx/model.onnx',
+        tokenizer: 'https://huggingface.co/sentence-transformers/all-MiniLM-L12-v2/resolve/main/tokenizer.json',
+    },
+
+    // BGE Models - State of the art
+    'bge-small-en-v1.5': {
+        name: 'bge-small-en-v1.5',
+        dimension: 384,
+        maxLength: 512,
+        size: '33MB',
+        description: 'State-of-the-art small model',
+        model: 'https://huggingface.co/BAAI/bge-small-en-v1.5/resolve/main/onnx/model.onnx',
+        tokenizer: 'https://huggingface.co/BAAI/bge-small-en-v1.5/resolve/main/tokenizer.json',
+    },
+    'bge-base-en-v1.5': {
+        name: 'bge-base-en-v1.5',
+        dimension: 768,
+        maxLength: 512,
+        size: '110MB',
+        description: 'Best overall quality',
+        model: 'https://huggingface.co/BAAI/bge-base-en-v1.5/resolve/main/onnx/model.onnx',
+        tokenizer: 'https://huggingface.co/BAAI/bge-base-en-v1.5/resolve/main/tokenizer.json',
+    },
+
+    // E5 Models - Microsoft
+    'e5-small-v2': {
+        name: 'e5-small-v2',
+        dimension: 384,
+        maxLength: 512,
+        size: '33MB',
+        description: 'Excellent for search & retrieval',
+        model: 'https://huggingface.co/intfloat/e5-small-v2/resolve/main/onnx/model.onnx',
+        tokenizer: 'https://huggingface.co/intfloat/e5-small-v2/resolve/main/tokenizer.json',
+    },
+
+    // GTE Models - Alibaba
+    'gte-small': {
+        name: 'gte-small',
+        dimension: 384,
+        maxLength: 512,
+        size: '33MB',
+        description: 'Good multilingual support',
+        model: 'https://huggingface.co/thenlper/gte-small/resolve/main/onnx/model.onnx',
+        tokenizer: 'https://huggingface.co/thenlper/gte-small/resolve/main/tokenizer.json',
+    },
+};
+
+/**
+ * Default model for quick start
+ */
+export const DEFAULT_MODEL = 'all-MiniLM-L6-v2';
+
+/**
+ * In-memory memo of loaded models, keyed by model name. Deduplicates the
+ * (re-)download + decode when multiple embedder instances load the same model
+ * in one process. In Node there is no Cache API, so without this every
+ * ModelLoader.loadModel() re-fetches the model from HuggingFace (issue #523).
+ */
+const _inMemoryModelCache = new Map();
+
+/**
+ * Model loader with caching support
+ */
+export class ModelLoader {
+    constructor(options = {}) {
+        this.cache = options.cache ?? true;
+        this.cacheStorage = options.cacheStorage ?? 'ruvector-models';
+        this.onProgress = options.onProgress ?? null;
+    }
+
+    /**
+     * Load a pre-configured model by name
+     * @param {string} modelName - Model name from MODELS
+     * @returns {Promise<{modelBytes: Uint8Array, tokenizerJson: string, config: object}>}
+     */
+    async loadModel(modelName = DEFAULT_MODEL) {
+        const modelConfig = MODELS[modelName];
+        if (!modelConfig) {
+            throw new Error(`Unknown model: ${modelName}. Available: ${Object.keys(MODELS).join(', ')}`);
+        }
+
+        // In-memory memo: a second load of the same model in this process reuses
+        // the already-downloaded bytes instead of re-fetching (issue #523).
+        if (this.cache && _inMemoryModelCache.has(modelName)) {
+            return _inMemoryModelCache.get(modelName);
+        }
+
+        // On-disk cache (Node only): models persist across processes so they are
+        // downloaded once, not every run. The browser has the Cache API instead
+        // (handled in fetchWithCache). See issue #523.
+        if (this.cache) {
+            const disk = await this._loadFromDisk(modelName);
+            if (disk) {
+                const cached = { ...disk, config: modelConfig };
+                _inMemoryModelCache.set(modelName, cached);
+                return cached;
+            }
+        }
+
+        console.log(`Loading model: ${modelConfig.name} (${modelConfig.size})`);
+
+        const [modelBytes, tokenizerJson] = await Promise.all([
+            this.fetchWithCache(modelConfig.model, `${modelName}-model.onnx`, 'arraybuffer'),
+            this.fetchWithCache(modelConfig.tokenizer, `${modelName}-tokenizer.json`, 'text'),
+        ]);
+
+        const result = {
+            modelBytes: new Uint8Array(modelBytes),
+            tokenizerJson,
+            config: modelConfig,
+        };
+
+        if (this.cache) {
+            _inMemoryModelCache.set(modelName, result);
+            await this._saveToDisk(modelName, result.modelBytes, tokenizerJson);
+        }
+
+        return result;
+    }
+
+    /**
+     * Resolve the Node on-disk cache dir for a model (null in non-Node envs).
+     * Uses dynamic import so this module stays loadable in browsers/bundlers.
+     */
+    async _diskCacheDir(modelName) {
+        if (typeof process === 'undefined' || !process.versions?.node) return null;
+        const home = process.env.RUVECTOR_CACHE_DIR
+            || process.env.HOME || process.env.USERPROFILE || '/tmp';
+        const path = await import('node:path');
+        return path.join(home, '.ruvector', 'models', modelName);
+    }
+
+    /** Load model bytes + tokenizer from the Node disk cache, or null if absent. */
+    async _loadFromDisk(modelName) {
+        const dir = await this._diskCacheDir(modelName);
+        if (!dir) return null;
+        try {
+            const fs = await import('node:fs');
+            const path = await import('node:path');
+            const modelPath = path.join(dir, 'model.onnx');
+            const tokPath = path.join(dir, 'tokenizer.json');
+            if (!fs.existsSync(modelPath) || !fs.existsSync(tokPath)) return null;
+            const modelBytes = new Uint8Array(fs.readFileSync(modelPath));
+            const tokenizerJson = fs.readFileSync(tokPath, 'utf8');
+            if (modelBytes.length === 0 || tokenizerJson.length === 0) return null;
+            console.log(`  Disk cache hit: ${modelName}`);
+            return { modelBytes, tokenizerJson };
+        } catch {
+            return null;
+        }
+    }
+
+    /** Persist model bytes + tokenizer to the Node disk cache (best-effort). */
+    async _saveToDisk(modelName, modelBytes, tokenizerJson) {
+        const dir = await this._diskCacheDir(modelName);
+        if (!dir) return;
+        try {
+            const fs = await import('node:fs');
+            const path = await import('node:path');
+            fs.mkdirSync(dir, { recursive: true });
+            // Write to temp files then rename, so a crash mid-write can't leave a
+            // truncated cache entry that later reads would trust.
+            const mTmp = path.join(dir, 'model.onnx.tmp');
+            const tTmp = path.join(dir, 'tokenizer.json.tmp');
+            fs.writeFileSync(mTmp, Buffer.from(modelBytes));
+            fs.writeFileSync(tTmp, tokenizerJson);
+            fs.renameSync(mTmp, path.join(dir, 'model.onnx'));
+            fs.renameSync(tTmp, path.join(dir, 'tokenizer.json'));
+        } catch {
+            // Cache write is best-effort; embedding still works without it.
+        }
+    }
+
+    /**
+     * Load model from custom URLs
+     * @param {string} modelUrl - URL to ONNX model
+     * @param {string} tokenizerUrl - URL to tokenizer.json
+     * @returns {Promise<{modelBytes: Uint8Array, tokenizerJson: string}>}
+     */
+    async loadFromUrls(modelUrl, tokenizerUrl) {
+        const [modelBytes, tokenizerJson] = await Promise.all([
+            this.fetchWithCache(modelUrl, null, 'arraybuffer'),
+            this.fetchWithCache(tokenizerUrl, null, 'text'),
+        ]);
+
+        return {
+            modelBytes: new Uint8Array(modelBytes),
+            tokenizerJson,
+        };
+    }
+
+    /**
+     * Load model from local files (Node.js)
+     * @param {string} modelPath - Path to ONNX model
+     * @param {string} tokenizerPath - Path to tokenizer.json
+     * @returns {Promise<{modelBytes: Uint8Array, tokenizerJson: string}>}
+     */
+    async loadFromFiles(modelPath, tokenizerPath) {
+        // Node.js environment
+        if (typeof process !== 'undefined' && process.versions?.node) {
+            const fs = await import('fs/promises');
+            const [modelBytes, tokenizerJson] = await Promise.all([
+                fs.readFile(modelPath),
+                fs.readFile(tokenizerPath, 'utf8'),
+            ]);
+            return {
+                modelBytes: new Uint8Array(modelBytes),
+                tokenizerJson,
+            };
+        }
+        throw new Error('loadFromFiles is only available in Node.js');
+    }
+
+    /**
+     * Fetch with optional caching (uses Cache API in browsers)
+     */
+    async fetchWithCache(url, cacheKey, responseType) {
+        // Try cache first (browser only)
+        if (this.cache && typeof caches !== 'undefined' && cacheKey) {
+            try {
+                const cache = await caches.open(this.cacheStorage);
+                const cached = await cache.match(cacheKey);
+                if (cached) {
+                    console.log(`  Cache hit: ${cacheKey}`);
+                    return responseType === 'arraybuffer'
+                        ? await cached.arrayBuffer()
+                        : await cached.text();
+                }
+            } catch (e) {
+                // Cache API not available, continue with fetch
+            }
+        }
+
+        // Fetch from network
+        console.log(`  Downloading: ${url}`);
+        const response = await this.fetchWithProgress(url);
+
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+        }
+
+        // Clone for caching
+        const responseClone = response.clone();
+
+        // Cache the response (browser only)
+        if (this.cache && typeof caches !== 'undefined' && cacheKey) {
+            try {
+                const cache = await caches.open(this.cacheStorage);
+                await cache.put(cacheKey, responseClone);
+            } catch (e) {
+                // Cache write failed, continue
+            }
+        }
+
+        return responseType === 'arraybuffer'
+            ? await response.arrayBuffer()
+            : await response.text();
+    }
+
+    /**
+     * Fetch with progress reporting
+     */
+    async fetchWithProgress(url) {
+        const response = await fetch(url);
+
+        if (!this.onProgress || !response.body) {
+            return response;
+        }
+
+        const contentLength = response.headers.get('content-length');
+        if (!contentLength) {
+            return response;
+        }
+
+        const total = parseInt(contentLength, 10);
+        let loaded = 0;
+
+        const reader = response.body.getReader();
+        const chunks = [];
+
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            chunks.push(value);
+            loaded += value.length;
+
+            this.onProgress({
+                loaded,
+                total,
+                percent: Math.round((loaded / total) * 100),
+            });
+        }
+
+        const body = new Uint8Array(loaded);
+        let position = 0;
+        for (const chunk of chunks) {
+            body.set(chunk, position);
+            position += chunk.length;
+        }
+
+        return new Response(body, {
+            headers: response.headers,
+            status: response.status,
+            statusText: response.statusText,
+        });
+    }
+
+    /**
+     * Clear cached models
+     */
+    async clearCache() {
+        if (typeof caches !== 'undefined') {
+            await caches.delete(this.cacheStorage);
+            console.log('Model cache cleared');
+        }
+    }
+
+    /**
+     * List available models
+     */
+    static listModels() {
+        return Object.entries(MODELS).map(([key, config]) => ({
+            id: key,
+            ...config,
+        }));
+    }
+}
+
+/**
+ * Quick helper to create an embedder with a pre-configured model
+ *
+ * @example
+ * ```javascript
+ * import { createEmbedder } from './loader.js';
+ *
+ * const embedder = await createEmbedder('all-MiniLM-L6-v2');
+ * const embedding = embedder.embedOne("Hello world");
+ * ```
+ */
+export async function createEmbedder(modelName = DEFAULT_MODEL, wasmModule = null) {
+    // Import WASM module if not provided
+    if (!wasmModule) {
+        wasmModule = await import('./pkg/ruvector_onnx_embeddings_wasm.js');
+        await wasmModule.default();
+    }
+
+    const loader = new ModelLoader();
+    const { modelBytes, tokenizerJson, config } = await loader.loadModel(modelName);
+
+    const embedderConfig = new wasmModule.WasmEmbedderConfig()
+        .setMaxLength(config.maxLength)
+        .setNormalize(true)
+        .setPooling(0); // Mean pooling
+
+    const embedder = wasmModule.WasmEmbedder.withConfig(
+        modelBytes,
+        tokenizerJson,
+        embedderConfig
+    );
+
+    return embedder;
+}
+
+/**
+ * Quick helper for one-off embedding (loads model, embeds, returns)
+ *
+ * @example
+ * ```javascript
+ * import { embed } from './loader.js';
+ *
+ * const embedding = await embed("Hello world");
+ * const embeddings = await embed(["Hello", "World"]);
+ * ```
+ */
+export async function embed(text, modelName = DEFAULT_MODEL) {
+    const embedder = await createEmbedder(modelName);
+
+    if (Array.isArray(text)) {
+        return embedder.embedBatch(text);
+    }
+    return embedder.embedOne(text);
+}
+
+/**
+ * Quick helper for similarity comparison
+ *
+ * @example
+ * ```javascript
+ * import { similarity } from './loader.js';
+ *
+ * const score = await similarity("I love dogs", "I adore puppies");
+ * console.log(score); // ~0.85
+ * ```
+ */
+export async function similarity(text1, text2, modelName = DEFAULT_MODEL) {
+    const embedder = await createEmbedder(modelName);
+    return embedder.similarity(text1, text2);
+}
+
+export default {
+    MODELS,
+    DEFAULT_MODEL,
+    ModelLoader,
+    createEmbedder,
+    embed,
+    similarity,
+};

package/dist/core/onnx/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/core/onnx/pkg/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 rUv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.