@ruvector/cnn 0.1.1 → 0.1.2

package/index.d.ts

@@ -151,7 +151,7 @@ export namespace LayerOps {
 
   /**
    * Apply global average pooling
-   * @param input - Input tensor [C, H, W]
+   * @param input - Input tensor, channels-last [H*W, C]
    * @param channels - Number of channels
    * @param spatialSize - H * W
    * @returns Output [C]

package/index.js

@@ -72,12 +72,14 @@ class CnnEmbedder {
     }
 
     const wasmConfig = new wasm.EmbedderConfig();
-    wasmConfig.input_size = config.inputSize || 224;
-    wasmConfig.embedding_dim = config.embeddingDim || 512;
+    wasmConfig.input_size = config.inputSize ?? 224;
+    wasmConfig.embedding_dim = config.embeddingDim ?? 512;
     wasmConfig.normalize = config.normalize !== false;
 
+    // The WASM constructor takes ownership of wasmConfig (its pointer is
+    // nulled), so read the dimension back from the embedder, not the config.
     this._inner = new wasm.WasmCnnEmbedder(wasmConfig);
-    this._embeddingDim = wasmConfig.embedding_dim;
+    this._embeddingDim = this._inner.embedding_dim;
   }
 
   /**
@@ -203,7 +205,7 @@ const SimdOps = {
    */
   relu(data) {
     if (!initialized) throw new Error('Module not initialized');
-    wasm.SimdOps.relu(data);
+    data.set(wasm.SimdOps.relu(data));
   },
 
   /**
@@ -212,7 +214,7 @@ const SimdOps = {
    */
   relu6(data) {
     if (!initialized) throw new Error('Module not initialized');
-    wasm.SimdOps.relu6(data);
+    data.set(wasm.SimdOps.relu6(data));
   },
 
   /**
@@ -221,7 +223,7 @@ const SimdOps = {
    */
   l2Normalize(data) {
     if (!initialized) throw new Error('Module not initialized');
-    wasm.SimdOps.l2_normalize(data);
+    data.set(wasm.SimdOps.l2_normalize(data));
   }
 };
 
