numkong 7.0.0

package/javascript/dist/cjs/numkong-wasm.js

@@ -0,0 +1,617 @@
+"use strict";
+/**
+ * @brief WASM wrapper for NumKong providing N-API compatible interface
+ * @file javascript/numkong-wasm.ts
+ * @date February 6, 2026
+ *
+ * This module wraps the Emscripten-compiled WASM module to provide the same
+ * TypeScript API as the native N-API bindings. It handles:
+ * - Zero-copy TensorBase interop for cross-module WASM sharing
+ * - TypedArray type detection and dispatch
+ * - Result extraction from WASM heap
+ * - Error handling
+ * - Both wasm32 and wasm64 (memory64) modes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inner = void 0;
+exports.initWasm = initWasm;
+exports.sqeuclidean = sqeuclidean;
+exports.euclidean = euclidean;
+exports.angular = angular;
+exports.dot = dot;
+exports.hamming = hamming;
+exports.jaccard = jaccard;
+exports.kullbackleibler = kullbackleibler;
+exports.jensenshannon = jensenshannon;
+exports.getCapabilities = getCapabilities;
+exports.hasCapability = hasCapability;
+exports.dotsPackedSize = dotsPackedSize;
+exports.dotsPack = dotsPack;
+exports.dotsPacked = dotsPacked;
+exports.angularsPacked = angularsPacked;
+exports.euclideansPacked = euclideansPacked;
+exports.dotsSymmetric = dotsSymmetric;
+exports.angularsSymmetric = angularsSymmetric;
+exports.euclideansSymmetric = euclideansSymmetric;
+const types_js_1 = require("./types.js");
+let Module = null;
+/**
+ * Whether the WASM module uses memory64.
+ * In memory64 mode, Emscripten wraps _malloc/_free to accept/return number,
+ * but raw C function exports expect BigInt (i64) for pointer parameters.
+ * nk_size_t is always i32 (number) in WASM since NK_IS_64BIT_=0.
+ */
+let isMemory64 = false;
+// Pre-allocated 8-byte result buffer (covers f64/f32/i32/u32), allocated once in initWasm()
+// Always a number (from Emscripten-wrapped _malloc), converted to WasmPtr for C calls
+let resultPtr = 0;
+// Heap views (created from wasmMemory buffer)
+let HEAP8;
+let HEAP16;
+let HEAP32;
+let HEAPU8;
+let HEAPU16;
+let HEAPU32;
+let HEAPF32;
+let HEAPF64;
+/**
+ * Convert a number (e.g. from _malloc or byteOffset) to the pointer type
+ * expected by raw C function exports. In wasm64, pointers are i64 (BigInt).
+ */
+function toWasmPtr(n) {
+    return isMemory64 ? BigInt(n) : n;
+}
+/**
+ * Initializes the WASM backend with an Emscripten module instance.
+ * @param wasmModule - The Emscripten-compiled WASM module to use.
+ */
+function initWasm(wasmModule) {
+    Module = wasmModule;
+    // 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);
+    // Detect memory64 mode by probing whether raw C functions expect BigInt pointers.
+    // Emscripten wraps _malloc/_free to always use number, but raw C exports use i64
+    // (BigInt) for pointers in memory64 mode. We probe by calling a distance function
+    // with BigInt(0) args — if it doesn't throw, we're in memory64 mode.
+    try {
+        const probe = wasmModule._malloc(8);
+        wasmModule._nk_dot_f32(BigInt(probe), BigInt(probe), 0, BigInt(probe));
+        isMemory64 = true;
+        wasmModule._free(probe);
+    }
+    catch {
+        isMemory64 = false;
+    }
+    // Pre-allocate an 8-byte result buffer (never freed during module lifetime)
+    // _malloc always returns number (Emscripten-wrapped in both modes)
+    resultPtr = wasmModule._malloc(8);
+}
+/**
+ * Detect dtype from TypedArray constructor
+ */
+function detectType(arr) {
+    if (arr instanceof Float64Array) {
+        return { dtype: types_js_1.DType.F64, bytesPerElement: 8, heapView: 'HEAPF64', resultType: 'f64' };
+    }
+    else if (arr instanceof Float32Array) {
+        return { dtype: types_js_1.DType.F32, bytesPerElement: 4, heapView: 'HEAPF32', resultType: 'f64' };
+    }
+    else if (arr instanceof Int8Array) {
+        return { dtype: types_js_1.DType.I8, bytesPerElement: 1, heapView: 'HEAP8', resultType: 'i32' };
+    }
+    else if (arr instanceof Uint8Array) {
+        return { dtype: types_js_1.DType.U8, bytesPerElement: 1, heapView: 'HEAPU8', resultType: 'u32' };
+    }
+    // Check for custom typed arrays from types.ts
+    const constructorName = arr.constructor.name;
+    if (constructorName === 'Float16Array') {
+        return { dtype: types_js_1.DType.F16, bytesPerElement: 2, heapView: 'HEAPU16', resultType: 'f32' };
+    }
+    else if (constructorName === 'BFloat16Array') {
+        return { dtype: types_js_1.DType.BF16, bytesPerElement: 2, heapView: 'HEAPU16', resultType: 'f32' };
+    }
+    else if (constructorName === 'E4M3Array') {
+        throw new Error('E4M3 not yet supported in WASM backend');
+    }
+    else if (constructorName === 'E5M2Array') {
+        throw new Error('E5M2 not yet supported in WASM backend');
+    }
+    else if (constructorName === 'BinaryArray') {
+        return { dtype: types_js_1.DType.U1, bytesPerElement: 1, heapView: 'HEAPU8', resultType: 'u32' };
+    }
+    throw new Error(`Unsupported array type: ${constructorName}`);
+}
+/**
+ * Get TypeInfo from a DType enum value.
+ */
+function typeInfoFromDtype(dtype) {
+    switch (dtype) {
+        case types_js_1.DType.F64: return { dtype, bytesPerElement: 8, heapView: 'HEAPF64', resultType: 'f64' };
+        case types_js_1.DType.F32: return { dtype, bytesPerElement: 4, heapView: 'HEAPF32', resultType: 'f64' };
+        case types_js_1.DType.F16: return { dtype, bytesPerElement: 2, heapView: 'HEAPU16', resultType: 'f32' };
+        case types_js_1.DType.BF16: return { dtype, bytesPerElement: 2, heapView: 'HEAPU16', resultType: 'f32' };
+        case types_js_1.DType.I8: return { dtype, bytesPerElement: 1, heapView: 'HEAP8', resultType: 'i32' };
+        case types_js_1.DType.U8: return { dtype, bytesPerElement: 1, heapView: 'HEAPU8', resultType: 'u32' };
+        case types_js_1.DType.U1: return { dtype, bytesPerElement: 1, heapView: 'HEAPU8', resultType: 'u32' };
+        default: throw new Error(`Unsupported dtype: ${dtype}`);
+    }
+}
+/**
+ * Resolve an input that may be a TensorBase or a TypedArray into a uniform
+ * ResolvedInput for distance dispatch.
+ */
+function resolveInput(a) {
+    if (a instanceof types_js_1.TensorBase) {
+        return {
+            buffer: a.buffer, byteOffset: a.byteOffset,
+            length: a.length, byteLength: a.byteLength,
+            typeInfo: typeInfoFromDtype(a.dtype),
+        };
+    }
+    const typeInfo = detectType(a);
+    return {
+        buffer: a.buffer, byteOffset: a.byteOffset,
+        length: a.length, byteLength: a.length * typeInfo.bytesPerElement,
+        typeInfo,
+    };
+}
+/**
+ * Allocate WASM memory and copy data into it.
+ * Returns a number byte-offset (from Emscripten-wrapped _malloc).
+ */
+function allocAndCopyResolved(buffer, byteOffset, byteLength) {
+    if (!Module)
+        throw new Error('WASM module not initialized');
+    const ptr = Module._malloc(byteLength);
+    const src = new Uint8Array(buffer, byteOffset, byteLength);
+    HEAPU8.set(src, ptr);
+    return ptr;
+}
+/**
+ * Read result from WASM heap. ptr is a number byte-offset.
+ */
+function readResult(ptr, resultType) {
+    if (!Module)
+        throw new Error('WASM module not initialized');
+    switch (resultType) {
+        case 'f64':
+            return HEAPF64[ptr / 8];
+        case 'f32':
+            return HEAPF32[ptr / 4];
+        case 'i32':
+            return HEAP32[ptr / 4];
+        case 'u32':
+            return HEAPU32[ptr / 4];
+    }
+}
+/**
+ * Generic distance function wrapper.
+ * Uses zero-copy when arrays already live on the WASM heap.
+ */
+function distance(metric, a, b) {
+    if (!Module) {
+        throw new Error('WASM module not initialized. Call initWasm() first.');
+    }
+    const resolvedA = resolveInput(a);
+    const resolvedB = resolveInput(b);
+    if (resolvedA.length !== resolvedB.length) {
+        throw new Error(`Array length mismatch: ${resolvedA.length} !== ${resolvedB.length}`);
+    }
+    const n = resolvedA.length;
+    // Zero-copy: if the buffer IS the WASM memory, byteOffset is the pointer (number)
+    const isOnHeapA = resolvedA.buffer === Module.wasmMemory.buffer;
+    const isOnHeapB = resolvedB.buffer === Module.wasmMemory.buffer;
+    const aOff = isOnHeapA ? resolvedA.byteOffset : allocAndCopyResolved(resolvedA.buffer, resolvedA.byteOffset, resolvedA.byteLength);
+    const bOff = isOnHeapB ? resolvedB.byteOffset : allocAndCopyResolved(resolvedB.buffer, resolvedB.byteOffset, resolvedB.byteLength);
+    try {
+        // Call C function
+        const fnName = `_nk_${metric}_${(0, types_js_1.dtypeToString)(resolvedA.typeInfo.dtype)}`;
+        const fn = Module[fnName];
+        if (!fn || typeof fn !== 'function') {
+            throw new Error(`Function ${fnName} not available in WASM module`);
+        }
+        // In wasm64, raw C exports expect BigInt for pointer args; nk_size_t is always i32 (number)
+        fn(toWasmPtr(aOff), toWasmPtr(bOff), n, toWasmPtr(resultPtr));
+        // Read result
+        return readResult(resultPtr, resolvedA.typeInfo.resultType);
+    }
+    finally {
+        // _free is Emscripten-wrapped: always takes number
+        if (!isOnHeapA)
+            Module._free(aOff);
+        if (!isOnHeapB)
+            Module._free(bOff);
+    }
+}
+/**
+ * Computes the squared Euclidean distance between two vectors.
+ * @param a - First vector (TypedArray or TensorBase).
+ * @param b - Second vector (must match type and length of a).
+ * @returns The squared Euclidean distance between a and b.
+ */
+function sqeuclidean(a, b) {
+    return distance('sqeuclidean', a, b);
+}
+/**
+ * Computes the Euclidean distance between two vectors.
+ * @param a - First vector (TypedArray or TensorBase).
+ * @param b - Second vector (must match type and length of a).
+ * @returns The Euclidean distance between a and b.
+ */
+function euclidean(a, b) {
+    return distance('euclidean', a, b);
+}
+/**
+ * Computes the angular distance between two vectors.
+ * @param a - First vector (TypedArray or TensorBase).
+ * @param b - Second vector (must match type and length of a).
+ * @returns The angular distance between a and b.
+ */
+function angular(a, b) {
+    return distance('angular', a, b);
+}
+/**
+ * Computes the dot product of two vectors.
+ * @param a - First vector (TypedArray or TensorBase).
+ * @param b - Second vector (must match type and length of a).
+ * @returns The dot product of a and b.
+ */
+function dot(a, b) {
+    return distance('dot', a, b);
+}
+/** Alias for {@link dot}. */
+exports.inner = dot;
+/**
+ * Computes the bitwise Hamming distance between two vectors.
+ *
+ * Following N-API behavior, always treats input as u1 (binary/bit-packed),
+ * even if passed as Uint8Array. Each byte represents 8 bits.
+ *
+ * @param a - First bit-packed vector (Uint8Array or TensorBase).
+ * @param b - Second bit-packed vector (must match length of a).
+ * @returns The Hamming distance (number of differing bits) between a and b.
+ */
+function hamming(a, b) {
+    if (!Module) {
+        throw new Error('WASM module not initialized');
+    }
+    // Extract flat fields; for raw TypedArrays treat as u1 (binary/bit-packed)
+    const bufferA = a.buffer, offsetA = a.byteOffset, lengthA = a.length;
+    const bufferB = b.buffer, offsetB = b.byteOffset, lengthB = b.length;
+    const byteLengthA = a instanceof types_js_1.TensorBase ? a.byteLength : lengthA;
+    const byteLengthB = b instanceof types_js_1.TensorBase ? b.byteLength : lengthB;
+    if (lengthA !== lengthB) {
+        throw new Error(`Array length mismatch: ${lengthA} !== ${lengthB}`);
+    }
+    const isOnHeapA = bufferA === Module.wasmMemory.buffer;
+    const isOnHeapB = bufferB === Module.wasmMemory.buffer;
+    const aOff = isOnHeapA ? offsetA : allocAndCopyResolved(bufferA, offsetA, byteLengthA);
+    const bOff = isOnHeapB ? offsetB : allocAndCopyResolved(bufferB, offsetB, byteLengthB);
+    try {
+        const fn = Module._nk_hamming_u1;
+        if (!fn || typeof fn !== 'function') {
+            throw new Error('Function _nk_hamming_u1 not available in WASM module');
+        }
+        fn(toWasmPtr(aOff), toWasmPtr(bOff), lengthA, toWasmPtr(resultPtr));
+        return readResult(resultPtr, 'u32');
+    }
+    finally {
+        if (!isOnHeapA)
+            Module._free(aOff);
+        if (!isOnHeapB)
+            Module._free(bOff);
+    }
+}
+/**
+ * Computes the bitwise Jaccard distance between two vectors.
+ *
+ * Following N-API behavior, always treats input as u1 (binary/bit-packed),
+ * even if passed as Uint8Array. Each byte represents 8 bits.
+ *
+ * @param a - First bit-packed vector (Uint8Array or TensorBase).
+ * @param b - Second bit-packed vector (must match length of a).
+ * @returns The Jaccard distance (1 - Jaccard similarity) between a and b.
+ */
+function jaccard(a, b) {
+    if (!Module) {
+        throw new Error('WASM module not initialized');
+    }
+    // Extract flat fields; for raw TypedArrays treat as u1 (binary/bit-packed)
+    const bufferA = a.buffer, offsetA = a.byteOffset, lengthA = a.length;
+    const bufferB = b.buffer, offsetB = b.byteOffset, lengthB = b.length;
+    const byteLengthA = a instanceof types_js_1.TensorBase ? a.byteLength : lengthA;
+    const byteLengthB = b instanceof types_js_1.TensorBase ? b.byteLength : lengthB;
+    if (lengthA !== lengthB) {
+        throw new Error(`Array length mismatch: ${lengthA} !== ${lengthB}`);
+    }
+    const isOnHeapA = bufferA === Module.wasmMemory.buffer;
+    const isOnHeapB = bufferB === Module.wasmMemory.buffer;
+    const aOff = isOnHeapA ? offsetA : allocAndCopyResolved(bufferA, offsetA, byteLengthA);
+    const bOff = isOnHeapB ? offsetB : allocAndCopyResolved(bufferB, offsetB, byteLengthB);
+    try {
+        const fn = Module._nk_jaccard_u1;
+        if (!fn || typeof fn !== 'function') {
+            throw new Error('Function _nk_jaccard_u1 not available in WASM module');
+        }
+        fn(toWasmPtr(aOff), toWasmPtr(bOff), lengthA, toWasmPtr(resultPtr));
+        return readResult(resultPtr, 'f32');
+    }
+    finally {
+        if (!isOnHeapA)
+            Module._free(aOff);
+        if (!isOnHeapB)
+            Module._free(bOff);
+    }
+}
+/**
+ * Computes the Kullback-Leibler divergence between two probability distributions.
+ * @param a - First probability distribution (Float32Array, Float64Array, or TensorBase).
+ * @param b - Second probability distribution (must match type and length of a).
+ * @returns The KL divergence KL(a || b).
+ */
+function kullbackleibler(a, b) {
+    if (!Module) {
+        throw new Error('WASM module not initialized');
+    }
+    const resolvedA = resolveInput(a);
+    const resolvedB = resolveInput(b);
+    if (resolvedA.length !== resolvedB.length) {
+        throw new Error(`Array length mismatch: ${resolvedA.length} !== ${resolvedB.length}`);
+    }
+    const n = resolvedA.length;
+    const isOnHeapA = resolvedA.buffer === Module.wasmMemory.buffer;
+    const isOnHeapB = resolvedB.buffer === Module.wasmMemory.buffer;
+    const aOff = isOnHeapA ? resolvedA.byteOffset : allocAndCopyResolved(resolvedA.buffer, resolvedA.byteOffset, resolvedA.byteLength);
+    const bOff = isOnHeapB ? resolvedB.byteOffset : allocAndCopyResolved(resolvedB.buffer, resolvedB.byteOffset, resolvedB.byteLength);
+    try {
+        const fnName = `_nk_kld_${(0, types_js_1.dtypeToString)(resolvedA.typeInfo.dtype)}`;
+        const fn = Module[fnName];
+        if (!fn || typeof fn !== 'function') {
+            throw new Error(`Function ${fnName} not available in WASM module`);
+        }
+        fn(toWasmPtr(aOff), toWasmPtr(bOff), n, toWasmPtr(resultPtr));
+        return readResult(resultPtr, resolvedA.typeInfo.resultType);
+    }
+    finally {
+        if (!isOnHeapA)
+            Module._free(aOff);
+        if (!isOnHeapB)
+            Module._free(bOff);
+    }
+}
+/**
+ * Computes the Jensen-Shannon distance between two probability distributions.
+ * @param a - First probability distribution (Float32Array, Float64Array, or TensorBase).
+ * @param b - Second probability distribution (must match type and length of a).
+ * @returns The Jensen-Shannon distance between a and b.
+ */
+function jensenshannon(a, b) {
+    if (!Module) {
+        throw new Error('WASM module not initialized');
+    }
+    const resolvedA = resolveInput(a);
+    const resolvedB = resolveInput(b);
+    if (resolvedA.length !== resolvedB.length) {
+        throw new Error(`Array length mismatch: ${resolvedA.length} !== ${resolvedB.length}`);
+    }
+    const n = resolvedA.length;
+    const isOnHeapA = resolvedA.buffer === Module.wasmMemory.buffer;
+    const isOnHeapB = resolvedB.buffer === Module.wasmMemory.buffer;
+    const aOff = isOnHeapA ? resolvedA.byteOffset : allocAndCopyResolved(resolvedA.buffer, resolvedA.byteOffset, resolvedA.byteLength);
+    const bOff = isOnHeapB ? resolvedB.byteOffset : allocAndCopyResolved(resolvedB.buffer, resolvedB.byteOffset, resolvedB.byteLength);
+    try {
+        const fnName = `_nk_jsd_${(0, types_js_1.dtypeToString)(resolvedA.typeInfo.dtype)}`;
+        const fn = Module[fnName];
+        if (!fn || typeof fn !== 'function') {
+            throw new Error(`Function ${fnName} not available in WASM module`);
+        }
+        fn(toWasmPtr(aOff), toWasmPtr(bOff), n, toWasmPtr(resultPtr));
+        return readResult(resultPtr, resolvedA.typeInfo.resultType);
+    }
+    finally {
+        if (!isOnHeapA)
+            Module._free(aOff);
+        if (!isOnHeapB)
+            Module._free(bOff);
+    }
+}
+/**
+ * Returns the runtime-detected SIMD capabilities as a bitmask.
+ * @returns Bitmask of capability flags (use with Capability constants).
+ */
+function getCapabilities() {
+    if (!Module) {
+        throw new Error('WASM module not initialized');
+    }
+    // nk_capabilities returns a 64-bit value
+    const caps = Module._nk_capabilities();
+    // In wasm64, caps is already bigint; in wasm32, it's a number
+    return typeof caps === 'bigint' ? caps : BigInt(caps);
+}
+/**
+ * Checks if a specific SIMD capability is available at runtime.
+ * @param cap - Capability flag to check (from Capability constants).
+ * @returns True if the capability is available.
+ */
+function hasCapability(cap) {
+    return (getCapabilities() & cap) !== 0n;
+}
+let packedRegistry = null;
+/**
+ * WASM-backed PackedMatrix that owns a WASM heap allocation.
+ */
+class WasmPackedMatrix extends types_js_1.PackedMatrix {
+    constructor(heapPointer, byteLength, width, depth, dtype) {
+        // Create a JS ArrayBuffer that is a copy of the WASM heap region for read access
+        const buffer = new ArrayBuffer(byteLength);
+        new Uint8Array(buffer).set(HEAPU8.subarray(heapPointer, heapPointer + byteLength));
+        super(buffer, width, depth, dtype, byteLength);
+        this._wasmDisposed = false;
+        this._heapPointer = heapPointer;
+        // Register with FinalizationRegistry as safety net
+        if (!packedRegistry && typeof FinalizationRegistry !== 'undefined') {
+            packedRegistry = new FinalizationRegistry((ptr) => {
+                if (Module)
+                    Module._free(ptr);
+            });
+        }
+        if (packedRegistry) {
+            packedRegistry.register(this, heapPointer);
+        }
+    }
+    get heapPointer() { return this._heapPointer; }
+    dispose() {
+        if (!this._wasmDisposed && Module) {
+            Module._free(this._heapPointer);
+            this._wasmDisposed = true;
+        }
+        // Call parent dispose to set disposed flag
+        super.dispose();
+    }
+}
+/**
+ * Allocate WASM heap, copy matrix data, return pointer. Caller must free.
+ */
+function allocAndCopyMatrix(matrix) {
+    const byteLength = matrix.rows * matrix.rowStride;
+    return allocAndCopyResolved(matrix.buffer, matrix.byteOffset, byteLength);
+}
+/**
+ * Query the packed buffer byte count for a given matrix shape and dtype.
+ */
+function dotsPackedSize(width, depth, dtype) {
+    if (!Module)
+        throw new Error('WASM module not initialized');
+    const fnName = `_nk_dots_packed_size_${(0, types_js_1.dtypeToString)(dtype)}`;
+    const fn = Module[fnName];
+    if (!fn || typeof fn !== 'function') {
+        throw new Error(`Function ${fnName} not available in WASM module`);
+    }
+    return fn(width, depth);
+}
+/**
+ * Pack a Matrix for use with packed GEMM-like operations.
+ */
+function dotsPack(matrix) {
+    if (!Module)
+        throw new Error('WASM module not initialized');
+    const dtypeStr = (0, types_js_1.dtypeToString)(matrix.dtype);
+    const sizeFnName = `_nk_dots_packed_size_${dtypeStr}`;
+    const packFnName = `_nk_dots_pack_${dtypeStr}`;
+    const sizeFn = Module[sizeFnName];
+    const packFn = Module[packFnName];
+    if (!sizeFn || !packFn) {
+        throw new Error(`Pack functions not available for dtype ${dtypeStr}`);
+    }
+    const packedByteCount = sizeFn(matrix.rows, matrix.cols);
+    const packedPtr = Module._malloc(packedByteCount);
+    const matrixPtr = allocAndCopyMatrix(matrix);
+    try {
+        packFn(toWasmPtr(matrixPtr), matrix.rows, matrix.cols, matrix.rowStride, toWasmPtr(packedPtr));
+    }
+    finally {
+        Module._free(matrixPtr);
+    }
+    return new WasmPackedMatrix(packedPtr, packedByteCount, matrix.rows, matrix.cols, matrix.dtype);
+}
+function wasmPackedOperation(metricPrefix, family, a, packed, out) {
+    if (!Module)
+        throw new Error('WASM module not initialized');
+    if (a.cols !== packed.depth) {
+        throw new Error(`Matrix cols (${a.cols}) must match packed depth (${packed.depth})`);
+    }
+    const outDtype = (0, types_js_1.outputDtype)(family, a.dtype);
+    if (!out) {
+        out = new types_js_1.Matrix(a.rows, packed.width, outDtype);
+    }
+    const dtypeStr = (0, types_js_1.dtypeToString)(a.dtype);
+    const fnName = `_nk_${metricPrefix}_${dtypeStr}`;
+    const fn = Module[fnName];
+    if (!fn || typeof fn !== 'function') {
+        throw new Error(`Function ${fnName} not available in WASM module`);
+    }
+    const outBpe = out.bytesPerElement;
+    const resultByteLength = out.rows * out.cols * outBpe;
+    const aPtr = allocAndCopyMatrix(a);
+    const resultPtr = Module._malloc(resultByteLength);
+    // For WasmPackedMatrix, copy the packed data to heap; otherwise use the buffer directly
+    let packedPtr;
+    let packedAllocated = false;
+    if (packed instanceof WasmPackedMatrix) {
+        // The heap pointer may have been freed if disposed; re-copy from JS buffer
+        packedPtr = allocAndCopyResolved(packed.buffer, 0, packed.byteLength);
+        packedAllocated = true;
+    }
+    else {
+        packedPtr = allocAndCopyResolved(packed.buffer, 0, packed.byteLength);
+        packedAllocated = true;
+    }
+    try {
+        fn(toWasmPtr(aPtr), toWasmPtr(packedPtr), toWasmPtr(resultPtr), a.rows, packed.width, a.cols, a.rowStride, out.rowStride);
+        // Copy result back
+        const outArray = new Uint8Array(out.buffer, out.byteOffset, resultByteLength);
+        outArray.set(HEAPU8.subarray(resultPtr, resultPtr + resultByteLength));
+    }
+    finally {
+        Module._free(aPtr);
+        Module._free(resultPtr);
+        if (packedAllocated)
+            Module._free(packedPtr);
+    }
+    return out;
+}
+function wasmSymmetricOperation(metricPrefix, family, vectors, out, rowStart = 0, rowCount) {
+    if (!Module)
+        throw new Error('WASM module not initialized');
+    const count = rowCount ?? vectors.rows - rowStart;
+    const outDtype = (0, types_js_1.outputDtype)(family, vectors.dtype);
+    if (!out) {
+        out = new types_js_1.Matrix(vectors.rows, vectors.rows, outDtype);
+    }
+    const dtypeStr = (0, types_js_1.dtypeToString)(vectors.dtype);
+    const fnName = `_nk_${metricPrefix}_${dtypeStr}`;
+    const fn = Module[fnName];
+    if (!fn || typeof fn !== 'function') {
+        throw new Error(`Function ${fnName} not available in WASM module`);
+    }
+    const resultByteLength = out.rows * out.cols * out.bytesPerElement;
+    const vectorsPtr = allocAndCopyMatrix(vectors);
+    const resultPtr = Module._malloc(resultByteLength);
+    try {
+        fn(toWasmPtr(vectorsPtr), vectors.rows, vectors.cols, vectors.rowStride, toWasmPtr(resultPtr), out.rowStride, rowStart, count);
+        // Copy result back
+        const outArray = new Uint8Array(out.buffer, out.byteOffset, resultByteLength);
+        outArray.set(HEAPU8.subarray(resultPtr, resultPtr + resultByteLength));
+    }
+    finally {
+        Module._free(vectorsPtr);
+        Module._free(resultPtr);
+    }
+    return out;
+}
+function dotsPacked(a, packed, out) {
+    return wasmPackedOperation('dots_packed', 'dots', a, packed, out);
+}
+function angularsPacked(a, packed, out) {
+    return wasmPackedOperation('angulars_packed', 'angulars', a, packed, out);
+}
+function euclideansPacked(a, packed, out) {
+    return wasmPackedOperation('euclideans_packed', 'euclideans', a, packed, out);
+}
+function dotsSymmetric(vectors, out, options) {
+    return wasmSymmetricOperation('dots_symmetric', 'dots', vectors, out, options?.rowStart ?? 0, options?.rowCount);
+}
+function angularsSymmetric(vectors, out, options) {
+    return wasmSymmetricOperation('angulars_symmetric', 'angulars', vectors, out, options?.rowStart ?? 0, options?.rowCount);
+}
+function euclideansSymmetric(vectors, out, options) {
+    return wasmSymmetricOperation('euclideans_symmetric', 'euclideans', vectors, out, options?.rowStart ?? 0, options?.rowCount);
+}