@justinelliottcobb/amari-wasm 0.13.0 → 0.15.1

package/amari_wasm.js

@@ -236,6 +236,98 @@ function passArrayF64ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
+
+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;
+}
+/**
+ * Power method for computing dominant eigenvalue
+ *
+ * # Arguments
+ * * `matrix` - The matrix operator
+ * * `initial` - Initial guess (optional, uses random if not provided)
+ * * `max_iterations` - Maximum iterations
+ * * `tolerance` - Convergence tolerance
+ *
+ * # Returns
+ * [eigenvalue, eigenvector...] flattened array
+ * @param {WasmMatrixOperator} matrix
+ * @param {Float64Array | null | undefined} initial
+ * @param {number} max_iterations
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function powerMethod(matrix, initial, max_iterations, tolerance) {
+    _assertClass(matrix, WasmMatrixOperator);
+    var ptr0 = isLikeNone(initial) ? 0 : passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.powerMethod(matrix.__wbg_ptr, ptr0, len0, max_iterations, tolerance);
+    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;
+}
+
+/**
+ * Inverse iteration for computing eigenvalue near a shift
+ *
+ * # Arguments
+ * * `matrix` - The matrix operator
+ * * `shift` - Value near the desired eigenvalue
+ * * `initial` - Initial guess (optional)
+ * * `max_iterations` - Maximum iterations
+ * * `tolerance` - Convergence tolerance
+ *
+ * # Returns
+ * [eigenvalue, eigenvector...] flattened array
+ * @param {WasmMatrixOperator} matrix
+ * @param {number} shift
+ * @param {Float64Array | null | undefined} initial
+ * @param {number} max_iterations
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function inverseIteration(matrix, shift, initial, max_iterations, tolerance) {
+    _assertClass(matrix, WasmMatrixOperator);
+    var ptr0 = isLikeNone(initial) ? 0 : passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.inverseIteration(matrix.__wbg_ptr, shift, ptr0, len0, max_iterations, tolerance);
+    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;
+}
+
+/**
+ * Compute all eigenvalues of a symmetric matrix
+ * @param {WasmMatrixOperator} matrix
+ * @param {number} max_iterations
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function computeEigenvalues(matrix, max_iterations, tolerance) {
+    _assertClass(matrix, WasmMatrixOperator);
+    const ret = wasm.computeEigenvalues(matrix.__wbg_ptr, max_iterations, tolerance);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Initialize the enumerative geometry module
  */
