@justinelliottcobb/amari-wasm 0.7.0 → 0.8.1

package/amari_wasm.js

@@ -1,20 +1,5 @@
 let wasm;
 
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_export_2.set(idx, obj);
-    return idx;
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
-    }
-}
-
 let cachedUint8ArrayMemory0 = null;
 
 function getUint8ArrayMemory0() {
@@ -45,31 +30,6 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_2.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
 let cachedFloat64ArrayMemory0 = null;
 
 function getFloat64ArrayMemory0() {
@@ -88,10 +48,22 @@ function passArrayF64ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_0.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
 function getArrayF64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
 /**
  * Initialize the WASM module
  */
@@ -99,54 +71,6 @@ export function init() {
     wasm.init();
 }
 
-const AutoDiffFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_autodiff_free(ptr >>> 0, 1));
-/**
- * Automatic differentiation utilities
- */
-export class AutoDiff {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        AutoDiffFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_autodiff_free(ptr, 0);
-    }
-    /**
-     * Compute numerical derivative using finite differences (fallback implementation)
-     * @param {number} x
-     * @param {Function} f
-     * @param {number} h
-     * @returns {number}
-     */
-    static numericalDerivative(x, f, h) {
-        const ret = wasm.autodiff_numericalDerivative(x, f, h);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
-    }
-    /**
-     * Create a dual number and evaluate a polynomial
-     * @param {number} x
-     * @param {Float64Array} coefficients
-     * @returns {WasmDualNumber}
-     */
-    static evaluatePolynomial(x, coefficients) {
-        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.autodiff_evaluatePolynomial(x, ptr0, len0);
-        return WasmDualNumber.__wrap(ret);
-    }
-}
-if (Symbol.dispose) AutoDiff.prototype[Symbol.dispose] = AutoDiff.prototype.free;
-
 const BatchOperationsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_batchoperations_free(ptr >>> 0, 1));
@@ -208,189 +132,6 @@ export class BatchOperations {
 }
 if (Symbol.dispose) BatchOperations.prototype[Symbol.dispose] = BatchOperations.prototype.free;
 
