numkong 7.0.0 → 7.4.2

package/javascript/dist/esm/numkong.d.ts

@@ -43,7 +43,7 @@ export declare const Capability: {
     readonly SVE: bigint;
     readonly SVEHALF: bigint;
     readonly SVESDOT: bigint;
-    readonly SIERRA: bigint;
+    readonly ALDER: bigint;
     readonly SVEBFDOT: bigint;
     readonly SVE2: bigint;
     readonly V128RELAXED: bigint;
@@ -64,6 +64,12 @@ export declare const Capability: {
     readonly SMEBF16: bigint;
     readonly SMELUT2: bigint;
     readonly RVVBB: bigint;
+    readonly SIERRA: bigint;
+    readonly SMEBI32: bigint;
+    readonly LOONGSONASX: bigint;
+    readonly POWERVSX: bigint;
+    readonly DIAMOND: bigint;
+    readonly NEONFP8: bigint;
 };
 export { Float16Array, BFloat16Array, E4M3Array, E5M2Array, BinaryArray, TensorBase, VectorBase, VectorView, Vector, MatrixBase, Matrix, PackedMatrix, outputDtype };
 /** Convert a single FP16 value (as uint16 bits) to FP32 */

package/javascript/dist/esm/numkong.js

@@ -25,15 +25,27 @@
  * ```
  */
 import build from "node-gyp-build";
+import { createRequire } from "node:module";
 import * as path from "node:path";
 import { existsSync } from "node:fs";
 import { getFileName, getRoot } from "bindings";
 import { setConversionFunctions, Float16Array, BFloat16Array, E4M3Array, E5M2Array, BinaryArray, TensorBase, VectorBase, VectorView, Vector, MatrixBase, Matrix, PackedMatrix, DType, dtypeToString, outputDtype } from "./types.js";
-let compiled;
-try {
-    let builddir = getBuildDir(getDirName());
-    compiled = build(builddir);
-    // Initialize conversion functions for types.ts
+function loadNativeAddon() {
+    // Tier 1: platform-specific optional dependency (@numkong/<os>-<arch>)
+    try {
+        const req = createRequire(path.join(getDirName(), "noop.js"));
+        return req(`@numkong/${process.platform}-${process.arch}`);
+    }
+    catch { }
+    // Tier 2: node-gyp-build fallback (local dev, unsupported platform, build-from-source)
+    try {
+        return build(getBuildDir(getDirName()));
+    }
+    catch { }
+    return null;
+}
+let compiled = loadNativeAddon();
+if (compiled) {
     setConversionFunctions({
         castF16ToF32: compiled.castF16ToF32,
         castF32ToF16: compiled.castF32ToF16,
@@ -46,11 +58,10 @@ try {
         cast: compiled.cast,
     });
 }
-catch (e) {
-    // Native addon not available
-    // For WASM usage, import the Emscripten module directly (see test/test-wasm.mjs)
-    throw new Error("NumKong native addon not found. Build with `npm run build` or use WASM " +
-        "by importing the Emscripten module directly. See test/test-wasm.mjs for examples.");
+else {
+    throw new Error("NumKong native addon not found. Install with `npm install numkong` (which fetches " +
+        "the prebuilt binary), or build from source with `npm run install`. " +
+        "For WASM, import from 'numkong/wasm' instead.");
 }
 /**
  * CPU capability bit masks in chronological order (by first commercial silicon).
@@ -70,7 +81,7 @@ export const Capability = {
     SVE: 1n << 10n, // 2020: ARM SVE
     SVEHALF: 1n << 11n, // 2020: ARM SVE FP16
     SVESDOT: 1n << 12n, // 2020: ARM SVE i8 dot
-    SIERRA: 1n << 13n, // 2021: Intel AVX2+VNNI
+    ALDER: 1n << 13n, // 2021: Intel AVX2+VNNI
     SVEBFDOT: 1n << 14n, // 2021: ARM SVE BF16
     SVE2: 1n << 15n, // 2022: ARM SVE2
     V128RELAXED: 1n << 16n, // 2022: WASM Relaxed SIMD
@@ -91,6 +102,12 @@ export const Capability = {
     SMEBF16: 1n << 31n, // 2025+: ARM SME B16B16
     SMELUT2: 1n << 32n, // 2025+: ARM SME LUTv2
     RVVBB: 1n << 33n, // 2025+: RISC-V Zvbb
+    SIERRA: 1n << 34n, // 2024: Intel AVXVNNIINT8
+    SMEBI32: 1n << 35n, // 2025+: ARM SME BI32I32
+    LOONGSONASX: 1n << 36n, // LoongArch LASX 256-bit SIMD
+    POWERVSX: 1n << 37n, // Power VSX 128-bit SIMD
+    DIAMOND: 1n << 38n, // 2025+: Intel AVX10.2
+    NEONFP8: 1n << 39n, // ARM NEON FP8
 };
 export { Float16Array, BFloat16Array, E4M3Array, E5M2Array, BinaryArray, TensorBase, VectorBase, VectorView, Vector, MatrixBase, Matrix, PackedMatrix, outputDtype };
 /** Convert a single FP16 value (as uint16 bits) to FP32 */
@@ -448,5 +465,14 @@ function getDirName() {
             return __dirname;
     }
     catch (e) { }
+    // Fall back to cwd, which is typically the project root in dev and CI.
+    // This helps runtimes like Deno and Bun where the `bindings` module's
+    // V8 stack-trace hack may not resolve correctly.
+    try {
+        const cwd = process.cwd();
+        if (existsSync(path.join(cwd, "build")) || existsSync(path.join(cwd, "prebuilds")))
+            return cwd;
+    }
+    catch (e) { }
     return getRoot(getFileName());
 }

package/javascript/dist/esm/types.d.ts

@@ -74,6 +74,7 @@ export declare abstract class VectorBase extends TensorBase {
  */
 export declare class VectorView extends VectorBase {
     constructor(buffer: ArrayBuffer, byteOffset: number, length: number, dtype: DType);
+    toString(): string;
     /** @brief Create a VectorView from any TypedArray, inferring or accepting dtype. */
     static from(arr: TypedArray, dtype?: DType): VectorView;
 }
@@ -86,6 +87,7 @@ export declare class VectorView extends VectorBase {
 export declare class Vector extends VectorBase {
     constructor(length: number, dtype: DType);
     constructor(buffer: ArrayBuffer, length: number, dtype: DType);
+    toString(): string;
     /** @brief Create an owning Vector by copying data from a TypedArray. */
     static fromTypedArray(arr: TypedArray, dtype?: DType): Vector;
     /** @brief Create an owning Vector by copying data from any TensorBase. */
@@ -117,6 +119,7 @@ export declare abstract class MatrixBase extends TensorBase {
 export declare class Matrix extends MatrixBase {
     constructor(rows: number, cols: number, dtype: DType);
     constructor(buffer: ArrayBuffer, byteOffset: number, dtype: DType, rows: number, cols: number, rowStride?: number, colStride?: number);
+    toString(): string;
     static fromTypedArray(array: TypedArray, rows: number, cols: number, dtype?: DType): Matrix;
     toTypedArray(): TypedArray;
     row(index: number): VectorView;
@@ -138,6 +141,7 @@ export declare class PackedMatrix {
     constructor(buffer: ArrayBuffer, width: number, depth: number, dtype: DType, byteLength: number);
     dispose(): void;
     get disposed(): boolean;
+    toString(): string;
 }
 /** @brief Kernel family identifiers for output dtype resolution. */
 export type KernelFamily = 'dots' | 'angulars' | 'euclideans';
@@ -174,6 +178,7 @@ export declare class Float16Array extends Uint16Array {
      * @param value f32 value to encode and store
      */
     setFloat32(index: number, value: number): void;
+    toString(): string;
 }
 /**
  * @brief Brain Float 16 (bf16)
@@ -190,6 +195,7 @@ export declare class BFloat16Array extends Uint16Array {
     toFloat32Array(): Float32Array;
     getFloat32(index: number): number;
     setFloat32(index: number, value: number): void;
+    toString(): string;
 }
 /**
  * @brief FP8 E4M3 (4-bit exponent, 3-bit mantissa)
@@ -205,6 +211,7 @@ export declare class E4M3Array extends Uint8Array {
     toFloat32Array(): Float32Array;
     getFloat32(index: number): number;
     setFloat32(index: number, value: number): void;
+    toString(): string;
 }
 /**
  * @brief FP8 E5M2 (5-bit exponent, 2-bit mantissa)
@@ -220,6 +227,7 @@ export declare class E5M2Array extends Uint8Array {
     toFloat32Array(): Float32Array;
     getFloat32(index: number): number;
     setFloat32(index: number, value: number): void;
+    toString(): string;
 }
 /**
  * @brief Binary Array (u1) - Bit-packed binary vectors
@@ -260,6 +268,7 @@ export declare class BinaryArray extends Uint8Array {
      * @returns Binary array with quantized values
      */
     static fromFloat64Array(vector: Float64Array): BinaryArray;
+    toString(): string;
 }
 /**
  * @brief Type guard to check if an object is a Float16Array.

package/javascript/dist/esm/types.js

@@ -102,6 +102,12 @@ export class VectorView extends VectorBase {
     constructor(buffer, byteOffset, length, dtype) {
         super(buffer, byteOffset, length, dtype);
     }
+    toString() {
+        return `VectorView(${this.length}, ${dtypeToString(this.dtype)})`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
     /** @brief Create a VectorView from any TypedArray, inferring or accepting dtype. */
     static from(arr, dtype) {
         const d = dtype ?? inferDtype(arr);
@@ -143,6 +149,12 @@ export class Vector extends VectorBase {
             super(lengthOrBuffer, 0, dtypeOrLength, dtype);
         }
     }
+    toString() {
+        return `Vector(${this.length}, ${dtypeToString(this.dtype)})`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
     /** @brief Create an owning Vector by copying data from a TypedArray. */
     static fromTypedArray(arr, dtype) {
         const d = dtype ?? inferDtype(arr);
@@ -238,6 +250,12 @@ export class Matrix extends MatrixBase {
             super(rowsOrBuffer, colsOrByteOffset, dtype, r, c, rowStride ?? c * bpe, colStride ?? bpe);
         }
     }
+    toString() {
+        return `Matrix(${this.rows}\u00d7${this.cols}, ${dtypeToString(this.dtype)})`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
     static fromTypedArray(array, rows, cols, dtype) {
         const d = dtype ?? inferDtype(array);
         const buf = array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength);
@@ -277,6 +295,12 @@ export class PackedMatrix {
     }
     dispose() { this._disposed = true; }
     get disposed() { return this._disposed; }
+    toString() {
+        return `PackedMatrix(${this.width}\u00d7${this.depth}, ${dtypeToString(this.dtype)}, ${this.byteLength} bytes)`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
 }
 /**
  * @brief Determines the output dtype for a given kernel family and input dtype.
@@ -363,6 +387,21 @@ export class Float16Array extends Uint16Array {
         }
         this[index] = conversionFunctions.castF32ToF16(value);
     }
+    toString() {
+        if (!conversionFunctions)
+            return `Float16Array(${this.length})`;
+        const limit = Math.min(this.length, 20);
+        const parts = [];
+        for (let i = 0; i < limit; i++) {
+            const f = conversionFunctions.castF16ToF32(this[i]);
+            parts.push(`${f} [0x${this[i].toString(16).padStart(4, '0')}]`);
+        }
+        const suffix = this.length > 20 ? ', ...' : '';
+        return `Float16Array(${this.length}) [${parts.join(', ')}${suffix}]`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
 }
 /**
  * @brief Brain Float 16 (bf16)
@@ -415,6 +454,21 @@ export class BFloat16Array extends Uint16Array {
         }
         this[index] = conversionFunctions.castF32ToBF16(value);
     }
+    toString() {
+        if (!conversionFunctions)
+            return `BFloat16Array(${this.length})`;
+        const limit = Math.min(this.length, 20);
+        const parts = [];
+        for (let i = 0; i < limit; i++) {
+            const f = conversionFunctions.castBF16ToF32(this[i]);
+            parts.push(`${f} [0x${this[i].toString(16).padStart(4, '0')}]`);
+        }
+        const suffix = this.length > 20 ? ', ...' : '';
+        return `BFloat16Array(${this.length}) [${parts.join(', ')}${suffix}]`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
 }
 /**
  * @brief FP8 E4M3 (4-bit exponent, 3-bit mantissa)
@@ -466,6 +520,21 @@ export class E4M3Array extends Uint8Array {
         }
         this[index] = conversionFunctions.castF32ToE4M3(value);
     }
+    toString() {
+        if (!conversionFunctions)
+            return `E4M3Array(${this.length})`;
+        const limit = Math.min(this.length, 20);
+        const parts = [];
+        for (let i = 0; i < limit; i++) {
+            const f = conversionFunctions.castE4M3ToF32(this[i]);
+            parts.push(`${f} [0x${this[i].toString(16).padStart(2, '0')}]`);
+        }
+        const suffix = this.length > 20 ? ', ...' : '';
+        return `E4M3Array(${this.length}) [${parts.join(', ')}${suffix}]`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
 }
 /**
  * @brief FP8 E5M2 (5-bit exponent, 2-bit mantissa)
@@ -517,6 +586,21 @@ export class E5M2Array extends Uint8Array {
         }
         this[index] = conversionFunctions.castF32ToE5M2(value);
     }
+    toString() {
+        if (!conversionFunctions)
+            return `E5M2Array(${this.length})`;
+        const limit = Math.min(this.length, 20);
+        const parts = [];
+        for (let i = 0; i < limit; i++) {
+            const f = conversionFunctions.castE5M2ToF32(this[i]);
+            parts.push(`${f} [0x${this[i].toString(16).padStart(2, '0')}]`);
+        }
+        const suffix = this.length > 20 ? ', ...' : '';
+        return `E5M2Array(${this.length}) [${parts.join(', ')}${suffix}]`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
 }
 /**
  * @brief Binary Array (u1) - Bit-packed binary vectors
@@ -597,6 +681,18 @@ export class BinaryArray extends Uint8Array {
         }
         return binary;
     }
+    toString() {
+        const limit = Math.min(this.length, 20);
+        const parts = [];
+        for (let i = 0; i < limit; i++) {
+            parts.push(`0b${this[i].toString(2).padStart(8, '0')}`);
+        }
+        const suffix = this.length > 20 ? ', ...' : '';
+        return `BinaryArray(${this._bitLength}) [${parts.join(', ')}${suffix}]`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
 }
 /**
  * @brief Type guard to check if an object is a Float16Array.

package/javascript/node-gyp-build.d.ts

@@ -1 +1,4 @@
-declare module "node-gyp-build";
+declare module "node-gyp-build" {
+    function build(dir: string): any;
+    export = build;
+}

package/javascript/numkong-browser.ts

@@ -0,0 +1,40 @@
+/**
+ * @brief Self-contained browser ESM entry point for NumKong WASM.
+ * @file javascript/numkong-browser.ts
+ *
+ * Auto-initializes the Emscripten module on import via top-level await.
+ * The Emscripten glue (`numkong-emscripten.js`) and binary (`numkong.wasm`)
+ * must be co-located with this file (same directory or CDN prefix).
+ *
+ * Usage:
+ *   import { dot, euclidean } from './numkong.js';
+ *   console.log(dot(new Float32Array([1,2,3]), new Float32Array([4,5,6])));
+ */
+
+export {
+    TensorBase, VectorBase, VectorView, Vector,
+    MatrixBase, Matrix, PackedMatrix,
+    DType, TypedArray, KernelFamily,
+    dtypeToString, outputDtype,
+    Float16Array, BFloat16Array, E4M3Array, E5M2Array, BinaryArray,
+    isFloat16Array, isBFloat16Array, isE4M3Array, isE5M2Array, isBinaryArray,
+} from './types.js';
+
+import { initWasm } from './numkong-wasm.js';
+export {
+    dot, inner, euclidean, sqeuclidean, angular,
+    hamming, jaccard, kullbackleibler, jensenshannon,
+    getCapabilities, hasCapability,
+    dotsPack, dotsPackedSize,
+    dotsPacked, angularsPacked, euclideansPacked,
+    dotsSymmetric, angularsSymmetric, euclideansSymmetric,
+} from './numkong-wasm.js';
+
+// Auto-initialize: load the Emscripten glue relative to this module's URL,
+// instantiate the WASM module, and wire up the wrapper before any export is used.
+const glueUrl = new URL('./numkong-emscripten.js', import.meta.url);
+const { default: NumKongModule } = await import(glueUrl.href);
+const wasmInstance = await NumKongModule({
+    locateFile: (path: string) => new URL(path, glueUrl).href,
+});
+initWasm(wasmInstance);

package/javascript/numkong-wasm.ts

@@ -80,11 +80,8 @@ let isMemory64 = false;
 let resultPtr: number = 0;
 
 // Heap views (created from wasmMemory buffer)
-let HEAP8: Int8Array;
-let HEAP16: Int16Array;
 let HEAP32: Int32Array;
 let HEAPU8: Uint8Array;
-let HEAPU16: Uint16Array;
 let HEAPU32: Uint32Array;
 let HEAPF32: Float32Array;
 let HEAPF64: Float64Array;
@@ -106,11 +103,8 @@ export function initWasm(wasmModule: EmscriptenModule): void {
 
   // Create heap views from the WASM memory buffer
   const buffer = wasmModule.wasmMemory.buffer;
-  HEAP8 = new Int8Array(buffer);
-  HEAP16 = new Int16Array(buffer);
   HEAP32 = new Int32Array(buffer);
   HEAPU8 = new Uint8Array(buffer);
-  HEAPU16 = new Uint16Array(buffer);
   HEAPU32 = new Uint32Array(buffer);
   HEAPF32 = new Float32Array(buffer);
   HEAPF64 = new Float64Array(buffer);
@@ -139,7 +133,7 @@ export function initWasm(wasmModule: EmscriptenModule): void {
 interface TypeInfo {
   dtype: DType;
   bytesPerElement: number;
-  heapView: 'HEAP8' | 'HEAP16' | 'HEAP32' | 'HEAPU8' | 'HEAPU16' | 'HEAPU32' | 'HEAPF32' | 'HEAPF64';
+  heapView: 'HEAP32' | 'HEAPU8' | 'HEAPU32' | 'HEAPF32' | 'HEAPF64';
   resultType: 'f32' | 'f64' | 'i32' | 'u32';
 }
 
@@ -152,7 +146,7 @@ function detectType(arr: any): TypeInfo {
   } else if (arr instanceof Float32Array) {
     return { dtype: DType.F32, bytesPerElement: 4, heapView: 'HEAPF32', resultType: 'f64' };
   } else if (arr instanceof Int8Array) {
-    return { dtype: DType.I8, bytesPerElement: 1, heapView: 'HEAP8', resultType: 'i32' };
+    return { dtype: DType.I8, bytesPerElement: 1, heapView: 'HEAPU8', resultType: 'i32' };
   } else if (arr instanceof Uint8Array) {
     return { dtype: DType.U8, bytesPerElement: 1, heapView: 'HEAPU8', resultType: 'u32' };
   }
@@ -161,9 +155,9 @@ function detectType(arr: any): TypeInfo {
   const constructorName = arr.constructor.name;
 
   if (constructorName === 'Float16Array') {
-    return { dtype: DType.F16, bytesPerElement: 2, heapView: 'HEAPU16', resultType: 'f32' };
+    return { dtype: DType.F16, bytesPerElement: 2, heapView: 'HEAPU8', resultType: 'f32' };
   } else if (constructorName === 'BFloat16Array') {
-    return { dtype: DType.BF16, bytesPerElement: 2, heapView: 'HEAPU16', resultType: 'f32' };
+    return { dtype: DType.BF16, bytesPerElement: 2, heapView: 'HEAPU8', resultType: 'f32' };
   } else if (constructorName === 'E4M3Array') {
     throw new Error('E4M3 not yet supported in WASM backend');
   } else if (constructorName === 'E5M2Array') {
@@ -182,9 +176,9 @@ function typeInfoFromDtype(dtype: DType): TypeInfo {
   switch (dtype) {
     case DType.F64: return { dtype, bytesPerElement: 8, heapView: 'HEAPF64', resultType: 'f64' };
     case DType.F32: return { dtype, bytesPerElement: 4, heapView: 'HEAPF32', resultType: 'f64' };
-    case DType.F16: return { dtype, bytesPerElement: 2, heapView: 'HEAPU16', resultType: 'f32' };
-    case DType.BF16: return { dtype, bytesPerElement: 2, heapView: 'HEAPU16', resultType: 'f32' };
-    case DType.I8: return { dtype, bytesPerElement: 1, heapView: 'HEAP8', resultType: 'i32' };
+    case DType.F16: return { dtype, bytesPerElement: 2, heapView: 'HEAPU8', resultType: 'f32' };
+    case DType.BF16: return { dtype, bytesPerElement: 2, heapView: 'HEAPU8', resultType: 'f32' };
+    case DType.I8: return { dtype, bytesPerElement: 1, heapView: 'HEAPU8', resultType: 'i32' };
     case DType.U8: return { dtype, bytesPerElement: 1, heapView: 'HEAPU8', resultType: 'u32' };
     case DType.U1: return { dtype, bytesPerElement: 1, heapView: 'HEAPU8', resultType: 'u32' };
     default: throw new Error(`Unsupported dtype: ${dtype}`);

package/javascript/numkong.c

@@ -65,7 +65,7 @@ static int is_compatible_napi_type(napi_typedarray_type napi_type, nk_dtype_t dt
  *  @param out_dtype The dtype of the value stored in the buffer.
  *  @return napi_value containing the result as a JavaScript Number, or NULL on error.
  */
-static napi_value scalar_to_js_number(napi_env env, nk_scalar_buffer_t const *result, nk_dtype_t out_dtype) {
+static napi_value nk_scalar_buffer_to_js_number(napi_env env, nk_scalar_buffer_t const *result, nk_dtype_t out_dtype) {
     // i64/u64 must return BigInt since they may exceed Number.MAX_SAFE_INTEGER
     if (out_dtype == nk_i64_k) {
         napi_value js_result;
@@ -77,30 +77,9 @@ static napi_value scalar_to_js_number(napi_env env, nk_scalar_buffer_t const *re
         if (napi_create_bigint_uint64(env, result->u64, &js_result) != napi_ok) return NULL;
         return js_result;
     }
-    double result_f64;
-    switch (out_dtype) {
-    case nk_f64_k: result_f64 = (double)result->f64; break;
-    case nk_f32_k: result_f64 = (double)result->f32; break;
-    case nk_f16_k: {
-        nk_f32_t t;
-        nk_f16_to_f32(&result->f16, &t);
-        result_f64 = (double)t;
-        break;
-    }
-    case nk_bf16_k: {
-        nk_f32_t t;
-        nk_bf16_to_f32(&result->bf16, &t);
-        result_f64 = (double)t;
-        break;
-    }
-    case nk_i8_k: result_f64 = (double)result->i8; break;
-    case nk_u8_k: result_f64 = (double)result->u8; break;
-    case nk_i16_k: result_f64 = (double)result->i16; break;
-    case nk_u16_k: result_f64 = (double)result->u16; break;
-    case nk_i32_k: result_f64 = (double)result->i32; break;
-    case nk_u32_k: result_f64 = (double)result->u32; break;
-    default: napi_throw_error(env, NULL, "Unexpected output dtype in result conversion"); return NULL;
-    }
+    nk_f64c_t result_c;
+    nk_scalar_buffer_to_f64c(result, out_dtype, &result_c);
+    double result_f64 = result_c.real;
     napi_value js_result;
     if (napi_create_double(env, result_f64, &js_result) != napi_ok) return NULL;
     return js_result;
@@ -209,7 +188,7 @@ static napi_value dense(napi_env env, napi_callback_info info, nk_kernel_kind_t
     nk_scalar_buffer_t result;
     metric(data_a, data_b, dimensions, &result);
 
-    return scalar_to_js_number(env, &result, out_dtype);
+    return nk_scalar_buffer_to_js_number(env, &result, out_dtype);
 }
 
 /** @brief N-API entry for inner product (dot).  */

package/javascript/numkong.ts

@@ -26,18 +26,30 @@
  */
 
 import build from "node-gyp-build";
+import { createRequire } from "node:module";
 import * as path from "node:path";
 import { existsSync } from "node:fs";
 import { getFileName, getRoot } from "bindings";
 import { setConversionFunctions, Float16Array, BFloat16Array, E4M3Array, E5M2Array, BinaryArray, TensorBase, VectorBase, VectorView, Vector, MatrixBase, Matrix, PackedMatrix, DType, dtypeToString, outputDtype, KernelFamily } from "./types.js";
 
-let compiled: any;
+function loadNativeAddon(): any {
+  // Tier 1: platform-specific optional dependency (@numkong/<os>-<arch>)
+  try {
+    const req = createRequire(path.join(getDirName(), "noop.js"));
+    return req(`@numkong/${process.platform}-${process.arch}`);
+  } catch { }
+
+  // Tier 2: node-gyp-build fallback (local dev, unsupported platform, build-from-source)
+  try {
+    return build(getBuildDir(getDirName()));
+  } catch { }
 
-try {
-  let builddir = getBuildDir(getDirName());
-  compiled = build(builddir);
+  return null;
+}
 
-  // Initialize conversion functions for types.ts
+let compiled: any = loadNativeAddon();
+
+if (compiled) {
   setConversionFunctions({
     castF16ToF32: compiled.castF16ToF32,
     castF32ToF16: compiled.castF32ToF16,
@@ -49,12 +61,11 @@ try {
     castF32ToE5M2: compiled.castF32ToE5M2,
     cast: compiled.cast,
   });
-} catch (e) {
-  // Native addon not available
-  // For WASM usage, import the Emscripten module directly (see test/test-wasm.mjs)
+} else {
   throw new Error(
-    "NumKong native addon not found. Build with `npm run build` or use WASM " +
-    "by importing the Emscripten module directly. See test/test-wasm.mjs for examples."
+    "NumKong native addon not found. Install with `npm install numkong` (which fetches " +
+    "the prebuilt binary), or build from source with `npm run install`. " +
+    "For WASM, import from 'numkong/wasm' instead."
   );
 }
 
@@ -76,7 +87,7 @@ export const Capability = {
   SVE: 1n << 10n,            // 2020: ARM SVE
   SVEHALF: 1n << 11n,        // 2020: ARM SVE FP16
   SVESDOT: 1n << 12n,        // 2020: ARM SVE i8 dot
-  SIERRA: 1n << 13n,         // 2021: Intel AVX2+VNNI
+  ALDER: 1n << 13n,          // 2021: Intel AVX2+VNNI
   SVEBFDOT: 1n << 14n,       // 2021: ARM SVE BF16
   SVE2: 1n << 15n,           // 2022: ARM SVE2
   V128RELAXED: 1n << 16n,    // 2022: WASM Relaxed SIMD
@@ -97,6 +108,12 @@ export const Capability = {
   SMEBF16: 1n << 31n,        // 2025+: ARM SME B16B16
   SMELUT2: 1n << 32n,        // 2025+: ARM SME LUTv2
   RVVBB: 1n << 33n,          // 2025+: RISC-V Zvbb
+  SIERRA: 1n << 34n,         // 2024: Intel AVXVNNIINT8
+  SMEBI32: 1n << 35n,        // 2025+: ARM SME BI32I32
+  LOONGSONASX: 1n << 36n,    // LoongArch LASX 256-bit SIMD
+  POWERVSX: 1n << 37n,       // Power VSX 128-bit SIMD
+  DIAMOND: 1n << 38n,        // 2025+: Intel AVX10.2
+  NEONFP8: 1n << 39n,        // ARM NEON FP8
 } as const;
 
 export { Float16Array, BFloat16Array, E4M3Array, E5M2Array, BinaryArray, TensorBase, VectorBase, VectorView, Vector, MatrixBase, Matrix, PackedMatrix, outputDtype };
@@ -571,5 +588,13 @@ function getDirName() {
   try {
     if (__dirname) return __dirname;
   } catch (e) { }
+  // Fall back to cwd, which is typically the project root in dev and CI.
+  // This helps runtimes like Deno and Bun where the `bindings` module's
+  // V8 stack-trace hack may not resolve correctly.
+  try {
+    const cwd = process.cwd();
+    if (existsSync(path.join(cwd, "build")) || existsSync(path.join(cwd, "prebuilds")))
+      return cwd;
+  } catch (e) { }
   return getRoot(getFileName());
 }

package/javascript/tsconfig-base.json

@@ -8,6 +8,7 @@
         "node-gyp-build.d.ts",
         "numkong.ts",
         "numkong-wasm.ts",
+        "numkong-browser.ts",
         "types.ts"
     ],
     "compilerOptions": {

package/javascript/tsconfig-cjs.json

@@ -4,5 +4,10 @@
         "module": "commonjs",
         "outDir": "dist/cjs",
         "target": "ES2020"
-    }
+    },
+    "exclude": [
+        "node_modules",
+        "dist",
+        "numkong-browser.ts"
+    ]
 }