usearch 0.22.2 → 1.0.0

package/java/README.md

@@ -18,5 +18,5 @@ Add that snippet to your `pom.xml` and hit `mvn install`.
 Index index = new Index.Config().metric("cos").dimensions(2).build();
 float vec[] = {10, 20};
 index.add(42, vec);
-int[] labels = index.search(vec, 5);
+int[] keys = index.search(vec, 5);
 ```

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

@@ -16,12 +16,12 @@ public class Index {
 
   private long c_ptr = 0;
 
-  public Index(String metric, String accuracy, //
+  public Index(String metric, String quantization, //
       long dimensions, long capacity, long connectivity, //
       long expansion_add, long expansion_search) {
     c_ptr = c_create(
         metric,
-        accuracy,
+        quantization,
         dimensions,
         capacity,
         connectivity,
@@ -49,8 +49,8 @@ public class Index {
     c_reserve(c_ptr, capacity);
   }
 
-  public void add(int label, float vector[]) {
-    c_add(c_ptr, label, vector);
+  public void add(int key, float vector[]) {
+    c_add(c_ptr, key, vector);
   }
 
   public int[] search(float vector[], long count) {
@@ -71,7 +71,7 @@ public class Index {
 
   public static class Config {
     private String _metric = "ip";
-    private String _accuracy = "f32";
+    private String _quantization = "f32";
     private long _dimensions = 0;
     private long _capacity = 0;
     private long _connectivity = 0;
@@ -84,7 +84,7 @@ public class Index {
     public Index build() {
       return new Index(
           _metric,
-          _accuracy,
+          _quantization,
           _dimensions,
           _capacity,
           _connectivity,
@@ -97,8 +97,8 @@ public class Index {
       return this;
     }
 
-    public Config accuracy(String _accuracy) {
-      this._accuracy = _accuracy;
+    public Config quantization(String _quantization) {
+      this._quantization = _quantization;
       return this;
     }
 
@@ -138,7 +138,7 @@ public class Index {
   }
 
   private static native long c_create(//
-      String metric, String accuracy, //
+      String metric, String quantization, //
       long dimensions, long capacity, long connectivity, //
       long expansion_add, long expansion_search);
 
@@ -154,7 +154,7 @@ public class Index {
 
   private static native void c_reserve(long ptr, long capacity);
 
-  private static native void c_add(long ptr, int label, float vector[]);
+  private static native void c_add(long ptr, int key, float vector[]);
 
   private static native int[] c_search(long ptr, float vector[], long count);
 

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

@@ -4,53 +4,44 @@
 
 #include <thread>
 
-#include <usearch/index_punned_dense.hpp>
+#include <usearch/index_dense.hpp>
 
 using namespace unum::usearch;
 using namespace unum;
 
-using metric_t = index_punned_dense_metric_t;
-using distance_t = punned_distance_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 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>;
+using float_span_t = unum::usearch::span_gt<float>;
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
     JNIEnv* env, jclass,                                         //
-    jstring metric, jstring accuracy,                            //
+    jstring metric, jstring quantization,                        //
     jlong dimensions, jlong capacity, jlong connectivity,        //
     jlong expansion_add, jlong expansion_search) {
 
     jlong result{};
     char const* metric_cstr{};
-    char const* accuracy_cstr{};
+    char const* quantization_cstr{};
     try {
 
-        index_config_t config;
-        config.connectivity = static_cast<std::size_t>(connectivity);
+        std::size_t connectivity = static_cast<std::size_t>(connectivity);
         std::size_t expansion_add = static_cast<std::size_t>(expansion_add);
         std::size_t expansion_search = static_cast<std::size_t>(expansion_search);
 
         metric_cstr = (*env).GetStringUTFChars(metric, 0);
         std::size_t metric_length = (*env).GetStringUTFLength(metric);
-        accuracy_cstr = (*env).GetStringUTFChars(accuracy, 0);
-        std::size_t accuracy_length = (*env).GetStringUTFLength(accuracy);
+        quantization_cstr = (*env).GetStringUTFChars(quantization, 0);
+        std::size_t quantization_length = (*env).GetStringUTFLength(quantization);
 
-        scalar_kind_t accuracy = scalar_kind_from_name(accuracy_cstr, accuracy_length);
         metric_kind_t metric_kind = metric_from_name(metric_cstr, metric_length);
-        index_t index = index_t::make( //
-            static_cast<std::size_t>(dimensions), metric_kind, config, accuracy, expansion_add, expansion_search);
+        scalar_kind_t quantization = scalar_kind_from_name(quantization_cstr, quantization_length);
+        index_dense_config_t config(connectivity, expansion_add, expansion_search);
+        metric_punned_t metric(static_cast<std::size_t>(dimensions), metric_kind, quantization);
+        index_dense_t index = index_dense_t::make(metric, config);
         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 {
-            index_t* result_ptr = new index_t(std::move(index));
+            index_dense_t* result_ptr = new index_dense_t(std::move(index));
             std::memcpy(&result, &result_ptr, sizeof(jlong));
         }
 
@@ -61,13 +52,13 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
     }
 
     (*env).ReleaseStringUTFChars(metric, metric_cstr);
-    (*env).ReleaseStringUTFChars(accuracy, accuracy_cstr);
+    (*env).ReleaseStringUTFChars(quantization, quantization_cstr);
     return result;
 }
 
 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_t*>(c_ptr)->save(path_cstr)) {
+    if (!reinterpret_cast<index_dense_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!");
@@ -77,7 +68,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<index_t*>(c_ptr)->load(path_cstr)) {
+    if (!reinterpret_cast<index_dense_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!");
@@ -87,7 +78,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<index_t*>(c_ptr)->view(path_cstr)) {
+    if (!reinterpret_cast<index_dense_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!");
@@ -96,27 +87,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<index_t*>(c_ptr);
+    delete reinterpret_cast<index_dense_t*>(c_ptr);
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1size(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<index_t*>(c_ptr)->size();
+    return reinterpret_cast<index_dense_t*>(c_ptr)->size();
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1connectivity(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<index_t*>(c_ptr)->connectivity();
+    return reinterpret_cast<index_dense_t*>(c_ptr)->connectivity();
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1dimensions(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<index_t*>(c_ptr)->dimensions();
+    return reinterpret_cast<index_dense_t*>(c_ptr)->dimensions();
 }
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1capacity(JNIEnv*, jclass, jlong c_ptr) {
-    return reinterpret_cast<index_t*>(c_ptr)->capacity();
+    return reinterpret_cast<index_dense_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<index_t*>(c_ptr)->reserve(static_cast<std::size_t>(capacity))) {
+    if (!reinterpret_cast<index_dense_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!");
@@ -124,13 +115,14 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1reserve(JNIEnv* env, jcl
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add( //
-    JNIEnv* env, jclass, jlong c_ptr, jint label, jfloatArray vector) {
+    JNIEnv* env, jclass, jlong c_ptr, jint key, jfloatArray vector) {
 
     jfloat* vector_data = (*env).GetFloatArrayElements(vector, 0);
     jsize vector_dims = (*env).GetArrayLength(vector);
-    vector_view_t vector_span = vector_view_t{vector_data, static_cast<std::size_t>(vector_dims)};
+    float_span_t vector_span = float_span_t{vector_data, static_cast<std::size_t>(vector_dims)};
 
-    if (!reinterpret_cast<index_t*>(c_ptr)->add(static_cast<label_t>(label), vector_span)) {
+    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)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to insert a new point in vector index!");
@@ -152,10 +144,15 @@ JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
 
     jfloat* vector_data = (*env).GetFloatArrayElements(vector, 0);
     jsize vector_dims = (*env).GetArrayLength(vector);
-    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));
+    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;
+    using search_result_t = typename index_dense_t::search_result_t;
+
+    search_result_t result =
+        reinterpret_cast<index_dense_t*>(c_ptr)->search(vector_span, static_cast<std::size_t>(wanted));
     if (result) {
-        std::size_t found = result.dump_to(reinterpret_cast<label_t*>(matches_data), NULL);
+        std::size_t found = result.dump_to(reinterpret_cast<key_t*>(matches_data), NULL);
         (*env).SetIntArrayRegion(matches, 0, found, matches_data);
     } else {
         jclass jc = (*env).FindClass("java/lang/Error");

package/java/test/IndexTest.java

@@ -23,7 +23,7 @@ public class IndexTest {
         // Index index = new Index.Config().metric("cos").dimensions(2).build();
         // float vec[] = {10, 20};
         // index.add(42, vec);
-        // int[] labels = index.search(vec, 5);
+        // int[] keys = index.search(vec, 5);
 
         System.out.println("Java Tests Passed!");
     }

package/javascript/README.md

@@ -3,7 +3,7 @@
 ## Installation
 
 USearch is available both for Node.js backend runtime and WASM frontend runtime.
-For first use the conventional `npm install`:
+For the first option, use the conventional `npm install`:
 
 ```sh
 npm install usearch