-const FusionBatchFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_fusionbatch_free(ptr >>> 0, 1));
-/**
- * Fusion utilities for batch operations
- */
-export class FusionBatch {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        FusionBatchFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_fusionbatch_free(ptr, 0);
-    }
-    /**
-     * Batch tropical attention across multiple queries
-     * @param {Float64Array} queries
-     * @param {Float64Array} keys
-     * @param {Float64Array} values
-     * @param {number} query_dim
-     * @returns {Float64Array}
-     */
-    static batchTropicalAttention(queries, keys, values, query_dim) {
-        const ptr0 = passArrayF64ToWasm0(queries, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(keys, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.fusionbatch_batchTropicalAttention(ptr0, len0, ptr1, len1, ptr2, len2, query_dim);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v4;
-    }
-    /**
-     * Compute fusion similarity between two TDC objects
-     * @param {WasmTropicalDualClifford} tdc1
-     * @param {WasmTropicalDualClifford} tdc2
-     * @returns {number}
-     */
-    static fusionSimilarity(tdc1, tdc2) {
-        _assertClass(tdc1, WasmTropicalDualClifford);
-        _assertClass(tdc2, WasmTropicalDualClifford);
-        const ret = wasm.fusionbatch_fusionSimilarity(tdc1.__wbg_ptr, tdc2.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Optimize TDC parameters using gradient information
-     * @param {WasmTropicalDualClifford} tdc
-     * @param {number} learning_rate
-     * @returns {WasmTropicalDualClifford}
-     */
-    static gradientStep(tdc, learning_rate) {
-        _assertClass(tdc, WasmTropicalDualClifford);
-        const ret = wasm.fusionbatch_gradientStep(tdc.__wbg_ptr, learning_rate);
-        return WasmTropicalDualClifford.__wrap(ret);
-    }
-}
-if (Symbol.dispose) FusionBatch.prototype[Symbol.dispose] = FusionBatch.prototype.free;
-
-const InfoGeomUtilsFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_infogeomutils_free(ptr >>> 0, 1));
-/**
- * Information geometry utilities
- */
-export class InfoGeomUtils {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        InfoGeomUtilsFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_infogeomutils_free(ptr, 0);
-    }
-    /**
-     * Normalize array to probability distribution
-     * @param {Float64Array} values
-     * @returns {Float64Array}
-     */
-    static normalize(values) {
-        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.infogeomutils_normalize(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;
-    }
-    /**
-     * Convert log probabilities to probabilities
-     * @param {Float64Array} logits
-     * @returns {Float64Array}
-     */
-    static softmax(logits) {
-        const ptr0 = passArrayF64ToWasm0(logits, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.infogeomutils_softmax(ptr0, len0);
-        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v2;
-    }
-    /**
-     * Compute entropy of a probability distribution
-     * @param {Float64Array} p
-     * @returns {number}
-     */
-    static entropy(p) {
-        const ptr0 = passArrayF64ToWasm0(p, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.infogeomutils_entropy(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
-    }
-    /**
-     * Compute cross-entropy between two distributions
-     * @param {Float64Array} p
-     * @param {Float64Array} q
-     * @returns {number}
-     */
-    static crossEntropy(p, q) {
-        const ptr0 = passArrayF64ToWasm0(p, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(q, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.infogeomutils_crossEntropy(ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
-    }
-    /**
-     * Compute mutual information between two discrete distributions
-     * @param {Float64Array} joint
-     * @param {Float64Array} marginal_x
-     * @param {Float64Array} marginal_y
-     * @param {number} dim_x
-     * @returns {number}
-     */
-    static mutualInformation(joint, marginal_x, marginal_y, dim_x) {
-        const ptr0 = passArrayF64ToWasm0(joint, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(marginal_x, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArrayF64ToWasm0(marginal_y, wasm.__wbindgen_malloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.infogeomutils_mutualInformation(ptr0, len0, ptr1, len1, ptr2, len2, dim_x);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
-    }
-    /**
-     * Generate points on the probability simplex for testing
-     * Note: Uses a simple deterministic sequence for reproducibility in WASM
-     * @param {number} dimension
-     * @returns {Float64Array}
-     */
-    static randomSimplex(dimension) {
-        const ret = wasm.infogeomutils_randomSimplex(dimension);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-}
-if (Symbol.dispose) InfoGeomUtils.prototype[Symbol.dispose] = InfoGeomUtils.prototype.free;
-
 const PerformanceOperationsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_performanceoperations_free(ptr >>> 0, 1));
@@ -403,705 +144,75 @@ export class PerformanceOperations {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         PerformanceOperationsFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_performanceoperations_free(ptr, 0);
-    }
-    /**
-     * Fast geometric product for hot paths with memory pooling
-     * @param {Float64Array} lhs
-     * @param {Float64Array} rhs
-     * @returns {Float64Array}
-     */
-    static fastGeometricProduct(lhs, rhs) {
-        const ptr0 = passArrayF64ToWasm0(lhs, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(rhs, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.performanceoperations_fastGeometricProduct(ptr0, len0, ptr1, len1);
-        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v3;
-    }
-    /**
-     * Optimized vector operations for 3D space
-     * @param {Float64Array} v1
-     * @param {Float64Array} v2
-     * @returns {Float64Array}
-     */
-    static vectorCrossProduct(v1, v2) {
-        const ptr0 = passArrayF64ToWasm0(v1, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(v2, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.performanceoperations_vectorCrossProduct(ptr0, len0, ptr1, len1);
-        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v3;
-    }
-    /**
-     * Optimized vector dot product
-     * @param {Float64Array} v1
-     * @param {Float64Array} v2
-     * @returns {number}
-     */
-    static vectorDotProduct(v1, v2) {
-        const ptr0 = passArrayF64ToWasm0(v1, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(v2, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.performanceoperations_vectorDotProduct(ptr0, len0, ptr1, len1);
-        return ret;
-    }
-    /**
-     * Batch normalize vectors for efficiency
-     * @param {Float64Array} vectors
-     * @param {number} vector_size
-     * @returns {Float64Array}
-     */
-    static batchNormalize(vectors, vector_size) {
-        const ptr0 = passArrayF64ToWasm0(vectors, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.performanceoperations_batchNormalize(ptr0, len0, vector_size);
-        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v2;
-    }
-}
-if (Symbol.dispose) PerformanceOperations.prototype[Symbol.dispose] = PerformanceOperations.prototype.free;
-
-const TropicalBatchFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_tropicalbatch_free(ptr >>> 0, 1));
-/**
- * Batch operations for tropical numbers
- */
-export class TropicalBatch {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        TropicalBatchFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tropicalbatch_free(ptr, 0);
-    }
-    /**
-     * Batch tropical addition (max operation)
-     * @param {Float64Array} values
-     * @returns {number}
-     */
-    static batchTropicalAdd(values) {
-        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.tropicalbatch_batchTropicalAdd(ptr0, len0);
-        return ret;
-    }
-    /**
-     * Batch tropical multiplication (addition)
-     * @param {Float64Array} values
-     * @returns {number}
-     */
-    static batchTropicalMul(values) {
-        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.tropicalbatch_batchTropicalMul(ptr0, len0);
-        return ret;
-    }
-    /**
-     * Convert array of log probabilities to tropical numbers and find maximum
-     * @param {Float64Array} log_probs
-     * @returns {number}
-     */
-    static maxLogProb(log_probs) {
-        const ptr0 = passArrayF64ToWasm0(log_probs, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.tropicalbatch_maxLogProb(ptr0, len0);
-        return ret;
-    }
-    /**
-     * Viterbi algorithm helper: find best path through trellis
-     * @param {Float64Array} prev_scores
-     * @param {Float64Array} transition_scores
-     * @param {Float64Array} emission_scores
-     * @param {number} num_states
-     * @returns {Float64Array}
-     */
-    static viterbiStep(prev_scores, transition_scores, emission_scores, num_states) {
-        const ptr0 = passArrayF64ToWasm0(prev_scores, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(transition_scores, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArrayF64ToWasm0(emission_scores, wasm.__wbindgen_malloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.tropicalbatch_viterbiStep(ptr0, len0, ptr1, len1, ptr2, len2, num_states);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v4;
-    }
-}
-if (Symbol.dispose) TropicalBatch.prototype[Symbol.dispose] = TropicalBatch.prototype.free;
-
-const WasmAlphaConnectionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmalphaconnection_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for AlphaConnection
- */
-export class WasmAlphaConnection {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmAlphaConnectionFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmalphaconnection_free(ptr, 0);
-    }
-    /**
-     * Create a new α-connection
-     * @param {number} alpha
-     */
-    constructor(alpha) {
-        const ret = wasm.wasmalphaconnection_new(alpha);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        WasmAlphaConnectionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Get the α parameter
-     * @returns {number}
-     */
-    getAlpha() {
-        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Check if this is the exponential connection (α = 1)
-     * @returns {boolean}
-     */
-    isExponential() {
-        const ret = wasm.wasmalphaconnection_isExponential(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Check if this is the mixture connection (α = -1)
-     * @returns {boolean}
-     */
-    isMixture() {
-        const ret = wasm.wasmalphaconnection_isMixture(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Check if this is the Levi-Civita connection (α = 0)
-     * @returns {boolean}
-     */
-    isLeviCivita() {
-        const ret = wasm.wasmalphaconnection_isLeviCivita(this.__wbg_ptr);
-        return ret !== 0;
-    }
-}
-if (Symbol.dispose) WasmAlphaConnection.prototype[Symbol.dispose] = WasmAlphaConnection.prototype.free;
-
-const WasmDualNumberFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmdualnumber_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for single-variable dual numbers
- */
-export class WasmDualNumber {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmDualNumber.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmDualNumberFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmDualNumberFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmdualnumber_free(ptr, 0);
-    }
-    /**
-     * Create a new dual number with given real and dual parts
-     * @param {number} real
-     * @param {number} dual
-     */
-    constructor(real, dual) {
-        const ret = wasm.wasmdualnumber_new(real, dual);
-        this.__wbg_ptr = ret >>> 0;
-        WasmDualNumberFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Create a variable (derivative = 1)
-     * @param {number} value
-     * @returns {WasmDualNumber}
-     */
-    static variable(value) {
-        const ret = wasm.wasmdualnumber_variable(value);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Create a constant (derivative = 0)
-     * @param {number} value
-     * @returns {WasmDualNumber}
-     */
-    static constant(value) {
-        const ret = wasm.wasmdualnumber_constant(value);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Get the real part (function value)
-     * @returns {number}
-     */
-    getReal() {
-        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Get the dual part (derivative)
-     * @returns {number}
-     */
-    getDual() {
-        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Addition
-     * @param {WasmDualNumber} other
-     * @returns {WasmDualNumber}
-     */
-    add(other) {
-        _assertClass(other, WasmDualNumber);
-        const ret = wasm.wasmdualnumber_add(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Subtraction
-     * @param {WasmDualNumber} other
-     * @returns {WasmDualNumber}
-     */
-    sub(other) {
-        _assertClass(other, WasmDualNumber);
-        const ret = wasm.wasmdualnumber_sub(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Multiplication
-     * @param {WasmDualNumber} other
-     * @returns {WasmDualNumber}
-     */
-    mul(other) {
-        _assertClass(other, WasmDualNumber);
-        const ret = wasm.wasmdualnumber_mul(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Division
-     * @param {WasmDualNumber} other
-     * @returns {WasmDualNumber}
-     */
-    div(other) {
-        _assertClass(other, WasmDualNumber);
-        const ret = wasm.wasmdualnumber_div(this.__wbg_ptr, other.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmDualNumber.__wrap(ret[0]);
-    }
-    /**
-     * Negation
-     * @returns {WasmDualNumber}
-     */
-    neg() {
-        const ret = wasm.wasmdualnumber_neg(this.__wbg_ptr);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Power function
-     * @param {number} exponent
-     * @returns {WasmDualNumber}
-     */
-    pow(exponent) {
-        const ret = wasm.wasmdualnumber_pow(this.__wbg_ptr, exponent);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Exponential function
-     * @returns {WasmDualNumber}
-     */
-    exp() {
-        const ret = wasm.wasmdualnumber_exp(this.__wbg_ptr);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Natural logarithm
-     * @returns {WasmDualNumber}
-     */
-    ln() {
-        const ret = wasm.wasmdualnumber_ln(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmDualNumber.__wrap(ret[0]);
-    }
-    /**
-     * Sine function
-     * @returns {WasmDualNumber}
-     */
-    sin() {
-        const ret = wasm.wasmdualnumber_sin(this.__wbg_ptr);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Cosine function
-     * @returns {WasmDualNumber}
-     */
-    cos() {
-        const ret = wasm.wasmdualnumber_cos(this.__wbg_ptr);
-        return WasmDualNumber.__wrap(ret);
-    }
-    /**
-     * Square root
-     * @returns {WasmDualNumber}
-     */
-    sqrt() {
-        const ret = wasm.wasmdualnumber_sqrt(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmDualNumber.__wrap(ret[0]);
-    }
-}
-if (Symbol.dispose) WasmDualNumber.prototype[Symbol.dispose] = WasmDualNumber.prototype.free;
-
-const WasmDuallyFlatManifoldFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmduallyflatmanifold_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for DuallyFlatManifold
- */
-export class WasmDuallyFlatManifold {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmDuallyFlatManifoldFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmduallyflatmanifold_free(ptr, 0);
-    }
-    /**
-     * Create a new dually flat manifold
-     * @param {number} dimension
-     * @param {number} alpha
-     */
-    constructor(dimension, alpha) {
-        const ret = wasm.wasmduallyflatmanifold_new(dimension, alpha);
-        this.__wbg_ptr = ret >>> 0;
-        WasmDuallyFlatManifoldFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Compute Fisher information metric at a point
-     * @param {Float64Array} point
-     * @returns {WasmFisherInformationMatrix}
-     */
-    fisherMetricAt(point) {
-        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmduallyflatmanifold_fisherMetricAt(this.__wbg_ptr, ptr0, len0);
-        return WasmFisherInformationMatrix.__wrap(ret);
-    }
-    /**
-     * Compute Bregman divergence (KL divergence for probability distributions)
-     * @param {Float64Array} p
-     * @param {Float64Array} q
-     * @returns {number}
-     */
-    bregmanDivergence(p, q) {
-        const ptr0 = passArrayF64ToWasm0(p, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(q, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmduallyflatmanifold_bregmanDivergence(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        return ret;
-    }
-    /**
-     * Compute KL divergence between two probability distributions
-     * @param {Float64Array} p
-     * @param {Float64Array} q
-     * @returns {number}
-     */
-    klDivergence(p, q) {
-        const ptr0 = passArrayF64ToWasm0(p, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(q, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmduallyflatmanifold_klDivergence(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
-    }
-    /**
-     * Compute JS divergence (symmetric version of KL divergence)
-     * @param {Float64Array} p
-     * @param {Float64Array} q
-     * @returns {number}
-     */
-    jsDivergence(p, q) {
-        const ptr0 = passArrayF64ToWasm0(p, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(q, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmduallyflatmanifold_jsDivergence(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
-    }
-    /**
-     * Compute Wasserstein-1 distance (Earth Mover's Distance)
-     * @param {Float64Array} p
-     * @param {Float64Array} q
-     * @returns {number}
-     */
-    wassersteinDistance(p, q) {
-        const ptr0 = passArrayF64ToWasm0(p, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(q, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmduallyflatmanifold_wassersteinDistance(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
-    }
-}
-if (Symbol.dispose) WasmDuallyFlatManifold.prototype[Symbol.dispose] = WasmDuallyFlatManifold.prototype.free;
-
-const WasmFisherInformationMatrixFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmfisherinformationmatrix_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for FisherInformationMatrix
- */
-export class WasmFisherInformationMatrix {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmFisherInformationMatrix.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmFisherInformationMatrixFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmFisherInformationMatrixFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmfisherinformationmatrix_free(ptr, 0);
-    }
-    /**
-     * Get eigenvalues of the Fisher matrix
-     * @returns {Float64Array}
-     */
-    getEigenvalues() {
-        const ret = wasm.wasmfisherinformationmatrix_getEigenvalues(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-    /**
-     * Check if the matrix is positive definite
-     * @returns {boolean}
-     */
-    isPositiveDefinite() {
-        const ret = wasm.wasmfisherinformationmatrix_isPositiveDefinite(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Compute condition number (ratio of largest to smallest eigenvalue)
-     * @returns {number}
-     */
-    conditionNumber() {
-        const ret = wasm.wasmfisherinformationmatrix_conditionNumber(this.__wbg_ptr);
-        return ret;
-    }
-}
-if (Symbol.dispose) WasmFisherInformationMatrix.prototype[Symbol.dispose] = WasmFisherInformationMatrix.prototype.free;
-
-const WasmMultiDualNumberFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmultidualnumber_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for multi-variable dual numbers
- */
-export class WasmMultiDualNumber {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmMultiDualNumber.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmMultiDualNumberFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmMultiDualNumberFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmmultidualnumber_free(ptr, 0);
-    }
-    /**
-     * Create a new multi-dual number
-     * @param {number} real
-     * @param {Float64Array} duals
-     */
-    constructor(real, duals) {
-        const ptr0 = passArrayF64ToWasm0(duals, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmmultidualnumber_new(real, ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        WasmMultiDualNumberFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Create a variable with derivative 1 at the specified index
-     * @param {number} value
-     * @param {number} num_vars
-     * @param {number} var_index
-     * @returns {WasmMultiDualNumber}
-     */
-    static variable(value, num_vars, var_index) {
-        const ret = wasm.wasmmultidualnumber_variable(value, num_vars, var_index);
-        return WasmMultiDualNumber.__wrap(ret);
-    }
-    /**
-     * Create a constant (all derivatives are zero)
-     * @param {number} value
-     * @param {number} num_vars
-     * @returns {WasmMultiDualNumber}
-     */
-    static constant(value, num_vars) {
-        const ret = wasm.wasmmultidualnumber_constant(value, num_vars);
-        return WasmMultiDualNumber.__wrap(ret);
-    }
-    /**
-     * Get the real part (function value)
-     * @returns {number}
-     */
-    getReal() {
-        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
-        return ret;
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_performanceoperations_free(ptr, 0);
     }
     /**
-     * Get the gradient (all partial derivatives)
+     * Fast geometric product for hot paths with memory pooling
+     * @param {Float64Array} lhs
+     * @param {Float64Array} rhs
      * @returns {Float64Array}
      */
-    getGradient() {
-        const ret = wasm.wasmmultidualnumber_getGradient(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    static fastGeometricProduct(lhs, rhs) {
+        const ptr0 = passArrayF64ToWasm0(lhs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(rhs, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.performanceoperations_fastGeometricProduct(ptr0, len0, ptr1, len1);
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+        return v3;
     }
     /**
-     * Get a specific partial derivative
-     * @param {number} index
-     * @returns {number}
+     * Optimized vector operations for 3D space
+     * @param {Float64Array} v1
+     * @param {Float64Array} v2
+     * @returns {Float64Array}
      */
-    getPartial(index) {
-        const ret = wasm.wasmmultidualnumber_getPartial(this.__wbg_ptr, index);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
+    static vectorCrossProduct(v1, v2) {
+        const ptr0 = passArrayF64ToWasm0(v1, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(v2, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.performanceoperations_vectorCrossProduct(ptr0, len0, ptr1, len1);
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
     }
     /**
-     * Get number of variables
+     * Optimized vector dot product
+     * @param {Float64Array} v1
+     * @param {Float64Array} v2
      * @returns {number}
      */
-    getNumVars() {
-        const ret = wasm.wasmmultidualnumber_getNumVars(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Addition
-     * @param {WasmMultiDualNumber} other
-     * @returns {WasmMultiDualNumber}
-     */
-    add(other) {
-        _assertClass(other, WasmMultiDualNumber);
-        const ret = wasm.wasmmultidualnumber_add(this.__wbg_ptr, other.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmMultiDualNumber.__wrap(ret[0]);
-    }
-    /**
-     * Multiplication
-     * @param {WasmMultiDualNumber} other
-     * @returns {WasmMultiDualNumber}
-     */
-    mul(other) {
-        _assertClass(other, WasmMultiDualNumber);
-        const ret = wasm.wasmmultidualnumber_mul(this.__wbg_ptr, other.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmMultiDualNumber.__wrap(ret[0]);
+    static vectorDotProduct(v1, v2) {
+        const ptr0 = passArrayF64ToWasm0(v1, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(v2, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.performanceoperations_vectorDotProduct(ptr0, len0, ptr1, len1);
+        return ret;
     }
     /**
-     * Square root
-     * @returns {WasmMultiDualNumber}
+     * Batch normalize vectors for efficiency
+     * @param {Float64Array} vectors
+     * @param {number} vector_size
+     * @returns {Float64Array}
      */
-    sqrt() {
-        const ret = wasm.wasmmultidualnumber_sqrt(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmMultiDualNumber.__wrap(ret[0]);
+    static batchNormalize(vectors, vector_size) {
+        const ptr0 = passArrayF64ToWasm0(vectors, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.performanceoperations_batchNormalize(ptr0, len0, vector_size);
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
     }
 }
-if (Symbol.dispose) WasmMultiDualNumber.prototype[Symbol.dispose] = WasmMultiDualNumber.prototype.free;
+if (Symbol.dispose) PerformanceOperations.prototype[Symbol.dispose] = PerformanceOperations.prototype.free;
 
 const WasmMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1405,339 +516,6 @@ export class WasmRotor {
 }
 if (Symbol.dispose) WasmRotor.prototype[Symbol.dispose] = WasmRotor.prototype.free;
 
-const WasmTropicalDualCliffordFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmtropicaldualclifford_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for TropicalDualClifford fusion system
- */
-export class WasmTropicalDualClifford {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmTropicalDualClifford.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmTropicalDualCliffordFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmTropicalDualCliffordFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmtropicaldualclifford_free(ptr, 0);
-    }
-    /**
-     * Create a zero TDC object
-     */
-    constructor() {
-        const ret = wasm.wasmtropicaldualclifford_new();
-        this.__wbg_ptr = ret >>> 0;
-        WasmTropicalDualCliffordFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Create from logits (array of log-probabilities)
-     * @param {Float64Array} logits
-     * @returns {WasmTropicalDualClifford}
-     */
-    static fromLogits(logits) {
-        const ptr0 = passArrayF64ToWasm0(logits, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmtropicaldualclifford_fromLogits(ptr0, len0);
-        return WasmTropicalDualClifford.__wrap(ret);
-    }
-    /**
-     * Create random TDC for testing
-     * @returns {WasmTropicalDualClifford}
-     */
-    static random() {
-        const ret = wasm.wasmtropicaldualclifford_random();
-        return WasmTropicalDualClifford.__wrap(ret);
-    }
-    /**
-     * Create random TDC with specific scale
-     * @param {number} scale
-     * @returns {WasmTropicalDualClifford}
-     */
-    static randomWithScale(scale) {
-        const ret = wasm.wasmtropicaldualclifford_randomWithScale(scale);
-        return WasmTropicalDualClifford.__wrap(ret);
-    }
-    /**
-     * Check if TDC is zero
-     * @returns {boolean}
-     */
-    isZero() {
-        const ret = wasm.wasmtropicaldualclifford_isZero(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Extract tropical features as array
-     * @returns {Float64Array}
-     */
-    getTropicalFeatures() {
-        const ret = wasm.wasmtropicaldualclifford_getTropicalFeatures(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-    /**
-     * Extract dual features as array of real parts
-     * @returns {Float64Array}
-     */
-    getDualReals() {
-        const ret = wasm.wasmtropicaldualclifford_getDualReals(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-    /**
-     * Extract dual features as array of dual parts (derivatives)
-     * @returns {Float64Array}
-     */
-    getDualDerivatives() {
-        const ret = wasm.wasmtropicaldualclifford_getDualDerivatives(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-    /**
-     * Get Clifford coefficients
-     * @returns {Float64Array}
-     */
-    getCliffordCoefficients() {
-        const ret = wasm.wasmtropicaldualclifford_getCliffordCoefficients(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-    /**
-     * Add two TDC objects
-     * @param {WasmTropicalDualClifford} other
-     * @returns {WasmTropicalDualClifford}
-     */
-    add(other) {
-        _assertClass(other, WasmTropicalDualClifford);
-        const ret = wasm.wasmtropicaldualclifford_add(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmTropicalDualClifford.__wrap(ret);
-    }
-    /**
-     * Scale TDC object
-     * @param {number} factor
-     * @returns {WasmTropicalDualClifford}
-     */
-    scale(factor) {
-        const ret = wasm.wasmtropicaldualclifford_scale(this.__wbg_ptr, factor);
-        return WasmTropicalDualClifford.__wrap(ret);
-    }
-    /**
-     * Compute fusion norm (combined measure across all systems)
-     * @returns {number}
-     */
-    fusionNorm() {
-        const ret = wasm.wasmtropicaldualclifford_fusionNorm(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Perform tropical attention operation
-     * @param {Float64Array} keys
-     * @param {Float64Array} values
-     * @returns {Float64Array}
-     */
-    tropicalAttention(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.wasmtropicaldualclifford_tropicalAttention(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v3;
-    }
-    /**
-     * Extract geometric features using Clifford operations
-     * @returns {Float64Array}
-     */
-    extractGeometricFeatures() {
-        const ret = wasm.wasmtropicaldualclifford_extractGeometricFeatures(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-}
-if (Symbol.dispose) WasmTropicalDualClifford.prototype[Symbol.dispose] = WasmTropicalDualClifford.prototype.free;
-
-const WasmTropicalNumberFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmtropicalnumber_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for TropicalNumber
- */
-export class WasmTropicalNumber {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmTropicalNumber.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmTropicalNumberFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmTropicalNumberFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmtropicalnumber_free(ptr, 0);
-    }
-    /**
-     * Create a new tropical number from a regular number
-     * @param {number} value
-     */
-    constructor(value) {
-        const ret = wasm.wasmtropicalnumber_fromLogProb(value);
-        this.__wbg_ptr = ret >>> 0;
-        WasmTropicalNumberFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Create tropical zero (negative infinity)
-     * @returns {WasmTropicalNumber}
-     */
-    static zero() {
-        const ret = wasm.wasmtropicalnumber_zero();
-        return WasmTropicalNumber.__wrap(ret);
-    }
-    /**
-     * Create tropical one (regular zero)
-     * @returns {WasmTropicalNumber}
-     */
-    static one() {
-        const ret = wasm.wasmtropicalnumber_one();
-        return WasmTropicalNumber.__wrap(ret);
-    }
-    /**
-     * Create from log probability
-     * @param {number} log_p
-     * @returns {WasmTropicalNumber}
-     */
-    static fromLogProb(log_p) {
-        const ret = wasm.wasmtropicalnumber_fromLogProb(log_p);
-        return WasmTropicalNumber.__wrap(ret);
-    }
-    /**
-     * Get the underlying value
-     * @returns {number}
-     */
-    getValue() {
-        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Convert to probability (via exp)
-     * @returns {number}
-     */
-    toProb() {
-        const ret = wasm.wasmtropicalnumber_toProb(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Check if this is tropical zero (negative infinity)
-     * @returns {boolean}
-     */
-    isZero() {
-        const ret = wasm.wasmtropicalnumber_isZero(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Check if this is tropical one (zero)
-     * @returns {boolean}
-     */
-    isOne() {
-        const ret = wasm.wasmtropicalnumber_isOne(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Check if this is infinite
-     * @returns {boolean}
-     */
-    isInfinity() {
-        const ret = wasm.wasmtropicalnumber_isInfinity(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Tropical addition (max operation)
-     * @param {WasmTropicalNumber} other
-     * @returns {WasmTropicalNumber}
-     */
-    tropicalAdd(other) {
-        _assertClass(other, WasmTropicalNumber);
-        const ret = wasm.wasmtropicalnumber_add(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmTropicalNumber.__wrap(ret);
-    }
-    /**
-     * Tropical multiplication (addition)
-     * @param {WasmTropicalNumber} other
-     * @returns {WasmTropicalNumber}
-     */
-    tropicalMul(other) {
-        _assertClass(other, WasmTropicalNumber);
-        const ret = wasm.wasmtropicalnumber_mul(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmTropicalNumber.__wrap(ret);
-    }
-    /**
-     * Tropical power (scalar multiplication)
-     * @param {number} n
-     * @returns {WasmTropicalNumber}
-     */
-    tropicalPow(n) {
-        const ret = wasm.wasmtropicalnumber_tropicalPow(this.__wbg_ptr, n);
-        return WasmTropicalNumber.__wrap(ret);
-    }
-    /**
-     * Standard addition (for convenience)
-     * @param {WasmTropicalNumber} other
-     * @returns {WasmTropicalNumber}
-     */
-    add(other) {
-        _assertClass(other, WasmTropicalNumber);
-        const ret = wasm.wasmtropicalnumber_add(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmTropicalNumber.__wrap(ret);
-    }
-    /**
-     * Standard multiplication (for convenience)
-     * @param {WasmTropicalNumber} other
-     * @returns {WasmTropicalNumber}
-     */
-    mul(other) {
-        _assertClass(other, WasmTropicalNumber);
-        const ret = wasm.wasmtropicalnumber_mul(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmTropicalNumber.__wrap(ret);
-    }
-    /**
-     * Negation
-     * @returns {WasmTropicalNumber}
-     */
-    neg() {
-        const ret = wasm.wasmtropicalnumber_neg(this.__wbg_ptr);
-        return WasmTropicalNumber.__wrap(ret);
-    }
-}
-if (Symbol.dispose) WasmTropicalNumber.prototype[Symbol.dispose] = WasmTropicalNumber.prototype.free;
-
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
@@ -1776,27 +554,9 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_apply_dc50eb58583d2a57 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = arg0.apply(arg1, arg2);
-        return ret;
-    }, arguments) };
-    imports.wbg.__wbg_log_2855aa4ea73e1eff = function(arg0, arg1) {
+    imports.wbg.__wbg_log_b5e9db469edac08b = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
-    imports.wbg.__wbg_new_1f3a344cf3123716 = function() {
-        const ret = new Array();
-        return ret;
-    };
-    imports.wbg.__wbg_push_330b2eb93e4e1212 = function(arg0, arg1) {
-        const ret = arg0.push(arg1);
-        return ret;
-    };
-    imports.wbg.__wbg_wbindgennumberget_f74b4c7525ac05cb = function(arg0, arg1) {
-        const obj = arg1;
-        const ret = typeof(obj) === 'number' ? obj : undefined;
-        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-    };
     imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
@@ -1805,13 +565,8 @@ function __wbg_get_imports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return ret;
     };
-    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
-        // Cast intrinsic for `F64 -> Externref`.
-        const ret = arg0;
-        return ret;
-    };
     imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_export_2;
+        const table = wasm.__wbindgen_export_0;
         const offset = table.grow(4);
         table.set(0, undefined);
         table.set(offset + 0, undefined);
@@ -1831,7 +586,6 @@ function __wbg_init_memory(imports, memory) {
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
-    cachedDataViewMemory0 = null;
     cachedFloat64ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;