@justinelliottcobb/amari-wasm 0.12.2 → 0.12.3

package/amari_wasm.d.ts

@@ -877,29 +877,6 @@ export class WasmChowClass {
    */
   multiply(other: WasmChowClass): WasmChowClass;
 }
-/**
- * WASM wrapper for cleanup results
- */
-export class WasmCleanupResult {
-  private constructor();
-  free(): void;
-  /**
-   * Get the cleaned (denoised) value
-   */
-  getCleaned(): WasmTropicalDualClifford;
-  /**
-   * Check if the cleanup converged
-   */
-  didConverge(): boolean;
-  /**
-   * Get the number of iterations used
-   */
-  getIterations(): number;
-  /**
-   * Get the index of the best matching codebook item
-   */
-  getBestMatchIndex(): number;
-}
 /**
  * WASM wrapper for community detection results
  */
@@ -1422,7 +1399,7 @@ export class WasmGrassmannian {
   constructor(k: number, n: number);
 }
 /**
- * WASM wrapper for HolographicMemory
+ * WASM wrapper for HolographicMemory using ProductClifford algebra
  */
 export class WasmHolographicMemory {
   free(): void;
@@ -1430,38 +1407,30 @@ export class WasmHolographicMemory {
    * Get the number of stored items
    */
   itemCount(): number;
-  /**
-   * Batch store multiple key-value pairs
-   */
-  storeBatch(keys: Float64Array, values: Float64Array): void;
   /**
    * Get the estimated SNR (signal-to-noise ratio)
    */
   estimatedSnr(): number;
   /**
-   * Check if memory is near capacity
+   * Generate a random versor (for use as key/value)
    */
-  isNearCapacity(): boolean;
+  static randomVersor(num_factors: number): Float64Array;
   /**
-   * Check if memory probably contains a key
+   * Check if memory is near capacity
    */
-  probablyContains(key: WasmTropicalDualClifford): boolean;
+  isNearCapacity(): boolean;
   /**
    * Create with key tracking enabled (for attribution)
    */
   static withKeyTracking(): WasmHolographicMemory;
   /**
-   * Get the theoretical capacity
-   */
-  theoreticalCapacity(): number;
-  /**
-   * Retrieve with custom temperature
+   * Get retrieval confidence for a key
    */
-  retrieveAtTemperature(key: WasmTropicalDualClifford, beta: number): WasmRetrievalResult;
+  retrieveConfidence(key: Float64Array): number;
   /**
-   * Create with custom bundle temperature
+   * Get capacity information
    */
-  static withBundleTemperature(beta: number): WasmHolographicMemory;
+  theoreticalCapacity(): number;
   /**
    * Create a new holographic memory with default settings
    */
@@ -1471,17 +1440,17 @@ export class WasmHolographicMemory {
    */
   clear(): void;
   /**
-   * Merge another memory into this one
-   */
-  merge(other: WasmHolographicMemory): void;
-  /**
-   * Store a key-value pair in memory
+   * Store a key-value pair in memory (using flat coefficient arrays)
+   *
+   * Each array should have 256 coefficients for ProductCl3x32.
    */
-  store(key: WasmTropicalDualClifford, value: WasmTropicalDualClifford): void;
+  store(key: Float64Array, value: Float64Array): void;
   /**
    * Retrieve a value by key
+   *
+   * Returns the retrieved coefficients as a Float64Array.
    */
-  retrieve(key: WasmTropicalDualClifford): WasmRetrievalResult;
+  retrieve(key: Float64Array): Float64Array;
 }
 /**
  * WASM wrapper for Inverse CA Designer (simplified)
@@ -1987,45 +1956,28 @@ export class WasmRelativisticParticle {
   to_string(): string;
 }
 /**
- * WASM wrapper for Resonator (iterative cleanup)
+ * WASM wrapper for Resonator using ProductClifford algebra
  */
 export class WasmResonator {
   free(): void;
-  /**
-   * Create with custom configuration
-   */
-  static withConfig(codebook_flat: Float64Array, max_iterations: number, convergence_threshold: number): WasmResonator;
   /**
    * Get the codebook size
    */
   codebookSize(): number;
   /**
-   * Create a resonator from a codebook of TDC vectors
+   * Get cleanup result with metadata
    */
-  constructor(codebook_flat: Float64Array);
+  cleanupWithInfo(input: Float64Array): any;
   /**
-   * Clean up a noisy input to find the closest codebook item
-   */
-  cleanup(input: WasmTropicalDualClifford): WasmCleanupResult;
-}
-/**
- * WASM wrapper for retrieval results
- */
-export class WasmRetrievalResult {
-  private constructor();
-  free(): void;
-  /**
-   * Get the retrieval confidence (0 to 1)
-   */
-  getConfidence(): number;
-  /**
-   * Get attribution as arrays of [index, weight] pairs
+   * Create a resonator from a flat codebook array
+   *
+   * Each item should have 256 coefficients for ProductCl3x32.
    */
-  getAttribution(): any;
+  constructor(codebook_flat: Float64Array);
   /**
-   * Get the retrieved value
+   * Clean up a noisy input to find the closest codebook item
    */
-  getValue(): WasmTropicalDualClifford;
+  cleanup(input: Float64Array): Float64Array;
 }
 /**
  * Rotor operations for WASM
@@ -2569,7 +2521,6 @@ export interface InitOutput {
   readonly __wbg_scalarfield_free: (a: number, b: number) => void;
   readonly __wbg_set_wasmtrajectorypoint_time: (a: number, b: number) => void;
   readonly __wbg_wasmchowclass_free: (a: number, b: number) => void;
-  readonly __wbg_wasmcleanupresult_free: (a: number, b: number) => void;
   readonly __wbg_wasmcommunity_free: (a: number, b: number) => void;
   readonly __wbg_wasmduallyflatmanifold_free: (a: number, b: number) => void;
   readonly __wbg_wasmevaluationresult_free: (a: number, b: number) => void;
@@ -2590,7 +2541,6 @@ export interface InitOutput {
   readonly __wbg_wasmpropagationanalysis_free: (a: number, b: number) => void;
   readonly __wbg_wasmrelativisticparticle_free: (a: number, b: number) => void;
   readonly __wbg_wasmresonator_free: (a: number, b: number) => void;
-  readonly __wbg_wasmretrievalresult_free: (a: number, b: number) => void;
   readonly __wbg_wasmschwarzschildmetric_free: (a: number, b: number) => void;
   readonly __wbg_wasmselfassembler_free: (a: number, b: number) => void;
   readonly __wbg_wasmsensitivitymap_free: (a: number, b: number) => void;
@@ -2705,10 +2655,6 @@ export interface InitOutput {
   readonly wasmchowclass_new: (a: number, b: number) => number;
   readonly wasmchowclass_point: () => number;
   readonly wasmchowclass_power: (a: number, b: number) => number;
-  readonly wasmcleanupresult_didConverge: (a: number) => number;
-  readonly wasmcleanupresult_getBestMatchIndex: (a: number) => number;
-  readonly wasmcleanupresult_getCleaned: (a: number) => number;
-  readonly wasmcleanupresult_getIterations: (a: number) => number;
   readonly wasmcommunity_centroid_coefficients: (a: number) => [number, number];
   readonly wasmcommunity_nodes: (a: number) => [number, number];
   readonly wasmcountingmeasure_isMeasurable: (a: number) => number;
@@ -2812,15 +2758,12 @@ export interface InitOutput {
   readonly wasmholographicmemory_estimatedSnr: (a: number) => number;
   readonly wasmholographicmemory_isNearCapacity: (a: number) => number;
   readonly wasmholographicmemory_itemCount: (a: number) => number;
-  readonly wasmholographicmemory_merge: (a: number, b: number) => void;
   readonly wasmholographicmemory_new: () => number;
-  readonly wasmholographicmemory_probablyContains: (a: number, b: number) => number;
-  readonly wasmholographicmemory_retrieve: (a: number, b: number) => number;
-  readonly wasmholographicmemory_retrieveAtTemperature: (a: number, b: number, c: number) => number;
-  readonly wasmholographicmemory_store: (a: number, b: number, c: number) => void;
-  readonly wasmholographicmemory_storeBatch: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+  readonly wasmholographicmemory_randomVersor: (a: number) => [number, number];
+  readonly wasmholographicmemory_retrieve: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmholographicmemory_retrieveConfidence: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmholographicmemory_store: (a: number, b: number, c: number, d: number, e: number) => [number, number];
   readonly wasmholographicmemory_theoreticalCapacity: (a: number) => number;
-  readonly wasmholographicmemory_withBundleTemperature: (a: number) => number;
   readonly wasmholographicmemory_withKeyTracking: () => number;
   readonly wasminversecadesigner_evaluateFitness: (a: number, b: number, c: number) => [number, number, number];
   readonly wasminversecadesigner_findSeed: (a: number, b: number, c: number) => [number, number, number, number];
@@ -2910,13 +2853,10 @@ export interface InitOutput {
   readonly wasmrelativisticparticle_to_string: (a: number) => [number, number];
   readonly wasmrelativisticparticle_total_energy: (a: number) => number;
   readonly wasmrelativisticparticle_with_energy: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
-  readonly wasmresonator_cleanup: (a: number, b: number) => number;
+  readonly wasmresonator_cleanup: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmresonator_cleanupWithInfo: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmresonator_codebookSize: (a: number) => number;
   readonly wasmresonator_new: (a: number, b: number) => [number, number, number];
-  readonly wasmresonator_withConfig: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly wasmretrievalresult_getAttribution: (a: number) => [number, number, number];
-  readonly wasmretrievalresult_getConfidence: (a: number) => number;
-  readonly wasmretrievalresult_getValue: (a: number) => number;
   readonly wasmrotor_apply: (a: number, b: number) => number;
   readonly wasmrotor_compose: (a: number, b: number) => number;
   readonly wasmrotor_fromBivector: (a: number, b: number) => number;
@@ -3077,8 +3017,8 @@ export interface InitOutput {
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_export_6: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
-  readonly closure58_externref_shim: (a: number, b: number, c: any) => void;
-  readonly closure49_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly closure40_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure33_externref_shim: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_start: () => void;
 }
 

package/amari_wasm.js

@@ -45,6 +45,20 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
+let cachedFloat64ArrayMemory0 = null;
+
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 let WASM_VECTOR_LEN = 0;
 
 const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
@@ -209,20 +223,6 @@ function debugString(val) {
     // TODO we could test for more things here, like `Set`s and `Map`s.
     return className;
 }
-
-let cachedFloat64ArrayMemory0 = null;
-
-function getFloat64ArrayMemory0() {
-    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
-        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
-    }
-    return cachedFloat64ArrayMemory0;
-}
-
-function getArrayF64FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
-}
 /**
  * Initialize the WASM module
  */
@@ -429,11 +429,11 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 function __wbg_adapter_28(arg0, arg1, arg2) {
-    wasm.closure58_externref_shim(arg0, arg1, arg2);
+    wasm.closure40_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_496(arg0, arg1, arg2, arg3) {
-    wasm.closure49_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_486(arg0, arg1, arg2, arg3) {
+    wasm.closure33_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -2572,67 +2572,6 @@ export class WasmChowClass {
     }
 }
 
-const WasmCleanupResultFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcleanupresult_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for cleanup results
- */
-export class WasmCleanupResult {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmCleanupResult.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmCleanupResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmCleanupResultFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmcleanupresult_free(ptr, 0);
-    }
-    /**
-     * Get the cleaned (denoised) value
-     * @returns {WasmTropicalDualClifford}
-     */
-    getCleaned() {
-        const ret = wasm.wasmcleanupresult_getCleaned(this.__wbg_ptr);
-        return WasmTropicalDualClifford.__wrap(ret);
-    }
-    /**
-     * Check if the cleanup converged
-     * @returns {boolean}
-     */
-    didConverge() {
-        const ret = wasm.wasmcleanupresult_didConverge(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Get the number of iterations used
-     * @returns {number}
-     */
-    getIterations() {
-        const ret = wasm.wasmcleanupresult_getIterations(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get the index of the best matching codebook item
-     * @returns {number}
-     */
-    getBestMatchIndex() {
-        const ret = wasm.wasmcleanupresult_getBestMatchIndex(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-}
-
 const WasmCommunityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmcommunity_free(ptr >>> 0, 1));
@@ -4113,7 +4052,7 @@ const WasmHolographicMemoryFinalization = (typeof FinalizationRegistry === 'unde
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmholographicmemory_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for HolographicMemory
+ * WASM wrapper for HolographicMemory using ProductClifford algebra
  */
 export class WasmHolographicMemory {
 
@@ -4144,21 +4083,6 @@ export class WasmHolographicMemory {
         const ret = wasm.wasmholographicmemory_itemCount(this.__wbg_ptr);
         return ret >>> 0;
     }
-    /**
-     * Batch store multiple key-value pairs
-     * @param {Float64Array} keys
-     * @param {Float64Array} values
-     */
-    storeBatch(keys, values) {
-        const ptr0 = passArrayF64ToWasm0(keys, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmholographicmemory_storeBatch(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
     /**
      * Get the estimated SNR (signal-to-noise ratio)
      * @returns {number}
@@ -4168,21 +4092,22 @@ export class WasmHolographicMemory {
         return ret;
     }
     /**
-     * Check if memory is near capacity
-     * @returns {boolean}
+     * Generate a random versor (for use as key/value)
+     * @param {number} num_factors
+     * @returns {Float64Array}
      */
-    isNearCapacity() {
-        const ret = wasm.wasmholographicmemory_isNearCapacity(this.__wbg_ptr);
-        return ret !== 0;
+    static randomVersor(num_factors) {
+        const ret = wasm.wasmholographicmemory_randomVersor(num_factors);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * Check if memory probably contains a key
-     * @param {WasmTropicalDualClifford} key
+     * Check if memory is near capacity
      * @returns {boolean}
      */
-    probablyContains(key) {
-        _assertClass(key, WasmTropicalDualClifford);
-        const ret = wasm.wasmholographicmemory_probablyContains(this.__wbg_ptr, key.__wbg_ptr);
+    isNearCapacity() {
+        const ret = wasm.wasmholographicmemory_isNearCapacity(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -4194,32 +4119,26 @@ export class WasmHolographicMemory {
         return WasmHolographicMemory.__wrap(ret);
     }
     /**
-     * Get the theoretical capacity
+     * Get retrieval confidence for a key
+     * @param {Float64Array} key
      * @returns {number}
      */
-    theoreticalCapacity() {
-        const ret = wasm.wasmholographicmemory_theoreticalCapacity(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Retrieve with custom temperature
-     * @param {WasmTropicalDualClifford} key
-     * @param {number} beta
-     * @returns {WasmRetrievalResult}
-     */
-    retrieveAtTemperature(key, beta) {
-        _assertClass(key, WasmTropicalDualClifford);
-        const ret = wasm.wasmholographicmemory_retrieveAtTemperature(this.__wbg_ptr, key.__wbg_ptr, beta);
-        return WasmRetrievalResult.__wrap(ret);
+    retrieveConfidence(key) {
+        const ptr0 = passArrayF64ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmholographicmemory_retrieveConfidence(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
     /**
-     * Create with custom bundle temperature
-     * @param {number} beta
-     * @returns {WasmHolographicMemory}
+     * Get capacity information
+     * @returns {number}
      */
-    static withBundleTemperature(beta) {
-        const ret = wasm.wasmholographicmemory_withBundleTemperature(beta);
-        return WasmHolographicMemory.__wrap(ret);
+    theoreticalCapacity() {
+        const ret = wasm.wasmholographicmemory_theoreticalCapacity(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
      * Create a new holographic memory with default settings
@@ -4237,32 +4156,39 @@ export class WasmHolographicMemory {
         wasm.wasmholographicmemory_clear(this.__wbg_ptr);
     }
     /**
-     * Merge another memory into this one
-     * @param {WasmHolographicMemory} other
-     */
-    merge(other) {
-        _assertClass(other, WasmHolographicMemory);
-        wasm.wasmholographicmemory_merge(this.__wbg_ptr, other.__wbg_ptr);
-    }
-    /**
-     * Store a key-value pair in memory
-     * @param {WasmTropicalDualClifford} key
-     * @param {WasmTropicalDualClifford} value
+     * Store a key-value pair in memory (using flat coefficient arrays)
+     *
+     * Each array should have 256 coefficients for ProductCl3x32.
+     * @param {Float64Array} key
+     * @param {Float64Array} value
      */
     store(key, value) {
-        _assertClass(key, WasmTropicalDualClifford);
-        _assertClass(value, WasmTropicalDualClifford);
-        wasm.wasmholographicmemory_store(this.__wbg_ptr, key.__wbg_ptr, value.__wbg_ptr);
+        const ptr0 = passArrayF64ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(value, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmholographicmemory_store(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
      * Retrieve a value by key
-     * @param {WasmTropicalDualClifford} key
-     * @returns {WasmRetrievalResult}
+     *
+     * Returns the retrieved coefficients as a Float64Array.
+     * @param {Float64Array} key
+     * @returns {Float64Array}
      */
     retrieve(key) {
-        _assertClass(key, WasmTropicalDualClifford);
-        const ret = wasm.wasmholographicmemory_retrieve(this.__wbg_ptr, key.__wbg_ptr);
-        return WasmRetrievalResult.__wrap(ret);
+        const ptr0 = passArrayF64ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmholographicmemory_retrieve(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
     }
 }
 
@@ -5716,18 +5642,10 @@ const WasmResonatorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmresonator_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for Resonator (iterative cleanup)
+ * WASM wrapper for Resonator using ProductClifford algebra
  */
 export class WasmResonator {
 
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmResonator.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmResonatorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -5739,22 +5657,6 @@ export class WasmResonator {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmresonator_free(ptr, 0);
     }
-    /**
-     * Create with custom configuration
-     * @param {Float64Array} codebook_flat
-     * @param {number} max_iterations
-     * @param {number} convergence_threshold
-     * @returns {WasmResonator}
-     */
-    static withConfig(codebook_flat, max_iterations, convergence_threshold) {
-        const ptr0 = passArrayF64ToWasm0(codebook_flat, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmresonator_withConfig(ptr0, len0, max_iterations, convergence_threshold);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmResonator.__wrap(ret[0]);
-    }
     /**
      * Get the codebook size
      * @returns {number}
@@ -5764,7 +5666,23 @@ export class WasmResonator {
         return ret >>> 0;
     }
     /**
-     * Create a resonator from a codebook of TDC vectors
+     * Get cleanup result with metadata
+     * @param {Float64Array} input
+     * @returns {any}
+     */
+    cleanupWithInfo(input) {
+        const ptr0 = passArrayF64ToWasm0(input, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmresonator_cleanupWithInfo(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Create a resonator from a flat codebook array
+     *
+     * Each item should have 256 coefficients for ProductCl3x32.
      * @param {Float64Array} codebook_flat
      */
     constructor(codebook_flat) {
@@ -5780,69 +5698,19 @@ export class WasmResonator {
     }
     /**
      * Clean up a noisy input to find the closest codebook item
-     * @param {WasmTropicalDualClifford} input
-     * @returns {WasmCleanupResult}
+     * @param {Float64Array} input
+     * @returns {Float64Array}
      */
     cleanup(input) {
-        _assertClass(input, WasmTropicalDualClifford);
-        const ret = wasm.wasmresonator_cleanup(this.__wbg_ptr, input.__wbg_ptr);
-        return WasmCleanupResult.__wrap(ret);
-    }
-}
-
-const WasmRetrievalResultFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmretrievalresult_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for retrieval results
- */
-export class WasmRetrievalResult {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmRetrievalResult.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmRetrievalResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmRetrievalResultFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmretrievalresult_free(ptr, 0);
-    }
-    /**
-     * Get the retrieval confidence (0 to 1)
-     * @returns {number}
-     */
-    getConfidence() {
-        const ret = wasm.wasmretrievalresult_getConfidence(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Get attribution as arrays of [index, weight] pairs
-     * @returns {any}
-     */
-    getAttribution() {
-        const ret = wasm.wasmretrievalresult_getAttribution(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+        const ptr0 = passArrayF64ToWasm0(input, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmresonator_cleanup(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
         }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * Get the retrieved value
-     * @returns {WasmTropicalDualClifford}
-     */
-    getValue() {
-        const ret = wasm.wasmretrievalresult_getValue(this.__wbg_ptr);
-        return WasmTropicalDualClifford.__wrap(ret);
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
     }
 }
 
@@ -7323,7 +7191,7 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_bf345a94df4f1349 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_73e7856ded7435b4 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_log_ea240990d83e374e = function(arg0) {
@@ -7348,7 +7216,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_496(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_486(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -7359,6 +7227,10 @@ function __wbg_get_imports() {
             state0.a = state0.b = 0;
         }
     };
+    imports.wbg.__wbg_newfromslice_bcd6b1e87ab624a5 = function(arg0, arg1) {
+        const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
+        return ret;
+    };
     imports.wbg.__wbg_newnoargs_ff528e72d35de39a = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return ret;
@@ -7444,8 +7316,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper1715 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57, __wbg_adapter_28);
+    imports.wbg.__wbindgen_closure_wrapper1599 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 39, __wbg_adapter_28);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {

package/package.json

@@ -5,7 +5,7 @@
     "Amari Contributors"
   ],
   "description": "WebAssembly bindings for Amari mathematical computing library - geometric algebra, tropical algebra, automatic differentiation, measure theory, fusion systems, and information geometry",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",