@justinelliottcobb/amari-wasm 0.14.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_550(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));
@@ -3944,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;
     }
     /**
@@ -3957,6 +4281,129 @@ export class WasmGeometricEdge {
     }
 }
 
+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));
@@ -4458,18 +4905,188 @@ export class WasmGrassmannian {
     }
 }
 
-const WasmHolographicMemoryFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmHilbertSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmholographicmemory_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmhilbertspace_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for HolographicMemory using ProductClifford algebra
+ * WASM wrapper for MultivectorHilbertSpace over Cl(2,0,0)
+ *
+ * Provides finite-dimensional Hilbert space operations on multivectors.
  */
-export class WasmHolographicMemory {
+export class WasmHilbertSpace {
 
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmHolographicMemory.prototype);
-        obj.__wbg_ptr = ptr;
+    __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));
+/**
+ * WASM wrapper for HolographicMemory using ProductClifford algebra
+ */
+export class WasmHolographicMemory {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmHolographicMemory.prototype);
+        obj.__wbg_ptr = ptr;
         WasmHolographicMemoryFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
@@ -4840,6 +5457,201 @@ export class WasmMCMCDiagnostics {
     }
 }
 
+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));
@@ -5335,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;
     }
     /**
@@ -5682,46 +6494,624 @@ export class WasmNodeMetadata {
     }
 }
 
-const WasmOptimizationResultFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmOpticalCodebookFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmoptimizationresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmopticalcodebook_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for optimization results
+ * WASM wrapper for OpticalCodebook.
+ *
+ * Maps symbols to deterministically-generated rotor fields.
  */
