@justinelliottcobb/amari-wasm 0.3.6 → 0.6.0

package/amari_wasm.js

@@ -1,5 +1,20 @@
 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() {
@@ -30,6 +45,31 @@ 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() {
@@ -48,22 +88,10 @@ 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
  */
@@ -71,6 +99,54 @@ 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));
@@ -85,51 +161,947 @@ export class BatchOperations {
         BatchOperationsFinalization.unregister(this);
         return ptr;
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_batchoperations_free(ptr, 0);
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_batchoperations_free(ptr, 0);
+    }
+    /**
+     * Batch geometric product: compute a[i] * b[i] for all i
+     * Optimized for WebAssembly performance with reduced allocations
+     * @param {Float64Array} a_batch
+     * @param {Float64Array} b_batch
+     * @returns {Float64Array}
+     */
+    static batchGeometricProduct(a_batch, b_batch) {
+        const ptr0 = passArrayF64ToWasm0(a_batch, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(b_batch, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.batchoperations_batchGeometricProduct(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;
+    }
+    /**
+     * Batch addition
+     * @param {Float64Array} a_batch
+     * @param {Float64Array} b_batch
+     * @returns {Float64Array}
+     */
+    static batchAdd(a_batch, b_batch) {
+        const ptr0 = passArrayF64ToWasm0(a_batch, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(b_batch, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.batchoperations_batchAdd(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;
+    }
+}
+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));
+/**
+ * High-performance WASM operations with memory pooling
+ */
+export class PerformanceOperations {
+
+    __destroy_into_raw() {
+        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);
     }
     /**
-     * Batch geometric product: compute a[i] * b[i] for all i
-     * @param {Float64Array} a_batch
-     * @param {Float64Array} b_batch
+     * 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;
+    }
+    /**
+     * Get the gradient (all partial derivatives)
      * @returns {Float64Array}
      */
-    static batchGeometricProduct(a_batch, b_batch) {
-        const ptr0 = passArrayF64ToWasm0(a_batch, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(b_batch, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.batchoperations_batchGeometricProduct(ptr0, len0, ptr1, len1);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    getGradient() {
+        const ret = wasm.wasmmultidualnumber_getGradient(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v3;
+        return v1;
     }
     /**
-     * Batch addition
-     * @param {Float64Array} a_batch
-     * @param {Float64Array} b_batch
-     * @returns {Float64Array}
+     * Get a specific partial derivative
+     * @param {number} index
+     * @returns {number}
      */
-    static batchAdd(a_batch, b_batch) {
-        const ptr0 = passArrayF64ToWasm0(a_batch, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(b_batch, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.batchoperations_batchAdd(ptr0, len0, ptr1, len1);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
+    getPartial(index) {
+        const ret = wasm.wasmmultidualnumber_getPartial(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v3;
+        return ret[0];
+    }
+    /**
+     * Get number of variables
+     * @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]);
+    }
+    /**
+     * Square root
+     * @returns {WasmMultiDualNumber}
+     */
+    sqrt() {
+        const ret = wasm.wasmmultidualnumber_sqrt(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultiDualNumber.__wrap(ret[0]);
     }
 }
-if (Symbol.dispose) BatchOperations.prototype[Symbol.dispose] = BatchOperations.prototype.free;
+if (Symbol.dispose) WasmMultiDualNumber.prototype[Symbol.dispose] = WasmMultiDualNumber.prototype.free;
 
 const WasmMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -433,6 +1405,339 @@ 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) {
@@ -471,9 +1776,27 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_log_21b8c47c8527c444 = function(arg0, arg1) {
+    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_041c6d6bb408830f = 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));
     };
@@ -482,8 +1805,13 @@ 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_0;
+        const table = wasm.__wbindgen_export_2;
         const offset = table.grow(4);
         table.set(0, undefined);
         table.set(offset + 0, undefined);
@@ -503,6 +1831,7 @@ 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;