@@ -12,18 +12,18 @@ npm install usearch
 For latter:
 
 ```sh
-
+wasmer install unum/usearch
 ```
 
 ## Quickstart
 
 ```js
-var index = new usearch.Index({ metric: 'cos', connectivity: 16, dimensions: 3 })
-index.add(42, new Float32Array([0.2, 0.6, 0.4]))
-var results = index.search(new Float32Array([0.2, 0.6, 0.4]), 10)
+var index = new usearch.Index({ metric: 'cos', connectivity: 16n, dimensions: 3n })
+index.add(42n, new Float32Array([0.2, 0.6, 0.4]))
+var results = index.search(new Float32Array([0.2, 0.6, 0.4]), 10n)
 
-assert.equal(index.size(), 1)
-assert.deepEqual(results.labels, new BigUint64Array([42n]))
+assert.equal(index.size(), 1n)
+assert.deepEqual(results.keys, new BigUint64Array([42n]))
 assert.deepEqual(results.distances, new Float32Array([0]))
 ```
 

package/javascript/lib.cpp

@@ -1,6 +1,6 @@
 /**
  *  @file javascript.cpp
- *  @author Ashot Vardanian
+ *  @author Ash Vardanian
  *  @brief JavaScript bindings for Unum USearch.
  *  @date 2023-04-26
  *
@@ -15,19 +15,11 @@
 #include <napi.h>
 #include <node_api.h>
 
-#include <usearch/index_punned_dense.hpp>
+#include <usearch/index_dense.hpp>
 
 using namespace unum::usearch;
 using namespace unum;
 
-using metric_t = index_punned_dense_metric_t;
-using distance_t = punned_distance_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:
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
@@ -46,7 +38,7 @@ class Index : public Napi::ObjectWrap<Index> {
     void Add(Napi::CallbackInfo const& ctx);
     Napi::Value Search(Napi::CallbackInfo const& ctx);
 
-    std::unique_ptr<index_t> native_;
+    std::unique_ptr<index_dense_t> native_;
 };
 
 Napi::Object Index::Init(Napi::Env env, Napi::Object exports) {
@@ -82,32 +74,38 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
         return;
     }
 
+    bool lossless = true;
     Napi::Object params = ctx[0].As<Napi::Object>();
-    std::size_t dimensions = params.Has("dimensions") ? params.Get("dimensions").As<Napi::Number>().Uint32Value() : 0;
+    std::size_t dimensions =
+        params.Has("dimensions") ? params.Get("dimensions").As<Napi::BigInt>().Uint64Value(&lossless) : 0;
 
-    index_config_t config;
     index_limits_t limits;
+    std::size_t connectivity = default_connectivity();
     std::size_t expansion_add = default_expansion_add();
     std::size_t expansion_search = default_expansion_search();
 
     if (params.Has("capacity"))
-        limits.members = params.Get("capacity").As<Napi::Number>().Uint32Value();
+        limits.members = params.Get("capacity").As<Napi::BigInt>().Uint64Value(&lossless);
     if (params.Has("connectivity"))
-        config.connectivity = params.Get("connectivity").As<Napi::Number>().Uint32Value();
+        connectivity = params.Get("connectivity").As<Napi::BigInt>().Uint64Value(&lossless);
     if (params.Has("expansion_add"))
-        expansion_add = params.Get("expansion_add").As<Napi::Number>().Uint32Value();
+        expansion_add = params.Get("expansion_add").As<Napi::BigInt>().Uint64Value(&lossless);
     if (params.Has("expansion_search"))
-        expansion_search = params.Get("expansion_search").As<Napi::Number>().Uint32Value();
+        expansion_search = params.Get("expansion_search").As<Napi::BigInt>().Uint64Value(&lossless);
+    if (!lossless) {
+        Napi::TypeError::New(env, "Arguments must be unsigned integers").ThrowAsJavaScriptException();
+        return;
+    }
 
-    scalar_kind_t accuracy = scalar_kind_t::f32_k;
-    if (params.Has("accuracy")) {
-        std::string accuracy_str = params.Get("accuracy").As<Napi::String>().Utf8Value();
-        expected_gt<scalar_kind_t> expected = scalar_kind_from_name(accuracy_str.c_str(), accuracy_str.size());
+    scalar_kind_t quantization = scalar_kind_t::f32_k;
+    if (params.Has("quantization")) {
+        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();
             return;
         }
-        accuracy = *expected;
+        quantization = *expected;
     }
 
     // By default we use the Inner Product similarity
@@ -122,20 +120,23 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
         metric_kind = *expected;
     }
 
-    native_.reset(
-        new index_t(index_t::make(dimensions, metric_kind, config, accuracy, expansion_add, expansion_search)));
+    metric_punned_t metric(dimensions, metric_kind, quantization);
+    index_dense_config_t config(connectivity, expansion_add, expansion_search);
+    native_.reset(new index_dense_t(index_dense_t::make(metric, config)));
     native_->reserve(limits);
 }
 
 Napi::Value Index::GetDimensions(Napi::CallbackInfo const& ctx) {
-    return Napi::Number::New(ctx.Env(), native_->dimensions());
+    return Napi::BigInt::New(ctx.Env(), static_cast<std::uint64_t>(native_->dimensions()));
+}
+Napi::Value Index::GetSize(Napi::CallbackInfo const& ctx) {
+    return Napi::BigInt::New(ctx.Env(), static_cast<std::uint64_t>(native_->size()));
 }
-Napi::Value Index::GetSize(Napi::CallbackInfo const& ctx) { return Napi::Number::New(ctx.Env(), native_->size()); }
 Napi::Value Index::GetConnectivity(Napi::CallbackInfo const& ctx) {
-    return Napi::Number::New(ctx.Env(), native_->connectivity());
+    return Napi::BigInt::New(ctx.Env(), static_cast<std::uint64_t>(native_->connectivity()));
 }
 Napi::Value Index::GetCapacity(Napi::CallbackInfo const& ctx) {
-    return Napi::Number::New(ctx.Env(), native_->capacity());
+    return Napi::BigInt::New(ctx.Env(), static_cast<std::uint64_t>(native_->capacity()));
 }
 
 void Index::Save(Napi::CallbackInfo const& ctx) {
@@ -191,57 +192,95 @@ void Index::View(Napi::CallbackInfo const& ctx) {
 
 void Index::Add(Napi::CallbackInfo const& ctx) {
     Napi::Env env = ctx.Env();
-    if (ctx.Length() < 2 || !ctx[0].IsNumber() || !ctx[1].IsTypedArray())
-        return Napi::TypeError::New(env, "Expects an integral label and a float vector").ThrowAsJavaScriptException();
 
-    Napi::Number label_js = ctx[0].As<Napi::Number>();
-    Napi::Float32Array vector_js = ctx[1].As<Napi::Float32Array>();
+    if (ctx.Length() < 2)
+        return Napi::TypeError::New(env, "Expects at least two arguments").ThrowAsJavaScriptException();
 
-    label_t label = label_js.Uint32Value();
-    float const* vector = vector_js.Data();
-    std::size_t dimensions = static_cast<std::size_t>(vector_js.ElementLength());
-    if (dimensions != native_->dimensions())
-        return Napi::TypeError::New(env, "Wrong number of dimensions").ThrowAsJavaScriptException();
+    using key_t = typename index_dense_t::key_t;
+    std::size_t index_dimensions = native_->dimensions();
 
-    if (native_->size() + 1 >= native_->capacity())
-        native_->reserve(ceil2(native_->size() + 1));
+    auto add = [&](Napi::BigInt key_js, Napi::Float32Array vector_js) {
+        bool lossless = true;
+        key_t key = static_cast<key_t>(key_js.Uint64Value(&lossless));
+        if (!lossless)
+            return Napi::TypeError::New(env, "Keys must be unsigned integers").ThrowAsJavaScriptException();
 
-    try {
-        native_->add(label, vector);
-    } catch (std::bad_alloc const&) {
-        Napi::TypeError::New(env, "Out of memory").ThrowAsJavaScriptException();
-    } catch (...) {
-        Napi::TypeError::New(env, "Insertion failed").ThrowAsJavaScriptException();
-    }
+        float const* vector = vector_js.Data();
+        std::size_t dimensions = static_cast<std::size_t>(vector_js.ElementLength());
+
+        if (dimensions != index_dimensions)
+            return Napi::TypeError::New(env, "Wrong number of dimensions").ThrowAsJavaScriptException();
+
+        try {
+            native_->add(key, vector);
+        } catch (std::bad_alloc const&) {
+            return Napi::TypeError::New(env, "Out of memory").ThrowAsJavaScriptException();
+        } catch (...) {
+            return Napi::TypeError::New(env, "Insertion failed").ThrowAsJavaScriptException();
+        }
+    };
+
+    if (ctx[0].IsArray() && ctx[1].IsArray()) {
+        Napi::Array keys_js = ctx[0].As<Napi::Array>();
+        Napi::Array vectors_js = ctx[1].As<Napi::Array>();
+        auto length = keys_js.Length();
+
+        if (length != vectors_js.Length())
+            return Napi::TypeError::New(env, "The number of keys must match the number of vectors")
+                .ThrowAsJavaScriptException();
+
+        if (native_->size() + length >= native_->capacity())
+            native_->reserve(ceil2(native_->size() + length));
+
+        for (std::size_t i = 0; i < length; i++) {
+            Napi::Value key_js = keys_js[i];
+            Napi::Value vector_js = vectors_js[i];
+            add(key_js.As<Napi::BigInt>(), vector_js.As<Napi::Float32Array>());
+        }
+
+    } else if (ctx[0].IsBigInt() && ctx[1].IsTypedArray()) {
+        if (native_->size() + 1 >= native_->capacity())
+            native_->reserve(ceil2(native_->size() + 1));
+        add(ctx[0].As<Napi::BigInt>(), ctx[1].As<Napi::Float32Array>());
+    } else
+        return Napi::TypeError::New(env, "Invalid argument type, expects integral key(s) and float vector(s)")
+            .ThrowAsJavaScriptException();
 }
 
 Napi::Value Index::Search(Napi::CallbackInfo const& ctx) {
     Napi::Env env = ctx.Env();
-    if (ctx.Length() < 2 || !ctx[0].IsTypedArray() || !ctx[1].IsNumber()) {
-        Napi::TypeError::New(env, "Expects a float vector and the number of wanted results")
-            .ThrowAsJavaScriptException();
+    if (ctx.Length() < 2 || !ctx[0].IsTypedArray() || !ctx[1].IsBigInt()) {
+        Napi::TypeError::New(env, "Expects a  and the number of wanted results").ThrowAsJavaScriptException();
         return {};
     }
 
     Napi::Float32Array vector_js = ctx[0].As<Napi::Float32Array>();
-    Napi::Number wanted_js = ctx[1].As<Napi::Number>();
+    Napi::BigInt wanted_js = ctx[1].As<Napi::BigInt>();
 
     float const* vector = vector_js.Data();
     std::size_t dimensions = static_cast<std::size_t>(vector_js.ElementLength());
-    std::uint32_t wanted = wanted_js.Uint32Value();
     if (dimensions != native_->dimensions()) {
         Napi::TypeError::New(env, "Wrong number of dimensions").ThrowAsJavaScriptException();
         return {};
     }
 
-    Napi::TypedArrayOf<label_t> matches_js = Napi::TypedArrayOf<label_t>::New(env, wanted);
+    bool lossless = true;
+    std::uint64_t wanted = wanted_js.Uint64Value(&lossless);
+    if (!lossless) {
+        Napi::TypeError::New(env, "Wanted number of matches must be an unsigned integer").ThrowAsJavaScriptException();
+        return {};
+    }
+
+    using key_t = typename index_dense_t::key_t;
+    Napi::TypedArrayOf<key_t> matches_js = Napi::TypedArrayOf<key_t>::New(env, wanted);
+    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::size_t count = native_->search(vector, wanted).dump_to(matches_js.Data(), distances_js.Data());
+        std::uint64_t count = native_->search(vector, wanted).dump_to(matches_js.Data(), distances_js.Data());
         Napi::Object result_js = Napi::Object::New(env);
-        result_js.Set("labels", matches_js);
+        result_js.Set("keys", matches_js);
         result_js.Set("distances", distances_js);
-        result_js.Set("count", Napi::Number::New(env, count));
+        result_js.Set("count", Napi::BigInt::New(env, count));
         return result_js;
     } catch (std::bad_alloc const&) {
         Napi::TypeError::New(env, "Out of memory").ThrowAsJavaScriptException();

package/javascript/test.js

@@ -1,17 +1,31 @@
 var assert = require('assert');
 var usearch = require('bindings')('usearch');
 
-var index = new usearch.Index({ metric: 'l2sq', connectivity: 16, dimensions: 2 })
-assert.equal(index.connectivity(), 16)
-assert.equal(index.dimensions(), 2)
-assert.equal(index.size(), 0)
+// Single-entry operations
 
-index.add(15, new Float32Array([10, 20]))
-index.add(16, new Float32Array([10, 25]))
-assert.equal(index.size(), 2)
+var index = new usearch.Index({ metric: 'l2sq', connectivity: 16n, dimensions: 2n });
+assert.equal(index.connectivity(), 16n, 'connectivity should be 16');
+assert.equal(index.dimensions(), 2n, 'dimensions should be 2');
+assert.equal(index.size(), 0n, 'initial size should be 0');
 
-var results = index.search(new Float32Array([13, 14]), 2)
-assert.deepEqual(results.labels, new BigUint64Array([15n, 16n]))
-assert.deepEqual(results.distances, new Float32Array([45, 130]))
+index.add(15n, new Float32Array([10, 20]));
+index.add(16n, new Float32Array([10, 25]));
+assert.equal(index.size(), 2n, 'size after adding elements should be 2');
 
-console.log('JavaScript tests passed!')
+var results = index.search(new Float32Array([13, 14]), 2n);
+assert.deepEqual(results.keys, new BigUint64Array([15n, 16n]), 'keys should be 15 and 16');
+assert.deepEqual(results.distances, new Float32Array([45, 130]), 'distances should be 45 and 130');
+
+// Batch operations
+
+var indexBatch = new usearch.Index({ metric: 'l2sq', connectivity: 16n, dimensions: 2n });
+const keys = [15n, 16n];
+const vectors = [new Float32Array([10, 20]), new Float32Array([10, 25])];
+indexBatch.add(keys, vectors);
+assert.equal(indexBatch.size(), 2, 'size after adding batch should be 2');
+
+results = indexBatch.search(new Float32Array([13, 14]), 2n);
+assert.deepEqual(results.keys, new BigUint64Array([15n, 16n]), 'keys should be 15 and 16');
+assert.deepEqual(results.distances, new Float32Array([45, 130]), 'distances should be 45 and 130');
+
+console.log('JavaScript tests passed!');

package/javascript/usearch.d.ts

@@ -0,0 +1,87 @@
+
+/** Search result object. */
+export interface Matches {
+    /** The keys of the nearest neighbors found, size n*k. */
+    keys: BigUint64Array,
+    /** The distances of the nearest neighbors found, size n*k. */
+    distances: Float32Array,
+    /** The distances of the nearest neighbors found, size n*k. */
+    count: bigint
+}
+
+/** K-Approximate Nearest Neighbors search index. */
+export 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(...args);
+
+    /**
+     * Returns the dimensionality of vectors.
+     * @return {bigint} The dimensionality of vectors.
+     */
+    dimensions(): bigint;
+
+    /**
+     * Returns the bigint of vectors currently indexed.
+     * @return {bigint} The bigint of vectors currently indexed.
+     */
+    size(): bigint;
+
+    /**
+     * Returns index capacity.
+     * @return {bigints} The capacity of index.
+     */
+    capacity(): bigint;
+    
+    /**
+     * Returns connectivity.
+     * @return {bigint} The connectivity of index.
+     */
+    connectivity(): bigint;
+
+    /** 
+     * Write index to a file.
+     * @param {string} path File path to write.
+     */
+    save(path: string): void;
+
+    /** 
+     * Load index from a file.
+     * @param {string} path File path to read.
+     */
+    load(path: string): void;
+
+    /** 
+     * View index from a file, without loading into RAM.
+     * @param {string} path File path to read.
+     */
+    load(path: string): void;
+
+    /** 
+     * 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: bigint | bigint[], mat: Float32Array | Float32Array[]): void;
+
+    /** 
+     * 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: Float32Array, k: bigint): Matches;
+}