-export class WasmOptimizationResult {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmOptimizationResult.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmOptimizationResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export class WasmOpticalCodebook {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmOptimizationResultFinalization.unregister(this);
+        WasmOpticalCodebookFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmoptimizationresult_free(ptr, 0);
+        wasm.__wbg_wasmopticalcodebook_free(ptr, 0);
     }
     /**
-     * Get number of iterations
-     * @returns {number}
+     * Clear the field cache (seeds retained).
      */
-    get iterations() {
-        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
-        return ret >>> 0;
+    clearCache() {
+        wasm.wasmopticalcodebook_clearCache(this.__wbg_ptr);
     }
     /**
-     * Get final objective value
-     * @returns {number}
+     * Register multiple symbols at once.
+     * @param {string[]} symbols
      */
-    get objective_value() {
+    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}
+     */
+    get length() {
+        const ret = wasm.wasmopticalrotorfield_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create with random phase (deterministic from seed).
+     * @param {number} width
+     * @param {number} height
+     * @param {bigint} seed
+     * @returns {WasmOpticalRotorField}
+     */
+    static random(width, height, seed) {
+        const ret = wasm.wasmopticalrotorfield_random(width, height, seed);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Create uniform field (constant phase and amplitude).
+     * @param {number} phase
+     * @param {number} amplitude
+     * @param {number} width
+     * @param {number} height
+     * @returns {WasmOpticalRotorField}
+     */
+    static uniform(phase, amplitude, width, height) {
+        const ret = wasm.wasmopticalrotorfield_uniform(phase, amplitude, width, height);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Create identity field (phase = 0, amplitude = 1).
+     * @param {number} width
+     * @param {number} height
+     * @returns {WasmOpticalRotorField}
+     */
+    static identity(width, height) {
+        const ret = wasm.wasmopticalrotorfield_identity(width, height);
+        return WasmOpticalRotorField.__wrap(ret);
+    }
+    /**
+     * Get phase at a point (in radians, range [-π, π]).
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    phaseAt(x, y) {
+        const ret = wasm.wasmopticalrotorfield_phaseAt(this.__wbg_ptr, x, y);
+        return ret;
+    }
+}
+
+const WasmOptimizationResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmoptimizationresult_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for optimization results
+ */
+export class WasmOptimizationResult {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmOptimizationResult.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmOptimizationResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmOptimizationResultFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmoptimizationresult_free(ptr, 0);
+    }
+    /**
+     * Get number of iterations
+     * @returns {number}
+     */
+    get iterations() {
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get final objective value
+     * @returns {number}
+     */
+    get objective_value() {
         const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
         return ret;
     }
@@ -6666,67 +8056,223 @@ export class WasmSensitivityMap {
      * Get all sensitivities as JavaScript arrays
      * @returns {any}
      */
-    getAllSensitivities() {
-        const ret = wasm.wasmsensitivitymap_getAllSensitivities(this.__wbg_ptr);
+    getAllSensitivities() {
+        const ret = wasm.wasmsensitivitymap_getAllSensitivities(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Get total sensitivity across all components
+     * @returns {number}
+     */
+    getTotalSensitivity() {
+        const ret = wasm.wasmsensitivitymap_getTotalSensitivity(this.__wbg_ptr);
+        return ret;
+    }
+}
+
+const WasmSimpleOptimizerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsimpleoptimizer_free(ptr >>> 0, 1));
+/**
+ * Simple quadratic optimization problem for WASM demonstration
+ */
+export class WasmSimpleOptimizer {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSimpleOptimizerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsimpleoptimizer_free(ptr, 0);
+    }
+    /**
+     * Optimize a simple quadratic function: minimize sum(c_i * x_i^2)
+     * @param {Float64Array} coefficients
+     * @param {Float64Array} initial_point
+     * @returns {WasmOptimizationResult}
+     */
+    optimizeQuadratic(coefficients, initial_point) {
+        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(initial_point, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsimpleoptimizer_optimizeQuadratic(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOptimizationResult.__wrap(ret[0]);
+    }
+    /**
+     * Create a new simple optimizer
+     */
+    constructor() {
+        const ret = wasm.wasmcountingmeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmSimpleOptimizerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+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 takeFromExternrefTable0(ret[0]);
+        return ret[0];
     }
     /**
-     * Get total sensitivity across all components
+     * Compute L^2 norm of a function
+     * @param {Function} f
      * @returns {number}
      */
-    getTotalSensitivity() {
-        const ret = wasm.wasmsensitivitymap_getTotalSensitivity(this.__wbg_ptr);
-        return ret;
-    }
-}
-
-const WasmSimpleOptimizerFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsimpleoptimizer_free(ptr >>> 0, 1));
-/**
- * Simple quadratic optimization problem for WASM demonstration
- */
-export class WasmSimpleOptimizer {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmSimpleOptimizerFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmsimpleoptimizer_free(ptr, 0);
-    }
-    /**
-     * Optimize a simple quadratic function: minimize sum(c_i * x_i^2)
-     * @param {Float64Array} coefficients
-     * @param {Float64Array} initial_point
-     * @returns {WasmOptimizationResult}
-     */
-    optimizeQuadratic(coefficients, initial_point) {
-        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(initial_point, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmsimpleoptimizer_optimizeQuadratic(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    l2Norm(f) {
+        const ret = wasm.wasmsobolevspace_l2Norm(this.__wbg_ptr, f);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return WasmOptimizationResult.__wrap(ret[0]);
+        return ret[0];
     }
     /**
-     * Create a new simple optimizer
+     * Get the Sobolev order k
+     * @returns {number}
      */
-    constructor() {
-        const ret = wasm.wasmcountingmeasure_new();
-        this.__wbg_ptr = ret >>> 0;
-        WasmSimpleOptimizerFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    order() {
+        const ret = wasm.wasmsobolevspace_order(this.__wbg_ptr);
+        return ret >>> 0;
     }
 }
 
@@ -6882,6 +8428,156 @@ export class WasmSpacetimeVector {
     }
 }
 
+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]);
+    }
+}
+
 const WasmTrajectoryPointFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmtrajectorypoint_free(ptr >>> 0, 1));
@@ -7488,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;
     }
     /**
@@ -7674,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));
@@ -8264,12 +10135,12 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
+    imports.wbg.__wbg_log_9f891854f8fc562b = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
+    };
     imports.wbg.__wbg_log_ea240990d83e374e = function(arg0) {
         console.log(arg0);
     };
-    imports.wbg.__wbg_log_fcb816babb5e424a = function(arg0, arg1) {
-        console.log(getStringFromWasm0(arg0, arg1));
-    };
     imports.wbg.__wbg_new_07b483f72211fd66 = function() {
         const ret = new Object();
         return ret;
@@ -8289,7 +10160,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_550(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_683(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -8364,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;
@@ -8389,8 +10264,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper1708 = 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) {
@@ -8434,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;
@@ -8453,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;