usearch 2.26.3 → 2.26.5

package/README.md

@@ -525,20 +525,39 @@ index = Index(ndim=ndim, metric=CompiledMetric(
 
 ## Integrations & Users
 
+### Databases & Query Engines
+
 - [x] ClickHouse: [C++](https://github.com/ClickHouse/ClickHouse/pull/53447), [docs](https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/annindexes#usearch).
 - [x] DuckDB: [post](https://duckdb.org/2024/05/03/vector-similarity-search-vss.html).
 - [x] ScyllaDB: [Rust](https://github.com/scylladb/vector-store), [presentation](https://www.slideshare.net/slideshow/vector-search-with-scylladb-by-szymon-wasik/276571548).
 - [x] TiDB & TiFlash: [C++](https://github.com/pingcap/tiflash), [announcement](https://www.pingcap.com/article/introduce-vector-search-indexes-in-tidb/).
-- [x] YugaByte: [C++](https://github.com/yugabyte/yugabyte-db/blob/366b9f5e3c4df3a1a17d553db41d6dc50146f488/src/yb/vector_index/usearch_wrapper.cc).
+- [x] YugaByte: [C++](https://github.com/yugabyte/yugabyte-db/blob/366b9f5e3c4df3a1a17d553db41d6dc50146f488/src/yb/vector_index/usearch_wrapper.cc), [architecture](https://www.yugabyte.com/blog/yugabytedb-vector-indexing-architecture/), [1B-vector benchmark](https://www.yugabyte.com/blog/benchmarking-1-billion-vectors-in-yugabytedb/).
 - [x] MemGraph: [C++](https://github.com/memgraph/memgraph/blob/784dd8520f65050d033aea8b29446e84e487d091/src/storage/v2/indices/vector_index.cpp), [announcement](https://memgraph.com/blog/simplify-data-retrieval-memgraph-vector-search).
-- [x] Google: [UniSim](https://github.com/google/unisim), [RetSim](https://arxiv.org/abs/2311.17264) paper.
-- [x] LangChain: [Python](https://github.com/langchain-ai/langchain/releases/tag/v0.0.257) and [JavaScript](https://github.com/hwchase17/langchainjs/releases/tag/0.0.125).
-- [x] Microsoft Semantic Kernel: [Python](https://github.com/microsoft/semantic-kernel/releases/tag/python-0.3.9.dev) and C#.
+- [x] MatrixOne: [GoLang](https://github.com/matrixorigin/matrixone).
+- [x] GreptimeDB: [Rust](https://github.com/GreptimeTeam/greptimedb/blob/main/src/index/src/vector.rs).
+- [x] KurrentDB: [C#](https://github.com/kurrent-io/KurrentDB/blob/master/src/KurrentDB.Kontext/Indexing/USearch/USearchVectorStore.cs), [credits](https://github.com/kurrent-io/KurrentDB/blob/master/NOTICE.md).
+- [x] Chroma: [Rust](https://github.com/chroma-core/chroma/blob/main/rust/index/src/usearch.rs), behind their RaBitQ-quantized SPANN index.
+
+### AI Frameworks & Memory
+
+- [x] Google: [Perch](https://github.com/google-research/perch-hoplite) bioacoustics DB, [UniSim](https://github.com/google/unisim), [RetSim](https://arxiv.org/abs/2311.17264) paper.
+- [x] Microsoft: [Semantic Kernel](https://github.com/microsoft/semantic-kernel/releases/tag/python-0.3.9.dev) and [vcpkg](https://github.com/microsoft/vcpkg/tree/master/ports/usearch).
+- [x] LangChain: [Python](https://github.com/langchain-ai/langchain/releases/tag/v0.0.257) and [JavaScript](https://github.com/langchain-ai/langchainjs/releases/tag/0.0.125).
+- [x] Hugging Face: Sentence-Transformers [docs](https://www.sbert.net/docs/package_reference/quantization.html#sentence_transformers.quantization.semantic_search_usearch), [quantization benchmarks](https://huggingface.co/blog/embedding-quantization).
 - [x] GPTCache: [Python](https://github.com/zilliztech/GPTCache/releases/tag/0.1.29).
-- [x] Sentence-Transformers: Python [docs](https://www.sbert.net/docs/package_reference/quantization.html#sentence_transformers.quantization.semantic_search_usearch).
+- [x] MemMachine: [Python](https://github.com/MemMachine/MemMachine/blob/main/packages/server/src/memmachine_server/common/vector_store/vector_search_engine/usearch_engine.py).
 - [x] Pathway: [Rust](https://github.com/pathwaycom/pathway).
 - [x] Vald: [GoLang](https://github.com/vdaas/vald).
-- [x] MatrixOne: [GoLang](https://github.com/matrixorigin/matrixone).
+
+### Applications & Products
+
+- [x] Arm MCP: [Python](https://github.com/arm/mcp/blob/main/arm_kb_search/loaders.py).
+- [x] GPT4All: [C++](https://github.com/nomic-ai/gpt4all/blob/main/gpt4all-chat/src/database.cpp).
+- [x] Ente: [Rust](https://github.com/ente-io/ente/blob/main/rust/crates/photos/src/ml/vector_db.rs), [post](https://ente.com/blog/vector-db/).
+- [x] Tracy profiler: [C++](https://github.com/wolfpld/tracy/blob/master/profiler/src/profiler/TracyLlmEmbeddings.cpp), behind the embeddings index of its LLM assistant.
+- [x] Copilot for Xcode by Intitni: [Swift](https://github.com/intitni/CopilotForXcode/blob/main/Tool/Sources/USearchIndex/UsearchIndex.swift).
+- [x] LLM for Unity: [C#](https://github.com/undreamai/LLMUnity/tree/main/Runtime/RAG/usearch), [docs](https://undream.ai/LLMUnity/).
+- [x] Music Assistant: [Python](https://github.com/music-assistant/server/blob/dev/music_assistant/providers/sonic_similarity/vectors.py), [docs](https://www.music-assistant.io/plugins/sonic-similarity/).
   
 
 ## Citations
@@ -549,7 +568,7 @@ doi = {10.5281/zenodo.7949415},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/USearch},
-version = {2.26.3},
+version = {2.26.5},
 year = {2026},
 }
 ```

package/c/CMakeLists.txt

@@ -30,4 +30,13 @@ if (USEARCH_BUILD_LIB_C)
     setup_target(usearch_c)
     setup_target(usearch_static_c)
 
+    if (USEARCH_INSTALL)
+        install(TARGETS usearch_c usearch_static_c
+                LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+                ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+                RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+        install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/usearch.h
+                DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+    endif ()
+
 endif ()

package/c/README.md

@@ -19,7 +19,7 @@ int main() {
     usearch_error_t error = NULL;
     usearch_init_options_t opts = {
         .metric_kind = usearch_metric_cos_k,
-        .scalar_kind = usearch_scalar_f16_k, // or f32_k, bf16_k, e5m2_k, e4m3_k, e3m2_k, e2m3_k, i8_k, u8_k
+        .quantization = usearch_scalar_f16_k, // or f32_k, bf16_k, e5m2_k, e4m3_k, e3m2_k, e2m3_k, i8_k, u8_k, b1_k
         .dimensions = dimensions,
         .expansion_add = 0, // for defaults
         .expansion_search = 0 // for defaults

package/cmake/pkg-config.pc.in

@@ -1,4 +1,7 @@
-Name: ${PROJECT_NAME}
+prefix=@CMAKE_INSTALL_PREFIX@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: @PROJECT_NAME@
 Description: Smaller & Faster Single-File Vector Search Engine from Unum
-Version: ${PROJECT_VERSION}
-Cflags: -I${CMAKE_INSTALL_FULL_INCLUDEDIR}
+Version: @PROJECT_VERSION@
+Cflags: -I${includedir}

package/cpp/test.cpp

@@ -1319,6 +1319,51 @@ void test_isolate() {
     }
 }
 
+/**
+ *  @brief  Regression test: `compact()` permutes the slots of all members, so the
+ *          key-to-slot lookup and the free-slot list must follow the permutation.
+ *          Otherwise `get` returns other members' vectors and later `add` calls
+ *          overwrite live members.
+ */
+void test_compact() {
+    constexpr std::size_t dataset_count = 256;
+    constexpr std::size_t added_count = 64;
+    constexpr std::size_t dimensions = 16;
+    metric_punned_t metric(dimensions, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);
+
+    std::mt19937 generator(42);
+    std::uniform_real_distribution<float> distribution(0.0, 1.0);
+    std::vector<std::vector<float>> vectors(dataset_count + added_count, std::vector<float>(dimensions));
+    for (auto& vector : vectors)
+        std::generate(vector.begin(), vector.end(), [&] { return distribution(generator); });
+
+    index_dense_t index = index_dense_t::make(metric);
+    index.reserve(dataset_count + added_count);
+    for (std::size_t idx = 0; idx < dataset_count; ++idx)
+        expect(index.add(idx, vectors[idx].data()));
+    for (std::size_t idx = 0; idx < dataset_count; idx += 3)
+        expect(index.remove(idx));
+    std::size_t const removed_count = (dataset_count + 2) / 3;
+
+    expect(index.compact());
+    expect_eq(index.size(), dataset_count - removed_count);
+
+    // Freed slots must be reused without clobbering live members
+    for (std::size_t idx = dataset_count; idx < dataset_count + added_count; ++idx)
+        expect(index.add(idx, vectors[idx].data()));
+    expect_eq(index.size(), dataset_count - removed_count + added_count);
+
+    std::vector<float> reconstructed(dimensions);
+    for (std::size_t idx = 0; idx < dataset_count + added_count; ++idx) {
+        bool const removed = idx < dataset_count && idx % 3 == 0;
+        expect_eq(index.contains(idx), !removed);
+        if (removed)
+            continue;
+        expect_eq(index.get(idx, reconstructed.data()), std::size_t(1));
+        expect(std::equal(reconstructed.begin(), reconstructed.end(), vectors[idx].begin()));
+    }
+}
+
 static void usearch_write_backtrace(int signal_number) {
     std::fprintf(stderr, "\n[usearch] Fatal signal %d. Back-trace:\n", signal_number);
 #if USEARCH_HAS_STD_STACKTRACE
@@ -1489,6 +1534,36 @@ void test_view_of_truncated_file() {
     std::remove(path);
 }
 
+/**
+ *  @brief  Regression test: every thread context must draw node levels of its own. Default-seeded, all
+ *          contexts drew the same levels and started over after every `reserve`, so every per-level node
+ *          count was a multiple of `contexts * steps`, the upper levels too full and the top ones missing.
+ */
+void test_level_generators() {
+    constexpr std::size_t contexts = 16, steps = 16, per_context_step = 64, dimensions = 2;
+    metric_punned_t metric(dimensions, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);
+    index_dense_t index = index_dense_t::make(metric);
+
+    std::mt19937 generator(42);
+    std::uniform_real_distribution<float> distribution(0.0, 1.0);
+
+    std::size_t key = 0;
+    for (std::size_t step = 0; step != steps; ++step) {
+        expect(index.try_reserve(index_limits_t((step + 1) * contexts * per_context_step, contexts)));
+        for (std::size_t idx = 0; idx != contexts * per_context_step; ++idx, ++key) {
+            float vector[dimensions] = {distribution(generator), distribution(generator)};
+            expect(index.add(key, vector, idx % contexts));
+        }
+    }
+    expect_eq(index.size(), contexts * steps * per_context_step);
+
+    // Independent draws put about 1024 nodes on level 1 and 64 on level 2: almost never multiples of 256.
+    bool all_multiples = true;
+    for (std::size_t level = 1; level <= index.max_level(); ++level)
+        all_multiples = all_multiples && index.stats(level).nodes % (contexts * steps) == 0;
+    expect(!all_multiples);
+}
+
 int main(int, char**) {
     install_crash_handlers();
 
@@ -1584,7 +1659,9 @@ int main(int, char**) {
 
     test_filtered_search();
     test_isolate();
+    test_compact();
     test_load_after_metric_make();
     test_view_of_truncated_file();
+    test_level_generators();
     return 0;
 }

package/include/usearch/index.hpp

@@ -9,7 +9,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 26
-#define USEARCH_VERSION_PATCH 3
+#define USEARCH_VERSION_PATCH 5
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074
@@ -96,7 +96,7 @@
 #include <cstring>   // `std::memset`
 #include <iterator>  // `std::reverse_iterator`
 #include <mutex>     // `std::unique_lock` - replacement candidate
-#include <random>    // `std::default_random_engine` - replacement candidate
+#include <random>    // `std::uniform_real_distribution`
 #include <stdexcept> // `std::runtime_exception`
 #include <thread>    // `std::thread`
 #include <utility>   // `std::pair`
@@ -1277,6 +1277,29 @@ template <typename element_at> struct hash_gt {
     std::size_t operator()(element_at const& element) const noexcept { return std::hash<element_at>{}(element); }
 };
 
+/**
+ *  @brief Eight-byte, non-cryptographic uniform random bit generator for STL distributions.
+ *  @see https://prng.di.unimi.it/splitmix64.c (public-domain reference implementation).
+ *  @details Every seed is valid, including zero. Generation and skipping use unsigned wraparound.
+ */
+class splitmix64_t {
+    std::uint64_t state_;
+
+  public:
+    using result_type = std::uint64_t;
+    static result_type mix_uint64(result_type x) noexcept {
+        x = (x ^ (x >> 30u)) * 0xBF58476D1CE4E5B9ULL;
+        x = (x ^ (x >> 27u)) * 0x94D049BB133111EBULL;
+        return x ^ (x >> 31u);
+    }
+    constexpr explicit splitmix64_t(result_type value = 0) noexcept : state_(value) {}
+    static constexpr result_type(min)() noexcept { return 0; }
+    static constexpr result_type(max)() noexcept { return (std::numeric_limits<result_type>::max)(); }
+    void seed(result_type value = 0) noexcept { state_ = value; }
+    result_type operator()() noexcept { return mix_uint64(state_ += 0x9E3779B97F4A7C15ULL); }
+    void discard(unsigned long long count) noexcept { state_ += result_type(count) * 0x9E3779B97F4A7C15ULL; }
+};
+
 /**
  *  @brief  SplitMix64 finalizer, used to scatter integer keys before masking.
  *
@@ -1289,10 +1312,7 @@ template <typename element_at> struct hash_gt {
  */
 template <> struct hash_gt<std::uint64_t> {
     std::size_t operator()(std::uint64_t const& element) const noexcept {
-        std::uint64_t x = element;
-        x = (x ^ (x >> 30u)) * 0xBF58476D1CE4E5B9ULL;
-        x = (x ^ (x >> 27u)) * 0x94D049BB133111EBULL;
-        return static_cast<std::size_t>(x ^ (x >> 31u));
+        return static_cast<std::size_t>(splitmix64_t::mix_uint64(element));
     }
 };
 
@@ -2489,7 +2509,7 @@ class index_gt {
         top_candidates_t top_for_refine{};
         next_candidates_t next_candidates{};
         visits_hash_set_t visits{};
-        std::default_random_engine level_generator{};
+        splitmix64_t level_generator{};
         std::size_t iteration_cycles{};
         std::size_t computed_distances{};
         std::size_t computed_distances_in_refines{};
@@ -2687,6 +2707,10 @@ class index_gt {
         if (!other.reserve(limits_))
             return result.failed("Failed to reserve the contexts");
 
+        // A copy must continue the same node-level streams as the original.
+        for (std::size_t i = 0; i != contexts_.size(); ++i)
+            other.contexts_[i].level_generator = contexts_[i].level_generator;
+
         // Now all is left - is to allocate new `node_t` instances and populate
         // the `other.nodes_` array into it.
         for (std::size_t i = 0; i != nodes_count_; ++i)
@@ -2892,10 +2916,15 @@ class index_gt {
 
     /**
      *  @brief  Increases the `capacity()` of the index to allow adding more vectors.
+     *  @note Thread reservations never shrink; `reset()` releases all contexts.
      *  @return `true` on success, `false` on memory allocation errors.
      */
     bool try_reserve(index_limits_t limits) usearch_noexcept_m {
 
+        // Keep previously allocated contexts, including streams for temporarily unused threads.
+        limits.threads_add = (std::max)(limits.threads_add, limits_.threads_add);
+        limits.threads_search = (std::max)(limits.threads_search, limits_.threads_search);
+
         if (limits.threads_add <= limits_.threads_add          //
             && limits.threads_search <= limits_.threads_search //
             && limits.members <= limits_.members)
@@ -2918,10 +2947,19 @@ class index_gt {
         // Move the nodes info, and deallocate previous buffers.
         if (nodes_)
             std::memcpy(new_nodes.data(), nodes_.data(), sizeof(node_t) * size());
-        for (std::size_t i = 0; i != new_contexts.size(); ++i)
+        for (std::size_t i = 0; i != new_contexts.size(); ++i) {
             if (!new_contexts[i].top_for_refine.reserve(connectivity_max + 1))
                 return false;
 
+            // Copy rather than advance the old stream, so a failed reserve leaves it unchanged.
+            if (i < contexts_.size())
+                new_contexts[i].level_generator = contexts_[i].level_generator;
+            else {
+                // Mix logical thread slots instead of using adjacent seeds (or an OS thread ID).
+                new_contexts[i].level_generator.seed(splitmix64_t::mix_uint64(static_cast<std::uint64_t>(i) + 1));
+            }
+        }
+
         limits_ = limits;
         nodes_capacity_ = limits.members;
         nodes_ = std::move(new_nodes);
@@ -3211,11 +3249,13 @@ class index_gt {
         if (!next.reserve(config.expansion))
             return result.failed("Out of memory!");
 
+        // Each caller exclusively owns its context; sampling needs no shared graph lock.
+        level_t new_target_level = choose_random_level_(context.level_generator);
+
         // Determining how much memory to allocate for the node depends on the target level
         std::unique_lock<std::mutex> new_level_lock(global_mutex_);
         level_t max_level_copy = max_level_;                                             // Copy under lock
         compressed_slot_t entry_slot_copy = static_cast<compressed_slot_t>(entry_slot_); // Copy under lock
-        level_t new_target_level = choose_random_level_(context.level_generator);
 
         // Make sure we are not overflowing
         std::size_t capacity = nodes_capacity_.load();
@@ -4366,10 +4406,11 @@ class index_gt {
         }
     }
 
-    level_t choose_random_level_(std::default_random_engine& level_generator) const noexcept {
+    level_t choose_random_level_(splitmix64_t& level_generator) const noexcept {
         std::uniform_real_distribution<double> distribution(0.0, 1.0);
-        double r = -std::log(distribution(level_generator)) * pre_.inverse_log_connectivity;
-        return (level_t)r;
+        // Reflect into (0, 1] and guard against a rounded upper endpoint from the STL.
+        double uniform = (std::max)(1.0 - distribution(level_generator), (std::numeric_limits<double>::min)());
+        return static_cast<level_t>(-std::log(uniform) * pre_.inverse_log_connectivity);
     }
 
     struct candidates_range_t;

package/include/usearch/index_dense.hpp

@@ -1053,6 +1053,9 @@ class index_dense_gt {
         // Reserving is monotonic: reducing thread limits must not shrink member-addressed storage.
         limits.members = (std::max)(limits.members, typed_->capacity());
         limits.members = (std::max)(limits.members, vectors_lookup_.size());
+        // Match the core's retained contexts so cast buffers and available thread IDs stay consistent.
+        limits.threads_add = (std::max)(limits.threads_add, typed_->limits().threads_add);
+        limits.threads_search = (std::max)(limits.threads_search, typed_->limits().threads_search);
 
         // The slot lookup system will generally prefer power-of-two sizes.
         if (config_.enable_key_lookups) {
@@ -1923,6 +1926,9 @@ class index_dense_gt {
                         std::forward<executor_at>(executor), std::forward<progress_at>(progress));
         vectors_lookup_ = std::move(new_vectors_lookup);
         vectors_tape_allocator_ = std::move(new_vectors_allocator);
+
+        // Slots were permuted, so the key-to-slot lookup and the free-slot list are stale
+        reindex_keys_();
         return result;
     }
 

package/include/usearch/index_plugins.hpp

@@ -3,10 +3,11 @@
 #include <float.h>  // `_Float16`
 #include <stdlib.h> // `aligned_alloc`
 
-#include <atomic>  // `std::atomic`
-#include <chrono>  // `std::chrono`
-#include <cstring> // `std::strncmp`
-#include <thread>  // `std::thread`
+#include <atomic>      // `std::atomic`
+#include <chrono>      // `std::chrono`
+#include <cstring>     // `std::strncmp`
+#include <thread>      // `std::thread`
+#include <type_traits> // `std::is_floating_point`
 
 #include <usearch/index.hpp> // `expected_gt` and macros
 
@@ -374,10 +375,10 @@ inline expected_gt<scalar_kind_t> scalar_kind_from_name(char const* name, std::s
         parsed.result = scalar_kind_t::i8_k;
     else if (str_equals(name, len, "u8"))
         parsed.result = scalar_kind_t::u8_k;
-    else if (str_equals(name, len, "b1"))
+    else if (str_equals(name, len, "b1") || str_equals(name, len, "b1x8"))
         parsed.result = scalar_kind_t::b1x8_k;
     else
-        parsed.failed("Unknown type, choose: f64, f32, bf16, f16, e5m2, e4m3, e3m2, e2m3, i8, u8, b1");
+        parsed.failed("Unknown type, choose: f64, f32, bf16, f16, e5m2, e4m3, e3m2, e2m3, i8, u8, b1, b1x8");
     return parsed;
 }
 
@@ -525,8 +526,10 @@ inline std::uint16_t f32_to_f16(float f32) noexcept {
  */
 inline float bf16_to_f32(std::uint16_t u16) noexcept {
 #if USEARCH_USE_NUMKONG
+    nk_bf16_t bits;
+    std::memcpy(&bits, &u16, sizeof(bits));
     nk_f32_t result;
-    nk_bf16_to_f32_serial((nk_bf16_t const*)&u16, &result);
+    nk_bf16_to_f32_serial(&bits, &result);
     return result;
 #else
     union float_or_unsigned_int_t {
@@ -2280,8 +2283,23 @@ template <typename scalar_at = float, typename result_at = scalar_at> struct met
 
     inline result_t operator()(scalar_t const* a, scalar_t const* b, std::size_t dim) const noexcept {
         result_t ab{}, a2{}, b2{};
+        // OpenMP only accepts `x += expr` as a reduction update, not a comma-expression.
+        // With a function-call cast, GCC leaves `a2` and `b2` at zero and every distance becomes 0.
+        add_products_(a, b, dim, ab, a2, b2, std::is_floating_point<scalar_t>());
+
+        result_t result_if_zero[2][2];
+        result_if_zero[0][0] = 1 - ab / (std::sqrt(a2) * std::sqrt(b2));
+        result_if_zero[0][1] = result_if_zero[1][0] = 1;
+        result_if_zero[1][1] = 0;
+        return result_if_zero[a2 == 0][b2 == 0];
+    }
+
+  private:
+    inline void add_products_(scalar_t const* a, scalar_t const* b, std::size_t dim, result_t& ab, result_t& a2,
+                              result_t& b2, std::true_type) const noexcept {
+        result_t product{}, first_squared{}, second_squared{};
 #if USEARCH_USE_OPENMP
-#pragma omp simd reduction(+ : ab, a2, b2)
+#pragma omp simd reduction(+ : product, first_squared, second_squared)
 #elif defined(USEARCH_DEFINED_CLANG)
 #pragma clang loop vectorize(enable)
 #elif defined(USEARCH_DEFINED_GCC)
@@ -2290,14 +2308,24 @@ template <typename scalar_at = float, typename result_at = scalar_at> struct met
         for (std::size_t i = 0; i != dim; ++i) {
             result_t ai = static_cast<result_t>(a[i]);
             result_t bi = static_cast<result_t>(b[i]);
-            ab += ai * bi, a2 += square(ai), b2 += square(bi);
+            product += ai * bi;
+            first_squared += square(ai);
+            second_squared += square(bi);
         }
+        ab = product;
+        a2 = first_squared;
+        b2 = second_squared;
+    }
 
-        result_t result_if_zero[2][2];
-        result_if_zero[0][0] = 1 - ab / (std::sqrt(a2) * std::sqrt(b2));
-        result_if_zero[0][1] = result_if_zero[1][0] = 1;
-        result_if_zero[1][1] = 0;
-        return result_if_zero[a2 == 0][b2 == 0];
+    inline void add_products_(scalar_t const* a, scalar_t const* b, std::size_t dim, result_t& ab, result_t& a2,
+                              result_t& b2, std::false_type) const noexcept {
+        for (std::size_t i = 0; i != dim; ++i) {
+            result_t ai = static_cast<result_t>(a[i]);
+            result_t bi = static_cast<result_t>(b[i]);
+            ab += ai * bi;
+            a2 += square(ai);
+            b2 += square(bi);
+        }
     }
 };
 
@@ -2544,9 +2572,14 @@ struct metric_cos_i8_t {
             a2 += square(ai);
             b2 += square(bi);
         }
-        result_t a2f = std::sqrt(static_cast<result_t>(a2));
-        result_t b2f = std::sqrt(static_cast<result_t>(b2));
-        return (ab != 0) ? (1.f - ab / (a2f * b2f)) : 0;
+        // Same tail as `nk_angular_i8_serial`: a zero dot product is orthogonal, not identical.
+        if (a2 == 0 && b2 == 0)
+            return 0;
+        if (ab == 0)
+            return 1;
+        result_t norms = std::sqrt(static_cast<result_t>(a2)) * std::sqrt(static_cast<result_t>(b2));
+        result_t unclipped = 1 - static_cast<result_t>(ab) / norms;
+        return unclipped < 0 ? 0 : unclipped;
     }
 };
 
@@ -2596,9 +2629,14 @@ struct metric_cos_u8_t {
             a2 += square(ai);
             b2 += square(bi);
         }
-        result_t a2f = std::sqrt(static_cast<result_t>(a2));
-        result_t b2f = std::sqrt(static_cast<result_t>(b2));
-        return (ab != 0) ? (1.f - ab / (a2f * b2f)) : 0;
+        // Same tail as `nk_angular_u8_serial`: a zero dot product is orthogonal, not identical.
+        if (a2 == 0 && b2 == 0)
+            return 0;
+        if (ab == 0)
+            return 1;
+        result_t norms = std::sqrt(static_cast<result_t>(a2)) * std::sqrt(static_cast<result_t>(b2));
+        result_t unclipped = 1 - static_cast<result_t>(ab) / norms;
+        return unclipped < 0 ? 0 : unclipped;
     }
 };
 

package/javascript/README.md

@@ -1,6 +1,7 @@
 # USearch for JavaScript
 
-USearch is a high-performance library for building and querying vector search indexes, optimized for Node.js and WASM environments.
+USearch is a high-performance library for building and querying vector search indexes.
+This page is the Node.js addon. The browser build is the C library compiled with Emscripten, documented in `wasm/README.md`.
 
 ## Installation
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.26.3",
+    "version": "2.26.5",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",