usearch 0.19.2 → 0.20.0

package/include/usearch/index.hpp

@@ -48,8 +48,11 @@
 // OS-specific includes
 #if defined(USEARCH_DEFINED_WINDOWS)
 #define _USE_MATH_DEFINES
+#define NOMINMAX
 #include <Windows.h>
 #include <sys/stat.h> // `fstat` for file size
+#undef NOMINMAX
+#undef _USE_MATH_DEFINES
 #else
 #include <fcntl.h>    // `fallocate`
 #include <stdlib.h>   // `posix_memalign`
@@ -159,6 +162,10 @@ template <std::size_t multiple_ak> std::size_t divide_round_up(std::size_t num)
     return (num + multiple_ak - 1) / multiple_ak;
 }
 
+inline std::size_t divide_round_up(std::size_t num, std::size_t denominator) noexcept {
+    return (num + denominator - 1) / denominator;
+}
+
 inline std::size_t ceil2(std::size_t v) noexcept {
     v--;
     v |= v >> 1;
@@ -171,12 +178,16 @@ inline std::size_t ceil2(std::size_t v) noexcept {
     return v;
 }
 
-template <typename at> void misaligned_store(void* ptr, at v) noexcept { std::memcpy(ptr, &v, sizeof(v)); }
+template <typename at> void misaligned_store(void* ptr, at v) noexcept {
+    static_assert(!std::is_reference<at>::value);
+    std::memcpy(ptr, &v, sizeof(at));
+}
 
 /// @brief  Simply dereferencing misaligned pointers can be dangerous.
 template <typename at> at misaligned_load(void* ptr) noexcept {
+    static_assert(!std::is_reference<at>::value);
     at v;
-    std::memcpy(&v, ptr, sizeof(v));
+    std::memcpy(&v, ptr, sizeof(at));
     return v;
 }
 
@@ -637,7 +648,9 @@ template <typename allocator_at = std::allocator<char>> class visits_bitset_gt {
 
     void reset() noexcept {
         if (slots_)
-            allocator_t{}.deallocate((byte_t*)slots_, count_ * sizeof(slot_t)), slots_ = nullptr, count_ = 0;
+            allocator_t{}.deallocate((byte_t*)slots_, count_ * sizeof(slot_t));
+        slots_ = nullptr;
+        count_ = 0;
     }
 
     bool resize(std::size_t capacity) noexcept {
@@ -658,10 +671,8 @@ template <typename allocator_at = std::allocator<char>> class visits_bitset_gt {
     }
 
     visits_bitset_gt(visits_bitset_gt&& other) noexcept {
-        slots_ = other.slots_;
-        count_ = other.count_;
-        other.slots_ = nullptr;
-        other.count_ = 0;
+        slots_ = exchange(other.slots_, nullptr);
+        count_ = exchange(other.count_, 0);
     }
 
     visits_bitset_gt& operator=(visits_bitset_gt&& other) noexcept {
@@ -670,6 +681,9 @@ template <typename allocator_at = std::allocator<char>> class visits_bitset_gt {
         return *this;
     }
 
+    visits_bitset_gt(visits_bitset_gt const&) = delete;
+    visits_bitset_gt& operator=(visits_bitset_gt const&) = delete;
+
     inline bool test(std::size_t i) const noexcept { return slots_[i / bits_per_slot()] & (1ul << (i & bits_mask())); }
     inline void set(std::size_t i) noexcept { slots_[i / bits_per_slot()] |= (1ul << (i & bits_mask())); }
 
@@ -908,17 +922,18 @@ class sorted_buffer_gt {
         if (!new_elements)
             return false;
 
-        if (size_) {
+        if (size_)
             std::memcpy(new_elements, elements_, size_ * sizeof(element_t));
+        if (elements_)
             allocator.deallocate(elements_, capacity_);
-        }
+
         elements_ = new_elements;
         capacity_ = new_capacity;
         return true;
     }
 
     inline void insert_reserved(element_t&& element) noexcept {
-        std::size_t slot = std::lower_bound(elements_, elements_ + size_, element, &less) - elements_;
+        std::size_t slot = size_ ? std::lower_bound(elements_, elements_ + size_, element, &less) - elements_ : 0;
         std::size_t to_move = size_ - slot;
         element_t* source = elements_ + size_ - 1;
         for (; to_move; --to_move, --source)
@@ -931,7 +946,7 @@ class sorted_buffer_gt {
      *  @return `true` if the entry was added, `false` if it wasn't relevant enough.
      */
     inline bool insert(element_t&& element, std::size_t limit) noexcept {
-        std::size_t slot = std::lower_bound(elements_, elements_ + size_, element, &less) - elements_;
+        std::size_t slot = size_ ? std::lower_bound(elements_, elements_ + size_, element, &less) - elements_ : 0;
         if (slot == limit)
             return false;
         std::size_t to_move = size_ - slot - (size_ == limit);
@@ -972,10 +987,10 @@ class usearch_pack_m uint40_t {
 
   public:
     inline uint40_t() noexcept { std::memset(octets, 0, 5); }
-    inline uint40_t(std::uint32_t n) noexcept { std::memcpy(octets + 1, (char*)&n, 4), octets[0] = 0; }
-    inline uint40_t(std::uint64_t n) noexcept { std::memcpy(octets, (char*)&n + 3, 5); }
+    inline uint40_t(std::uint32_t n) noexcept { std::memcpy(octets, (char*)&n, 4); }
+    inline uint40_t(std::uint64_t n) noexcept { std::memcpy(octets, (char*)&n, 5); }
 #if defined(USEARCH_DEFINED_CLANG) && defined(USEARCH_DEFINED_APPLE)
-    inline uint40_t(std::size_t n) noexcept { std::memcpy(octets, (char*)&n + 3, 5); }
+    inline uint40_t(std::size_t n) noexcept { std::memcpy(octets, (char*)&n, 5); }
 #endif
 
     uint40_t(uint40_t&&) = default;
@@ -983,24 +998,40 @@ class usearch_pack_m uint40_t {
     uint40_t& operator=(uint40_t&&) = default;
     uint40_t& operator=(uint40_t const&) = default;
 
-    inline uint40_t& operator+=(std::uint32_t i) noexcept {
-        std::uint32_t& tail = *reinterpret_cast<std::uint32_t*>(octets + 1);
-        octets[0] += static_cast<unsigned char>((tail + i) < tail);
-        tail += i;
+    inline uint40_t& operator+=(std::uint32_t n) noexcept {
+        std::uint32_t& tail = *reinterpret_cast<std::uint32_t*>(octets);
+        octets[4] += static_cast<unsigned char>((tail + n) < tail);
+        tail += n;
+        return *this;
+    }
+
+    inline uint40_t& operator+=(std::size_t n) noexcept {
+        unsigned char* n_octets = reinterpret_cast<unsigned char*>(&n);
+        std::uint32_t& n_tail = *reinterpret_cast<std::uint32_t*>(&n);
+        std::uint32_t& tail = *reinterpret_cast<std::uint32_t*>(octets);
+        octets[4] += static_cast<unsigned char>((tail + n_tail) < tail);
+        tail += n_tail;
+        octets[4] += n_octets[4];
         return *this;
     }
 
+    inline uint40_t operator+(std::size_t n) noexcept {
+        uint40_t other(*this);
+        other += n;
+        return other;
+    }
+
     inline operator std::size_t() const noexcept {
         std::size_t result = 0;
-        std::memcpy((char*)&result + 3, octets, 5);
+        std::memcpy((char*)&result, octets, 5);
         return result;
     }
 
-    inline uint40_t& operator++() noexcept { return *this += 1; }
+    inline uint40_t& operator++() noexcept { return *this += 1u; }
 
     inline uint40_t operator++(int) noexcept {
         uint40_t old = *this;
-        *this += 1;
+        *this += 1u;
         return old;
     }
 };
@@ -1305,6 +1336,7 @@ class index_gt {
     using id_t = id_at;
     using allocator_t = allocator_at;
     using point_allocator_t = point_allocator_at;
+    static_assert(sizeof(label_t) >= sizeof(id_t), "Having tiny labels doesn't make sense.");
 
     using scalar_t = typename metric_t::scalar_t;
     using vector_view_t = span_gt<scalar_t const>;
@@ -1313,11 +1345,13 @@ class index_gt {
     struct member_ref_t {
         misaligned_ref_gt<label_t> label;
         vector_view_t vector;
+        id_t id;
     };
 
     struct member_cref_t {
         label_t label;
         vector_view_t vector;
+        id_t id;
     };
 
     template <typename ref_at, typename index_at> class member_iterator_gt {
@@ -1337,7 +1371,11 @@ class index_gt {
         using pointer = void;
         using reference = ref_t;
 
-        reference operator*() const noexcept { return ref_t(index_->node_with_id_(offset_)); }
+        reference operator*() const noexcept {
+            node_t node = index_->node_with_id_(offset_);
+            return {node.label(), node.vector_view(), static_cast<id_t>(offset_)};
+        }
+
         member_iterator_gt operator++(int) noexcept { return member_iterator_gt(index_, offset_ + 1); }
         member_iterator_gt operator--(int) noexcept { return member_iterator_gt(index_, offset_ - 1); }
         member_iterator_gt operator+(difference_type d) noexcept { return member_iterator_gt(index_, offset_ + d); }
@@ -1449,9 +1487,9 @@ class index_gt {
         node_t(node_t const&) = default;
         node_t& operator=(node_t const&) = default;
 
-        label_t label() const noexcept { return misaligned_load<label_t>(tape_); }
-        dim_t dim() const noexcept { return misaligned_load<dim_t>(tape_ + sizeof(label_t)); }
-        level_t level() const noexcept { return misaligned_load<level_t>(tape_ + sizeof(label_t) + sizeof(dim_t)); }
+        misaligned_ref_gt<label_t> label() const noexcept { return {tape_}; }
+        misaligned_ref_gt<dim_t> dim() const noexcept { return {tape_ + sizeof(label_t)}; }
+        misaligned_ref_gt<level_t> level() const noexcept { return {tape_ + sizeof(label_t) + sizeof(dim_t)}; }
 
         void label(label_t v) noexcept { return misaligned_store<label_t>(tape_, v); }
         void dim(dim_t v) noexcept { return misaligned_store<dim_t>(tape_ + sizeof(label_t), v); }
@@ -1601,8 +1639,11 @@ class index_gt {
 
         if (nodes_)
             node_allocator_t{}.deallocate(exchange(nodes_, nullptr), limits_.elements);
-        if (contexts_)
+        if (contexts_) {
+            for (std::size_t i = 0; i != limits_.threads(); ++i)
+                contexts_[i].~context_t();
             context_allocator_t{}.deallocate(exchange(contexts_, nullptr), limits_.threads());
+        }
         limits_ = index_limits_t{0, 0};
         capacity_ = 0;
         reset_view_();
@@ -1726,7 +1767,7 @@ class index_gt {
     };
 
     struct match_t {
-        member_cref_t element;
+        member_cref_t member;
         distance_t distance;
     };
 
@@ -1759,14 +1800,23 @@ class index_gt {
 
         inline operator std::size_t() const noexcept { return count; }
         inline std::size_t size() const noexcept { return count; }
-        inline match_t operator[](std::size_t i) const noexcept {
+        inline match_t operator[](std::size_t i) const noexcept { return at(i); }
+        inline bool contains(label_t label) const noexcept {
+            for (std::size_t i = 0; i != count; ++i)
+                if (at(i).member.label == label)
+                    return true;
+            return false;
+        }
+        inline match_t at(std::size_t i) const noexcept {
             candidate_t const* top_ordered = top_.data();
-            return {member_cref_t(index_.node_with_id_(top_ordered[i].id)), top_ordered[i].distance};
+            candidate_t candidate = top_ordered[i];
+            node_t node = index_.node_with_id_(candidate.id);
+            return {member_cref_t{node.label(), node.vector_view(), candidate.id}, candidate.distance};
         }
         inline std::size_t dump_to(label_t* labels, distance_t* distances) const noexcept {
             for (std::size_t i = 0; i != count; ++i) {
                 match_t result = operator[](i);
-                labels[i] = result.element.label;
+                labels[i] = result.member.label;
                 distances[i] = result.distance;
             }
             return count;
@@ -1774,7 +1824,7 @@ class index_gt {
         inline std::size_t dump_to(label_t* labels) const noexcept {
             for (std::size_t i = 0; i != count; ++i) {
                 match_t result = operator[](i);
-                labels[i] = result.element.label;
+                labels[i] = result.member.label;
             }
             return count;
         }
@@ -1845,6 +1895,7 @@ class index_gt {
             // TODO: Handle out of memory conditions
             search_to_insert_(closest_id, vector, level, config.expansion, context);
             closest_id = connect_new_node_(new_id, level, context);
+            reconnect_neighbor_nodes_(new_id, level, context);
         }
 
         // Normalize stats
@@ -1859,15 +1910,23 @@ class index_gt {
         return result;
     }
 
+    struct dummy_predicate_t {
+        constexpr bool operator()(match_t const&) const noexcept { return true; }
+    };
+
     /**
      *  @brief Searches for the closest elements to the given ::query. Thread-safe.
      *
      *  @param[in] query Contiguous range of scalars forming a vector view.
      *  @param[in] wanted The upper bound for the number of results to return.
      *  @param[in] config Configuration options for this specific operation.
+     *  @param[in] predicate Optional filtering predicate for `member_cref_t`.
      *  @return Smart object referencing temporary memory. Valid until next `search()` or `add()`.
      */
-    search_result_t search(vector_view_t query, std::size_t wanted, search_config_t config = {}) const noexcept {
+    template <typename predicate_at = dummy_predicate_t>
+    search_result_t search( //
+        vector_view_t query, std::size_t wanted, search_config_t config = {},
+        predicate_at&& predicate = dummy_predicate_t{}) const noexcept {
 
         context_t& context = contexts_[config.thread];
         top_candidates_t& top = context.top_candidates;
@@ -1882,7 +1941,7 @@ class index_gt {
         if (config.exact) {
             if (!top.reserve(wanted))
                 return result.failed("Out of memory!");
-            search_exact_(query, wanted, context);
+            search_exact_(query, wanted, context, std::forward<predicate_at>(predicate));
         } else {
             next_candidates_t& next = context.next_candidates;
             std::size_t expansion = (std::max)(config.expansion, wanted);
@@ -1893,7 +1952,7 @@ class index_gt {
 
             id_t closest_id = search_for_one_(entry_id_, query, max_level_, 0, context);
             // For bottom layer we need a more optimized procedure
-            if (!search_to_find_in_base_(closest_id, query, expansion, context))
+            if (!search_to_find_in_base_(closest_id, query, expansion, context, std::forward<predicate_at>(predicate)))
                 return result.failed("Out of memory!");
         }
 
@@ -1907,9 +1966,10 @@ class index_gt {
         return result;
     }
 
+    template <typename predicate_at = dummy_predicate_t>
     search_result_t search_around(                          //
         id_t hint, vector_view_t query, std::size_t wanted, //
-        search_config_t config = {}) const noexcept {
+        search_config_t config = {}, predicate_at&& predicate = dummy_predicate_t{}) const noexcept {
 
         context_t& context = contexts_[config.thread];
         top_candidates_t& top = context.top_candidates;
@@ -1929,7 +1989,7 @@ class index_gt {
         result.measurements = context.measurements_count;
         result.cycles = context.iteration_cycles;
 
-        search_to_find_in_base_(hint, query, expansion, context);
+        search_to_find_in_base_(hint, query, expansion, context, std::forward<predicate_at>(predicate));
         top.sort_ascending();
         top.shrink(wanted);
 
@@ -1940,6 +2000,10 @@ class index_gt {
         return result;
     }
 
+#pragma endregion
+
+#pragma region Metadata
+
     struct stats_t {
         std::size_t nodes;
         std::size_t edges;
@@ -1954,7 +2018,7 @@ class index_gt {
             node_t node = node_with_id_(i);
             std::size_t max_edges = node.level() * config_.connectivity + base_level_multiple_() * config_.connectivity;
             std::size_t edges = 0;
-            for (level_t level = 0; level != node.level(); ++level)
+            for (level_t level = 0; level <= node.level(); ++level)
                 edges += neighbors_(node, level).size();
 
             result.allocated_bytes += node_bytes_(node);
@@ -2003,6 +2067,8 @@ class index_gt {
         return total;
     }
 
+    std::size_t memory_usage_per_node(dim_t dim, level_t level) const noexcept { return node_bytes_(dim, level); }
+
     void change_metric(metric_t const& m) noexcept {
         metric_ = m;
         for (std::size_t i = 0; i != limits_.threads(); ++i)
@@ -2281,7 +2347,6 @@ class index_gt {
             std::size_t node_vector_bytes = dim * sizeof(scalar_t);
             nodes_[i] = node_t{tape, (scalar_t*)(tape + node_bytes - node_vector_bytes)};
             progress += node_bytes;
-            max_level_ = (std::max)(max_level_, level);
         }
 
         return {};
@@ -2392,7 +2457,6 @@ class index_gt {
 
         node_t new_node = node_with_id_(new_id);
         top_candidates_t& top = context.top_candidates;
-        std::size_t const connectivity_max = level ? config_.connectivity : pre_.connectivity_max_base;
 
         // Outgoing links from `new_id`:
         neighbors_ref_t new_neighbors = neighbors_(new_node, level);
@@ -2407,7 +2471,17 @@ class index_gt {
             }
         }
 
+        return new_neighbors[0];
+    }
+
+    void reconnect_neighbor_nodes_(id_t new_id, level_t level, context_t& context) usearch_noexcept_m {
+
+        node_t new_node = node_with_id_(new_id);
+        top_candidates_t& top = context.top_candidates;
+        neighbors_ref_t new_neighbors = neighbors_(new_node, level);
+
         // Reverse links from the neighbors:
+        std::size_t const connectivity_max = level ? config_.connectivity : pre_.connectivity_max_base;
         for (id_t close_id : new_neighbors) {
             node_t close_node = node_with_id_(close_id);
             node_lock_t close_lock = node_lock_(close_id);
@@ -2437,8 +2511,6 @@ class index_gt {
             for (std::size_t idx = 0; idx != top_view.size(); idx++)
                 close_header.push_back(top_view[idx].id);
         }
-
-        return new_neighbors[0];
     }
 
     level_t choose_random_level_(std::default_random_engine& level_generator) const noexcept {
@@ -2534,8 +2606,10 @@ class index_gt {
      *          Doesn't lock any nodes, assuming read-only simultaneous access.
      *  @return `true` if procedure succeeded, `false` if run out of memory.
      */
+    template <typename predicate_at>
     bool search_to_find_in_base_( //
-        id_t start_id, vector_view_t query, std::size_t expansion, context_t& context) const noexcept {
+        id_t start_id, vector_view_t query, std::size_t expansion, context_t& context,
+        predicate_at&& predicate) const noexcept {
 
         visits_bitset_t& visits = context.visits;
         next_candidates_t& next = context.next_candidates; // pop min, push
@@ -2569,14 +2643,19 @@ class index_gt {
                     continue;
 
                 visits.set(successor_id);
-                distance_t successor_dist = context.measure(query, node_with_id_(successor_id));
+                node_t successor = node_with_id_(successor_id);
+                distance_t successor_dist = context.measure(query, successor);
 
                 if (top.size() < top_limit || successor_dist < radius) {
                     // This can substantially grow our priority queue:
                     next.insert({-successor_dist, successor_id});
-                    // This will automatically evict poor matches:
-                    top.insert({successor_dist, successor_id}, top_limit);
-                    radius = top.top().distance;
+                    if (predicate( //
+                            match_t{member_cref_t{successor.label(), successor.vector_view(), successor_id},
+                                    successor_dist})) {
+                        // This will automatically evict poor matches:
+                        top.insert({successor_dist, successor_id}, top_limit);
+                        radius = top.top().distance;
+                    }
                 }
             }
         }
@@ -2587,12 +2666,21 @@ class index_gt {
     /**
      *  @brief  Iterates through all managed vectors, without actually touching the index.
      */
-    void search_exact_(vector_view_t query, std::size_t count, context_t& context) const noexcept {
+    template <typename predicate_at>
+    void search_exact_(                                             //
+        vector_view_t query, std::size_t count, context_t& context, //
+        predicate_at&& predicate) const noexcept {
+
         top_candidates_t& top = context.top_candidates;
         top.clear();
         top.reserve(count);
-        for (std::size_t i = 0; i != size(); ++i)
-            top.insert({context.measure(query, node_with_id_(i)), static_cast<id_t>(i)}, count);
+        for (std::size_t i = 0; i != size(); ++i) {
+            id_t id = static_cast<id_t>(i);
+            node_t node = node_with_id_(i);
+            distance_t distance = context.measure(query, node);
+            if (predicate(match_t{member_cref_t{node.label(), node.vector_view(), id}, distance}))
+                top.insert(candidate_t{distance, id}, count);
+        }
     }
 
     void prefetch_neighbors_(neighbors_ref_t, visits_bitset_t const&) const noexcept {}

package/include/usearch/index_punned_dense.hpp

@@ -652,7 +652,7 @@ class index_punned_dense_gt {
     }
 };
 
-using punned_small_t = index_punned_dense_gt<std::int64_t, std::uint32_t>;
+using punned_small_t = index_punned_dense_gt<std::uint64_t, std::uint32_t>;
 using punned_big_t = index_punned_dense_gt<uuid_t, uint40_t>;
 
 } // namespace usearch

package/include/usearch/index_punned_helpers.hpp

@@ -295,6 +295,8 @@ class f8_bits_t {
     inline explicit operator std::int32_t() const noexcept { return int8_; }
     inline explicit operator std::int64_t() const noexcept { return int8_; }
 
+    inline f8_bits_t(f16_t v)
+        : int8_(usearch::clamp<std::int8_t>(static_cast<std::int8_t>(v * divisor_k), min_k, max_k)) {}
     inline f8_bits_t(float v)
         : int8_(usearch::clamp<std::int8_t>(static_cast<std::int8_t>(v * divisor_k), min_k, max_k)) {}
     inline f8_bits_t(double v)

package/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp

@@ -9,14 +9,16 @@
 using namespace unum::usearch;
 using namespace unum;
 
-using label_t = jint;
-using span_t = span_gt<float>;
+using metric_t = index_punned_dense_metric_t;
 using distance_t = punned_distance_t;
-using punned_t = index_punned_dense_gt<label_t>;
+using index_t = punned_small_t;
 
-using add_result_t = typename punned_t::add_result_t;
-using search_result_t = typename punned_t::search_result_t;
-using serialization_result_t = typename punned_t::serialization_result_t;
+using add_result_t = typename index_t::add_result_t;
+using search_result_t = typename index_t::search_result_t;
+using serialization_result_t = typename index_t::serialization_result_t;
+using label_t = typename index_t::label_t;
+using id_t = typename index_t::id_t;
+using vector_view_t = unum::usearch::span_gt<float>;
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
     JNIEnv* env, jclass,                                         //
@@ -41,14 +43,14 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
 
         scalar_kind_t accuracy = scalar_kind_from_name(accuracy_cstr, accuracy_length);
         metric_kind_t metric_kind = metric_from_name(metric_cstr, metric_length);
-        punned_t index = punned_t::make(static_cast<std::size_t>(dimensions), metric_kind, config, accuracy,
-                                        expansion_add, expansion_search);
+        index_t index = index_t::make( //
+            static_cast<std::size_t>(dimensions), metric_kind, config, accuracy, expansion_add, expansion_search);
         if (!index.reserve(static_cast<std::size_t>(capacity))) {
             jclass jc = (*env).FindClass("java/lang/Error");
             if (jc)
                 (*env).ThrowNew(jc, "Failed to reserve desired capacity!");
         } else {
-            punned_t* result_ptr = new punned_t(std::move(index));
+            index_t* result_ptr = new index_t(std::move(index));
             std::memcpy(&result, &result_ptr, sizeof(jlong));
         }
 
@@ -65,7 +67,7 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1save(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
     char const* path_cstr = (*env).GetStringUTFChars(path, 0);
-    if (!reinterpret_cast<punned_t*>(c_ptr)->save(path_cstr)) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->save(path_cstr)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to dump vector index to path!");
@@ -75,7 +77,7 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1save(JNIEnv* env, jclass
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1load(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
     char const* path_cstr = (*env).GetStringUTFChars(path, 0);
-    if (!reinterpret_cast<punned_t*>(c_ptr)->load(path_cstr)) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->load(path_cstr)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to load vector index from path!");
@@ -85,7 +87,7 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1load(JNIEnv* env, jclass
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1view(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
     char const* path_cstr = (*env).GetStringUTFChars(path, 0);
-    if (!reinterpret_cast<punned_t*>(c_ptr)->view(path_cstr)) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->view(path_cstr)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to view vector index from path!");
@@ -94,27 +96,27 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1view(JNIEnv* env, jclass
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1destroy(JNIEnv*, jclass, jlong c_ptr) {
-    delete reinterpret_cast<punned_t*>(c_ptr);
+    delete reinterpret_cast<index_t*>(c_ptr);
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1size(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<punned_t*>(c_ptr)->size();
+    return reinterpret_cast<index_t*>(c_ptr)->size();
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1connectivity(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<punned_t*>(c_ptr)->connectivity();
+    return reinterpret_cast<index_t*>(c_ptr)->connectivity();
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1dimensions(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<punned_t*>(c_ptr)->dimensions();
+    return reinterpret_cast<index_t*>(c_ptr)->dimensions();
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1capacity(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<punned_t*>(c_ptr)->capacity();
+    return reinterpret_cast<index_t*>(c_ptr)->capacity();
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1reserve(JNIEnv* env, jclass, jlong c_ptr, jlong capacity) {
-    if (!reinterpret_cast<punned_t*>(c_ptr)->reserve(static_cast<std::size_t>(capacity))) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->reserve(static_cast<std::size_t>(capacity))) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to grow vector index!");
@@ -126,9 +128,9 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add( //
 
     jfloat* vector_data = (*env).GetFloatArrayElements(vector, 0);
     jsize vector_dims = (*env).GetArrayLength(vector);
-    span_t vector_span = span_t{vector_data, static_cast<std::size_t>(vector_dims)};
+    vector_view_t vector_span = vector_view_t{vector_data, static_cast<std::size_t>(vector_dims)};
 
-    if (!reinterpret_cast<punned_t*>(c_ptr)->add(label, vector_span)) {
+    if (!reinterpret_cast<index_t*>(c_ptr)->add(static_cast<label_t>(label), vector_span)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to insert a new point in vector index!");
@@ -150,10 +152,10 @@ JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
 
     jfloat* vector_data = (*env).GetFloatArrayElements(vector, 0);
     jsize vector_dims = (*env).GetArrayLength(vector);
-    span_t vector_span = span_t{vector_data, static_cast<std::size_t>(vector_dims)};
-    search_result_t result = reinterpret_cast<punned_t*>(c_ptr)->search(vector_span, static_cast<std::size_t>(wanted));
+    vector_view_t vector_span = vector_view_t{vector_data, static_cast<std::size_t>(vector_dims)};
+    search_result_t result = reinterpret_cast<index_t*>(c_ptr)->search(vector_span, static_cast<std::size_t>(wanted));
     if (result) {
-        std::size_t found = result.dump_to(matches_data, NULL);
+        std::size_t found = result.dump_to(reinterpret_cast<label_t*>(matches_data), NULL);
         (*env).SetIntArrayRegion(matches, 0, found, matches_data);
     } else {
         jclass jc = (*env).FindClass("java/lang/Error");

package/javascript/lib.cpp

@@ -9,14 +9,9 @@
  *  @see NodeJS docs: https://nodejs.org/api/addons.html#hello-world
  *
  */
-
-#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
-#define _USE_MATH_DEFINES
-#define NAPI_CPP_EXCEPTIONS
-#endif
-
 #include <new> // `std::bad_alloc`
 
+#define NAPI_CPP_EXCEPTIONS
 #include <napi.h>
 #include <node_api.h>
 
@@ -25,9 +20,13 @@
 using namespace unum::usearch;
 using namespace unum;
 
-using label_t = std::uint32_t;
+using metric_t = index_punned_dense_metric_t;
 using distance_t = punned_distance_t;
-using punned_t = index_punned_dense_gt<label_t>;
+using index_t = punned_small_t;
+using add_result_t = typename index_t::add_result_t;
+using search_result_t = typename index_t::search_result_t;
+using label_t = typename index_t::label_t;
+using id_t = typename index_t::id_t;
 
 class Index : public Napi::ObjectWrap<Index> {
   public:
@@ -47,7 +46,7 @@ class Index : public Napi::ObjectWrap<Index> {
     void Add(Napi::CallbackInfo const& ctx);
     Napi::Value Search(Napi::CallbackInfo const& ctx);
 
-    std::unique_ptr<punned_t> native_;
+    std::unique_ptr<index_t> native_;
 };
 
 Napi::Object Index::Init(Napi::Env env, Napi::Object exports) {
@@ -124,7 +123,7 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
     }
 
     native_.reset(
-        new punned_t(punned_t::make(dimensions, metric_kind, config, accuracy, expansion_add, expansion_search)));
+        new index_t(index_t::make(dimensions, metric_kind, config, accuracy, expansion_add, expansion_search)));
     native_->reserve(limits);
 }
 
@@ -235,7 +234,7 @@ Napi::Value Index::Search(Napi::CallbackInfo const& ctx) {
         return {};
     }
 
-    Napi::Uint32Array matches_js = Napi::Uint32Array::New(env, wanted);
+    Napi::TypedArrayOf<label_t> matches_js = Napi::TypedArrayOf<label_t>::New(env, wanted);
     Napi::Float32Array distances_js = Napi::Float32Array::New(env, wanted);
     try {
         std::size_t count = native_->search(vector, wanted).dump_to(matches_js.Data(), distances_js.Data());