usearch 1.1.1 → 1.2.1

package/include/usearch/index_plugins.hpp

@@ -6,6 +6,9 @@
 #include <thread>  // `std::thread`
 #include <vector>  // `std::vector`
 
+#include <atomic> // `std::atomic`
+#include <thread> // `std::thread`
+
 #include <usearch/index.hpp> // `expected_gt` and macros
 
 #if USEARCH_USE_OPENMP
@@ -30,7 +33,6 @@
 #include <fp16/fp16.h>
 #endif
 #else
-#define USEARCH_USE_NATIVE_F16 0
 #include <fp16/fp16.h>
 #endif
 
@@ -196,6 +198,9 @@ inline char const* isa_name(isa_kind_t isa_kind) noexcept {
 }
 
 inline bool hardware_supports(isa_kind_t isa_kind) noexcept {
+
+    // On Linux Arm machines the `getauxval` can be queried to check
+    // if SVE extensions are available. Arm Neon has no separate capability check.
 #if defined(USEARCH_DEFINED_ARM) && defined(USEARCH_DEFINED_LINUX)
     unsigned long capabilities = getauxval(AT_HWCAP);
     switch (isa_kind) {
@@ -205,6 +210,8 @@ inline bool hardware_supports(isa_kind_t isa_kind) noexcept {
     }
 #endif
 
+    // When compiling with GCC, one may use the "built-ins", including ones
+    // designed for CPU capability detection.
 #if defined(USEARCH_DEFINED_X86) && defined(USEARCH_DEFINED_GCC)
     __builtin_cpu_init();
     switch (isa_kind) {
@@ -214,6 +221,19 @@ inline bool hardware_supports(isa_kind_t isa_kind) noexcept {
     }
 #endif
 
+    // On Apple we can expect Arm devices to support Neon extesions,
+    // and the x86 machines to support AVX2 extensions.
+#if defined(USEARCH_DEFINED_APPLE)
+    switch (isa_kind) {
+#if defined(USEARCH_DEFINED_ARM)
+    case isa_kind_t::neon_k: return true;
+#else
+    case isa_kind_t::avx2_k: return true;
+#endif
+    default: return false;
+    }
+#endif
+
     (void)isa_kind;
     return false;
 }
@@ -429,6 +449,20 @@ inline f16_bits_t::f16_bits_t(i8_bits_t v) noexcept : f16_bits_t(float(v)) {}
 class executor_stl_t {
     std::size_t threads_count_{};
 
+    struct jthread_t {
+        std::thread native_;
+
+        jthread_t() = default;
+        jthread_t(jthread_t&&) = default;
+        jthread_t(jthread_t const&) = delete;
+        template <typename callable_at> jthread_t(callable_at&& func) : native_([=]() { func(); }) {}
+
+        ~jthread_t() {
+            if (native_.joinable())
+                native_.join();
+        }
+    };
+
   public:
     /**
      *  @param threads_count The number of threads to be used for parallel execution.
@@ -442,18 +476,19 @@ class executor_stl_t {
     std::size_t size() const noexcept { return threads_count_; }
 
     /**
-     *  @brief Executes tasks in bulk using the specified thread-aware function.
+     *  @brief Executes a fixed number of tasks using the specified thread-aware function.
      *  @param tasks                 The total number of tasks to be executed.
      *  @param thread_aware_function The thread-aware function to be called for each thread index and task index.
      *  @throws If an exception occurs during execution of the thread-aware function.
      */
     template <typename thread_aware_function_at>
-    void execute_bulk(std::size_t tasks, thread_aware_function_at&& thread_aware_function) noexcept(false) {
-        std::vector<std::thread> threads_pool;
+    void fixed(std::size_t tasks, thread_aware_function_at&& thread_aware_function) noexcept(false) {
+        std::vector<jthread_t> threads_pool;
         std::size_t tasks_per_thread = tasks;
-        if (threads_count_ > 1) {
-            tasks_per_thread = (tasks / threads_count_) + ((tasks % threads_count_) != 0);
-            for (std::size_t thread_idx = 1; thread_idx < threads_count_; ++thread_idx) {
+        std::size_t threads_count = (std::min)(threads_count_, tasks);
+        if (threads_count > 1) {
+            tasks_per_thread = (tasks / threads_count) + ((tasks % threads_count) != 0);
+            for (std::size_t thread_idx = 1; thread_idx < threads_count; ++thread_idx) {
                 threads_pool.emplace_back([=]() {
                     for (std::size_t task_idx = thread_idx * tasks_per_thread;
                          task_idx < (std::min)(tasks, thread_idx * tasks_per_thread + tasks_per_thread); ++task_idx)
@@ -463,8 +498,37 @@ class executor_stl_t {
         }
         for (std::size_t task_idx = 0; task_idx < (std::min)(tasks, tasks_per_thread); ++task_idx)
             thread_aware_function(0, task_idx);
-        for (std::thread& thread : threads_pool)
-            thread.join();
+    }
+
+    /**
+     *  @brief Executes limited number of tasks using the specified thread-aware function.
+     *  @param tasks                 The upper bound on the number of tasks.
+     *  @param thread_aware_function The thread-aware function to be called for each thread index and task index.
+     *  @throws If an exception occurs during execution of the thread-aware function.
+     */
+    template <typename thread_aware_function_at>
+    void dynamic(std::size_t tasks, thread_aware_function_at&& thread_aware_function) noexcept(false) {
+        std::vector<jthread_t> threads_pool;
+        std::size_t tasks_per_thread = tasks;
+        std::size_t threads_count = (std::min)(threads_count_, tasks);
+        std::atomic_bool stop{false};
+        if (threads_count > 1) {
+            tasks_per_thread = (tasks / threads_count) + ((tasks % threads_count) != 0);
+            for (std::size_t thread_idx = 1; thread_idx < threads_count; ++thread_idx) {
+                threads_pool.emplace_back([=, &stop]() {
+                    for (std::size_t task_idx = thread_idx * tasks_per_thread;
+                         task_idx < (std::min)(tasks, thread_idx * tasks_per_thread + tasks_per_thread) &&
+                         !stop.load(std::memory_order_relaxed);
+                         ++task_idx)
+                        if (!thread_aware_function(thread_idx, task_idx))
+                            stop.store(true, std::memory_order_relaxed);
+                });
+            }
+        }
+        for (std::size_t task_idx = 0;
+             task_idx < (std::min)(tasks, tasks_per_thread) && !stop.load(std::memory_order_relaxed); ++task_idx)
+            if (!thread_aware_function(0, task_idx))
+                stop.store(true, std::memory_order_relaxed);
     }
 
     /**
@@ -473,15 +537,13 @@ class executor_stl_t {
      *  @throws If an exception occurs during execution of the thread-aware function.
      */
     template <typename thread_aware_function_at>
-    void execute_bulk(thread_aware_function_at&& thread_aware_function) noexcept(false) {
+    void parallel(thread_aware_function_at&& thread_aware_function) noexcept(false) {
         if (threads_count_ == 1)
             return thread_aware_function(0);
-        std::vector<std::thread> threads_pool;
+        std::vector<jthread_t> threads_pool;
         for (std::size_t thread_idx = 1; thread_idx < threads_count_; ++thread_idx)
             threads_pool.emplace_back([=]() { thread_aware_function(thread_idx); });
         thread_aware_function(0);
-        for (std::thread& thread : threads_pool)
-            thread.join();
     }
 };
 
@@ -512,20 +574,48 @@ class executor_openmp_t {
      *  @throws If an exception occurs during execution of the thread-aware function.
      */
     template <typename thread_aware_function_at>
-    void execute_bulk(std::size_t tasks, thread_aware_function_at&& thread_aware_function) noexcept(false) {
-#pragma omp parallel for schedule(dynamic)
+    void fixed(std::size_t tasks, thread_aware_function_at&& thread_aware_function) noexcept(false) {
+#pragma omp parallel for schedule(dynamic, 1)
         for (std::size_t i = 0; i != tasks; ++i) {
             thread_aware_function(omp_get_thread_num(), i);
         }
     }
 
+    /**
+     *  @brief Executes tasks in bulk using the specified thread-aware function.
+     *  @param tasks                 The total number of tasks to be executed.
+     *  @param thread_aware_function The thread-aware function to be called for each thread index and task index.
+     *  @throws If an exception occurs during execution of the thread-aware function.
+     */
+    template <typename thread_aware_function_at>
+    void dynamic(std::size_t tasks, thread_aware_function_at&& thread_aware_function) noexcept(false) {
+        // OpenMP cancellation points are not yet available on most platforms, and require
+        // the `OMP_CANCELLATION` environment variable to be set.
+        // http://jakascorner.com/blog/2016/08/omp-cancel.html
+        // if (omp_get_cancellation()) {
+        // #pragma omp parallel for schedule(dynamic, 1)
+        //     for (std::size_t i = 0; i != tasks; ++i) {
+        // #pragma omp cancellation point for
+        //         if (!thread_aware_function(omp_get_thread_num(), i)) {
+        // #pragma omp cancel for
+        //         }
+        //     }
+        // }
+        std::atomic_bool stop{false};
+#pragma omp parallel for schedule(dynamic, 1) shared(stop)
+        for (std::size_t i = 0; i != tasks; ++i) {
+            if (!stop.load(std::memory_order_relaxed) && !thread_aware_function(omp_get_thread_num(), i))
+                stop.store(true, std::memory_order_relaxed);
+        }
+    }
+
     /**
      *  @brief Saturates every available thread with the given workload, until they finish.
      *  @param thread_aware_function The thread-aware function to be called for each thread index.
      *  @throws If an exception occurs during execution of the thread-aware function.
      */
     template <typename thread_aware_function_at>
-    void execute_bulk(thread_aware_function_at&& thread_aware_function) noexcept(false) {
+    void parallel(thread_aware_function_at&& thread_aware_function) noexcept(false) {
 #pragma omp parallel
         { thread_aware_function(omp_get_thread_num()); }
     }
@@ -735,6 +825,94 @@ template <std::size_t alignment_ak = 1> class memory_mapping_allocator_gt {
 
 using memory_mapping_allocator_t = memory_mapping_allocator_gt<>;
 
+/**
+ *  @brief  C++11 userspace implementation of an oversimplified `std::shared_mutex`,
+ *          that assumes rare interleaving of shared and unique locks. It's not fair,
+ *          but requires only a single 32-bit atomic integer to work.
+ */
+class unfair_shared_mutex_t {
+    /** Any positive integer describes the number of concurrent readers */
+    enum state_t : std::int32_t {
+        idle_k = 0,
+        writing_k = -1,
+    };
+    std::atomic<std::int32_t> state_{idle_k};
+
+  public:
+    inline void lock() noexcept {
+        std::int32_t raw;
+    relock:
+        raw = idle_k;
+        if (!state_.compare_exchange_weak(raw, writing_k, std::memory_order_acquire, std::memory_order_relaxed)) {
+            std::this_thread::yield();
+            goto relock;
+        }
+    }
+
+    inline void unlock() noexcept { state_.store(idle_k, std::memory_order_release); }
+
+    inline void lock_shared() noexcept {
+        std::int32_t raw;
+    relock_shared:
+        raw = state_.load(std::memory_order_acquire);
+        // Spin while it's uniquely locked
+        if (raw == writing_k) {
+            std::this_thread::yield();
+            goto relock_shared;
+        }
+        // Try incrementing the counter
+        if (!state_.compare_exchange_weak(raw, raw + 1, std::memory_order_acquire, std::memory_order_relaxed)) {
+            std::this_thread::yield();
+            goto relock_shared;
+        }
+    }
+
+    inline void unlock_shared() noexcept { state_.fetch_sub(1, std::memory_order_release); }
+
+    /**
+     *  @brief Try upgrades the current `lock_shared()` to a unique `lock()` state.
+     */
+    inline bool try_escalate() noexcept {
+        std::int32_t one_read = 1;
+        return state_.compare_exchange_weak(one_read, writing_k, std::memory_order_acquire, std::memory_order_relaxed);
+    }
+
+    /**
+     *  @brief Escalates current lock potentially loosing control in the middle.
+     *  It's a shortcut for `try_escalate`-`unlock_shared`-`lock` trio.
+     */
+    inline void unsafe_escalate() noexcept {
+        if (!try_escalate()) {
+            unlock_shared();
+            lock();
+        }
+    }
+
+    /**
+     *  @brief Upgrades the current `lock_shared()` to a unique `lock()` state.
+     */
+    inline void escalate() noexcept {
+        while (!try_escalate())
+            std::this_thread::yield();
+    }
+
+    /**
+     *  @brief De-escalation of a previously escalated state.
+     */
+    inline void de_escalate() noexcept {
+        std::int32_t one_read = 1;
+        state_.store(one_read, std::memory_order_release);
+    }
+};
+
+template <typename mutex_at = unfair_shared_mutex_t> class shared_lock_gt {
+    mutex_at& mutex_;
+
+  public:
+    inline explicit shared_lock_gt(mutex_at& m) noexcept : mutex_(m) { mutex_.lock_shared(); }
+    inline ~shared_lock_gt() noexcept { mutex_.unlock_shared(); }
+};
+
 /**
  *  @brief  Utility class used to cast arrays of one scalar type to another,
  *          avoiding unnecessary conversions.

package/java/cloud/unum/usearch/Index.java

@@ -69,6 +69,14 @@ public class Index {
     c_view(c_ptr, path);
   }
 
+  public boolean remove(int key) {
+    return c_remove(c_ptr, key);
+  }
+  
+  public boolean rename(int from, int to) {
+    return c_rename(c_ptr, from, to);
+  }
+
   public static class Config {
     private String _metric = "ip";
     private String _quantization = "f32";
@@ -135,6 +143,7 @@ public class Index {
   public static void main(String[] args) {
     Index index = new Index.Config().metric("cos").dimensions(100).build();
     index.size();
+    System.out.println("Java tests passed!");
   }
 
   private static native long c_create(//
@@ -163,4 +172,8 @@ public class Index {
   private static native void c_load(long ptr, String path);
 
   private static native void c_view(long ptr, String path);
+
+  private static native boolean c_remove(long ptr, int key);
+
+  private static native boolean c_rename(long ptr, int from, int to);
 }

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

@@ -58,30 +58,33 @@ 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<index_dense_t*>(c_ptr)->save(path_cstr)) {
+    serialization_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->save(path_cstr);
+    if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
-            (*env).ThrowNew(jc, "Failed to dump vector index to path!");
+            (*env).ThrowNew(jc, result.error.release());
     }
     (*env).ReleaseStringUTFChars(path, path_cstr);
 }
 
 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<index_dense_t*>(c_ptr)->load(path_cstr)) {
+    serialization_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->load(path_cstr);
+    if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
-            (*env).ThrowNew(jc, "Failed to load vector index from path!");
+            (*env).ThrowNew(jc, result.error.release());
     }
     (*env).ReleaseStringUTFChars(path, path_cstr);
 }
 
 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<index_dense_t*>(c_ptr)->view(path_cstr)) {
+    serialization_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->view(path_cstr);
+    if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
-            (*env).ThrowNew(jc, "Failed to view vector index from path!");
+            (*env).ThrowNew(jc, result.error.release());
     }
     (*env).ReleaseStringUTFChars(path, path_cstr);
 }
@@ -122,10 +125,13 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add( //
     float_span_t vector_span = float_span_t{vector_data, static_cast<std::size_t>(vector_dims)};
 
     using key_t = typename index_dense_t::key_t;
-    if (!reinterpret_cast<index_dense_t*>(c_ptr)->add(static_cast<key_t>(key), vector_span)) {
+    using add_result_t = typename index_dense_t::add_result_t;
+
+    add_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->add(static_cast<key_t>(key), vector_span);
+    if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
-            (*env).ThrowNew(jc, "Failed to insert a new point in vector index!");
+            (*env).ThrowNew(jc, result.error.release());
     }
     (*env).ReleaseFloatArrayElements(vector, vector_data, 0);
 }
@@ -157,10 +163,35 @@ JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
     } else {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
-            (*env).ThrowNew(jc, "Failed to find in vector index!");
+            (*env).ThrowNew(jc, result.error.release());
     }
 
     (*env).ReleaseFloatArrayElements(vector, vector_data, 0);
     std::free(matches_data);
     return matches;
 }
+
+JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1remove(JNIEnv* env, jclass, jlong c_ptr, jlong key) {
+    using key_t = typename index_dense_t::key_t;
+    using labeling_result_t = typename index_dense_t::labeling_result_t;
+    labeling_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->remove(static_cast<key_t>(key));
+    if (!result) {
+        jclass jc = (*env).FindClass("java/lang/Error");
+        if (jc)
+            (*env).ThrowNew(jc, result.error.release());
+    }
+    return result.completed;
+}
+
+JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1rename(JNIEnv* env, jclass, jlong c_ptr, jlong from, jlong to) {
+    using key_t = typename index_dense_t::key_t;
+    using labeling_result_t = typename index_dense_t::labeling_result_t;
+    labeling_result_t result =
+        reinterpret_cast<index_dense_t*>(c_ptr)->rename(static_cast<key_t>(from), static_cast<key_t>(to));
+    if (!result) {
+        jclass jc = (*env).FindClass("java/lang/Error");
+        if (jc)
+            (*env).ThrowNew(jc, result.error.release());
+    }
+    return result.completed;
+}

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

@@ -103,6 +103,22 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1load
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1view
   (JNIEnv *, jclass, jlong, jstring);
 
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_remove
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1remove
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_rename
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1rename
+  (JNIEnv *, jclass, jlong, jlong);
+  
 #ifdef __cplusplus
 }
 #endif

package/javascript/docs.js

@@ -0,0 +1,111 @@
+/** Search result object. */
+class Matches {
+    /**
+     * @param {BigUint64Array} keys - The keys of the nearest neighbors found.
+     * @param {Float32Array} distances - The distances of the nearest neighbors found.
+     * @param {bigint} count - The count of nearest neighbors found.
+     */
+    constructor(keys, distances, count) {
+        this.keys = keys;
+        this.distances = distances;
+        this.count = count;
+    }
+}
+
+/** K-Approximate Nearest Neighbors search index. */
+class Index {
+    /**
+     * Constructs a new index.
+     * 
+     * @param {bigint} dimensions
+     * @param {string} metric
+     * @param {string} quantization
+     * @param {bigint} capacity
+     * @param {bigint} connectivity
+     * @param {bigint} expansion_add
+     * @param {bigint} expansion_search
+     */
+    constructor(
+        dimensions,
+        metric,
+        quantization,
+        capacity,
+        connectivity,
+        expansion_add,
+        expansion_search
+    ) {}
+
+    /**
+     * Returns the dimensionality of vectors.
+     * @return {bigint} The dimensionality of vectors.
+     */
+    dimensions() {}
+
+    /**
+     * Returns the bigint of vectors currently indexed.
+     * @return {bigint} The bigint of vectors currently indexed.
+     */
+    size() {}
+
+    /**
+     * Returns index capacity.
+     * @return {bigint} The capacity of index.
+     */
+    capacity() {}
+
+    /**
+     * Returns connectivity.
+     * @return {bigint} The connectivity of index.
+     */
+    connectivity() {}
+
+    /** 
+     * Write index to a file.
+     * @param {string} path File path to write.
+     */
+    save(path) {}
+
+    /** 
+     * Load index from a file.
+     * @param {string} path File path to read.
+     */
+    load(path) {}
+
+    /** 
+     * View index from a file, without loading into RAM.
+     * @param {string} path File path to read.
+     */
+    view(path) {}
+
+    /** 
+     * Add n vectors of dimension d to the index.
+     * 
+     * @param {bigint | bigint[]} keys Input identifiers for every vector.
+     * @param {Float32Array | Float32Array[]} mat Input matrix, matrix of size n * d.
+     */
+    add(keys, mat) {}
+
+    /** 
+     * Query n vectors of dimension d to the index. Return at most k vectors for each. 
+     * If there are not enough results for a query, the result array is padded with -1s.
+     *
+     * @param {Float32Array} mat Input vectors to search, matrix of size n * d.
+     * @param {bigint} k The bigint of nearest neighbors to search for.
+     * @return {Matches} Output of the search result.
+     */
+    search(mat, k) {}
+
+    /** 
+     * Check if an entry is contained in the index.
+     * 
+     * @param {bigint} key Identifier to look up.
+     */
+    contains(key) {}
+
+    /** 
+     * Remove a vector from the index.
+     * 
+     * @param {bigint} key Input identifier for every vector to be removed.
+     */
+    remove(key) {}
+}

package/javascript/lib.cpp

@@ -106,7 +106,7 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
         std::string quantization_str = params.Get("quantization").As<Napi::String>().Utf8Value();
         expected_gt<scalar_kind_t> expected = scalar_kind_from_name(quantization_str.c_str(), quantization_str.size());
         if (!expected) {
-            Napi::TypeError::New(env, expected.error.what()).ThrowAsJavaScriptException();
+            Napi::TypeError::New(env, expected.error.release()).ThrowAsJavaScriptException();
             return;
         }
         quantization = *expected;
@@ -118,7 +118,7 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
         std::string metric_str = params.Get("metric").As<Napi::String>().Utf8Value();
         expected_gt<metric_kind_t> expected = metric_from_name(metric_str.c_str(), metric_str.size());
         if (!expected) {
-            Napi::TypeError::New(env, expected.error.what()).ThrowAsJavaScriptException();
+            Napi::TypeError::New(env, expected.error.release()).ThrowAsJavaScriptException();
             return;
         }
         metric_kind = *expected;
@@ -154,7 +154,10 @@ void Index::Save(Napi::CallbackInfo const& ctx) {
 
     try {
         std::string path = ctx[0].As<Napi::String>();
-        native_->save(path.c_str());
+        auto result = native_->save(path.c_str());
+        if (!result)
+            return Napi::TypeError::New(env, result.error.release()).ThrowAsJavaScriptException();
+
     } catch (...) {
         Napi::TypeError::New(env, "Serialization failed").ThrowAsJavaScriptException();
     }
@@ -171,7 +174,10 @@ void Index::Load(Napi::CallbackInfo const& ctx) {
 
     try {
         std::string path = ctx[0].As<Napi::String>();
-        native_->load(path.c_str());
+        auto result = native_->load(path.c_str());
+        if (!result)
+            return Napi::TypeError::New(env, result.error.release()).ThrowAsJavaScriptException();
+
     } catch (...) {
         Napi::TypeError::New(env, "Loading failed").ThrowAsJavaScriptException();
     }
@@ -188,7 +194,10 @@ void Index::View(Napi::CallbackInfo const& ctx) {
 
     try {
         std::string path = ctx[0].As<Napi::String>();
-        native_->view(path.c_str());
+        auto result = native_->view(path.c_str());
+        if (!result)
+            return Napi::TypeError::New(env, result.error.release()).ThrowAsJavaScriptException();
+
     } catch (...) {
         Napi::TypeError::New(env, "Memory-mapping failed").ThrowAsJavaScriptException();
     }
@@ -216,7 +225,10 @@ void Index::Add(Napi::CallbackInfo const& ctx) {
             return Napi::TypeError::New(env, "Wrong number of dimensions").ThrowAsJavaScriptException();
 
         try {
-            native_->add(key, vector);
+            auto result = native_->add(key, vector);
+            if (!result)
+                return Napi::TypeError::New(env, result.error.release()).ThrowAsJavaScriptException();
+
         } catch (std::bad_alloc const&) {
             return Napi::TypeError::New(env, "Out of memory").ThrowAsJavaScriptException();
         } catch (...) {
@@ -234,7 +246,8 @@ void Index::Add(Napi::CallbackInfo const& ctx) {
                 .ThrowAsJavaScriptException();
 
         if (native_->size() + length >= native_->capacity())
-            native_->reserve(ceil2(native_->size() + length));
+            if (!native_->reserve(ceil2(native_->size() + length)))
+                return Napi::TypeError::New(env, "Out of memory!").ThrowAsJavaScriptException();
 
         for (std::size_t i = 0; i < length; i++) {
             Napi::Value key_js = keys_js[i];
@@ -280,7 +293,14 @@ Napi::Value Index::Search(Napi::CallbackInfo const& ctx) {
     static_assert(std::is_same<std::uint64_t, key_t>::value, "Matches.key interface expects BigUint64Array");
     Napi::Float32Array distances_js = Napi::Float32Array::New(env, wanted);
     try {
-        std::uint64_t count = native_->search(vector, wanted).dump_to(matches_js.Data(), distances_js.Data());
+
+        auto result = native_->search(vector, wanted);
+        if (!result) {
+            Napi::TypeError::New(env, result.error.release()).ThrowAsJavaScriptException();
+            return {};
+        }
+
+        std::uint64_t count = result.dump_to(matches_js.Data(), distances_js.Data());
         Napi::Object result_js = Napi::Object::New(env);
         result_js.Set("keys", matches_js);
         result_js.Set("distances", distances_js);
@@ -313,7 +333,7 @@ Napi::Value Index::Remove(Napi::CallbackInfo const& ctx) {
     try {
         auto result = native_->remove(key);
         if (!result) {
-            Napi::TypeError::New(env, "Removal has failed").ThrowAsJavaScriptException();
+            Napi::TypeError::New(env, result.error.release()).ThrowAsJavaScriptException();
             return {};
         }
         return Napi::Boolean::New(env, result.completed);

package/javascript/usearch.d.ts

@@ -23,7 +23,15 @@ export class Index {
      * @param {bigint} expansion_add
      * @param {bigint} expansion_search
      */
-    constructor(...args);
+    constructor(
+        dimensions: bigint,
+        metric: string,
+        quantization: string,
+        capacity: bigint,
+        connectivity: bigint,
+        expansion_add: bigint,
+        expansion_search: bigint
+    );
 
     /**
      * Returns the dimensionality of vectors.