usearch 2.8.9 → 2.8.12

package/.github/workflows/prerelease.yml

@@ -127,7 +127,7 @@ jobs:
           wget https://apt.llvm.org/llvm.sh
           chmod +x llvm.sh
           sudo ./llvm.sh 16
-          cmake -B build_artifacts -DCMAKE_BUILD_TYPE=RelWithDebInfo -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_LIB_C=1 -DDUSEARCH_USE_OPENMP=0 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1
+          cmake -B build_artifacts -DCMAKE_BUILD_TYPE=RelWithDebInfo -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_USE_OPENMP=0 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1
           cmake --build build_artifacts --config RelWithDebInfo
       - name: Test C++
         run: ./build_artifacts/test_cpp

package/.github/workflows/release.yml

@@ -432,6 +432,7 @@ jobs:
           npm install
           npm ci
           npm test
+          npm run typegen
 
       - name: Publish
         uses: JS-DevTools/npm-publish@v2

package/CITATION.cff

@@ -5,7 +5,7 @@ authors:
   given-names: "Ash"
   orcid: "https://orcid.org/0000-0002-4882-1815"
 title: "USearch by Unum Cloud"
-version: 2.8.9
+version: 2.8.12
 doi: 10.5281/zenodo.7949416
 date-released: 2023-10-22
 url: "https://github.com/unum-cloud/usearch"

package/CONTRIBUTING.md

@@ -232,21 +232,30 @@ Afterwards, in a new terminal:
 
 ```sh
 gradle clean build
-java -cp . -Djava.library.path="$(pwd)/build/libs/usearch/shared" java/cloud/unum/usearch/Index.java
+gradle test
+```
+
+Alternatively, to run the `Index.main`:
+
+```sh
+java -cp "$(pwd)/build/classes/java/main" -Djava.library.path="$(pwd)/build/libs/usearch/shared" java/cloud/unum/usearch/Index.java
 ```
 
 Or step by-step:
 
 ```sh
-cs java/unum/cloud/usearch
-javac -h . Index.java
+cd java/cloud/unum/usearch
+javac -h . Index.java NativeUtils.java
+
+# Ensure JAVA_HOME system environment variable has been set
+# e.g. export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
 
 # Ubuntu:
-g++ -c -fPIC -I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux cloud_unum_usearch_Index.cpp -o cloud_unum_usearch_Index.o
-g++ -shared -fPIC -o libusearch_c.so cloud_unum_usearch_Index.o -lc
+g++ -c -fPIC -I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux -I../../../../include cloud_unum_usearch_Index.cpp -o cloud_unum_usearch_Index.o
+g++ -shared -fPIC -o libusearch.so cloud_unum_usearch_Index.o -lc
 
 # Windows
-g++ -c -I%JAVA_HOME%\include -I%JAVA_HOME%\include\win32 cloud_unum_usearch_Index.cpp -o cloud_unum_usearch_Index.o
+g++ -c -I%JAVA_HOME%\include -I%JAVA_HOME%\include\win32 cloud_unum_usearch_Index.cpp -I..\..\..\..\include -o cloud_unum_usearch_Index.o
 g++ -shared -o USearchJNI.dll cloud_unum_usearch_Index.o -Wl,--add-stdcall-alias
 
 # MacOS
@@ -256,9 +265,11 @@ g++ -std=c++11 -c -fPIC \
     -I../../../../simsimd/include \
     -I${JAVA_HOME}/include -I${JAVA_HOME}/include/darwin cloud_unum_usearch_Index.cpp -o cloud_unum_usearch_Index.o
 g++ -dynamiclib -o libusearch.dylib cloud_unum_usearch_Index.o -lc
+
 # Run linking to that directory
-java -cp . -Djava.library.path="$(pwd)/java/cloud/unum/usearch/" Index.java
-java -cp . -Djava.library.path="$(pwd)/java" cloud.unum.usearch.Index
+cd ../../../..
+cp cloud/unum/usearch/libusearch.* .
+java -cp . -Djava.library.path="$(pwd)" cloud.unum.usearch.Index
 ```
 
 ## Wolfram

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "2.8.9"
+version = "2.8.12"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/README.md

@@ -50,6 +50,7 @@ Linux • MacOS • Windows • iOS • WebAssembly
 - ✅ [20x faster than][faster-than-faiss] [FAISS][faiss] implementation of [HNSW algorithm][hnsw-algorithm].
 - ✅ Simple and extensible [single C++11 header][usearch-header] implementation.
 - ✅ Compatible with a dozen programming languages out of the box.