@@ -254,11 +346,6 @@ export function light_deflection_angle(impact_parameter, mass) {
     return ret;
 }
 
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_2.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
 /**
  * Convert velocity to Lorentz factor
  * @param {number} velocity_magnitude
@@ -359,11 +446,6 @@ export function expectation(f, a, b, samples) {
     return ret[0];
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
 /**
  * Compute KL divergence D_KL(P||Q) between two distributions
  *
@@ -403,6 +485,32 @@ export function initAutomata() {
     wasm.initAutomata();
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+let cachedFloat32ArrayMemory0 = null;
+
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -428,12 +536,35 @@ function passArray32ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
-function __wbg_adapter_28(arg0, arg1, arg2) {
-    wasm.closure41_externref_shim(arg0, arg1, arg2);
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+function __wbg_adapter_30(arg0, arg1, arg2) {
+    wasm.closure44_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_511(arg0, arg1, arg2, arg3) {
-    wasm.closure34_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_683(arg0, arg1, arg2, arg3) {
+    wasm.closure37_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -2463,6 +2594,199 @@ export class WasmAlphaConnection {
     }
 }
 
+const WasmBinaryHologramFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmbinaryhologram_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for BinaryHologram.
+ *
+ * Bit-packed binary pattern for DMD display, the output of Lee encoding.
+ */
+export class WasmBinaryHologram {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmBinaryHologram.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmBinaryHologramFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmBinaryHologramFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmbinaryhologram_free(ptr, 0);
+    }
+    /**
+     * Fill factor (fraction of "on" pixels, 0 to 1).
+     * @returns {number}
+     */
+    fillFactor() {
+        const ret = wasm.wasmbinaryhologram_fillFactor(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compute Hamming distance between two holograms.
+     * @param {WasmBinaryHologram} other
+     * @returns {number}
+     */
+    hammingDistance(other) {
+        _assertClass(other, WasmBinaryHologram);
+        const ret = wasm.wasmbinaryhologram_hammingDistance(this.__wbg_ptr, other.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Compute normalized Hamming distance (0 to 1).
+     * @param {WasmBinaryHologram} other
+     * @returns {number}
+     */
+    normalizedHammingDistance(other) {
+        _assertClass(other, WasmBinaryHologram);
+        const ret = wasm.wasmbinaryhologram_normalizedHammingDistance(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get pixel value at (x, y).
+     * @param {number} x
+     * @param {number} y
+     * @returns {boolean}
+     */
+    get(x, y) {
+        const ret = wasm.wasmbinaryhologram_get(this.__wbg_ptr, x, y);
+        return ret !== 0;
+    }
+    /**
+     * Create from boolean array (as u8: 0 = false, non-zero = true).
+     * @param {Uint8Array} pattern
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(pattern, width, height) {
+        const ptr0 = passArray8ToWasm0(pattern, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmbinaryhologram_new(ptr0, len0, width, height);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmBinaryHologramFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Set pixel value at (x, y).
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} value
+     */
+    set(x, y, value) {
+        wasm.wasmbinaryhologram_set(this.__wbg_ptr, x, y, value);
+    }
+    /**
+     * XOR two holograms.
+     * @param {WasmBinaryHologram} other
+     * @returns {WasmBinaryHologram}
+     */
+    xor(other) {
+        _assertClass(other, WasmBinaryHologram);
+        const ret = wasm.wasmbinaryhologram_xor(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmBinaryHologram.__wrap(ret);
+    }
+    /**
+     * Create an all-ones hologram.
+     * @param {number} width
+     * @param {number} height
+     * @returns {WasmBinaryHologram}
+     */
+    static ones(width, height) {
+        const ret = wasm.wasmbinaryhologram_ones(width, height);
+        return WasmBinaryHologram.__wrap(ret);
+    }
+    /**
+     * Get grid width.
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.wasmbinaryhologram_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create an all-zeros hologram.
+     * @param {number} width
+     * @param {number} height
+     * @returns {WasmBinaryHologram}
+     */
+    static zeros(width, height) {
+        const ret = wasm.wasmbinaryhologram_zeros(width, height);
+        return WasmBinaryHologram.__wrap(ret);
+    }
+    /**
+     * Get grid height.
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.wasmbinaryhologram_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get total number of pixels.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.wasmbinaryhologram_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Toggle pixel at (x, y).
+     * @param {number} x
+     * @param {number} y
+     */
+    toggle(x, y) {
+        wasm.wasmbinaryhologram_toggle(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Get packed binary data (for hardware interface).
+     * @returns {Uint8Array}
+     */
+    asBytes() {
+        const ret = wasm.wasmbinaryhologram_asBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Create an inverted copy.
+     * @returns {WasmBinaryHologram}
+     */
+    inverted() {
+        const ret = wasm.wasmbinaryhologram_inverted(this.__wbg_ptr);
+        return WasmBinaryHologram.__wrap(ret);
+    }
+    /**
+     * Count of "on" pixels.
+     * @returns {number}
+     */
+    popcount() {
+        const ret = wasm.wasmbinaryhologram_popcount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Convert to boolean array (as u8: 0 = false, 1 = true).
+     * @returns {Uint8Array}
+     */
+    toBools() {
+        const ret = wasm.wasmbinaryhologram_toBools(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
 const WasmChowClassFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmchowclass_free(ptr >>> 0, 1));
@@ -3604,6 +3928,126 @@ export class WasmGeodesicIntegrator {
     }
 }
 
+const WasmGeometricBrownianMotionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgeometricbrownianmotion_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Geometric Brownian Motion on multivector space
+ *
+ * dX = μX dt + σX dW
+ *
+ * Useful for modeling multiplicative noise processes in geometric algebra.
+ */
+export class WasmGeometricBrownianMotion {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGeometricBrownianMotionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgeometricbrownianmotion_free(ptr, 0);
+    }
+    /**
+     * Sample a single path of the process
+     *
+     * # Arguments
+     * * `initial` - Initial multivector (8 coefficients)
+     * * `t_end` - End time
+     * * `num_steps` - Number of time steps
+     *
+     * Returns flat array: (num_steps + 1) * 9 values
+     * Each point is [time, coeff0, coeff1, ..., coeff7]
+     * @param {Float64Array} initial
+     * @param {number} t_end
+     * @param {number} num_steps
+     * @returns {Float64Array}
+     */
+    samplePath(initial, t_end, num_steps) {
+        const ptr0 = passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgeometricbrownianmotion_samplePath(this.__wbg_ptr, ptr0, len0, t_end, num_steps);
+        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;
+    }
+    /**
+     * Compute expected value at time t given initial value
+     *
+     * E[X(t)] = X(0) * exp(μt)
+     * @param {Float64Array} initial
+     * @param {number} t
+     * @returns {Float64Array}
+     */
+    expectedValue(initial, t) {
+        const ptr0 = passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgeometricbrownianmotion_expectedValue(this.__wbg_ptr, ptr0, len0, t);
+        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;
+    }
+    /**
+     * Create a new Geometric Brownian Motion process
+     *
+     * # Arguments
+     * * `mu` - Drift coefficient (expected growth rate)
+     * * `sigma` - Diffusion coefficient (volatility)
+     * @param {number} mu
+     * @param {number} sigma
+     */
+    constructor(mu, sigma) {
+        const ret = wasm.wasmdualnumber_new(mu, sigma);
+        this.__wbg_ptr = ret >>> 0;
+        WasmGeometricBrownianMotionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get drift coefficient
+     * @returns {number}
+     */
+    getMu() {
+        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compute variance at time t given initial value
+     *
+     * Var(X(t)) = X(0)² * exp(2μt) * (exp(σ²t) - 1)
+     * @param {Float64Array} initial
+     * @param {number} t
+     * @returns {Float64Array}
+     */
+    variance(initial, t) {
+        const ptr0 = passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgeometricbrownianmotion_variance(this.__wbg_ptr, ptr0, len0, t);
+        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;
+    }
+    /**
+     * Get diffusion coefficient
+     * @returns {number}
+     */
+    getSigma() {
+        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
+        return ret;
+    }
+}
+
 const WasmGeometricCAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgeometricca_free(ptr >>> 0, 1));
@@ -3824,7 +4268,7 @@ export class WasmGeometricEdge {
      * @returns {number}
      */
     get target() {
-        const ret = wasm.wasmgeometricedge_target(this.__wbg_ptr);
+        const ret = wasm.wasmbinaryhologram_height(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -3837,7 +4281,130 @@ export class WasmGeometricEdge {
     }
 }
 
-const WasmGeometricNetworkFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmGeometricLeeEncoderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgeometricleeencoder_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for GeometricLeeEncoder.
+ *
+ * Encodes optical rotor fields to binary holograms using Lee's method.
+ */
+export class WasmGeometricLeeEncoder {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmGeometricLeeEncoder.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmGeometricLeeEncoderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGeometricLeeEncoderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgeometricleeencoder_free(ptr, 0);
+    }
+    /**
+     * Get carrier angle.
+     * @returns {number}
+     */
+    get carrierAngle() {
+        const ret = wasm.wasmgeometricleeencoder_carrierAngle(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create encoder with horizontal carrier (angle = 0).
+     * @param {number} width
+     * @param {number} height
+     * @param {number} carrier_frequency
+     * @returns {WasmGeometricLeeEncoder}
+     */
+    static withFrequency(width, height, carrier_frequency) {
+        const ret = wasm.wasmgeometricleeencoder_withFrequency(width, height, carrier_frequency);
+        return WasmGeometricLeeEncoder.__wrap(ret);
+    }
+    /**
+     * Get carrier frequency.
+     * @returns {number}
+     */
+    get carrierFrequency() {
+        const ret = wasm.wasmgeometricleeencoder_carrierFrequency(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Theoretical diffraction efficiency for the given field.
+     * @param {WasmOpticalRotorField} field
+     * @returns {number}
+     */
+    theoreticalEfficiency(field) {
+        _assertClass(field, WasmOpticalRotorField);
+        const ret = wasm.wasmgeometricleeencoder_theoreticalEfficiency(this.__wbg_ptr, field.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create encoder with configuration.
+     *
+     * # Arguments
+     * * `width` - Grid width
+     * * `height` - Grid height
+     * * `carrier_frequency` - Carrier frequency in cycles per pixel
+     * * `carrier_angle` - Carrier direction angle (radians, 0 = horizontal)
+     * @param {number} width
+     * @param {number} height
+     * @param {number} carrier_frequency
+     * @param {number} carrier_angle
+     */
+    constructor(width, height, carrier_frequency, carrier_angle) {
+        const ret = wasm.wasmgeometricleeencoder_new(width, height, carrier_frequency, carrier_angle);
+        this.__wbg_ptr = ret >>> 0;
+        WasmGeometricLeeEncoderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get encoder width.
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.wasmgeometricca_generation(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Encode a rotor field to binary hologram.
+     * @param {WasmOpticalRotorField} field
+     * @returns {WasmBinaryHologram}
+     */
+    encode(field) {
+        _assertClass(field, WasmOpticalRotorField);
+        const ret = wasm.wasmgeometricleeencoder_encode(this.__wbg_ptr, field.__wbg_ptr);
+        return WasmBinaryHologram.__wrap(ret);
+    }
+    /**
+     * Get encoder height.
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.wasmgeometricleeencoder_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Compute the modulated rotor field (before thresholding).
+     * @param {WasmOpticalRotorField} field
+     * @returns {WasmOpticalRotorField}
+     */
+    modulate(field) {
+        _assertClass(field, WasmOpticalRotorField);
+        const ret = wasm.wasmgeometricleeencoder_modulate(this.__wbg_ptr, field.__wbg_ptr);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+}
+
+const WasmGeometricNetworkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgeometricnetwork_free(ptr >>> 0, 1));
 /**
@@ -4183,6 +4750,108 @@ export class WasmGpuOptimizer {
     }
 }
 
+const WasmGradeProjectedDistributionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgradeprojecteddistribution_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for grade-projected distribution
+ *
+ * A distribution that only operates on components of a specific grade.
+ */
+export class WasmGradeProjectedDistribution {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGradeProjectedDistributionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgradeprojecteddistribution_free(ptr, 0);
+    }
+    /**
+     * Sample and embed into full multivector (other grades are zero)
+     *
+     * Returns 8 coefficients
+     * @returns {Float64Array}
+     */
+    sampleFull() {
+        const ret = wasm.wasmgradeprojecteddistribution_sampleFull(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get standard deviations
+     * @returns {Float64Array}
+     */
+    getStdDevs() {
+        const ret = wasm.wasmgradeprojecteddistribution_getStdDevs(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get number of components in this grade
+     * @returns {number}
+     */
+    getNumComponents() {
+        const ret = wasm.wasmgradeprojecteddistribution_getNumComponents(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a grade-projected distribution from a Gaussian
+     *
+     * # Arguments
+     * * `gaussian` - Source Gaussian distribution
+     * * `grade` - Grade to project onto (0, 1, 2, or 3 for Cl(3,0,0))
+     * @param {WasmGaussianMultivector} gaussian
+     * @param {number} grade
+     */
+    constructor(gaussian, grade) {
+        _assertClass(gaussian, WasmGaussianMultivector);
+        const ret = wasm.wasmgradeprojecteddistribution_new(gaussian.__wbg_ptr, grade);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmGradeProjectedDistributionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sample from this grade-projected distribution
+     *
+     * Returns components for just this grade
+     * @returns {Float64Array}
+     */
+    sample() {
+        const ret = wasm.wasmgradeprojecteddistribution_sample(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the mean for this grade's components
+     * @returns {Float64Array}
+     */
+    getMean() {
+        const ret = wasm.wasmgradeprojecteddistribution_getMean(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the grade
+     * @returns {number}
+     */
+    getGrade() {
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const WasmGrassmannianFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgrassmannian_free(ptr >>> 0, 1));
@@ -4236,6 +4905,176 @@ export class WasmGrassmannian {
     }
 }
 
+const WasmHilbertSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmhilbertspace_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for MultivectorHilbertSpace over Cl(2,0,0)
+ *
+ * Provides finite-dimensional Hilbert space operations on multivectors.
+ */
+export class WasmHilbertSpace {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmHilbertSpaceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmhilbertspace_free(ptr, 0);
+    }
+    /**
+     * Compute inner product <x, y>
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {number}
+     */
+    innerProduct(x, y) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmhilbertspace_innerProduct(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Check if two vectors are orthogonal
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @param {number} tolerance
+     * @returns {boolean}
+     */
+    isOrthogonal(x, y, tolerance) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmhilbertspace_isOrthogonal(this.__wbg_ptr, ptr0, len0, ptr1, len1, tolerance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Create a multivector from coefficients
+     *
+     * # Arguments
+     * * `coefficients` - Array of 4 coefficients [scalar, e1, e2, e12]
+     * @param {Float64Array} coefficients
+     * @returns {Float64Array}
+     */
+    fromCoefficients(coefficients) {
+        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmhilbertspace_fromCoefficients(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Create a new Hilbert space Cl(2,0,0) ~ R^4
+     */
+    constructor() {
+        const ret = wasm.wasmcountingmeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmHilbertSpaceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Compute the norm ||x||
+     * @param {Float64Array} x
+     * @returns {number}
+     */
+    norm(x) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmhilbertspace_norm(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Orthogonal projection of x onto y
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {Float64Array}
+     */
+    project(x, y) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmhilbertspace_project(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;
+    }
+    /**
+     * Compute distance d(x, y) = ||x - y||
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {number}
+     */
+    distance(x, y) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmhilbertspace_distance(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Get the dimension of the space (4 for Cl(2,0,0))
+     * @returns {number}
+     */
+    dimension() {
+        const ret = wasm.wasmhilbertspace_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Normalize a vector to unit length
+     * @param {Float64Array} x
+     * @returns {Float64Array}
+     */
+    normalize(x) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmhilbertspace_normalize(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Get the Clifford algebra signature (p, q, r)
+     * @returns {Uint32Array}
+     */
+    signature() {
+        const ret = wasm.wasmhilbertspace_signature(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+
 const WasmHolographicMemoryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmholographicmemory_free(ptr >>> 0, 1));
@@ -4535,11 +5374,384 @@ export class WasmLebesgueMeasure {
     }
 }
 
-const WasmModuliSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmMCMCDiagnosticsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmodulispace_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmcmcdiagnostics_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for moduli spaces (simplified)
+ * WASM wrapper for MCMC diagnostics
+ */
+export class WasmMCMCDiagnostics {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmMCMCDiagnostics.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmMCMCDiagnosticsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMCMCDiagnosticsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmcmcdiagnostics_free(ptr, 0);
+    }
+    /**
+     * Total number of steps
+     * @returns {number}
+     */
+    get num_steps() {
+        const ret = wasm.__wbg_get_wasmmcmcdiagnostics_num_steps(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Total number of steps
+     * @param {number} arg0
+     */
+    set num_steps(arg0) {
+        wasm.__wbg_set_wasmmcmcdiagnostics_num_steps(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Acceptance rate
+     * @returns {number}
+     */
+    get acceptance_rate() {
+        const ret = wasm.__wbg_get_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Acceptance rate
+     * @param {number} arg0
+     */
+    set acceptance_rate(arg0) {
+        wasm.__wbg_set_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Check if the sampler has converged (R-hat < 1.1)
+     * @returns {boolean}
+     */
+    isConverged() {
+        const ret = wasm.wasmmcmcdiagnostics_isConverged(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get effective sample size (or -1 if not computed)
+     * @returns {number}
+     */
+    getEffectiveSampleSize() {
+        const ret = wasm.wasmmcmcdiagnostics_getEffectiveSampleSize(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get R-hat statistic (or -1 if not computed)
+     * @returns {number}
+     */
+    getRHat() {
+        const ret = wasm.wasmmcmcdiagnostics_getRHat(this.__wbg_ptr);
+        return ret;
+    }
+}
+
+const WasmMatrixOperatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmatrixoperator_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for matrix operators on Hilbert spaces
+ *
+ * Represents bounded linear operators as matrices.
+ */
+export class WasmMatrixOperator {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmMatrixOperator.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmMatrixOperatorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMatrixOperatorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmatrixoperator_free(ptr, 0);
+    }
+    /**
+     * Get the matrix entries as a flat array (row-major)
+     * @returns {Float64Array}
+     */
+    getEntries() {
+        const ret = wasm.wasmmatrixoperator_getEntries(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 symmetric
+     * @param {number} tolerance
+     * @returns {boolean}
+     */
+    isSymmetric(tolerance) {
+        const ret = wasm.wasmmatrixoperator_isSymmetric(this.__wbg_ptr, tolerance);
+        return ret !== 0;
+    }
+    /**
+     * Compute operator norm ||T||
+     * @returns {number}
+     */
+    operatorNorm() {
+        const ret = wasm.wasmmatrixoperator_operatorNorm(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Add two operators
+     * @param {WasmMatrixOperator} other
+     * @returns {WasmMatrixOperator}
+     */
+    add(other) {
+        _assertClass(other, WasmMatrixOperator);
+        const ret = wasm.wasmmatrixoperator_add(this.__wbg_ptr, other.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMatrixOperator.__wrap(ret[0]);
+    }
+    /**
+     * Create a matrix operator from a flattened row-major matrix
+     *
+     * # Arguments
+     * * `entries` - 16 entries for a 4x4 matrix in row-major order
+     * @param {Float64Array} entries
+     */
+    constructor(entries) {
+        const ptr0 = passArrayF64ToWasm0(entries, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatrixoperator_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmMatrixOperatorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a zero operator
+     * @returns {WasmMatrixOperator}
+     */
+    static zero() {
+        const ret = wasm.wasmmatrixoperator_zero();
+        return WasmMatrixOperator.__wrap(ret);
+    }
+    /**
+     * Apply the operator to a vector: T(x)
+     * @param {Float64Array} x
+     * @returns {Float64Array}
+     */
+    apply(x) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatrixoperator_apply(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Scale operator by scalar
+     * @param {number} lambda
+     * @returns {WasmMatrixOperator}
+     */
+    scale(lambda) {
+        const ret = wasm.wasmmatrixoperator_scale(this.__wbg_ptr, lambda);
+        return WasmMatrixOperator.__wrap(ret);
+    }
+    /**
+     * Compute the trace
+     * @returns {number}
+     */
+    trace() {
+        const ret = wasm.wasmmatrixoperator_trace(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compose two operators (matrix multiplication)
+     * @param {WasmMatrixOperator} other
+     * @returns {WasmMatrixOperator}
+     */
+    compose(other) {
+        _assertClass(other, WasmMatrixOperator);
+        const ret = wasm.wasmmatrixoperator_compose(this.__wbg_ptr, other.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMatrixOperator.__wrap(ret[0]);
+    }
+    /**
+     * Create a scaling operator (λI)
+     * @param {number} lambda
+     * @returns {WasmMatrixOperator}
+     */
+    static scaling(lambda) {
+        const ret = wasm.wasmmatrixoperator_scaling(lambda);
+        return WasmMatrixOperator.__wrap(ret);
+    }
+    /**
+     * Create a diagonal matrix from diagonal entries
+     * @param {Float64Array} entries
+     * @returns {WasmMatrixOperator}
+     */
+    static diagonal(entries) {
+        const ptr0 = passArrayF64ToWasm0(entries, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatrixoperator_diagonal(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMatrixOperator.__wrap(ret[0]);
+    }
+    /**
+     * Create the identity operator
+     * @returns {WasmMatrixOperator}
+     */
+    static identity() {
+        const ret = wasm.wasmmatrixoperator_identity();
+        return WasmMatrixOperator.__wrap(ret);
+    }
+    /**
+     * Get a single matrix entry at (i, j)
+     * @param {number} i
+     * @param {number} j
+     * @returns {number}
+     */
+    getEntry(i, j) {
+        const ret = wasm.wasmmatrixoperator_getEntry(this.__wbg_ptr, i, j);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute the transpose
+     * @returns {WasmMatrixOperator}
+     */
+    transpose() {
+        const ret = wasm.wasmmatrixoperator_transpose(this.__wbg_ptr);
+        return WasmMatrixOperator.__wrap(ret);
+    }
+}
+
+const WasmMetropolisHastingsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmetropolishastings_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Metropolis-Hastings MCMC sampler
+ *
+ * Samples from a target distribution using random-walk proposals.
+ */
+export class WasmMetropolisHastings {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMetropolisHastingsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmetropolishastings_free(ptr, 0);
+    }
+    /**
+     * Get sampling diagnostics
+     * @returns {WasmMCMCDiagnostics}
+     */
+    diagnostics() {
+        const ret = wasm.wasmmetropolishastings_diagnostics(this.__wbg_ptr);
+        return WasmMCMCDiagnostics.__wrap(ret);
+    }
+    /**
+     * Get current sample
+     * @returns {Float64Array}
+     */
+    getCurrent() {
+        const ret = wasm.wasmmetropolishastings_getCurrent(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get current acceptance rate
+     * @returns {number}
+     */
+    getAcceptanceRate() {
+        const ret = wasm.wasmmetropolishastings_getAcceptanceRate(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a new Metropolis-Hastings sampler for a Gaussian target
+     *
+     * # Arguments
+     * * `target` - The target Gaussian distribution to sample from
+     * * `proposal_std` - Standard deviation for the proposal distribution
+     * @param {WasmGaussianMultivector} target
+     * @param {number} proposal_std
+     */
+    constructor(target, proposal_std) {
+        _assertClass(target, WasmGaussianMultivector);
+        const ret = wasm.wasmmetropolishastings_new(target.__wbg_ptr, proposal_std);
+        this.__wbg_ptr = ret >>> 0;
+        WasmMetropolisHastingsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Run the sampler for multiple steps
+     *
+     * # Arguments
+     * * `num_samples` - Number of samples to collect
+     * * `burnin` - Number of burn-in steps to discard
+     *
+     * Returns flat array of samples (num_samples * 8)
+     * @param {number} num_samples
+     * @param {number} burnin
+     * @returns {Float64Array}
+     */
+    run(num_samples, burnin) {
+        const ret = wasm.wasmmetropolishastings_run(this.__wbg_ptr, num_samples, burnin);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Take a single MCMC step
+     *
+     * Returns the new sample (8 coefficients)
+     * @returns {Float64Array}
+     */
+    step() {
+        const ret = wasm.wasmmetropolishastings_step(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+
+const WasmModuliSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmodulispace_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for moduli spaces (simplified)
  */
 export class WasmModuliSpace {
 
@@ -4935,7 +6147,7 @@ export class WasmMultiObjectiveResult {
      * @returns {number}
      */
     get generations() {
-        const ret = wasm.wasmmultiobjectiveresult_generations(this.__wbg_ptr);
+        const ret = wasm.wasmbinaryhologram_width(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -5229,56 +6441,634 @@ export class WasmNodeMetadata {
         return WasmNodeMetadata.__wrap(ret);
     }
     /**
-     * Get a numerical property
-     * @param {string} key
-     * @returns {number | undefined}
+     * Get a numerical property
+     * @param {string} key
+     * @returns {number | undefined}
+     */
+    getProperty(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmnodemetadata_getProperty(this.__wbg_ptr, ptr0, len0);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Add a numerical property
+     * @param {string} key
+     * @param {number} value
+     */
+    setProperty(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmnodemetadata_setProperty(this.__wbg_ptr, ptr0, len0, value);
+    }
+    /**
+     * Create new empty metadata
+     */
+    constructor() {
+        const ret = wasm.wasmnodemetadata_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmNodeMetadataFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the label
+     * @returns {string | undefined}
+     */
+    get label() {
+        const ret = wasm.wasmnodemetadata_label(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Set the label
+     * @param {string | null} [label]
+     */
+    set label(label) {
+        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.wasmnodemetadata_set_label(this.__wbg_ptr, ptr0, len0);
+    }
+}
+
+const WasmOpticalCodebookFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmopticalcodebook_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for OpticalCodebook.
+ *
+ * Maps symbols to deterministically-generated rotor fields.
+ */
+export class WasmOpticalCodebook {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmOpticalCodebookFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmopticalcodebook_free(ptr, 0);
+    }
+    /**
+     * Clear the field cache (seeds retained).
+     */
+    clearCache() {
+        wasm.wasmopticalcodebook_clearCache(this.__wbg_ptr);
+    }
+    /**
+     * Register multiple symbols at once.
+     * @param {string[]} symbols
+     */
+    registerAll(symbols) {
+        const ptr0 = passArrayJsValueToWasm0(symbols, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmopticalcodebook_registerAll(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Register a symbol with specific seed.
+     * @param {string} symbol
+     * @param {bigint} seed
+     */
+    registerWithSeed(symbol, seed) {
+        const ptr0 = passStringToWasm0(symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmopticalcodebook_registerWithSeed(this.__wbg_ptr, ptr0, len0, seed);
+    }
+    /**
+     * Get or generate field for a symbol.
+     * @param {string} symbol
+     * @returns {WasmOpticalRotorField | undefined}
+     */
+    get(symbol) {
+        const ptr0 = passStringToWasm0(symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmopticalcodebook_get(this.__wbg_ptr, ptr0, len0);
+        return ret === 0 ? undefined : WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Create a new codebook.
+     *
+     * # Arguments
+     * * `width` - Field grid width
+     * * `height` - Field grid height
+     * * `base_seed` - Base seed for deterministic generation
+     * @param {number} width
+     * @param {number} height
+     * @param {bigint} base_seed
+     */
+    constructor(width, height, base_seed) {
+        const ret = wasm.wasmopticalcodebook_new(width, height, base_seed);
+        this.__wbg_ptr = ret >>> 0;
+        WasmOpticalCodebookFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Number of registered symbols.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.wasmopticalcodebook_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Remove a symbol from the codebook.
+     * @param {string} symbol
+     * @returns {boolean}
+     */
+    remove(symbol) {
+        const ptr0 = passStringToWasm0(symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmopticalcodebook_remove(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Get all registered symbol names.
+     * @returns {string[]}
+     */
+    symbols() {
+        const ret = wasm.wasmopticalcodebook_symbols(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Check if a symbol is registered.
+     * @param {string} symbol
+     * @returns {boolean}
+     */
+    contains(symbol) {
+        const ptr0 = passStringToWasm0(symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmopticalcodebook_contains(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Generate field without caching.
+     * @param {string} symbol
+     * @returns {WasmOpticalRotorField | undefined}
+     */
+    generate(symbol) {
+        const ptr0 = passStringToWasm0(symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmopticalcodebook_generate(this.__wbg_ptr, ptr0, len0);
+        return ret === 0 ? undefined : WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Get the seed for a registered symbol.
+     * @param {string} symbol
+     * @returns {bigint | undefined}
+     */
+    getSeed(symbol) {
+        const ptr0 = passStringToWasm0(symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmopticalcodebook_getSeed(this.__wbg_ptr, ptr0, len0);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * Check if codebook is empty.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.wasmopticalcodebook_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Register a symbol with auto-generated seed.
+     * @param {string} symbol
+     */
+    register(symbol) {
+        const ptr0 = passStringToWasm0(symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmopticalcodebook_register(this.__wbg_ptr, ptr0, len0);
+    }
+}
+
+const WasmOpticalFieldAlgebraFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmopticalfieldalgebra_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for OpticalFieldAlgebra.
+ *
+ * Provides VSA operations on rotor fields: bind, bundle, similarity, inverse.
+ */
+export class WasmOpticalFieldAlgebra {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmOpticalFieldAlgebraFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmopticalfieldalgebra_free(ptr, 0);
+    }
+    /**
+     * Compute the average phase (circular mean) of a field.
+     * @param {WasmOpticalRotorField} field
+     * @returns {number}
+     */
+    meanPhase(field) {
+        _assertClass(field, WasmOpticalRotorField);
+        const ret = wasm.wasmopticalfieldalgebra_meanPhase(this.__wbg_ptr, field.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compute similarity between two fields.
+     *
+     * Returns normalized inner product.
+     * Range: [-1, 1], where 1 = identical phase.
+     * @param {WasmOpticalRotorField} a
+     * @param {WasmOpticalRotorField} b
+     * @returns {number}
+     */
+    similarity(a, b) {
+        _assertClass(a, WasmOpticalRotorField);
+        _assertClass(b, WasmOpticalRotorField);
+        const ret = wasm.wasmopticalfieldalgebra_similarity(this.__wbg_ptr, a.__wbg_ptr, b.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Bundle with uniform weights (1/n).
+     * @param {WasmOpticalRotorField[]} fields
+     * @returns {WasmOpticalRotorField}
+     */
+    bundleUniform(fields) {
+        const ptr0 = passArrayJsValueToWasm0(fields, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmopticalfieldalgebra_bundleUniform(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Compute phase variance (circular variance) of a field.
+     * @param {WasmOpticalRotorField} field
+     * @returns {number}
+     */
+    phaseVariance(field) {
+        _assertClass(field, WasmOpticalRotorField);
+        const ret = wasm.wasmopticalfieldalgebra_phaseVariance(this.__wbg_ptr, field.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create new algebra instance for fields of the given dimensions.
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(width, height) {
+        const ret = wasm.wasmopticalfieldalgebra_new(width, height);
+        this.__wbg_ptr = ret >>> 0;
+        WasmOpticalFieldAlgebraFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Bind two fields (pointwise rotor product).
+     *
+     * Creates an association: bound = A ⊗ B.
+     * Unbind with: B ≈ inverse(A) ⊗ bound.
+     * @param {WasmOpticalRotorField} a
+     * @param {WasmOpticalRotorField} b
+     * @returns {WasmOpticalRotorField}
+     */
+    bind(a, b) {
+        _assertClass(a, WasmOpticalRotorField);
+        _assertClass(b, WasmOpticalRotorField);
+        const ret = wasm.wasmopticalfieldalgebra_bind(this.__wbg_ptr, a.__wbg_ptr, b.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Scale a field's amplitude by a constant factor.
+     * @param {WasmOpticalRotorField} field
+     * @param {number} factor
+     * @returns {WasmOpticalRotorField}
+     */
+    scale(field, factor) {
+        _assertClass(field, WasmOpticalRotorField);
+        const ret = wasm.wasmopticalfieldalgebra_scale(this.__wbg_ptr, field.__wbg_ptr, factor);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Get algebra width.
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Bundle multiple fields (weighted superposition).
+     *
+     * # Arguments
+     * * `fields` - Flattened array of field data (scalars, bivectors, amplitudes for each field)
+     * * `weights` - Weights for each field
+     * * `field_count` - Number of fields
+     * @param {WasmOpticalRotorField[]} fields
+     * @param {Float32Array} weights
+     * @returns {WasmOpticalRotorField}
+     */
+    bundle(fields, weights) {
+        const ptr0 = passArrayJsValueToWasm0(fields, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(weights, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmopticalfieldalgebra_bundle(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Get algebra height.
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.wasmmodulispace_getMarkedPoints(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create random field.
+     * @param {bigint} seed
+     * @returns {WasmOpticalRotorField}
+     */
+    random(seed) {
+        const ret = wasm.wasmopticalfieldalgebra_random(this.__wbg_ptr, seed);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Unbind operation: retrieve associated value.
+     *
+     * Given `bound = bind(key, value)`, calling `unbind(key, bound)`
+     * returns (approximately) `value`.
+     * @param {WasmOpticalRotorField} key
+     * @param {WasmOpticalRotorField} bound
+     * @returns {WasmOpticalRotorField}
+     */
+    unbind(key, bound) {
+        _assertClass(key, WasmOpticalRotorField);
+        _assertClass(bound, WasmOpticalRotorField);
+        const ret = wasm.wasmopticalfieldalgebra_unbind(this.__wbg_ptr, key.__wbg_ptr, bound.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Compute inverse field (rotor reverse).
+     *
+     * For rotors: R^(-1) = R^† = cos(φ) - sin(φ)·e₁₂
+     * @param {WasmOpticalRotorField} field
+     * @returns {WasmOpticalRotorField}
+     */
+    inverse(field) {
+        _assertClass(field, WasmOpticalRotorField);
+        const ret = wasm.wasmopticalfieldalgebra_inverse(this.__wbg_ptr, field.__wbg_ptr);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Create identity field (phase = 0, amplitude = 1).
+     * @returns {WasmOpticalRotorField}
+     */
+    identity() {
+        const ret = wasm.wasmopticalfieldalgebra_identity(this.__wbg_ptr);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Add a constant phase to all pixels.
+     * @param {WasmOpticalRotorField} field
+     * @param {number} phase
+     * @returns {WasmOpticalRotorField}
+     */
+    addPhase(field, phase) {
+        _assertClass(field, WasmOpticalRotorField);
+        const ret = wasm.wasmopticalfieldalgebra_addPhase(this.__wbg_ptr, field.__wbg_ptr, phase);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+}
+
+const WasmOpticalRotorFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmopticalrotorfield_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for OpticalRotorField.
+ *
+ * Represents an optical wavefront as a grid of rotors in Cl(2,0).
+ * Each point has phase (rotor angle) and amplitude components.
+ */
+export class WasmOpticalRotorField {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmOpticalRotorField.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmOpticalRotorFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof WasmOpticalRotorField)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmOpticalRotorFieldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmopticalrotorfield_free(ptr, 0);
+    }
+    /**
+     * Create from phase array with uniform amplitude of 1.0.
+     * @param {Float32Array} phase
+     * @param {number} width
+     * @param {number} height
+     * @returns {WasmOpticalRotorField}
+     */
+    static fromPhase(phase, width, height) {
+        const ptr0 = passArrayF32ToWasm0(phase, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmopticalrotorfield_fromPhase(ptr0, len0, width, height);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Create a normalized copy (total energy = 1).
+     * @returns {WasmOpticalRotorField}
+     */
+    normalized() {
+        const ret = wasm.wasmopticalrotorfield_normalized(this.__wbg_ptr);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Clone this field.
+     * @returns {WasmOpticalRotorField}
+     */
+    clone() {
+        const ret = wasm.wasmopticalrotorfield_clone(this.__wbg_ptr);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Get all scalar (cos φ) components.
+     * @returns {Float32Array}
+     */
+    getScalars() {
+        const ret = wasm.wasmopticalrotorfield_getScalars(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get amplitude at a point.
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    amplitudeAt(x, y) {
+        const ret = wasm.wasmopticalrotorfield_amplitudeAt(this.__wbg_ptr, x, y);
+        return ret;
+    }
+    /**
+     * Compute total energy (sum of squared amplitudes).
+     * @returns {number}
+     */
+    totalEnergy() {
+        const ret = wasm.wasmopticalrotorfield_totalEnergy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get all bivector (sin φ) components.
+     * @returns {Float32Array}
+     */
+    getBivectors() {
+        const ret = wasm.wasmopticalrotorfield_getBivectors(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get all amplitude components.
+     * @returns {Float32Array}
+     */
+    getAmplitudes() {
+        const ret = wasm.wasmopticalrotorfield_getAmplitudes(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Create from phase and amplitude arrays.
+     *
+     * # Arguments
+     * * `phase` - Phase values in radians (length = width * height)
+     * * `amplitude` - Amplitude values (length = width * height)
+     * * `width` - Grid width
+     * * `height` - Grid height
+     * @param {Float32Array} phase
+     * @param {Float32Array} amplitude
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(phase, amplitude, width, height) {
+        const ptr0 = passArrayF32ToWasm0(phase, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(amplitude, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmopticalrotorfield_new(ptr0, len0, ptr1, len1, width, height);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmOpticalRotorFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get grid width.
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.wasmopticalrotorfield_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get grid height.
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.wasmopticalrotorfield_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get total number of points.
+     * @returns {number}
      */
-    getProperty(key) {
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmnodemetadata_getProperty(this.__wbg_ptr, ptr0, len0);
-        return ret[0] === 0 ? undefined : ret[1];
+    get length() {
+        const ret = wasm.wasmopticalrotorfield_length(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Add a numerical property
-     * @param {string} key
-     * @param {number} value
+     * Create with random phase (deterministic from seed).
+     * @param {number} width
+     * @param {number} height
+     * @param {bigint} seed
+     * @returns {WasmOpticalRotorField}
      */
-    setProperty(key, value) {
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.wasmnodemetadata_setProperty(this.__wbg_ptr, ptr0, len0, value);
+    static random(width, height, seed) {
+        const ret = wasm.wasmopticalrotorfield_random(width, height, seed);
+        return WasmOpticalRotorField.__wrap(ret);
     }
     /**
-     * Create new empty metadata
+     * Create uniform field (constant phase and amplitude).
+     * @param {number} phase
+     * @param {number} amplitude
+     * @param {number} width
+     * @param {number} height
+     * @returns {WasmOpticalRotorField}
      */
-    constructor() {
-        const ret = wasm.wasmnodemetadata_new();
-        this.__wbg_ptr = ret >>> 0;
-        WasmNodeMetadataFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    static uniform(phase, amplitude, width, height) {
+        const ret = wasm.wasmopticalrotorfield_uniform(phase, amplitude, width, height);
+        return WasmOpticalRotorField.__wrap(ret);
     }
     /**
-     * Get the label
-     * @returns {string | undefined}
+     * Create identity field (phase = 0, amplitude = 1).
+     * @param {number} width
+     * @param {number} height
+     * @returns {WasmOpticalRotorField}
      */
-    get label() {
-        const ret = wasm.wasmnodemetadata_label(this.__wbg_ptr);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        }
-        return v1;
+    static identity(width, height) {
+        const ret = wasm.wasmopticalrotorfield_identity(width, height);
+        return WasmOpticalRotorField.__wrap(ret);
     }
     /**
-     * Set the label
-     * @param {string | null} [label]
+     * Get phase at a point (in radians, range [-π, π]).
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
      */
-    set label(label) {
-        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.wasmnodemetadata_set_label(this.__wbg_ptr, ptr0, len0);
+    phaseAt(x, y) {
+        const ret = wasm.wasmopticalrotorfield_phaseAt(this.__wbg_ptr, x, y);
+        return ret;
     }
 }
 
@@ -6330,6 +8120,162 @@ export class WasmSimpleOptimizer {
     }
 }
 
+const WasmSobolevSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsobolevspace_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Sobolev spaces H^k
+ *
+ * Provides function spaces with weak derivatives.
+ */
+export class WasmSobolevSpace {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSobolevSpace.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSobolevSpaceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSobolevSpaceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsobolevspace_free(ptr, 0);
+    }
+    /**
+     * Compute the H^1 seminorm |f|_{H^1} = ||f'||_{L^2}
+     * @param {Function} df
+     * @returns {number}
+     */
+    h1Seminorm(df) {
+        const ret = wasm.wasmsobolevspace_h1Seminorm(this.__wbg_ptr, df);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create H^1 over the unit interval [0, 1]
+     * @returns {WasmSobolevSpace}
+     */
+    static h1UnitInterval() {
+        const ret = wasm.wasmsobolevspace_h1UnitInterval();
+        return WasmSobolevSpace.__wrap(ret);
+    }
+    /**
+     * Create H^2 over the unit interval [0, 1]
+     * @returns {WasmSobolevSpace}
+     */
+    static h2UnitInterval() {
+        const ret = wasm.wasmsobolevspace_h2UnitInterval();
+        return WasmSobolevSpace.__wrap(ret);
+    }
+    /**
+     * Compute L^2 inner product <f, g>
+     * @param {Function} f
+     * @param {Function} g
+     * @returns {number}
+     */
+    l2InnerProduct(f, g) {
+        const ret = wasm.wasmsobolevspace_l2InnerProduct(this.__wbg_ptr, f, g);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute the Poincare constant estimate for the domain
+     *
+     * For [a,b], this is (b-a)/π
+     * @returns {number}
+     */
+    poincareConstant() {
+        const ret = wasm.wasmsobolevspace_poincareConstant(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Set the number of quadrature points
+     * @param {number} n
+     */
+    setQuadraturePoints(n) {
+        wasm.wasmsobolevspace_setQuadraturePoints(this.__wbg_ptr, n);
+    }
+    /**
+     * Create a Sobolev space H^k over an interval [a, b]
+     *
+     * # Arguments
+     * * `order` - The Sobolev regularity (1 for H^1, 2 for H^2)
+     * * `lower` - Lower bound of the interval
+     * * `upper` - Upper bound of the interval
+     * @param {number} order
+     * @param {number} lower
+     * @param {number} upper
+     */
+    constructor(order, lower, upper) {
+        const ret = wasm.wasmsobolevspace_new(order, lower, upper);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmSobolevSpaceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the domain bounds [lower, upper]
+     * @returns {Float64Array}
+     */
+    bounds() {
+        const ret = wasm.wasmsobolevspace_bounds(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Compute the H^k norm of a function using numerical integration
+     *
+     * # Arguments
+     * * `f` - JavaScript function f(x) to evaluate
+     * * `df` - JavaScript function f'(x) (first derivative)
+     * @param {Function} f
+     * @param {Function} df
+     * @returns {number}
+     */
+    h1Norm(f, df) {
+        const ret = wasm.wasmsobolevspace_h1Norm(this.__wbg_ptr, f, df);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute L^2 norm of a function
+     * @param {Function} f
+     * @returns {number}
+     */
+    l2Norm(f) {
+        const ret = wasm.wasmsobolevspace_l2Norm(this.__wbg_ptr, f);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Get the Sobolev order k
+     * @returns {number}
+     */
+    order() {
+        const ret = wasm.wasmsobolevspace_order(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const WasmSpacetimeVectorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmspacetimevector_free(ptr >>> 0, 1));
@@ -6468,17 +8414,167 @@ export class WasmSpacetimeVector {
      * Get string representation
      * @returns {string}
      */
-    to_string() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.wasmspacetimevector_to_string(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    to_string() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmspacetimevector_to_string(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const WasmSpectralDecompositionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmspectraldecomposition_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for spectral decomposition
+ *
+ * Provides eigenvalue decomposition for symmetric matrices.
+ */
+export class WasmSpectralDecomposition {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSpectralDecomposition.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSpectralDecompositionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSpectralDecompositionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmspectraldecomposition_free(ptr, 0);
+    }
+    /**
+     * Get the eigenvalues
+     * @returns {Float64Array}
+     */
+    eigenvalues() {
+        const ret = wasm.wasmspectraldecomposition_eigenvalues(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 decomposition is complete
+     * @returns {boolean}
+     */
+    isComplete() {
+        const ret = wasm.wasmspectraldecomposition_isComplete(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the eigenvectors as a flattened array
+     *
+     * Returns 4 eigenvectors of 4 components each (16 total)
+     * @returns {Float64Array}
+     */
+    eigenvectors() {
+        const ret = wasm.wasmspectraldecomposition_eigenvectors(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Apply f(T) = Σᵢ f(λᵢ) Pᵢ to a vector using functional calculus
+     *
+     * # Arguments
+     * * `f` - JavaScript function to apply to eigenvalues
+     * * `x` - Input vector
+     * @param {Function} f
+     * @param {Float64Array} x
+     * @returns {Float64Array}
+     */
+    applyFunction(f, x) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmspectraldecomposition_applyFunction(this.__wbg_ptr, f, 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;
+    }
+    /**
+     * Get the spectral radius (largest |eigenvalue|)
+     * @returns {number}
+     */
+    spectralRadius() {
+        const ret = wasm.wasmspectraldecomposition_spectralRadius(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the condition number
+     * @returns {number | undefined}
+     */
+    conditionNumber() {
+        const ret = wasm.wasmspectraldecomposition_conditionNumber(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Check if the operator is positive definite
+     * @returns {boolean}
+     */
+    isPositiveDefinite() {
+        const ret = wasm.wasmspectraldecomposition_isPositiveDefinite(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if the operator is positive semi-definite
+     * @returns {boolean}
+     */
+    isPositiveSemidefinite() {
+        const ret = wasm.wasmspectraldecomposition_isPositiveSemidefinite(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Apply the reconstructed operator T = Σᵢ λᵢ Pᵢ to a vector
+     * @param {Float64Array} x
+     * @returns {Float64Array}
+     */
+    apply(x) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmspectraldecomposition_apply(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Compute spectral decomposition of a symmetric matrix
+     *
+     * # Arguments
+     * * `matrix` - The symmetric matrix operator to decompose
+     * * `max_iterations` - Maximum iterations for eigenvalue computation
+     * * `tolerance` - Convergence tolerance
+     * @param {WasmMatrixOperator} matrix
+     * @param {number} max_iterations
+     * @param {number} tolerance
+     * @returns {WasmSpectralDecomposition}
+     */
+    static compute(matrix, max_iterations, tolerance) {
+        _assertClass(matrix, WasmMatrixOperator);
+        const ret = wasm.wasmspectraldecomposition_compute(matrix.__wbg_ptr, max_iterations, tolerance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return WasmSpectralDecomposition.__wrap(ret[0]);
     }
 }
 
@@ -6506,7 +8602,7 @@ export class WasmTrajectoryPoint {
      * @returns {number}
      */
     get time() {
-        const ret = wasm.__wbg_get_wasmtrajectorypoint_time(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -6514,7 +8610,7 @@ export class WasmTrajectoryPoint {
      * @param {number} arg0
      */
     set time(arg0) {
-        wasm.__wbg_set_wasmtrajectorypoint_time(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr, arg0);
     }
     /**
      * Get position
@@ -7088,7 +9184,7 @@ export class WasmTropicalNetwork {
      * @returns {number}
      */
     getSize() {
-        const ret = wasm.wasmmultiobjectiveresult_generations(this.__wbg_ptr);
+        const ret = wasm.wasmbinaryhologram_width(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -7274,6 +9370,181 @@ export class WasmTropicalNumber {
     }
 }
 
+const WasmTropicalOpticalAlgebraFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmtropicalopticalalgebra_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for TropicalOpticalAlgebra.
+ *
+ * Tropical (min, +) operations on optical fields for attractor dynamics.
+ */
+export class WasmTropicalOpticalAlgebra {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmTropicalOpticalAlgebraFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtropicalopticalalgebra_free(ptr, 0);
+    }
+    /**
+     * Tropical addition: pointwise minimum of phase magnitudes.
+     *
+     * For each pixel, selects the rotor with smaller absolute phase.
+     * @param {WasmOpticalRotorField} a
+     * @param {WasmOpticalRotorField} b
+     * @returns {WasmOpticalRotorField}
+     */
+    tropicalAdd(a, b) {
+        _assertClass(a, WasmOpticalRotorField);
+        _assertClass(b, WasmOpticalRotorField);
+        const ret = wasm.wasmtropicalopticalalgebra_tropicalAdd(this.__wbg_ptr, a.__wbg_ptr, b.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Tropical maximum: pointwise maximum of phase magnitudes.
+     * @param {WasmOpticalRotorField} a
+     * @param {WasmOpticalRotorField} b
+     * @returns {WasmOpticalRotorField}
+     */
+    tropicalMax(a, b) {
+        _assertClass(a, WasmOpticalRotorField);
+        _assertClass(b, WasmOpticalRotorField);
+        const ret = wasm.wasmtropicalopticalalgebra_tropicalMax(this.__wbg_ptr, a.__wbg_ptr, b.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Tropical multiplication: binding operation (phase addition).
+     * @param {WasmOpticalRotorField} a
+     * @param {WasmOpticalRotorField} b
+     * @returns {WasmOpticalRotorField}
+     */
+    tropicalMul(a, b) {
+        _assertClass(a, WasmOpticalRotorField);
+        _assertClass(b, WasmOpticalRotorField);
+        const ret = wasm.wasmtropicalopticalalgebra_tropicalMul(this.__wbg_ptr, a.__wbg_ptr, b.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Compute phase distance between two fields.
+     *
+     * Returns the sum of absolute phase differences.
+     * @param {WasmOpticalRotorField} a
+     * @param {WasmOpticalRotorField} b
+     * @returns {number}
+     */
+    phaseDistance(a, b) {
+        _assertClass(a, WasmOpticalRotorField);
+        _assertClass(b, WasmOpticalRotorField);
+        const ret = wasm.wasmtropicalopticalalgebra_phaseDistance(this.__wbg_ptr, a.__wbg_ptr, b.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Soft tropical addition using logsumexp-style smoothing.
+     *
+     * # Arguments
+     * * `a`, `b` - Fields to combine
+     * * `beta` - Temperature parameter (large = hard min, small = soft average)
+     * @param {WasmOpticalRotorField} a
+     * @param {WasmOpticalRotorField} b
+     * @param {number} beta
+     * @returns {WasmOpticalRotorField}
+     */
+    softTropicalAdd(a, b, beta) {
+        _assertClass(a, WasmOpticalRotorField);
+        _assertClass(b, WasmOpticalRotorField);
+        const ret = wasm.wasmtropicalopticalalgebra_softTropicalAdd(this.__wbg_ptr, a.__wbg_ptr, b.__wbg_ptr, beta);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Iterate attractor dynamics until convergence.
+     *
+     * # Arguments
+     * * `initial` - Starting state
+     * * `attractors` - Set of attractor fields
+     * * `max_iterations` - Maximum iterations
+     * * `tolerance` - Convergence tolerance
+     *
+     * Returns (final_state, iterations_taken).
+     * @param {WasmOpticalRotorField} initial
+     * @param {WasmOpticalRotorField[]} attractors
+     * @param {number} max_iterations
+     * @param {number} tolerance
+     * @returns {WasmOpticalRotorField}
+     */
+    attractorConverge(initial, attractors, max_iterations, tolerance) {
+        _assertClass(initial, WasmOpticalRotorField);
+        const ptr0 = passArrayJsValueToWasm0(attractors, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmtropicalopticalalgebra_attractorConverge(this.__wbg_ptr, initial.__wbg_ptr, ptr0, len0, max_iterations, tolerance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOpticalRotorField.__wrap(ret[0]);
+    }
+    /**
+     * Compute normalized phase distance (average per pixel).
+     * @param {WasmOpticalRotorField} a
+     * @param {WasmOpticalRotorField} b
+     * @returns {number}
+     */
+    normalizedPhaseDistance(a, b) {
+        _assertClass(a, WasmOpticalRotorField);
+        _assertClass(b, WasmOpticalRotorField);
+        const ret = wasm.wasmtropicalopticalalgebra_normalizedPhaseDistance(this.__wbg_ptr, a.__wbg_ptr, b.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create new tropical algebra instance for fields of the given dimensions.
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(width, height) {
+        const ret = wasm.wasmopticalfieldalgebra_new(width, height);
+        this.__wbg_ptr = ret >>> 0;
+        WasmTropicalOpticalAlgebraFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get algebra width.
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get algebra height.
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.wasmmodulispace_getMarkedPoints(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const WasmTropicalPolynomialFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmtropicalpolynomial_free(ptr >>> 0, 1));
@@ -7402,6 +9673,166 @@ export class WasmTropicalViterbi {
     }
 }
 
+const WasmUncertainMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmuncertainmultivector_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for uncertain multivector (mean + covariance)
+ *
+ * Represents a multivector with associated uncertainty, useful for
+ * error propagation through geometric operations.
+ */
+export class WasmUncertainMultivector {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmUncertainMultivector.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmUncertainMultivectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmUncertainMultivectorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmuncertainmultivector_free(ptr, 0);
+    }
+    /**
+     * Get standard deviations
+     * @returns {Float64Array}
+     */
+    getStdDevs() {
+        const ret = wasm.wasmuncertainmultivector_getStdDevs(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a deterministic (zero variance) uncertain multivector
+     * @param {Float64Array} value
+     * @returns {WasmUncertainMultivector}
+     */
+    static deterministic(value) {
+        const ptr0 = passArrayF64ToWasm0(value, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuncertainmultivector_deterministic(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmUncertainMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Get variances (diagonal of covariance)
+     * @returns {Float64Array}
+     */
+    getVariances() {
+        const ret = wasm.wasmuncertainmultivector_getVariances(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the covariance matrix (64 values, row-major)
+     * @returns {Float64Array}
+     */
+    getCovariance() {
+        const ret = wasm.wasmuncertainmultivector_getCovariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create with full covariance matrix
+     *
+     * # Arguments
+     * * `mean` - 8 coefficients for the mean
+     * * `covariance` - 64 values for 8x8 covariance matrix (row-major)
+     * @param {Float64Array} mean
+     * @param {Float64Array} covariance
+     * @returns {WasmUncertainMultivector}
+     */
+    static withCovariance(mean, covariance) {
+        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(covariance, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuncertainmultivector_withCovariance(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmUncertainMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Get total variance (trace of covariance)
+     * @returns {number}
+     */
+    getTotalVariance() {
+        const ret = wasm.wasmuncertainmultivector_getTotalVariance(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Add two uncertain multivectors (assuming independence)
+     *
+     * For Z = X + Y: E[Z] = E[X] + E[Y], Var(Z) = Var(X) + Var(Y)
+     * @param {WasmUncertainMultivector} other
+     * @returns {WasmUncertainMultivector}
+     */
+    add(other) {
+        _assertClass(other, WasmUncertainMultivector);
+        const ret = wasm.wasmuncertainmultivector_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmUncertainMultivector.__wrap(ret);
+    }
+    /**
+     * Create an uncertain multivector with diagonal covariance
+     *
+     * # Arguments
+     * * `mean` - 8 coefficients for the mean
+     * * `variances` - 8 values for per-coefficient variance
+     * @param {Float64Array} mean
+     * @param {Float64Array} variances
+     */
+    constructor(mean, variances) {
+        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(variances, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuncertainmultivector_new(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmUncertainMultivectorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Linear propagation: scale by a constant
+     *
+     * For Y = aX: E[Y] = aE[X], Var(Y) = a²Var(X)
+     * @param {number} scalar
+     * @returns {WasmUncertainMultivector}
+     */
+    scale(scalar) {
+        const ret = wasm.wasmuncertainmultivector_scale(this.__wbg_ptr, scalar);
+        return WasmUncertainMultivector.__wrap(ret);
+    }
+    /**
+     * Get the mean
+     * @returns {Float64Array}
+     */
+    getMean() {
+        const ret = wasm.wasmuncertainmultivector_getMean(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+
 const WasmUniformMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmuniformmultivector_free(ptr >>> 0, 1));
@@ -7560,6 +9991,69 @@ export class WasmUniformMultivector {
     }
 }
 
+const WasmWienerProcessFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmwienerprocess_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Wiener process (Brownian motion)
+ *
+ * Standard Brownian motion W(t) with W(0) = 0
+ */
+export class WasmWienerProcess {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmWienerProcessFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmwienerprocess_free(ptr, 0);
+    }
+    /**
+     * Sample a path of the Wiener process
+     *
+     * # Arguments
+     * * `t_end` - End time
+     * * `num_steps` - Number of time steps
+     *
+     * Returns flat array: (num_steps + 1) * (dim + 1) values
+     * Each point is [time, w0, w1, ...]
+     * @param {number} t_end
+     * @param {number} num_steps
+     * @returns {Float64Array}
+     */
+    samplePath(t_end, num_steps) {
+        const ret = wasm.wasmwienerprocess_samplePath(this.__wbg_ptr, t_end, num_steps);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a new Wiener process
+     *
+     * # Arguments
+     * * `dim` - Dimension of the process (default 8 for multivector space)
+     * @param {number | null} [dim]
+     */
+    constructor(dim) {
+        const ret = wasm.wasmwienerprocess_new(isLikeNone(dim) ? 0x100000001 : (dim) >>> 0);
+        this.__wbg_ptr = ret >>> 0;
+        WasmWienerProcessFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get dimension
+     * @returns {number}
+     */
+    getDim() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
@@ -7641,7 +10135,7 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_7696259bf4d9d36d = function(arg0, arg1) {
+    imports.wbg.__wbg_log_9f891854f8fc562b = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_log_ea240990d83e374e = function(arg0) {
@@ -7666,7 +10160,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_511(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_683(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -7741,6 +10235,10 @@ function __wbg_get_imports() {
         const ret = WasmCommunity.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbg_wasmopticalrotorfield_unwrap = function(arg0) {
+        const ret = WasmOpticalRotorField.__unwrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_wasmoptimizationresult_new = function(arg0) {
         const ret = WasmOptimizationResult.__wrap(arg0);
         return ret;
@@ -7766,8 +10264,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper1647 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 40, __wbg_adapter_28);
+    imports.wbg.__wbindgen_closure_wrapper1973 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 43, __wbg_adapter_30);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
@@ -7811,6 +10309,14 @@ function __wbg_get_imports() {
         const ret = arg0;
         return ret;
     };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
         const ret = getStringFromWasm0(arg0, arg1);
         return ret;
@@ -7830,6 +10336,7 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
     cachedFloat64ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;