{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"npm-ruvector-onnx-embeddings-wasm","slug":"ruvector-onnx-embeddings-wasm","name":"ruvector-onnx-embeddings-wasm","type":"repo","url":"https://github.com/ruvnet/ruvector/tree/main/examples/onnx-embeddings-wasm","page_url":"https://unfragile.ai/ruvector-onnx-embeddings-wasm","categories":["rag-knowledge"],"tags":["onnx","embeddings","wasm","webassembly","simd","parallel","worker-threads","ml","machine-learning","nlp","text-embeddings","semantic-search","vector-database","rag","sentence-transformers","huggingface","cloudflare-workers","edge-computing","browser"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"npm-ruvector-onnx-embeddings-wasm__cap_0","uri":"capability://memory.knowledge.cross.platform.wasm.embedding.generation.with.simd.acceleration","name":"cross-platform wasm embedding generation with simd acceleration","description":"Compiles ONNX sentence-transformer models to WebAssembly with SIMD (Single Instruction Multiple Data) intrinsics for vectorized tensor operations, enabling native embedding inference across browsers, Cloudflare Workers, Deno, and Node.js without external ML runtime dependencies. Uses WASM linear memory for model weights and intermediate activations, with SIMD instructions for matrix multiplication and normalization operations to achieve near-native performance on CPU-bound embedding tasks.","intents":["Run semantic embeddings client-side without sending text to external APIs","Deploy embedding models to edge runtimes (Cloudflare Workers, Deno) with zero cold-start overhead","Generate embeddings in browsers for real-time semantic search without backend calls","Avoid vendor lock-in by using standardized ONNX format instead of proprietary model formats"],"best_for":["Edge computing platforms requiring sub-100ms embedding latency","Privacy-conscious applications processing sensitive text locally","Teams building RAG systems with client-side vector generation","Developers targeting multiple runtimes (browser, Node.js, Deno, Cloudflare) with single codebase"],"limitations":["WASM module size typically 50-200MB for full sentence-transformer models, requiring lazy-loading or model quantization for browser deployment","SIMD performance gains plateau on CPU-bound operations; GPU acceleration unavailable in WASM (no WebGPU support in this implementation)","Model inference latency 2-5x slower than native Python/CUDA implementations due to WASM runtime overhead","Limited to models convertible to ONNX format; some transformer architectures require custom operator implementations"],"requires":["ONNX model file (e.g., from Hugging Face sentence-transformers library)","WASM runtime with SIMD support (Node.js 16.9+, modern browsers with WebAssembly.SIMD, Deno 1.30+, Cloudflare Workers with wasm_simd feature)","npm or compatible package manager for dependency installation"],"input_types":["text (UTF-8 strings, batch arrays)","ONNX model files (.onnx format)","tokenizer configuration (vocabulary, special tokens)"],"output_types":["float32 embedding vectors (typically 384-1024 dimensions)","normalized embeddings (L2 norm applied)","batch embeddings (multiple vectors in single inference pass)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-ruvector-onnx-embeddings-wasm__cap_1","uri":"capability://automation.workflow.parallel.worker.thread.batch.embedding.processing","name":"parallel worker-thread batch embedding processing","description":"Distributes embedding inference across multiple worker threads (Node.js Worker Threads, Web Workers in browsers, Deno workers) to parallelize computation on multi-core systems. Each worker maintains its own WASM module instance and embedding model state, processing disjoint batches of text independently and returning results via message passing, enabling linear throughput scaling with core count for large-scale embedding generation.","intents":["Process thousands of documents into embeddings without blocking the main thread","Maximize CPU utilization on multi-core servers by distributing embedding workload","Implement server-side batch embedding pipelines with predictable latency","Scale embedding generation horizontally within a single process"],"best_for":["Backend services processing document batches for RAG indexing","Data pipelines requiring high-throughput embedding generation (1000+ embeddings/sec)","Multi-core servers where single-threaded embedding becomes bottleneck","Applications with variable batch sizes needing dynamic worker pool scaling"],"limitations":["Worker thread creation overhead (~10-50ms per worker) amortized only for batches >100 embeddings; small batches may be slower than single-threaded execution","Memory overhead: each worker maintains full model copy in WASM memory, requiring N × model_size RAM for N workers (e.g., 8 workers × 100MB model = 800MB)","Message passing serialization adds ~1-5ms latency per batch due to structured clone overhead for large embedding arrays","Browser Web Worker support limited by same-origin policy and CORS; Cloudflare Workers do not support Worker Threads API"],"requires":["Node.js 10.5+ (Worker Threads API) or modern browser with Web Workers support","Sufficient available memory for N worker instances × model size","Deno 1.0+ for Deno worker support"],"input_types":["text arrays (batch of strings to embed)","batch configuration (worker count, batch size per worker)","optional: priority queue for dynamic task scheduling"],"output_types":["embedding vectors (float32 arrays, one per input text)","batch metadata (processing time, worker assignment)","error arrays (per-text error status for failed embeddings)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-ruvector-onnx-embeddings-wasm__cap_2","uri":"capability://memory.knowledge.onnx.model.loading.and.runtime.initialization","name":"onnx model loading and runtime initialization","description":"Loads ONNX model files (serialized protobuf format) into WASM memory, parses the computation graph (nodes, operators, tensor metadata), and initializes the WASM runtime with model weights and operator implementations. Supports lazy-loading of model weights from URLs or local files, with optional model quantization (int8, float16) to reduce memory footprint and improve inference speed on resource-constrained environments like browsers and edge workers.","intents":["Load pre-trained sentence-transformer models from Hugging Face or local storage","Reduce model size for browser deployment through quantization","Support multiple model formats (full precision, quantized) with automatic fallback","Initialize embedding models on-demand without blocking application startup"],"best_for":["Applications requiring model hot-swapping or A/B testing different embedding models","Browser-based tools with strict bundle size constraints","Edge deployments (Cloudflare Workers, Deno) with limited memory budgets","Multi-tenant systems serving different embedding models per customer"],"limitations":["ONNX model parsing adds 100-500ms startup latency depending on model complexity and file I/O speed","Quantized models (int8) lose ~1-3% embedding quality (cosine similarity) compared to full precision, measurable in downstream semantic search tasks","No built-in model versioning or schema validation; incompatible ONNX opset versions cause silent failures or runtime errors","Model weights must fit entirely in WASM linear memory (4GB theoretical limit, practical ~1GB on browsers due to GC pressure)"],"requires":["ONNX model file in opset 12+ format (compatible with sentence-transformers library)","WASM runtime with sufficient memory allocation","Optional: quantization tools (e.g., ONNX quantization scripts) for model compression"],"input_types":["ONNX model files (.onnx binary format)","model URLs (HTTP/HTTPS for lazy-loading)","quantization configuration (bit-width, calibration data)"],"output_types":["initialized WASM module instance with loaded weights","model metadata (input/output shapes, operator list)","memory usage statistics"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-ruvector-onnx-embeddings-wasm__cap_3","uri":"capability://data.processing.analysis.tokenization.and.text.preprocessing.for.embeddings","name":"tokenization and text preprocessing for embeddings","description":"Converts raw text input into token IDs using BPE (Byte-Pair Encoding) or WordPiece tokenization, applies special tokens (CLS, SEP, PAD), and generates attention masks required by transformer embedding models. Tokenization runs in WASM or JavaScript depending on performance requirements, with support for batch processing and configurable max sequence length with truncation/padding strategies.","intents":["Convert arbitrary text into model-compatible token sequences before embedding","Handle variable-length inputs with consistent padding and attention masking","Support multiple languages and special characters through Unicode-aware tokenization","Batch tokenize documents for efficient downstream embedding inference"],"best_for":["RAG pipelines requiring consistent text preprocessing before embedding","Multi-language applications needing language-agnostic tokenization","Systems with strict latency requirements where tokenization is on critical path","Batch processing workflows where tokenization overhead must be minimized"],"limitations":["BPE tokenization in JavaScript adds 5-50ms per document depending on text length and vocabulary size (typically 30k-50k tokens)","Vocabulary loading requires downloading tokenizer JSON (typically 1-5MB), blocking first embedding request","Truncation at max_length (typically 512 tokens) loses semantic information for long documents; no built-in chunking strategy","Special token handling (CLS, SEP, PAD) is model-specific; no automatic detection of correct token IDs"],"requires":["Tokenizer vocabulary file (JSON format with token → ID mapping)","Model-specific token configuration (CLS ID, SEP ID, PAD ID, max_length)","Text input as UTF-8 strings"],"input_types":["raw text (single string or array of strings)","tokenizer configuration (vocab file, special tokens, max_length)","optional: language hint for language-specific tokenization"],"output_types":["token ID arrays (int32 arrays of shape [batch_size, seq_length])","attention masks (binary arrays indicating valid tokens vs padding)","token type IDs (for models requiring segment information)"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-ruvector-onnx-embeddings-wasm__cap_4","uri":"capability://search.retrieval.semantic.similarity.computation.and.vector.operations","name":"semantic similarity computation and vector operations","description":"Computes cosine similarity, Euclidean distance, and dot-product similarity between embedding vectors using SIMD-accelerated operations in WASM. Supports batch similarity computation (e.g., query embedding vs. document embeddings matrix), with optional GPU acceleration via WebGPU for large-scale similarity searches. Results are typically used for semantic search ranking, nearest-neighbor retrieval, and clustering tasks.","intents":["Find most similar documents to a query by computing embedding similarities","Rank search results by semantic relevance without external vector database","Implement client-side semantic search in browsers without backend calls","Compute embedding-space distances for clustering or anomaly detection"],"best_for":["Real-time semantic search applications with <100ms latency requirements","Client-side search interfaces (browsers, Electron apps) avoiding backend calls","Small-to-medium document collections (1k-100k embeddings) where in-memory similarity computation is feasible","Applications requiring custom similarity metrics beyond standard cosine distance"],"limitations":["Quadratic memory complexity for full similarity matrix computation: N embeddings × M query embeddings × 4 bytes = O(N×M) memory, infeasible for >1M embeddings","SIMD similarity computation adds ~10-50μs per vector pair; for 10k documents, full similarity matrix takes 100-500ms, slower than specialized vector databases (Pinecone, Weaviate) with approximate nearest-neighbor indexes","No built-in approximate nearest-neighbor (ANN) algorithms (LSH, HNSW); exact similarity computation required for all queries","WebGPU acceleration not available in this implementation; GPU similarity computation requires separate WebGPU bindings"],"requires":["Pre-computed embedding vectors (float32 arrays)","WASM runtime with SIMD support for accelerated computation","Optional: WebGPU context for GPU-accelerated similarity on large batches"],"input_types":["embedding vectors (float32 arrays, typically 384-1024 dimensions)","query embeddings (single vector or batch of vectors)","similarity metric selection (cosine, euclidean, dot-product)"],"output_types":["similarity scores (float32 arrays, typically -1 to 1 for cosine similarity)","ranked indices (sorted document IDs by similarity)","optional: distance matrices (full N×M similarity matrix)"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-ruvector-onnx-embeddings-wasm__cap_5","uri":"capability://memory.knowledge.embedding.caching.and.memoization","name":"embedding caching and memoization","description":"Caches computed embeddings in memory (LRU cache, IndexedDB for browsers) keyed by text hash, avoiding redundant embedding computation for repeated inputs. Supports cache invalidation strategies (TTL, size limits, manual clearing) and optional persistence to local storage or IndexedDB for cross-session reuse, reducing embedding latency from 50-500ms to <1ms for cached queries.","intents":["Avoid recomputing embeddings for frequently queried documents","Persist embeddings across browser sessions without re-indexing","Reduce embedding API costs by caching results locally","Implement fast semantic search on cached document collections"],"best_for":["Applications with skewed query distributions (80/20 rule: 20% of documents queried 80% of the time)","Browser-based search tools with limited document collections (<10k documents)","Offline-first applications requiring embedding persistence across sessions","Cost-sensitive deployments where embedding computation is expensive"],"limitations":["LRU cache memory overhead: ~100-200 bytes per cached embedding (vector + metadata); 10k embeddings = 1-2MB memory","IndexedDB persistence adds 50-200ms latency for cache reads/writes, negating embedding computation savings for one-time queries","Cache invalidation complexity: no automatic detection of model version changes; stale embeddings from old model versions may be silently reused","Hash collisions (though rare with SHA-256) could cause incorrect embedding reuse for different texts"],"requires":["Hash function (SHA-256 or similar) for text-to-cache-key mapping","Memory budget for LRU cache (configurable, typically 10-100MB)","Optional: IndexedDB support in browser for persistent caching"],"input_types":["text input (string or array of strings)","cache configuration (max_size, ttl, persistence_enabled)","optional: cache invalidation signals (model version, timestamp)"],"output_types":["cached embedding vectors (float32 arrays)","cache hit/miss status","cache statistics (hit rate, memory usage)"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-ruvector-onnx-embeddings-wasm__cap_6","uri":"capability://tool.use.integration.multi.runtime.deployment.and.environment.detection","name":"multi-runtime deployment and environment detection","description":"Automatically detects runtime environment (Node.js, browser, Deno, Cloudflare Workers) and selects appropriate WASM module variant, worker thread implementation, and I/O APIs. Provides unified JavaScript API across all runtimes, abstracting away platform-specific differences (e.g., Node.js fs module vs. browser fetch API, Worker Threads vs. Web Workers). Enables single codebase deployment to multiple targets without conditional compilation.","intents":["Deploy embedding service to multiple platforms (browser, Node.js, edge) from single codebase","Automatically select optimal worker thread implementation per runtime","Handle platform-specific I/O (file system, network, storage) transparently","Simplify deployment pipeline by eliminating platform-specific builds"],"best_for":["Full-stack applications requiring embeddings in frontend and backend","Edge computing platforms (Cloudflare Workers, Deno Deploy) requiring portable code","Libraries and frameworks targeting multiple JavaScript runtimes","Teams avoiding platform-specific code branches and conditional compilation"],"limitations":["Runtime detection overhead adds 1-5ms to initialization; not critical for long-running processes but noticeable in serverless cold starts","Feature parity across runtimes not guaranteed; some APIs (e.g., Worker Threads) unavailable in browsers, requiring fallback to single-threaded execution","Cloudflare Workers environment has strict memory limits (128MB) and CPU time limits (50ms), requiring model quantization and batch size reduction vs. Node.js","Browser WASM module size constraints (typical 50-200MB) require lazy-loading or model splitting, not needed in Node.js"],"requires":["Runtime detection logic (checking for global objects: process, window, Deno, etc.)","Platform-specific WASM module variants (or single universal variant with runtime-specific optimizations)","Conditional imports for platform-specific APIs (fs, fetch, Worker Threads)"],"input_types":["runtime environment (auto-detected or explicitly specified)","configuration overrides per runtime (worker count, memory limits, cache strategy)"],"output_types":["unified embedding API (identical interface across all runtimes)","runtime metadata (detected platform, available features, resource limits)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-ruvector-onnx-embeddings-wasm__cap_7","uri":"capability://memory.knowledge.rag.integration.with.vector.storage.and.retrieval","name":"rag integration with vector storage and retrieval","description":"Provides integration points for Retrieval-Augmented Generation (RAG) workflows: embedding documents for indexing, storing embeddings in vector databases (Pinecone, Weaviate, Milvus, local vector stores), and retrieving top-K similar documents for LLM context. Includes utilities for document chunking, metadata attachment, and batch indexing to vector stores, enabling end-to-end RAG pipelines from raw documents to LLM-augmented responses.","intents":["Index document collections into vector databases for semantic search","Retrieve relevant documents for LLM context without full-text search","Build RAG pipelines combining embeddings with LLM inference","Implement semantic search over proprietary document collections"],"best_for":["Teams building LLM-powered search and Q&A systems","Document-heavy applications (legal, medical, technical documentation) requiring semantic search","RAG systems requiring client-side embedding generation to avoid API costs","Applications with privacy requirements preventing document transmission to external embedding APIs"],"limitations":["No built-in vector database client; requires separate integration with Pinecone, Weaviate, or custom vector store implementation","Document chunking strategy is application-specific; no automatic optimal chunk size detection (typical 256-1024 tokens per chunk)","Metadata attachment and filtering not standardized; each vector database has different metadata schema and query syntax","Embedding quality directly impacts RAG retrieval quality; poor embeddings lead to irrelevant context for LLM, no automatic quality validation"],"requires":["Document collection (text, PDFs, or other formats requiring preprocessing)","Vector database or local vector store (e.g., Pinecone, Weaviate, FAISS, or in-memory vector store)","Document chunking strategy (fixed size, semantic boundaries, or custom logic)","Optional: metadata schema for document filtering and ranking"],"input_types":["raw documents (text, PDF, HTML, or other formats)","document metadata (title, author, date, category, etc.)","chunking configuration (chunk_size, overlap, strategy)","vector database credentials and schema"],"output_types":["indexed embeddings in vector database","retrieval results (top-K documents with similarity scores)","optional: metadata and source information for retrieved documents"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-ruvector-onnx-embeddings-wasm__cap_8","uri":"capability://data.processing.analysis.model.quantization.and.compression.for.deployment","name":"model quantization and compression for deployment","description":"Reduces ONNX model size through quantization (int8, float16) and pruning, enabling deployment to resource-constrained environments (browsers, edge workers) where full-precision models exceed memory budgets. Quantization typically reduces model size by 4x (float32 → int8) with minimal embedding quality loss (<2% cosine similarity degradation). Includes quantization-aware training support and post-training quantization with calibration data.","intents":["Deploy embedding models to browsers with strict bundle size constraints","Reduce memory footprint for Cloudflare Workers and edge deployments","Minimize model download time for mobile and low-bandwidth environments","Trade embedding quality for deployment feasibility on resource-constrained devices"],"best_for":["Browser-based applications with <10MB model size budget","Cloudflare Workers and serverless edge deployments with 128MB memory limits","Mobile applications requiring on-device embedding generation","Cost-sensitive deployments where model size directly impacts infrastructure costs"],"limitations":["Quantization introduces 1-3% embedding quality loss (measured by cosine similarity degradation), measurable in downstream semantic search tasks with tight relevance thresholds","int8 quantization requires calibration data (representative text samples) to determine optimal quantization ranges; poor calibration leads to larger quality loss","Quantized models are not portable across different quantization schemes; switching from int8 to float16 requires re-quantization","Quantization tools (ONNX quantization scripts) require Python environment and expertise; not integrated into JavaScript toolchain"],"requires":["ONNX model file in full precision (float32)","Quantization tool (ONNX quantization library or custom quantization script)","Optional: calibration dataset (representative text samples for int8 quantization)","WASM runtime supporting quantized model inference"],"input_types":["full-precision ONNX model","quantization configuration (bit-width, calibration strategy)","optional: calibration dataset for int8 quantization"],"output_types":["quantized ONNX model (int8 or float16 format)","quantization statistics (size reduction, quality metrics)","optional: quantization report with per-layer quality analysis"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"npm-ruvector-onnx-embeddings-wasm__cap_9","uri":"capability://automation.workflow.batch.inference.with.dynamic.batching.and.scheduling","name":"batch inference with dynamic batching and scheduling","description":"Implements dynamic batching for embedding inference, accumulating multiple embedding requests and processing them together to maximize GPU/CPU utilization and amortize model loading overhead. Includes configurable batch size limits, timeout-based batch flushing (e.g., flush after 100ms even if batch not full), and priority queue support for latency-sensitive requests. Enables high-throughput embedding generation (1000+ embeddings/sec) on multi-core systems.","intents":["Process thousands of embedding requests efficiently without blocking on individual requests","Maximize CPU/GPU utilization by batching requests together","Implement server-side embedding pipelines with predictable throughput","Balance latency and throughput for mixed workloads (some latency-sensitive, some throughput-focused)"],"best_for":["High-throughput embedding services (1000+ embeddings/sec)","Batch document indexing pipelines for RAG systems","Server-side embedding generation with variable request rates","Applications requiring predictable latency SLAs with dynamic batching"],"limitations":["Dynamic batching adds latency variance: requests arriving just after batch flush must wait up to timeout duration (typically 10-100ms) for next batch, causing tail latency spikes","Batch size tuning is workload-dependent; optimal batch size depends on model size, hardware, and request rate; no automatic tuning","Priority queue implementation adds overhead for request scheduling; not beneficial for uniform request rates","Memory overhead for request buffering: large batch sizes require proportional memory for queued requests"],"requires":["Batch size configuration (max_batch_size, typically 32-256)","Timeout configuration (max_batch_wait_ms, typically 10-100ms)","Optional: priority queue for latency-sensitive request prioritization"],"input_types":["embedding requests (text, optional priority level)","batch configuration (max_batch_size, timeout, priority_enabled)"],"output_types":["embedding vectors (float32 arrays, one per request)","latency metrics (request latency, batch processing time)","optional: batch statistics (actual batch size, wait time)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":37,"verified":false,"data_access_risk":"high","permissions":["ONNX model file (e.g., from Hugging Face sentence-transformers library)","WASM runtime with SIMD support (Node.js 16.9+, modern browsers with WebAssembly.SIMD, Deno 1.30+, Cloudflare Workers with wasm_simd feature)","npm or compatible package manager for dependency installation","Node.js 10.5+ (Worker Threads API) or modern browser with Web Workers support","Sufficient available memory for N worker instances × model size","Deno 1.0+ for Deno worker support","ONNX model file in opset 12+ format (compatible with sentence-transformers library)","WASM runtime with sufficient memory allocation","Optional: quantization tools (e.g., ONNX quantization scripts) for model compression","Tokenizer vocabulary file (JSON format with token → ID mapping)"],"failure_modes":["WASM module size typically 50-200MB for full sentence-transformer models, requiring lazy-loading or model quantization for browser deployment","SIMD performance gains plateau on CPU-bound operations; GPU acceleration unavailable in WASM (no WebGPU support in this implementation)","Model inference latency 2-5x slower than native Python/CUDA implementations due to WASM runtime overhead","Limited to models convertible to ONNX format; some transformer architectures require custom operator implementations","Worker thread creation overhead (~10-50ms per worker) amortized only for batches >100 embeddings; small batches may be slower than single-threaded execution","Memory overhead: each worker maintains full model copy in WASM memory, requiring N × model_size RAM for N workers (e.g., 8 workers × 100MB model = 800MB)","Message passing serialization adds ~1-5ms latency per batch due to structured clone overhead for large embedding arrays","Browser Web Worker support limited by same-origin policy and CORS; Cloudflare Workers do not support Worker Threads API","ONNX model parsing adds 100-500ms startup latency depending on model complexity and file I/O speed","Quantized models (int8) lose ~1-3% embedding quality (cosine similarity) compared to full precision, measurable in downstream semantic search tasks","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.27075190796237436,"quality":0.45,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.6,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:23.902Z","last_scraped_at":"2026-04-22T08:08:13.653Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":25497,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=ruvector-onnx-embeddings-wasm","compare_url":"https://unfragile.ai/compare?artifact=ruvector-onnx-embeddings-wasm"}},"signature":"Ji+c0h4vBEPRT3VnZjFh7PmxhqV9TezZL5nPXlw7dPuhQdM3rc672z92fs3d2G8+CJKYI1CMQ0ocm8YNjDgtAA==","signedAt":"2026-06-20T07:08:24.589Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/ruvector-onnx-embeddings-wasm","artifact":"https://unfragile.ai/ruvector-onnx-embeddings-wasm","verify":"https://unfragile.ai/api/v1/verify?slug=ruvector-onnx-embeddings-wasm","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}