usearch 2.25.0 → 2.25.3

package/javascript/lib.cpp

@@ -320,8 +320,10 @@ Napi::Value CompiledIndex::Remove(Napi::CallbackInfo const& ctx) {
     Napi::Array results = Napi::Array::New(env, length);
     for (std::size_t i = 0; i < length; ++i) {
         auto result = native_->remove(static_cast<default_key_t>(keys[i]));
-        if (!result)
-            Napi::Error::New(ctx.Env(), result.error.release()).ThrowAsJavaScriptException();
+        if (!result) {
+            Napi::Error::New(env, result.error.release()).ThrowAsJavaScriptException();
+            return env.Null();
+        }
         results[i] = Napi::Number::New(env, result.completed);
     }
     return results;

package/javascript/usearch.test.js

@@ -1,23 +1,23 @@
-const nodeTest = require('node:test');
+const nodeTest = require("node:test");
 const realTest = nodeTest.test; // the original function
 
 function loggedTest(name, options, fn) {
   // The API has two call signatures:
   //   test(name, fn)
   //   test(name, options, fn)
-  if (typeof options === 'function') {
+  if (typeof options === "function") {
     fn = options;
     options = undefined;
   }
 
   // Wrap the body so we can log before / after
   const wrapped = async (t) => {
-    console.log('▶', name);
+    console.log("▶", name);
     try {
       await fn(t); // run the user’s test
-      console.log('✓', name);
+      console.log("✓", name);
     } catch (err) {
-      console.log('✖', name);
+      console.log("✖", name);
       throw err; // re-throw so the runner records the failure
     }
   };
@@ -30,43 +30,43 @@ function loggedTest(name, options, fn) {
 global.test = loggedTest;
 module.exports = loggedTest; // for completeness if this file is `require`d
 
-const assert = require('node:assert');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const usearch = require('./dist/cjs/usearch.js');
+const assert = require("node:assert");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const usearch = require("./dist/cjs/usearch.js");
 
 function assertAlmostEqual(actual, expected, tolerance = 1e-6) {
   const lowerBound = expected - tolerance;
   const upperBound = expected + tolerance;
   assert(
     actual >= lowerBound && actual <= upperBound,
-    `Expected ${actual} to be almost equal to ${expected}`
+    `Expected ${actual} to be almost equal to ${expected}`,
   );
 }
 
 const THREADS = 2;
 
-test('Single-entry operations', async (t) => {
-  await t.test('index info', () => {
-    const index = new usearch.Index(2, 'l2sq');
+test("Single-entry operations", async (t) => {
+  await t.test("index info", () => {
+    const index = new usearch.Index(2, "l2sq");
 
-    assert.equal(index.connectivity(), 16, 'connectivity should be 16');
-    assert.equal(index.dimensions(), 2, 'dimensions should be 2');
-    assert.equal(index.size(), 0, 'initial size should be 0');
+    assert.equal(index.connectivity(), 16, "connectivity should be 16");
+    assert.equal(index.dimensions(), 2, "dimensions should be 2");
+    assert.equal(index.size(), 0, "initial size should be 0");
   });
 
-  await t.test('add', () => {
-    const index = new usearch.Index(2, 'l2sq');
+  await t.test("add", () => {
+    const index = new usearch.Index(2, "l2sq");
 
     index.add(15n, new Float32Array([10, 20]));
     index.add(16n, new Float32Array([10, 25]));
 
-    assert.equal(index.size(), 2, 'size after adding elements should be 2');
+    assert.equal(index.size(), 2, "size after adding elements should be 2");
     assert.equal(
       index.contains(15),
       true,
-      'entry must be present after insertion'
+      "entry must be present after insertion",
     );
 
     const results = index.search(new Float32Array([13, 14]), 2);
@@ -74,17 +74,17 @@ test('Single-entry operations', async (t) => {
     assert.deepEqual(
       results.keys,
       new BigUint64Array([15n, 16n]),
-      'keys should be 15 and 16'
+      "keys should be 15 and 16",
     );
     assert.deepEqual(
       results.distances,
       new Float32Array([45, 130]),
-      'distances should be 45 and 130'
+      "distances should be 45 and 130",
     );
   });
 
-  await t.test('remove', () => {
-    const index = new usearch.Index(2, 'l2sq');
+  await t.test("remove", () => {
+    const index = new usearch.Index(2, "l2sq");
 
     index.add(15n, new Float32Array([10, 20]));
     index.add(16n, new Float32Array([10, 25]));
@@ -93,11 +93,11 @@ test('Single-entry operations', async (t) => {
 
     assert.equal(index.remove(15n), 1);
 
-    assert.equal(index.size(), 3, 'size after removing elements should be 3');
+    assert.equal(index.size(), 3, "size after removing elements should be 3");
     assert.equal(
       index.contains(15),
       false,
-      'entry must be absent after insertion'
+      "entry must be absent after insertion",
     );
 
     const results = index.search(new Float32Array([13, 14]), 2);
@@ -105,37 +105,37 @@ test('Single-entry operations', async (t) => {
     assert.deepEqual(
       results.keys,
       new BigUint64Array([16n, 25n]),
-      'keys should not include 15'
+      "keys should not include 15",
     );
   });
 });
 
-test('Batch operations', async (t) => {
-  await t.test('add', () => {
-    const indexBatch = new usearch.Index(2, 'l2sq');
+test("Batch operations", async (t) => {
+  await t.test("add", () => {
+    const indexBatch = new usearch.Index(2, "l2sq");
 
     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');
+    assert.equal(indexBatch.size(), 2, "size after adding batch should be 2");
 
     const results = indexBatch.search(new Float32Array([13, 14]), 2);
 
     assert.deepEqual(
       results.keys,
       new BigUint64Array([15n, 16n]),
-      'keys should be 15 and 16'
+      "keys should be 15 and 16",
     );
     assert.deepEqual(
       results.distances,
       new Float32Array([45, 130]),
-      'distances should be 45 and 130'
+      "distances should be 45 and 130",
     );
   });
 
-  await t.test('remove', () => {
-    const indexBatch = new usearch.Index(2, 'l2sq');
+  await t.test("remove", () => {
+    const indexBatch = new usearch.Index(2, "l2sq");
 
     const keys = [15n, 16n, 25n, 26n];
     const vectors = [
@@ -147,53 +147,58 @@ test('Batch operations', async (t) => {
     indexBatch.add(keys, vectors);
 
     assert.deepEqual(indexBatch.remove([15n, 25n]), [1, 1]);
-    assert.equal(indexBatch.size(), 2, 'size after removing batch should be 2');
+    assert.equal(indexBatch.size(), 2, "size after removing batch should be 2");
 
     const results = indexBatch.search(new Float32Array([13, 14]), 2);
 
     assert.deepEqual(
       results.keys,
       new BigUint64Array([16n, 26n]),
-      'keys should not include 15 and 25'
+      "keys should not include 15 and 25",
     );
   });
 
-  await t.test('search', () => {
-    const indexBatch = new usearch.Index(3, 'l2sq');
+  await t.test("search", () => {
+    const indexBatch = new usearch.Index(3, "l2sq");
 
     const keys = [15n, 16n];
-    const vectors = [new Float32Array([10, 20, 30]), new Float32Array([10, 25, 35])];
+    const vectors = [
+      new Float32Array([10, 20, 30]),
+      new Float32Array([10, 25, 35]),
+    ];
 
     indexBatch.add(keys, vectors);
-    assert.equal(indexBatch.size(), 2, 'size after adding batch should be 2');
+    assert.equal(indexBatch.size(), 2, "size after adding batch should be 2");
+
+    const results = indexBatch.search(
+      [new Float32Array([13, 14, 15]), new Float32Array([13, 14, 15])],
+      2,
+    );
 
-    const results = indexBatch.search([new Float32Array([13, 14, 15]), new Float32Array([13, 14, 15])], 2);
-    
-    assert.equal(results.k, 2, 'k should be 2');
+    assert.equal(results.k, 2, "k should be 2");
 
     assert.deepEqual(
       results.counts,
-      new BigUint64Array([ 2n, 2n ]) ,
-      'counts should be 2 for both keys'
+      new BigUint64Array([2n, 2n]),
+      "counts should be 2 for both keys",
     );
 
     assert.deepEqual(
       results.keys,
       new BigUint64Array([15n, 16n, 15n, 16n]),
-      'keys should be 15 and 16'
+      "keys should be 15 and 16",
     );
     assert.deepEqual(
       results.distances,
-      new Float32Array( [ 270, 530, 270, 530 ]),
-      'distances should be 270 and 530'
+      new Float32Array([270, 530, 270, 530]),
+      "distances should be 270 and 530",
     );
   });
-
 });
 
-test('Expected results', () => {
+test("Expected results", () => {
   const index = new usearch.Index({
-    metric: 'l2sq',
+    metric: "l2sq",
     connectivity: 16,
     dimensions: 3,
   });
@@ -205,9 +210,9 @@ test('Expected results', () => {
   assertAlmostEqual(results.distances[0], new Float32Array([0]));
 });
 
-test('Multithread search returns same results', () => {
+test("Multithread search returns same results", () => {
   const index = new usearch.Index({
-    metric: 'l2sq',
+    metric: "l2sq",
     connectivity: 16,
     dimensions: 3,
   });
@@ -218,14 +223,14 @@ test('Multithread search returns same results', () => {
   const results_2 = index.search(
     new Float32Array([0.2, 0.6, 0.4]),
     10,
-    THREADS
+    THREADS,
   );
 
   assert.deepEqual(results_1.keys, results_2.keys);
   assertAlmostEqual(results_1.distances, results_2.distances);
 });
 
-test('Exact search', async (t) => {
+test("Exact search", async (t) => {
   const dataset = [
     new Float32Array([0.2, 0.6, 0.4]),
     new Float32Array([0.6, 0.6, 0.4]),
@@ -233,16 +238,16 @@ test('Exact search', async (t) => {
   const queries = new Float32Array([0.2, 0.6, 0.4]);
   const dimensions = 3;
   const count = 2;
-  const metric = 'l2sq';
+  const metric = "l2sq";
 
-  await t.test('Single core search', () => {
+  await t.test("Single core search", () => {
     const result = usearch.exactSearch(
       dataset,
       queries,
       dimensions,
       count,
       metric,
-      1 // threads
+      1, // threads
     );
 
     assert.deepEqual(result.keys, new BigUint64Array([0n, 1n]));
@@ -250,14 +255,14 @@ test('Exact search', async (t) => {
     assertAlmostEqual(new Float32Array([0.16]), result.distances[1]);
   });
 
-  await t.test('Multithreaded search', () => {
+  await t.test("Multithreaded search", () => {
     const result = usearch.exactSearch(
       dataset,
       queries,
       dimensions,
       count,
       metric,
-      THREADS // threads
+      THREADS, // threads
     );
 
     assert.deepEqual(result.keys, new BigUint64Array([0n, 1n]));
@@ -266,30 +271,30 @@ test('Exact search', async (t) => {
   });
 });
 
-test('Expected count()', async (t) => {
+test("Expected count()", async (t) => {
   const index = new usearch.Index({
-    metric: 'l2sq',
+    metric: "l2sq",
     connectivity: 16,
     dimensions: 3,
   });
   index.add(
     [42n, 43n],
-    [new Float32Array([0.2, 0.6, 0.4]), new Float32Array([0.2, 0.6, 0.4])]
+    [new Float32Array([0.2, 0.6, 0.4]), new Float32Array([0.2, 0.6, 0.4])],
   );
 
-  await t.test('Argument is a number', () => {
+  await t.test("Argument is a number", () => {
     assert.equal(1, index.count(43n));
   });
-  await t.test('Argument is a number (does not exist)', () => {
+  await t.test("Argument is a number (does not exist)", () => {
     assert.equal(0, index.count(44n));
   });
-  await t.test('Argument is an array', () => {
+  await t.test("Argument is an array", () => {
     assert.deepEqual([1, 1, 0], index.count([42n, 43n, 44n]));
   });
 });
 
-test('Operations with invalid values', () => {
-  const indexBatch = new usearch.Index(2, 'l2sq');
+test("Operations with invalid values", () => {
+  const indexBatch = new usearch.Index(2, "l2sq");
 
   const keys = [NaN, 16n];
   const vectors = [new Float32Array([10, 30]), new Float32Array([1, 5])];
@@ -301,10 +306,10 @@ test('Operations with invalid values', () => {
   assert.throws(() => indexBatch.search(NaN, 2));
 });
 
-test('Invalid operations', async (t) => {
-  await t.test('Add the same keys', () => {
+test("Invalid operations", async (t) => {
+  await t.test("Add the same keys", () => {
     const index = new usearch.Index({
-      metric: 'l2sq',
+      metric: "l2sq",
       connectivity: 16,
       dimensions: 3,
     });
@@ -312,9 +317,9 @@ test('Invalid operations', async (t) => {
     assert.throws(() => index.add(42n, new Float32Array([0.2, 0.6, 0.4])));
   });
 
-  await t.test('Batch add containing the same key', () => {
+  await t.test("Batch add containing the same key", () => {
     const index = new usearch.Index({
-      metric: 'l2sq',
+      metric: "l2sq",
       connectivity: 16,
       dimensions: 3,
     });
@@ -326,18 +331,18 @@ test('Invalid operations', async (t) => {
           [0.1, 0.6, 0.4],
           [0.2, 0.6, 0.4],
           [0.3, 0.6, 0.4],
-        ]
+        ],
       );
     });
   });
 });
 
-test('Serialization', async (t) => {
-  const indexPath = path.join(os.tmpdir(), 'usearch.test.index');
+test("Serialization", async (t) => {
+  const indexPath = path.join(os.tmpdir(), "usearch.test.index");
 
   t.beforeEach(() => {
     const index = new usearch.Index({
-      metric: 'l2sq',
+      metric: "l2sq",
       connectivity: 16,
       dimensions: 3,
     });
@@ -349,9 +354,9 @@ test('Serialization', async (t) => {
     fs.unlinkSync(indexPath);
   });
 
-  await t.test('load', () => {
+  await t.test("load", () => {
     const index = new usearch.Index({
-      metric: 'l2sq',
+      metric: "l2sq",
       connectivity: 16,
       dimensions: 3,
     });
@@ -359,7 +364,7 @@ test('Serialization', async (t) => {
     const results = index.search(
       new Float32Array([0.2, 0.6, 0.4]),
       10,
-      THREADS
+      THREADS,
     );
 
     assert.equal(index.size(), 1);
@@ -371,11 +376,11 @@ test('Serialization', async (t) => {
   // The following error in afterEach().
   // `error: "EBUSY: resource busy or locked, unlink`
   await t.test(
-    'view: Read data',
-    { skip: process.platform === 'win32' },
+    "view: Read data",
+    { skip: process.platform === "win32" },
     () => {
       const index = new usearch.Index({
-        metric: 'l2sq',
+        metric: "l2sq",
         connectivity: 16,
         dimensions: 3,
       });
@@ -385,15 +390,15 @@ test('Serialization', async (t) => {
       assert.equal(index.size(), 1);
       assert.deepEqual(results.keys, new BigUint64Array([42n]));
       assertAlmostEqual(results.distances[0], new Float32Array([0]));
-    }
+    },
   );
 
   await t.test(
-    'view: Invalid operations: add',
-    { skip: process.platform === 'win32' },
+    "view: Invalid operations: add",
+    { skip: process.platform === "win32" },
     () => {
       const index = new usearch.Index({
-        metric: 'l2sq',
+        metric: "l2sq",
         connectivity: 16,
         dimensions: 3,
       });
@@ -401,15 +406,15 @@ test('Serialization', async (t) => {
 
       // Can't add to an immutable index
       assert.throws(() => index.add(43n, new Float32Array([0.2, 0.6, 0.4])));
-    }
+    },
   );
 
   await t.test(
-    'view: Invalid operations: remove',
-    { skip: process.platform === 'win32' },
+    "view: Invalid operations: remove",
+    { skip: process.platform === "win32" },
     () => {
       const index = new usearch.Index({
-        metric: 'l2sq',
+        metric: "l2sq",
         connectivity: 16,
         dimensions: 3,
       });
@@ -417,6 +422,24 @@ test('Serialization', async (t) => {
 
       // Can't remove from an immutable index
       assert.throws(() => index.remove(42n));
-    }
+    },
   );
 });
+
+test("Mini-float quantization types", async (t) => {
+  for (const quantization of ["e5m2", "e4m3", "e3m2", "e2m3"]) {
+    await t.test(`add and search with ${quantization}`, () => {
+      const index = new usearch.Index({
+        metric: "cos",
+        dimensions: 64,
+        quantization: quantization,
+      });
+      const vector = new Float32Array(64);
+      for (let i = 0; i < 64; i++) vector[i] = i * 0.1;
+      index.add(1n, vector);
+
+      const results = index.search(vector, 1);
+      assert.equal(results.keys[0], 1n);
+    });
+  }
+});

package/numkong/CITATION.cff

@@ -3,7 +3,7 @@ title: "NumKong: 2000 Mixed Precision Kernels For All"
 message: "If you use this software, please cite it as below."
 type: software
 license: Apache-2.0
-version: 7.5.0
+version: 7.6.0
 repository-code: https://github.com/ashvardanian/NumKong
 url: https://ashvardanian.com/posts/numkong/
 abstract: >-

package/numkong/Cargo.toml

@@ -19,7 +19,7 @@ name = "numkong"
 readme = "rust/README.md"
 repository = "https://github.com/ashvardanian/NumKong" 
 rust-version = "1.64" # Introduced Core C FFI in stable Rust
-version = "7.5.0" 
+version = "7.6.0" 
 
 [lib]
 name = "numkong"

package/numkong/bench/bench_cross_amx.cpp

@@ -58,5 +58,17 @@ void bench_cross_amx() {
     run_euclideans_packed<f16_k>("euclideans_packed_f16_graniteamx", nk_dots_packed_size_f16_graniteamx,
                                  nk_dots_pack_f16_graniteamx, nk_euclideans_packed_f16_graniteamx);
     run_euclideans_symmetric<f16_k>("euclideans_symmetric_f16_graniteamx", nk_euclideans_symmetric_f16_graniteamx);
+
+    run_dots_packed<e5m2_k>("dots_packed_e5m2_graniteamx", nk_dots_packed_size_e5m2_graniteamx,
+                            nk_dots_pack_e5m2_graniteamx, nk_dots_packed_e5m2_graniteamx);
+    run_dots_symmetric<e5m2_k>("dots_symmetric_e5m2_graniteamx", nk_dots_symmetric_e5m2_graniteamx);
+
+    run_angulars_packed<e5m2_k>("angulars_packed_e5m2_graniteamx", nk_dots_packed_size_e5m2_graniteamx,
+                                nk_dots_pack_e5m2_graniteamx, nk_angulars_packed_e5m2_graniteamx);
+    run_angulars_symmetric<e5m2_k>("angulars_symmetric_e5m2_graniteamx", nk_angulars_symmetric_e5m2_graniteamx);
+
+    run_euclideans_packed<e5m2_k>("euclideans_packed_e5m2_graniteamx", nk_dots_packed_size_e5m2_graniteamx,
+                                  nk_dots_pack_e5m2_graniteamx, nk_euclideans_packed_e5m2_graniteamx);
+    run_euclideans_symmetric<e5m2_k>("euclideans_symmetric_e5m2_graniteamx", nk_euclideans_symmetric_e5m2_graniteamx);
 #endif
 }

package/numkong/bench/bench_mesh.cpp

@@ -84,6 +84,12 @@ void bench_mesh() {
     run_mesh<bf16_k>("umeyama_bf16_neonbfdot", nk_umeyama_bf16_neonbfdot);
 #endif
 
+#if NK_TARGET_NEONFHM
+    run_mesh<f16_k>("rmsd_f16_neonfhm", nk_rmsd_f16_neonfhm);
+    run_mesh<f16_k>("kabsch_f16_neonfhm", nk_kabsch_f16_neonfhm);
+    run_mesh<f16_k>("umeyama_f16_neonfhm", nk_umeyama_f16_neonfhm);
+#endif
+
 #if NK_TARGET_HASWELL
     run_mesh<f32_k>("rmsd_f32_haswell", nk_rmsd_f32_haswell);
     run_mesh<f32_k>("kabsch_f32_haswell", nk_kabsch_f32_haswell);
@@ -114,6 +120,12 @@ void bench_mesh() {
     run_mesh<bf16_k>("umeyama_bf16_skylake", nk_umeyama_bf16_skylake);
 #endif
 
+#if NK_TARGET_GENOA
+    run_mesh<bf16_k>("rmsd_bf16_genoa", nk_rmsd_bf16_genoa);
+    run_mesh<bf16_k>("kabsch_bf16_genoa", nk_kabsch_bf16_genoa);
+    run_mesh<bf16_k>("umeyama_bf16_genoa", nk_umeyama_bf16_genoa);
+#endif
+
 #if NK_TARGET_RVV
     run_mesh<f32_k>("rmsd_f32_rvv", nk_rmsd_f32_rvv);
     run_mesh<f32_k>("kabsch_f32_rvv", nk_kabsch_f32_rvv);

package/numkong/bench/bench_spatial.cpp

@@ -232,9 +232,6 @@ void bench_spatial() {
     run_dense<bf16_k, f32_k>("angular_bf16_genoa", nk_angular_bf16_genoa);
     run_dense<bf16_k, f32_k>("sqeuclidean_bf16_genoa", nk_sqeuclidean_bf16_genoa);
     run_dense<bf16_k, f32_k>("euclidean_bf16_genoa", nk_euclidean_bf16_genoa);
-    run_dense<e5m2_k, f32_k>("angular_e5m2_genoa", nk_angular_e5m2_genoa);
-    run_dense<e5m2_k, f32_k>("sqeuclidean_e5m2_genoa", nk_sqeuclidean_e5m2_genoa);
-    run_dense<e5m2_k, f32_k>("euclidean_e5m2_genoa", nk_euclidean_e5m2_genoa);
 #endif
 
 #if NK_TARGET_DIAMOND

package/numkong/binding.gyp

@@ -70,6 +70,7 @@
             },
             "conditions": [
                 # Pin TU baseline to each arch's ABI floor; SIMD kernels use per-function pragmas.
+                # Keep per-arch table in sync with cmake/nk_compiler_flags.cmake, build.rs, setup.py.
                 [
                     "OS!='win' and target_arch=='arm64'",
                     {
@@ -94,6 +95,23 @@
                         ]
                     }
                 ],
+                [
+                    "OS!='win' and target_arch=='ppc64'",
+                    {
+                        "cflags": [
+                            "-mcpu=power8"
+                        ]
+                    }
+                ],
+                [
+                    "OS!='win' and target_arch=='loong64'",
+                    {
+                        "cflags": [
+                            "-march=loongarch64",
+                            "-mlasx"
+                        ]
+                    }
+                ],
                 # Forbid auto-vectorization so serial fallbacks don't get silently
                 # promoted to NEON/SSE2/VSX. SIMD kernels use explicit intrinsics
                 # and per-function `target` pragmas; unaffected. MSVC has no

package/numkong/build.rs

@@ -376,6 +376,7 @@ fn build_numkong() -> Result<HashMap<String, bool>, String> {
 
     // Pin TU baseline to each arch's ABI floor; SIMD kernels carry per-function pragmas.
     // `NK_MARCH_NATIVE=1` opts into a host-tuned, non-portable build (ignored on MSVC).
+    // Keep per-arch table in sync with cmake/nk_compiler_flags.cmake, setup.py, binding.gyp.
     let march_native = env::var("NK_MARCH_NATIVE").is_ok_and(|v| v == "1" || v == "true");
     // Portable baseline: pin TU ISA floor + forbid auto-vectorization so serial
     // fallbacks don't get silently promoted to NEON/SSE2/VSX. SIMD kernels use

package/numkong/c/dispatch_e5m2.c

@@ -113,6 +113,29 @@ void nk_dispatch_e5m2_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_pun
         default: break;
         }
 #endif
+#if NK_TARGET_GRANITEAMX
+    if (v & nk_cap_graniteamx_k) switch (k) {
+        case nk_kernel_dots_packed_size_k:
+            *m = (m_t)&nk_dots_packed_size_e5m2_graniteamx, *c = nk_cap_graniteamx_k;
+            return;
+        case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_e5m2_graniteamx, *c = nk_cap_graniteamx_k; return;
+        case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_e5m2_graniteamx, *c = nk_cap_graniteamx_k; return;
+        case nk_kernel_angulars_packed_k:
+            *m = (m_t)&nk_angulars_packed_e5m2_graniteamx, *c = nk_cap_graniteamx_k;
+            return;
+        case nk_kernel_euclideans_packed_k:
+            *m = (m_t)&nk_euclideans_packed_e5m2_graniteamx, *c = nk_cap_graniteamx_k;
+            return;
+        case nk_kernel_dots_symmetric_k: *m = (m_t)&nk_dots_symmetric_e5m2_graniteamx, *c = nk_cap_graniteamx_k; return;
+        case nk_kernel_angulars_symmetric_k:
+            *m = (m_t)&nk_angulars_symmetric_e5m2_graniteamx, *c = nk_cap_graniteamx_k;
+            return;
+        case nk_kernel_euclideans_symmetric_k:
+            *m = (m_t)&nk_euclideans_symmetric_e5m2_graniteamx, *c = nk_cap_graniteamx_k;
+            return;
+        default: break;
+        }
+#endif
 #if NK_TARGET_SAPPHIREAMX
     if (v & nk_cap_sapphireamx_k) switch (k) {
         case nk_kernel_dots_packed_size_k:
@@ -162,9 +185,6 @@ void nk_dispatch_e5m2_find_(nk_capability_t v, nk_kernel_kind_t k, nk_kernel_pun
 #if NK_TARGET_GENOA
     if (v & nk_cap_genoa_k) switch (k) {
         case nk_kernel_dot_k: *m = (m_t)&nk_dot_e5m2_genoa, *c = nk_cap_genoa_k; return;
-        case nk_kernel_euclidean_k: *m = (m_t)&nk_euclidean_e5m2_genoa, *c = nk_cap_genoa_k; return;
-        case nk_kernel_sqeuclidean_k: *m = (m_t)&nk_sqeuclidean_e5m2_genoa, *c = nk_cap_genoa_k; return;
-        case nk_kernel_angular_k: *m = (m_t)&nk_angular_e5m2_genoa, *c = nk_cap_genoa_k; return;
         case nk_kernel_dots_packed_size_k: *m = (m_t)&nk_dots_packed_size_e5m2_genoa, *c = nk_cap_genoa_k; return;
         case nk_kernel_dots_pack_k: *m = (m_t)&nk_dots_pack_e5m2_genoa, *c = nk_cap_genoa_k; return;
         case nk_kernel_dots_packed_k: *m = (m_t)&nk_dots_packed_e5m2_genoa, *c = nk_cap_genoa_k; return;