+- ✅ [Trusted](#integrations) by some of the most loved Datalakes and Databases, like [ClickHouse][clickhouse-docs].
 - ✅ [SIMD][simd]-optimized and [user-defined metrics](#user-defined-functions) with JIT compilation.
 - ✅ Hardware-agnostic `f16` & `i8` - [half-precision & quarter-precision support](#memory-efficiency-downcasting-and-quantization).
 - ✅ [View large indexes from disk](#serving-index-from-disk) without loading into RAM.
@@ -67,6 +68,17 @@ Linux • MacOS • Windows • iOS • WebAssembly
 [hnsw-algorithm]: https://arxiv.org/abs/1603.09320
 [simd]: https://en.wikipedia.org/wiki/Single_instruction,_multiple_data
 [faster-than-faiss]: https://www.unum.cloud/blog/2023-11-07-scaling-vector-search-with-intel
+[clickhouse-docs]: https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/annindexes#usearch
+
+__Technical Insights__ and related articles:
+
+- [Uses Horner's method for polynomial approximations, beating GCC 12 by 119x](https://ashvardanian.com/posts/gcc-12-vs-avx512fp16/).
+- [Uses Arm SVE and x86 AVX-512's masked loads to eliminate tail `for`-loops](https://ashvardanian.com/posts/simsimd-faster-scipy/#tails-of-the-past-the-significance-of-masked-loads).
+- [Uses AVX-512 FP16 for half-precision operations, that few compilers vectorize](https://ashvardanian.com/posts/simsimd-faster-scipy/#the-challenge-of-f16).
+- [Substitutes LibC's `sqrt` calls with bithacks using Jan Kadlec's constant](https://ashvardanian.com/posts/simsimd-faster-scipy/#bonus-section-bypassing-sqrt-and-libc-dependencies).
+- [For every language implements a custom separate binding](https://ashvardanian.com/posts/porting-cpp-library-to-ten-languages/).
+- [For Python avoids slow PyBind11, and even `PyArg_ParseTuple` for speed](https://ashvardanian.com/posts/pybind11-cpython-tutorial/).
+- [For JavaScript uses typed arrays and NAPI for zero-copy calls](https://ashvardanian.com/posts/javascript-ai-vector-search/).
 
 ## Comparison with FAISS
 
@@ -132,34 +144,6 @@ index = Index(
 )
 ```
 
-## User-Defined Functions
-
-While most vector search packages concentrate on just a few metrics - "Inner Product distance" and "Euclidean distance," USearch extends this list to include any user-defined metrics.
-This flexibility allows you to customize your search for various applications, from computing geospatial coordinates with the rare [Haversine][haversine] distance to creating custom metrics for composite embeddings from multiple AI models.
-
-![USearch: Vector Search Approaches](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-approaches-white.png?raw=true)
-
-Unlike older approaches indexing high-dimensional spaces, like KD-Trees and Locality Sensitive Hashing, HNSW doesn't require vectors to be identical in length.
-They only have to be comparable.
-So you can apply it in [obscure][obscure] applications, like searching for similar sets or fuzzy text matching, using [GZip][gzip-similarity] as a distance function.
-
-> Read more about [JIT and UDF in USearch Python SDK](https://unum-cloud.github.io/usearch/python#user-defined-metrics-and-jit-in-python).
-
-[haversine]: https://ashvardanian.com/posts/abusing-vector-search#geo-spatial-indexing
-[obscure]: https://ashvardanian.com/posts/abusing-vector-search
-[gzip-similarity]: https://twitter.com/LukeGessler/status/1679211291292889100?s=20
-
-## Memory Efficiency, Downcasting, and Quantization
-
-Training a quantization model and dimension-reduction is a common approach to accelerate vector search.
-Those, however, are only sometimes reliable, can significantly affect the statistical properties of your data, and require regular adjustments if your distribution shifts.
-
-![USearch uint40_t support](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-neighbor-types.png?raw=true)
-
-Instead, we have focused on high-precision arithmetic over low-precision downcasted vectors.
-The same index, and `add` and `search` operations will automatically down-cast or up-cast between `f32_t`, `f16_t`, `f64_t`, and `i8_t` representations, even if the hardware doesn't natively support it.
-Continuing the topic of memory efficiency, we provide a `uint40_t` to allow collection with over 4B+ vectors without allocating 8 bytes for every neighbor reference in the proximity graph.
-
 ## Serialization & Serving `Index` from Disk
 
 USearch supports multiple forms of serialization:
@@ -275,16 +259,56 @@ pairs: dict = men.join(women, max_proposals=0, exact=False)
 
 > Read more in the post: [Combinatorial Stable Marriages for Semantic Search 💍](https://ashvardanian.com/posts/searching-stable-marriages)
 
+## User-Defined Functions
+
+While most vector search packages concentrate on just a few metrics - "Inner Product distance" and "Euclidean distance," USearch extends this list to include any user-defined metrics.
+This flexibility allows you to customize your search for various applications, from computing geospatial coordinates with the rare [Haversine][haversine] distance to creating custom metrics for composite embeddings from multiple AI models.
+
+![USearch: Vector Search Approaches](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-approaches-white.png?raw=true)
+
+Unlike older approaches indexing high-dimensional spaces, like KD-Trees and Locality Sensitive Hashing, HNSW doesn't require vectors to be identical in length.
+They only have to be comparable.
+So you can apply it in [obscure][obscure] applications, like searching for similar sets or fuzzy text matching, using [GZip][gzip-similarity] as a distance function.
+
+> Read more about [JIT and UDF in USearch Python SDK](https://unum-cloud.github.io/usearch/python#user-defined-metrics-and-jit-in-python).
+
+[haversine]: https://ashvardanian.com/posts/abusing-vector-search#geo-spatial-indexing
+[obscure]: https://ashvardanian.com/posts/abusing-vector-search
+[gzip-similarity]: https://twitter.com/LukeGessler/status/1679211291292889100?s=20
+
+## Memory Efficiency, Downcasting, and Quantization
+
+Training a quantization model and dimension-reduction is a common approach to accelerate vector search.
+Those, however, are only sometimes reliable, can significantly affect the statistical properties of your data, and require regular adjustments if your distribution shifts.
+Instead, we have focused on high-precision arithmetic over low-precision downcasted vectors.
+The same index, and `add` and `search` operations will automatically down-cast or up-cast between `f64_t`, `f32_t`, `f16_t`, `i8_t`, and single-bit representations.
+You can use the following command to check, if hardware acceleration is enabled:
+
+```sh
+$ python -c 'from usearch.index import Index; print(Index(ndim=768, metric="cos", dtype="f16").hardware_acceleration)'
+> avx512+f16
+$ python -c 'from usearch.index import Index; print(Index(ndim=166, metric="tanimoto").hardware_acceleration)'
+> avx512+popcnt
+```
+
+Using smaller numeric types will save you RAM needed to store the vectors, but you can also compress the neighbors lists forming our proximity graphs.
+By default, 32-bit `uint32_t` is used to enumerate those, which is not enough if you need to address over 4 Billion entries.
+For such cases we provide a custom `uint40_t` type, that will still be 37.5% more space-efficient than the commonly used 8-byte integers, and will scale up to 1 Trillion entries.
+
+![USearch uint40_t support](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-neighbor-types.png?raw=true)
+
 ## Functionality
 
 By now, the core functionality is supported across all bindings.
 Broader functionality is ported per request.
+In some cases, like Batch operations, feature parity is meaningless, as the host language has full multi-threading capabilities and the USearch index structure is concurrent by design, so the users can implement batching/scheduling/load-balancing in the most optimal way for their applications.
 
 |                         | C++ 11 | Python 3 | C 99  | Java  | JavaScript | Rust  | GoLang | Swift |
 | :---------------------- | :----: | :------: | :---: | :---: | :--------: | :---: | :----: | :---: |
-| Add, search             |   ✅    |    ✅     |   ✅   |   ✅   |     ✅      |   ✅   |   ✅    |   ✅   |
+| Add, search, remove     |   ✅    |    ✅     |   ✅   |   ✅   |     ✅      |   ✅   |   ✅    |   ✅   |
 | Save, load, view        |   ✅    |    ✅     |   ✅   |   ✅   |     ✅      |   ✅   |   ✅    |   ✅   |
 | User-defined metrics    |   ✅    |    ✅     |   ✅   |   ❌   |     ❌      |   ❌   |   ❌    |   ❌   |
+| Batch operations        |   ❌    |    ✅     |   ❌   |   ❌   |     ✅      |   ❌   |   ❌    |   ❌   |
 | Joins                   |   ✅    |    ✅     |   ❌   |   ❌   |     ❌      |   ❌   |   ❌    |   ❌   |
 | Variable-length vectors |   ✅    |    ❌     |   ❌   |   ❌   |     ❌      |   ❌   |   ❌    |   ❌   |
 | 4B+ capacities          |   ✅    |    ❌     |   ❌   |   ❌   |     ❌      |   ❌   |   ❌    |   ❌   |
@@ -400,7 +424,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.8.9},
+version = {2.8.12},
 year = {2023},
 month = oct,
 }

package/VERSION

@@ -1 +1 @@
-2.8.9
+2.8.12

package/build.gradle

@@ -23,6 +23,11 @@ sourceSets {
             srcDir "java/"
             exclude "test/"
         }
+        // Ensure native libraries are included in the main source set
+        resources {
+            srcDirs "$buildDir/libs"
+            include "usearch/**"
+        }
     }
     test {
         java {
@@ -98,15 +103,25 @@ test {
 
     // Rearrange test classpath, add compiled JAR instead of main classes
     classpath = project.sourceSets.test.output + configurations.testRuntimeClasspath + files(jar.archiveFile)
+
+    // Enable detailed test logging
+    testLogging {
+        // Ensure that we get output from all tests, not just failing ones
+        showStandardStreams = true
+        exceptionFormat = 'full' // Can be 'short', 'full', or 'summary'
+
+        // More detailed test result logging
+        events "passed", "skipped", "failed"
+    }
 }
 
 jar {
     dependsOn("usearchSharedLibrary")
-    into("usearch") {
-        from("$buildDir/libs/usearch/shared/libusearch.dylib")
-        from("$buildDir/libs/usearch/shared/libusearch.dll")
-        from("$buildDir/libs/usearch/shared/libusearch.so")
+    from("$buildDir/libs/usearch/shared") {
+        include "libusearch.so", "libusearch.dylib", "libusearch.dll"
+        into "usearch"
     }
+    from sourceSets.main.output
 }
 
 signing {
@@ -180,4 +195,10 @@ publishing {
             }
         }
     }
-}
+}
+
+// Ensure that the native library is built before the Java code
+compileJava.dependsOn tasks.withType(SharedLibraryBinarySpec)
+tasks.named("processResources").configure {
+    dependsOn tasks.named("linkUsearchSharedLibrary")
+}

package/conanfile.py

@@ -7,7 +7,7 @@ required_conan_version = ">=1.53.0"
 class USearchConan(ConanFile):
 
     name = "usearch"
-    version = '2.8.9'
+    version = '2.8.12'
     license = "Apache-2.0"
     description = "Smaller & Faster Single-File Vector Search Engine from Unum"
     homepage = "https://github.com/unum-cloud/usearch"

package/include/usearch/index.hpp

@@ -11,7 +11,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 8
-#define USEARCH_VERSION_PATCH 9
+#define USEARCH_VERSION_PATCH 12
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074

package/include/usearch/index_dense.hpp

@@ -108,13 +108,10 @@ struct index_dense_config_t : public index_config_t {
 
     index_dense_config_t(index_config_t base) noexcept : index_config_t(base) {}
 
-    index_dense_config_t(                                  //
-        std::size_t connectivity = default_connectivity(), //
-        std::size_t expansion_add = default_expansion_add(),
-        std::size_t expansion_search = default_expansion_search()) noexcept
-        : index_config_t(connectivity), //
-          expansion_add(expansion_add ? expansion_add : default_expansion_add()),
-          expansion_search(expansion_search ? expansion_search : default_expansion_search()) {}
+    index_dense_config_t(std::size_t c = default_connectivity(), std::size_t ea = default_expansion_add(),
+                         std::size_t es = default_expansion_search()) noexcept
+        : index_config_t(c), expansion_add(ea ? ea : default_expansion_add()),
+          expansion_search(es ? es : default_expansion_search()) {}
 };
 
 struct index_dense_clustering_config_t {

package/include/usearch/index_plugins.hpp

@@ -1343,11 +1343,13 @@ class metric_punned_t {
           scalar_kind_(scalar_kind) {
 
 #if USEARCH_USE_SIMSIMD
-        if (configure_with_simsimd())
-            return;
+        if (!configure_with_simsimd())
+            configure_with_auto_vectorized();
 #endif
-
         configure_with_auto_vectorized();
+
+        if (scalar_kind == scalar_kind_t::b1x8_k)
+            raw_arg3_ = raw_arg4_ = divide_round_up<CHAR_BIT>(dimensions_);
     }
 
     inline metric_punned_t(                                                 //
@@ -1402,6 +1404,7 @@ class metric_punned_t {
         case metric_kind_t::cos_k: kind = simsimd_metric_cos_k; break;
         case metric_kind_t::l2sq_k: kind = simsimd_metric_l2sq_k; break;
         case metric_kind_t::hamming_k: kind = simsimd_metric_hamming_k; break;
+        case metric_kind_t::tanimoto_k: kind = simsimd_metric_jaccard_k; break;
         case metric_kind_t::jaccard_k: kind = simsimd_metric_jaccard_k; break;
         default: break;
         }
@@ -1498,18 +1501,9 @@ class metric_punned_t {
             break;
         }
         case metric_kind_t::jaccard_k: // Equivalent to Tanimoto
-        case metric_kind_t::tanimoto_k:
-            raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_tanimoto_gt<b1x8_t>>,
-            raw_arg3_ = raw_arg4_ = divide_round_up<CHAR_BIT>(dimensions_), scalar_kind_ = scalar_kind_t::b1x8_k;
-            break;
-        case metric_kind_t::hamming_k:
-            raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_hamming_gt<b1x8_t>>,
-            raw_arg3_ = raw_arg4_ = divide_round_up<CHAR_BIT>(dimensions_), scalar_kind_ = scalar_kind_t::b1x8_k;
-            break;
-        case metric_kind_t::sorensen_k:
-            raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_sorensen_gt<b1x8_t>>,
-            raw_arg3_ = raw_arg4_ = divide_round_up<CHAR_BIT>(dimensions_), scalar_kind_ = scalar_kind_t::b1x8_k;
-            break;
+        case metric_kind_t::tanimoto_k: raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_tanimoto_gt<b1x8_t>>; break;
+        case metric_kind_t::hamming_k: raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_hamming_gt<b1x8_t>>; break;
+        case metric_kind_t::sorensen_k: raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_sorensen_gt<b1x8_t>>; break;
         default: return;
         }
     }

package/javascript/types/usearch.d.ts

@@ -0,0 +1,237 @@
+export class Index {
+    /**
+     * Constructs a new index.
+     *
+     * @param {(number | {dimensions: number, metric: MetricKind = MetricKind.Cos, quantization: ScalarKind = ScalarKind.F32, connectivity: number = 0, expansion_add: number = 0, expansion_search: number = 0, multi: boolean = false})} dimensionsOrConfigs
+     * @param {MetricKind} [metric=MetricKind.Cos] - Optional, default is 'cos'.
+     * @param {ScalarKind} [quantization=ScalarKind.F32] - Optional, default is 'f32'.
+     * @param {number} [connectivity=0] - Optional, default is 0.
+     * @param {number} [expansion_add=0] - Optional, default is 0.
+     * @param {number} [expansion_search=0] - Optional, default is 0.
+     * @param {boolean} [multi=false] - Optional, default is false.
+     * @throws Will throw an error if any of the parameters are of incorrect type or invalid value.
+     */
+    constructor(dimensionsOrConfigs: number | {
+        dimensions: number;
+        metric: MetricKind;
+        quantization: ScalarKind;
+        connectivity: number;
+        expansion_add: number;
+        expansion_search: number;
+        multi: boolean;
+    }, metric?: MetricKind, quantization?: ScalarKind, connectivity?: number, expansion_add?: number, expansion_search?: number, multi?: boolean);
+    _compiledIndex: any;
+    /**
+     * Add vectors to the index.
+     *
+     * This method accepts vectors and their corresponding keys for indexing.
+     * Each key should correspond to a vector. If a single key is provided,
+     * it is broadcasted to match the number of provided vectors.
+     *
+     * Vectors should be provided as a flat typed array representing a matrix
+     * where each row is a vector to be indexed. The matrix should have a size
+     * of n * d, where n is the number of vectors, and d is the dimensionality
+     * of the vectors.
+     *
+     * Keys should be provided as a BigInt or an array-like object of BigInts
+     * representing the unique identifier for each vector.
+     *
+     * @param {bigint|bigint[]|BigUint64Array} keys - Input identifiers for every vector.
+     *        If a single key is provided, it is associated with all provided vectors.
+     * @param {Float32Array|Float64Array|Int8Array} vectors - Input matrix representing vectors,
+     *        matrix of size n * d, where n is the number of vectors, and d is their dimensionality.
+     * @throws Will throw an error if the length of keys doesn't match the number of vectors
+     *         or if it's not a single key.
+     */
+    add(keys: bigint | bigint[] | BigUint64Array, vectors: Float32Array | Float64Array | Int8Array): void;
+    /**
+     * Perform a k-nearest neighbor search on the index.
+     *
+     * This method accepts a matrix of query vectors and returns the closest vectors
+     * from the index for each query. The method returns an object containing the keys,
+     * distances, and counts of the matches found.
+     *
+     * Vectors should be provided as a flat typed array representing a matrix where
+     * each row is a vector. The matrix should be of size n * d, where n is the
+     * number of query vectors, and d is their dimensionality.
+     *
+     * The parameter `k` specifies the number of nearest neighbors to return for each
+     * query vector. If there are not enough results for a query, the result array is
+     * padded with -1s.
+     *
+     * @param {Float32Array|Float64Array|Int8Array|Array<Array<number>>} vectors - Input matrix representing query vectors, can be a TypedArray or an array of arrays.
+     * @param {number} k - The number of nearest neighbors to search for each query vector.
+     * @return {Matches|BatchMatches} - Search results for one or more queries, containing keys, distances, and counts of the matches found.
+     * @throws Will throw an error if `k` is not a positive integer or if the size of the vectors is not a multiple of dimensions.
+     * @throws Will throw an error if `vectors` is not a valid input type (TypedArray or an array of arrays) or if its flattened size is not a multiple of dimensions.
+     */
+    search(vectors: Float32Array | Float64Array | Int8Array | Array<Array<number>>, k: number): Matches | BatchMatches;
+    /**
+     * Verifies the presence of one or more keys in the index.
+     *
+     * This method accepts one or multiple keys as input and returns a boolean or
+     * an array of booleans indicating whether each key is present in the index.
+     *
+     * @param {bigint|bigint[]|BigUint64Array} keys - The identifier(s) of the vector(s) to be checked for presence in the index.
+     * @return {boolean|boolean[]} - Returns true if a single key is contained in the index, false otherwise. Returns an array of booleans corresponding to the presence of each key in the index when multiple keys are provided.
+     * @throws Will throw an error if keys are not integers.
+     */
+    contains(keys: bigint | bigint[] | BigUint64Array): boolean | boolean[];
+    /**
+     * Counts the number of times keys shows up in the index.
+     *
+     * @param {bigint|bigint[]|BigUint64Array} keys - The identifier(s) of the vector(s) to be enumerated.
+     * @return {number|number[]} - Returns the number of vectors found when a single key is provided. Returns an array of big integers corresponding to the number of vectors found for each key when multiple keys are provided.
+     * @throws Will throw an error if keys are not integers.
+     */
+    count(keys: bigint | bigint[] | BigUint64Array): number | number[];
+    /**
+     * Removes one or multiple vectors from the index.
+     *
+     * This method accepts one or multiple keys as input and removes the corresponding vectors from the index.
+     * It returns the number of vectors actually removed for each key provided.
+     *
+     * @param {bigint|bigint[]|BigUint64Array} keys - The identifier(s) of the vector(s) to be removed.
+     * @return {number|number[]} - Returns the number of vectors deleted when a single key is provided. Returns an array of big integers corresponding to the number of vectors deleted for each key when multiple keys are provided.
+     * @throws Will throw an error if keys are not integers.
+     */
+    remove(keys: bigint | bigint[] | BigUint64Array): number | number[];
+    /**
+     * Returns the dimensionality of vectors.
+     * @return {number} The dimensionality of vectors.
+     */
+    dimensions(): number;
+    /**
+     * Returns connectivity.
+     * @return {number} The connectivity of index.
+     */
+    connectivity(): number;
+    /**
+     * Returns the number of vectors currently indexed.
+     * @return {number} The number of vectors currently indexed.
+     */
+    size(): number;
+    /**
+     * Returns index capacity.
+     * @return {number} The capacity of index.
+     */
+    capacity(): number;
+    /**
+     * Write index to a file.
+     * @param {string} path File path to write.
+     * @throws Will throw an error if `path` is not a string.
+     */
+    save(path: string): void;
+    /**
+     * Load index from a file.
+     * @param {string} path File path to read.
+     * @throws Will throw an error if `path` is not a string.
+     */
+    load(path: string): void;
+    /**
+     * View index from a file, without loading into RAM.
+     * @param {string} path File path to read.
+     * @throws Will throw an error if `path` is not a string.
+     */
+    view(path: string): void;
+}
+/**
+ * *
+ */
+export type MetricKind = string;
+export namespace MetricKind {
+    let Unknown: string;
+    let Cos: string;
+    let IP: string;
+    let L2sq: string;
+    let Haversine: string;
+    let Divergence: string;
+    let Pearson: string;
+    let Jaccard: string;
+    let Hamming: string;
+    let Tanimoto: string;
+    let Sorensen: string;
+}
+/**
+ * *
+ */
+export type ScalarKind = string;
+export namespace ScalarKind {
+    let Unknown_1: string;
+    export { Unknown_1 as Unknown };
+    export let F32: string;
+    export let F64: string;
+    export let F16: string;
+    export let I8: string;
+    export let B1: string;
+}
+/**
+ * Represents a set of search results.
+ */
+export class Matches {
+    /**
+     * Constructs a Matches object.
+     *
+     * @param {BigUint64Array} keys - The keys of the nearest neighbors found.
+     * @param {Float32Array} distances - The distances of the nearest neighbors found.
+     */
+    constructor(keys: BigUint64Array, distances: Float32Array);
+    keys: BigUint64Array;
+    distances: Float32Array;
+}
+/**
+ * Represents a set of batched search results.
+ */
+export class BatchMatches {
+    /**
+     * Constructs a BatchMatches object.
+     *
+     * @param {BigUint64Array} keys - The keys of the nearest neighbors found in the batch.
+     * @param {Float32Array} distances - The distances of the nearest neighbors found in the batch.
+     * @param {BigUint64Array} counts - The number of neighbors found for each query in the batch.
+     * @param {bigint} k - The limit for search results per query in the batch.
+     */
+    constructor(keys: BigUint64Array, distances: Float32Array, counts: BigUint64Array, k: bigint);
+    keys: BigUint64Array;
+    distances: Float32Array;
+    counts: BigUint64Array;
+    k: bigint;
+    /**
+     * Retrieves a Matches object at the specified index in the batch.
+     *
+     * @param {number} i - The index at which to retrieve the Matches object.
+     * @returns {Matches} - A Matches object representing the search results at the specified index in the batch.
+     */
+    get(i: number): Matches;
+}
+/**
+ * Performs an exact search on the given dataset to find the best matching vectors for each query.
+ *
+ * @param {Float32Array|Float64Array|Int8Array|Array<Array<number>>} dataset - The dataset containing vectors to be searched. It can be a TypedArray or an array of arrays.
+ * @param {Float32Array|Float64Array|Int8Array|Array<Array<number>>} queries - The queries containing vectors to search for in the dataset. It can be a TypedArray or an array of arrays.
+ * @param {number} dimensions - The dimensionality of the vectors in both the dataset and the queries. It defines the number of elements in each vector.
+ * @param {number} count - The number of nearest neighbors to return for each query. If the dataset contains fewer vectors than the specified count, the result will contain only the available vectors.
+ * @param {MetricKind} metric - The distance metric to be used for the search.
+ * @return {Matches|BatchMatches} - Returns a `Matches` or `BatchMatches` object containing the results of the search.
+ * @throws Will throw an error if `dimensions` and `count` are not positive integers.
+ * @throws Will throw an error if `metric` is not a valid MetricKind.
+ * @throws Will throw an error if `dataset` and `queries` are not valid input types (TypedArray or an array of arrays).
+ * @throws Will throw an error if the sizes of the flattened `dataset` and `queries` are not multiples of `dimensions`.
+ * @throws Will throw an error if `count` is greater than the number of vectors in the `dataset`.
+ *
+ * @example
+ * const dataset = [[1.0, 2.0], [3.0, 4.0]]; // Two vectors: [1.0, 2.0] and [3.0, 4.0]
+ * const queries = [[1.5, 2.5]]; // One vector: [1.5, 2.5]
+ * const dimensions = 2; // The number of elements in each vector.
+ * const count = 1; // The number of nearest neighbors to return for each query.
+ * const metric = MetricKind.IP; // Using the Inner Product distance metric.
+ *
+ * const result = exactSearch(dataset, queries, dimensions, count, metric);
+ * // result might be:
+ * // {
+ * //    keys: BigUint64Array [ 1n ],
+ * //    distances: Float32Array [ some_value ],
+ * // }
+ */
+export function exactSearch(dataset: Float32Array | Float64Array | Int8Array | Array<Array<number>>, queries: Float32Array | Float64Array | Int8Array | Array<Array<number>>, dimensions: number, count: number, metric: MetricKind): Matches | BatchMatches;
+//# sourceMappingURL=usearch.d.ts.map

package/javascript/types/usearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usearch.d.ts","sourceRoot":"","sources":["../usearch.js"],"names":[],"mappings":"AAsIA;IAEI;;;;;;;;;;;OAWG;IACH;oBATkC,MAAM;gBAAU,UAAU;sBAAiC,UAAU;sBAAiC,MAAM;uBAAqB,MAAM;0BAAwB,MAAM;eAAa,OAAO;gBAChN,UAAU,iBACV,UAAU,iBACV,MAAM,kBACN,MAAM,qBACN,MAAM,UACN,OAAO,EAgCjB;IADG,oBAAwI;IAG5I;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,UAPW,MAAM,GAAC,MAAM,EAAE,GAAC,cAAc,WAE9B,YAAY,GAAC,YAAY,GAAC,SAAS,QAoB7C;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gBANW,YAAY,GAAC,YAAY,GAAC,SAAS,GAAC,MAAM,MAAM,MAAM,CAAC,CAAC,KACxD,MAAM,GACL,OAAO,GAAC,YAAY,CAqB/B;IAED;;;;;;;;;OASG;IACH,eAJW,MAAM,GAAC,MAAM,EAAE,GAAC,cAAc,GAC7B,OAAO,GAAC,OAAO,EAAE,CAU5B;IAED;;;;;;OAMG;IACH,YAJW,MAAM,GAAC,MAAM,EAAE,GAAC,cAAc,GAC7B,MAAM,GAAC,MAAM,EAAE,CAU1B;IAED;;;;;;;;;OASG;IACH,aAJW,MAAM,GAAC,MAAM,EAAE,GAAC,cAAc,GAC7B,MAAM,GAAC,MAAM,EAAE,CAU1B;IAED;;;OAGG;IACH,cAFY,MAAM,CAEsC;IAExD;;;OAGG;IACH,gBAFY,MAAM,CAE0C;IAE5D;;;OAGG;IACH,QAFY,MAAM,CAE0B;IAE5C;;;OAGG;IACH,YAFY,MAAM,CAEkC;IAEpD;;;;OAIG;IACH,WAHW,MAAM,QAMhB;IAED;;;;OAIG;IACH,WAHW,MAAM,QAMhB;IAED;;;;OAIG;IACH,WAHW,MAAM,QAMhB;CACJ;;;;yBAzWS,MAAM;;;;;;;;;;;;;;;;;yBAmBN,MAAM;;;;;;;;;;AAYhB;;GAEG;AACH;IACI;;;;;OAKG;IACH,kBAHW,cAAc,aACd,YAAY,EAKtB;IAFG,qBAAgB;IAChB,wBAA0B;CAEjC;AAED;;GAEG;AACH;IACI;;;;;;;OAOG;IACH,kBALW,cAAc,aACd,YAAY,UACZ,cAAc,KACd,MAAM,EAOhB;IAJG,qBAAgB;IAChB,wBAA0B;IAC1B,uBAAoB;IACpB,UAAU;IAGd;;;;;OAKG;IACH,OAHW,MAAM,GACJ,OAAO,CAQnB;CACJ;AA4RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qCA1BW,YAAY,GAAC,YAAY,GAAC,SAAS,GAAC,MAAM,MAAM,MAAM,CAAC,CAAC,WACxD,YAAY,GAAC,YAAY,GAAC,SAAS,GAAC,MAAM,MAAM,MAAM,CAAC,CAAC,cACxD,MAAM,SACN,MAAM,UACN,UAAU,GACT,OAAO,GAAC,YAAY,CA0D/B"}

package/javascript/usearch.js

@@ -137,7 +137,7 @@ class Index {
     /**
      * Constructs a new index.
      * 
-     * @param {number} dimensionsOrConfigs
+     * @param {(number | {dimensions: number, metric: MetricKind = MetricKind.Cos, quantization: ScalarKind = ScalarKind.F32, connectivity: number = 0, expansion_add: number = 0, expansion_search: number = 0, multi: boolean = false})} dimensionsOrConfigs
      * @param {MetricKind} [metric=MetricKind.Cos] - Optional, default is 'cos'.
      * @param {ScalarKind} [quantization=ScalarKind.F32] - Optional, default is 'f32'.
      * @param {number} [connectivity=0] - Optional, default is 0.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.8.9",
+    "version": "2.8.12",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",
@@ -25,9 +25,24 @@
     },
     "scripts": {
         "test": "node --test ./javascript/usearch.test.js",
-        "install": "node-gyp rebuild"
+        "install": "node-gyp rebuild",
+        "typegen": "npx tsc"
     },
     "devDependencies": {
         "typescript": "^5.1.6"
-    }
+    },
+    "exports": {
+        ".": {
+            "types": "./javascript/types/usearch.d.ts",
+            "require": "./javascript/usearch.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "typesVersions": {
+      "*": {
+          "*": [
+              "./javascript/types/usearch.d.ts"
+          ]
+      }
+  }
 }

package/pyproject.toml

@@ -9,7 +9,7 @@ xfail_strict = true
 filterwarnings = ["error"]
 
 # Avoid running tests, as everything is happening in a super slow container
-# We have already run all the relavent Python tests in `prerelease.yml`
+# We have already run all the relavent Python tests in `prerelease.yml`
 #   test-requires = ["pytest", "numpy"]
 #   test-command = "pytest {project}/python/scripts"
 [tool.cibuildwheel]

package/setup.py

@@ -14,18 +14,8 @@ def get_bool_env(name: str, preference: bool) -> bool:
     return os.environ.get(name, "1" if preference else "0") == "1"
 
 
-def get_bool_env_w_name(name: str, preference: bool) -> bool:
-    return name, get_bool_env(name, preference)
-
-
-def get_is_gcc():
-    try:
-        compiler_version = subprocess.check_output(
-            ["c++", "--version"], universal_newlines=True
-        )
-        return "gcc" in compiler_version.lower()
-    except Exception:
-        return False
+def get_bool_env_w_name(name: str, preference: bool) -> tuple:
+    return name, "1" if get_bool_env(name, preference) else "0"
 
 
 # Check the environment variables
@@ -33,9 +23,23 @@ is_linux: bool = sys.platform == "linux"
 is_macos: bool = sys.platform == "darwin"
 is_windows: bool = sys.platform == "win32"
 
+
+is_gcc = False
+if is_linux:
+    cxx = os.environ.get("CXX")
+    if cxx:
+        try:
+            command = "where" if os.name == "nt" else "which"
+            full_path = subprocess.check_output([command, cxx], text=True).strip()
+            compiler_name = os.path.basename(full_path)
+            is_gcc = ("g++" in compiler_name) and ("clang++" not in compiler_name)
+        except subprocess.CalledProcessError:
+            pass
+
+
 prefer_simsimd: bool = is_linux or is_macos
 prefer_fp16lib: bool = True
-prefer_openmp: bool = is_linux and get_is_gcc()
+prefer_openmp: bool = is_linux and is_gcc
 
 use_simsimd: bool = get_bool_env("USEARCH_USE_SIMSIMD", prefer_simsimd)
 use_fp16lib: bool = get_bool_env("USEARCH_USE_FP16LIB", prefer_fp16lib)
@@ -123,6 +127,8 @@ if is_windows:
             ]
         )
 
+print("macros_args", macros_args)
+
 ext_modules = [
     Pybind11Extension(
         "usearch.compiled",

package/simsimd/README.md

@@ -24,6 +24,15 @@ SimSIMD leverages SIMD intrinsics, capabilities that only select compilers effec
 [scipy]: https://docs.scipy.org/doc/scipy/reference/spatial.distance.html#module-scipy.spatial.distance
 [numpy]: https://numpy.org/doc/stable/reference/generated/numpy.inner.html
 
+__Technical Insights__ and related articles:
+
+- [Uses Horner's method for polynomial approximations, beating GCC 12 by 119x](https://ashvardanian.com/posts/gcc-12-vs-avx512fp16/).
+- [Uses Arm SVE and x86 AVX-512's masked loads to eliminate tail `for`-loops](https://ashvardanian.com/posts/simsimd-faster-scipy/#tails-of-the-past-the-significance-of-masked-loads).
+- [Uses AVX-512 FP16 for half-precision operations, that few compilers vectorize](https://ashvardanian.com/posts/simsimd-faster-scipy/#the-challenge-of-f16).
+- [Substitutes LibC's `sqrt` calls with bithacks using Jan Kadlec's constant](https://ashvardanian.com/posts/simsimd-faster-scipy/#bonus-section-bypassing-sqrt-and-libc-dependencies).
+- [For Python avoids slow PyBind11, SWIG, and even `PyArg_ParseTuple` for speed](https://ashvardanian.com/posts/pybind11-cpython-tutorial/).
+- [For JavaScript uses typed arrays and NAPI for zero-copy calls](https://ashvardanian.com/posts/javascript-ai-vector-search/).
+
 ## Benchmarks
 
 ### Apple M2 Pro
@@ -48,14 +57,6 @@ On the Intel Sapphire Rapids platform, SimSIMD was benchmarked against auto-vect
 | Inner Product  |     3.81 M/s | _192.02 k/s_ |    _5.99 M/s_ |          __31 x__ |
 | Jensen Shannon |     1.18 M/s |  _18.13 k/s_ |    _2.14 M/s_ |         __118 x__ |
 
-__Technical Insights__:
-
-- [Uses Arm SVE and x86 AVX-512's masked loads to eliminate tail `for`-loops](https://ashvardanian.com/posts/simsimd-faster-scipy/#tails-of-the-past-the-significance-of-masked-loads).
-- [Uses AVX-512 FP16 for half-precision operations, that few compilers vectorize](https://ashvardanian.com/posts/simsimd-faster-scipy/#the-challenge-of-f16).
-- [Substitutes LibC's `sqrt` calls with bithacks using Jan Kadlec's constant](https://ashvardanian.com/posts/simsimd-faster-scipy/#bonus-section-bypassing-sqrt-and-libc-dependencies).
-- Avoids slow PyBind11 and SWIG, directly using the CPython C API.
-- Avoids slow `PyArg_ParseTuple` and manually unpacks argument tuples.
-
 __Broader Benchmarking Results__:
 
 - [Apple M2 Pro](https://ashvardanian.com/posts/simsimd-faster-scipy/#appendix-1-performance-on-apple-m2-pro).

package/simsimd/include/simsimd/binary.h

@@ -17,8 +17,9 @@
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
  *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
  */
+#ifndef SIMSIMD_BINARY_H
+#define SIMSIMD_BINARY_H
 
-#pragma once
 #include "types.h"
 
 #ifdef __cplusplus
@@ -195,4 +196,6 @@ simsimd_avx512_b8_jaccard_cycle:
 
 #ifdef __cplusplus
 }
-#endif
+#endif
+
+#endif

package/simsimd/include/simsimd/probability.h

@@ -18,8 +18,9 @@
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
  *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
  */
+#ifndef SIMSIMD_PROBABILITY_H
+#define SIMSIMD_PROBABILITY_H
 
-#pragma once
 #include "types.h"
 
 #define SIMSIMD_MAKE_KL(name, input_type, accumulator_type, converter, epsilon)                                        \
@@ -539,4 +540,6 @@ simsimd_avx512_f16_js_cycle:
 
 #ifdef __cplusplus
 }
-#endif
+#endif
+
+#endif

package/simsimd/include/simsimd/simsimd.h

@@ -11,7 +11,9 @@
  *  Detecting target CPU features at compile time: https://stackoverflow.com/a/28939692/2766161
  */
 
-#pragma once
+#ifndef SIMSIMD_SIMSIMD_H
+#define SIMSIMD_SIMSIMD_H
+
 #include "binary.h"      // Hamming, Jaccard
 #include "probability.h" // Kullback-Leibler, Jensen–Shannon
 #include "spatial.h"     // L2, Inner Product, Cosine
@@ -423,3 +425,5 @@ inline static simsimd_metric_punned_t simsimd_metric_punned( //
 #ifdef __cplusplus
 }
 #endif
+
+#endif

package/simsimd/include/simsimd/spatial.h

@@ -20,8 +20,9 @@
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
  *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
  */
+#ifndef SIMSIMD_SPATIAL_H
+#define SIMSIMD_SPATIAL_H
 
-#pragma once
 #include "types.h"
 
 #define SIMSIMD_MAKE_L2SQ(name, input_type, accumulator_type, converter)                                               \
@@ -1000,4 +1001,6 @@ simsimd_avx512_i8_ip(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_
 
 #ifdef __cplusplus
 }
+#endif
+
 #endif

package/simsimd/include/simsimd/types.h

@@ -1,67 +1,59 @@
-#pragma once
+#ifndef SIMSIMD_TYPES_H
+#define SIMSIMD_TYPES_H
 
 // Compiling for Arm: SIMSIMD_TARGET_ARM
+#if !defined(SIMSIMD_TARGET_ARM)
 #if defined(__aarch64__) || defined(_M_ARM64)
 #define SIMSIMD_TARGET_ARM 1
+#else
+#define SIMSIMD_TARGET_ARM 0
+#endif // defined(__aarch64__) || defined(_M_ARM64)
+#endif // !defined(SIMSIMD_TARGET_ARM)
+
+// Compiling for x86: SIMSIMD_TARGET_X86
+#if !defined(SIMSIMD_TARGET_X86)
+#if defined(__x86_64__) || defined(_M_X64)
+#define SIMSIMD_TARGET_X86 1
+#else
+#define SIMSIMD_TARGET_X86 0
+#endif // defined(__x86_64__) || defined(_M_X64)
+#endif // !defined(SIMSIMD_TARGET_X86)
 
 // Compiling for Arm: SIMSIMD_TARGET_ARM_NEON
-#if !defined(SIMSIMD_TARGET_ARM_NEON)
+#if !defined(SIMSIMD_TARGET_ARM_NEON) || !SIMSIMD_TARGET_ARM
 #if defined(__ARM_NEON)
-#define SIMSIMD_TARGET_ARM_NEON 1
+#define SIMSIMD_TARGET_ARM_NEON SIMSIMD_TARGET_ARM
 #else
 #define SIMSIMD_TARGET_ARM_NEON 0
-#endif
-#endif
+#endif // defined(__ARM_NEON)
+#endif // !defined(SIMSIMD_TARGET_ARM_NEON)
 
 // Compiling for Arm: SIMSIMD_TARGET_ARM_SVE
-#if !defined(SIMSIMD_TARGET_ARM_SVE)
+#if !defined(SIMSIMD_TARGET_ARM_SVE) || !SIMSIMD_TARGET_ARM
 #if defined(__ARM_FEATURE_SVE)
-#define SIMSIMD_TARGET_ARM_SVE 1
+#define SIMSIMD_TARGET_ARM_SVE SIMSIMD_TARGET_ARM
 #else
 #define SIMSIMD_TARGET_ARM_SVE 0
-#endif
-#endif
-
-#undef SIMSIMD_TARGET_X86
-#undef SIMSIMD_TARGET_X86_AVX2
-#undef SIMSIMD_TARGET_X86_AVX512
-#define SIMSIMD_TARGET_X86 0
-#define SIMSIMD_TARGET_X86_AVX2 0
-#define SIMSIMD_TARGET_X86_AVX512 0
-
-// Compiling for x86: SIMSIMD_TARGET_X86
-#elif defined(__x86_64__) || defined(_M_X64)
-#define SIMSIMD_TARGET_X86 1
+#endif // defined(__ARM_FEATURE_SVE)
+#endif // !defined(SIMSIMD_TARGET_ARM_SVE)
 
 // Compiling for x86: SIMSIMD_TARGET_X86_AVX2
-#if !defined(SIMSIMD_TARGET_X86_AVX2)
+#if !defined(SIMSIMD_TARGET_X86_AVX2) || !SIMSIMD_TARGET_X86
 #if defined(__AVX2__)
 #define SIMSIMD_TARGET_X86_AVX2 1
 #else
 #define SIMSIMD_TARGET_X86_AVX2 0
-#endif
-#endif
+#endif // defined(__AVX2__)
+#endif // !defined(SIMSIMD_TARGET_X86_AVX2)
 
 // Compiling for x86: SIMSIMD_TARGET_X86_AVX512
-#if !defined(SIMSIMD_TARGET_X86_AVX512)
-#if defined(__AVX512F__) || defined(__AVX512VPOPCNTDQ__)
+#if !defined(SIMSIMD_TARGET_X86_AVX512) || !SIMSIMD_TARGET_X86
+#if defined(__AVX512F__) && defined(__AVX512FP16__) && defined(__AVX512VNNI__) && defined(__AVX512VPOPCNTDQ__)
 #define SIMSIMD_TARGET_X86_AVX512 1
 #else
 #define SIMSIMD_TARGET_X86_AVX512 0
-#endif
-#endif
-
-#undef SIMSIMD_TARGET_ARM
-#undef SIMSIMD_TARGET_ARM_NEON
-#undef SIMSIMD_TARGET_ARM_SVE
-#define SIMSIMD_TARGET_ARM 0
-#define SIMSIMD_TARGET_ARM_NEON 0
-#define SIMSIMD_TARGET_ARM_SVE 0
-
-// Compiling for unknown hardware architecture
-#else
-#error Unknown hardware architecture!
-#endif
+#endif // defined(__AVX512F__) && defined(__AVX512FP16__) && defined(__AVX512VNNI__) && defined(__AVX512VPOPCNTDQ__)
+#endif // !defined(SIMSIMD_TARGET_X86_AVX512)
 
 #ifdef _MSC_VER
 #include <intrin.h>
@@ -206,4 +198,6 @@ inline static float simsimd_uncompress_f16(unsigned short x) {
 
 #ifdef __cplusplus
 } // extern "C"
-#endif
+#endif
+
+#endif

package/simsimd/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simsimd",
-  "version": "3.5.4",
+  "version": "3.5.5",
   "description": "Vector Similarity Functions 3x-200x Faster than SciPy and NumPy",
   "author": "Ash Vardanian",
   "license": "Apache 2.0",

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  // Change this to match your project
+  "include": ["javascript/usearch.js"],
+  "compilerOptions": {
+    // Tells TypeScript to read JS files, as
+    // normally they are ignored as source files
+    "allowJs": true,
+    // Generate d.ts files
+    "declaration": true,
+    // This compiler run should
+    // only output d.ts files
+    "emitDeclarationOnly": true,
+    // Types should go into this directory.
+    // Removing this would place the .d.ts files
+    // next to the .js files
+    "outDir": "javascript/types",
+    // go to js file when using IDE functions like
+    // "Go to Definition" in VSCode
+    "declarationMap": true
+  }
+}

package/wasmer.toml

@@ -1,6 +1,6 @@
 [package]
 name="unum/usearch"
-version="2.8.9"
+version="2.8.12"
 description="Smaller & Faster Single-File Vector Search Engine from Unum"
 license="Apache-2.0"
 readme="README.md"