@@ -230,7 +232,7 @@ const SimdOps = {
  */
 const LayerOps = {
   /**
-   * Apply batch normalization
+   * Apply batch normalization over channels-last (NHWC) data
    * @param {Float32Array} input - Input data (modified in-place)
    * @param {Float32Array} gamma - Scale parameter
    * @param {Float32Array} beta - Shift parameter
@@ -240,19 +242,20 @@ const LayerOps = {
    */
   batchNorm(input, gamma, beta, mean, variance, epsilon = 1e-5) {
     if (!initialized) throw new Error('Module not initialized');
-    wasm.LayerOps.batch_norm(input, gamma, beta, mean, variance, epsilon);
+    input.set(wasm.LayerOps.batch_norm(input, gamma, beta, mean, variance, epsilon));
   },
 
   /**
    * Apply global average pooling
-   * @param {Float32Array} input - Input tensor [C, H, W]
+   * @param {Float32Array} input - Input tensor, channels-last [H*W, C]
    * @param {number} channels - Number of channels
    * @param {number} spatialSize - H * W
    * @returns {Float32Array} - Output [C]
    */
   globalAvgPool(input, channels, spatialSize) {
     if (!initialized) throw new Error('Module not initialized');
-    return new Float32Array(wasm.LayerOps.global_avg_pool(input, channels, spatialSize));
+    // WASM signature is (input, height, width, channels); pass H*W as 1 x spatialSize.
+    return new Float32Array(wasm.LayerOps.global_avg_pool(input, 1, spatialSize, channels));
   }
 };
 

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@ruvector/cnn",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "CNN feature extraction for image embeddings - SIMD-optimized, pure Rust/WASM",
   "main": "index.js",
-  "module": "index.mjs",
   "types": "index.d.ts",
   "files": [
     "index.js",
@@ -15,8 +14,8 @@
     "README.md"
   ],
   "scripts": {
-    "build": "wasm-pack build ../../crates/ruvector-cnn-wasm --target web --out-dir ../../npm/packages/ruvector-cnn/pkg",
-    "postbuild": "cp pkg/* . && rm -rf pkg",
+    "build": "wasm-pack build ../../../crates/ruvector-cnn-wasm --release --target web --out-dir ../../npm/packages/ruvector-cnn/pkg",
+    "postbuild": "cp pkg/ruvector_cnn_wasm* . && rm -rf pkg",
     "test": "node test.js"
   },
   "keywords": [

package/ruvector_cnn_wasm.d.ts

@@ -34,7 +34,7 @@ export class LayerOps {
      */
     static batch_norm(input: Float32Array, gamma: Float32Array, beta: Float32Array, mean: Float32Array, _var: Float32Array, epsilon: number): Float32Array;
     /**
-     * Apply global average pooling
+     * Apply global average pooling over an NHWC tensor [H, W, C]
      * Returns one value per channel
      */
     static global_avg_pool(input: Float32Array, height: number, width: number, channels: number): Float32Array;
@@ -157,7 +157,7 @@ export interface InitOutput {
     readonly embedderconfig_new: () => number;
     readonly layerops_batch_norm: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
     readonly layerops_global_avg_pool: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly simdops_dot_product: (a: number, b: number, c: number, d: number) => number;
+    readonly simdops_dot_product: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly simdops_l2_normalize: (a: number, b: number, c: number) => void;
     readonly simdops_relu: (a: number, b: number, c: number) => void;
     readonly simdops_relu6: (a: number, b: number, c: number) => void;
@@ -166,12 +166,12 @@ export interface InitOutput {
     readonly wasmcnnembedder_extract: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly wasmcnnembedder_new: (a: number, b: number) => void;
     readonly wasminfonceloss_forward: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly wasminfonceloss_new: (a: number) => number;
+    readonly wasminfonceloss_new: (a: number, b: number) => void;
     readonly wasminfonceloss_temperature: (a: number) => number;
     readonly wasmtripletloss_forward: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly wasmtripletloss_forward_single: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly wasmtripletloss_margin: (a: number) => number;
-    readonly wasmtripletloss_new: (a: number) => number;
+    readonly wasmtripletloss_new: (a: number, b: number) => void;
     readonly init: () => void;
     readonly __wbg_simdops_free: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number, b: number, c: number) => void;

package/ruvector_cnn_wasm.js

@@ -16,7 +16,7 @@ export class EmbedderConfig {
     }
     constructor() {
         const ret = wasm.embedderconfig_new();
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         EmbedderConfigFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -108,6 +108,11 @@ export class LayerOps {
             wasm.layerops_batch_norm(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, epsilon);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
             var v6 = getArrayF32FromWasm0(r0, r1).slice();
             wasm.__wbindgen_export(r0, r1 * 4, 4);
             return v6;
@@ -116,7 +121,7 @@ export class LayerOps {
         }
     }
     /**
-     * Apply global average pooling
+     * Apply global average pooling over an NHWC tensor [H, W, C]
      * Returns one value per channel
      * @param {Float32Array} input
      * @param {number} height
@@ -132,6 +137,11 @@ export class LayerOps {
             wasm.layerops_global_avg_pool(retptr, ptr0, len0, height, width, channels);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
             var v2 = getArrayF32FromWasm0(r0, r1).slice();
             wasm.__wbindgen_export(r0, r1 * 4, 4);
             return v2;
@@ -163,12 +173,23 @@ export class SimdOps {
      * @returns {number}
      */
     static dot_product(a, b) {
-        const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_export2);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.simdops_dot_product(ptr0, len0, ptr1, len1);
-        return ret;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.simdops_dot_product(retptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getFloat32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return r0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * L2 normalize a vector (returns new array)
@@ -326,7 +347,7 @@ export class WasmCnnEmbedder {
             if (r2) {
                 throw takeObject(r1);
             }
-            this.__wbg_ptr = r0 >>> 0;
+            this.__wbg_ptr = r0;
             WasmCnnEmbedderFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
@@ -380,10 +401,21 @@ export class WasmInfoNCELoss {
      * @param {number} temperature
      */
     constructor(temperature) {
-        const ret = wasm.wasminfonceloss_new(temperature);
-        this.__wbg_ptr = ret >>> 0;
-        WasmInfoNCELossFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasminfonceloss_new(retptr, temperature);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            WasmInfoNCELossFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * Get the temperature parameter
@@ -480,10 +512,21 @@ export class WasmTripletLoss {
      * @param {number} margin
      */
     constructor(margin) {
-        const ret = wasm.wasmtripletloss_new(margin);
-        this.__wbg_ptr = ret >>> 0;
-        WasmTripletLossFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmtripletloss_new(retptr, margin);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            WasmTripletLossFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
 }
 if (Symbol.dispose) WasmTripletLoss.prototype[Symbol.dispose] = WasmTripletLoss.prototype.free;
@@ -494,11 +537,10 @@ if (Symbol.dispose) WasmTripletLoss.prototype[Symbol.dispose] = WasmTripletLoss.
 export function init() {
     wasm.init();
 }
-
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wbindgen_throw_39bc967c0e5a9b58: function(arg0, arg1) {
+        __wbg___wbindgen_throw_ea4887a5f8f9a9db: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
         __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
@@ -540,22 +582,22 @@ function __wbg_get_imports() {
 
 const EmbedderConfigFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_embedderconfig_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_embedderconfig_free(ptr, 1));
 const LayerOpsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_layerops_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_layerops_free(ptr, 1));
 const SimdOpsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_simdops_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_simdops_free(ptr, 1));
 const WasmCnnEmbedderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcnnembedder_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcnnembedder_free(ptr, 1));
 const WasmInfoNCELossFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasminfonceloss_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasminfonceloss_free(ptr, 1));
 const WasmTripletLossFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmtripletloss_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmtripletloss_free(ptr, 1));
 
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);
@@ -600,8 +642,7 @@ function getFloat32ArrayMemory0() {
 }
 
 function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
+    return decodeText(ptr >>> 0, len);
 }
 
 let cachedUint8ArrayMemory0 = null;
@@ -709,8 +750,9 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-let wasmModule, wasm;
+let wasmModule, wasmInstance, wasm;
 function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
     wasm = instance.exports;
     wasmModule = module;
     cachedDataViewMemory0 = null;

package/ruvector_cnn_wasm_bg.wasm.d.ts

@@ -15,7 +15,7 @@ export const __wbg_wasmtripletloss_free: (a: number, b: number) => void;
 export const embedderconfig_new: () => number;
 export const layerops_batch_norm: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
 export const layerops_global_avg_pool: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const simdops_dot_product: (a: number, b: number, c: number, d: number) => number;
+export const simdops_dot_product: (a: number, b: number, c: number, d: number, e: number) => void;
 export const simdops_l2_normalize: (a: number, b: number, c: number) => void;
 export const simdops_relu: (a: number, b: number, c: number) => void;
 export const simdops_relu6: (a: number, b: number, c: number) => void;
@@ -24,12 +24,12 @@ export const wasmcnnembedder_embedding_dim: (a: number) => number;
 export const wasmcnnembedder_extract: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const wasmcnnembedder_new: (a: number, b: number) => void;
 export const wasminfonceloss_forward: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const wasminfonceloss_new: (a: number) => number;
+export const wasminfonceloss_new: (a: number, b: number) => void;
 export const wasminfonceloss_temperature: (a: number) => number;
 export const wasmtripletloss_forward: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
 export const wasmtripletloss_forward_single: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
 export const wasmtripletloss_margin: (a: number) => number;
-export const wasmtripletloss_new: (a: number) => number;
+export const wasmtripletloss_new: (a: number, b: number) => void;
 export const init: () => void;
 export const __wbg_simdops_free: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number, c: number) => void;