@justinelliottcobb/amari-wasm 0.9.10 → 0.11.0

package/amari_wasm.js

@@ -177,6 +177,20 @@ function handleError(f, args) {
     }
 }
 
+let cachedFloat64ArrayMemory0 = null;
+
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => state.dtor(state.a, state.b));
@@ -208,53 +222,19 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     CLOSURE_DTORS.register(real, state, state);
     return real;
 }
-
-let cachedFloat64ArrayMemory0 = null;
-
-function getFloat64ArrayMemory0() {
-    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
-        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
-    }
-    return cachedFloat64ArrayMemory0;
-}
-
-function getArrayF64FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
-}
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
-let cachedUint32ArrayMemory0 = null;
-
-function getUint32ArrayMemory0() {
-    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
-        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
-    }
-    return cachedUint32ArrayMemory0;
+/**
+ * Initialize the WASM module
+ */
+export function init() {
+    wasm.init();
 }
 
-function passArray32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getUint32ArrayMemory0().set(arg, ptr / 4);
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
 /**
  * Initialize the enumerative geometry module
  */
@@ -262,11 +242,21 @@ export function initEnumerative() {
     wasm.initEnumerative();
 }
 
-function passArrayF64ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 8, 8) >>> 0;
-    getFloat64ArrayMemory0().set(arg, ptr / 8);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+/**
+ * Calculate light deflection angle for photon grazing massive object
+ * @param {number} impact_parameter
+ * @param {number} mass
+ * @returns {number}
+ */
+export function light_deflection_angle(impact_parameter, mass) {
+    const ret = wasm.light_deflection_angle(impact_parameter, mass);
+    return ret;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
 }
 /**
  * Convert velocity to Lorentz factor
@@ -304,28 +294,98 @@ export function validate_relativistic_module() {
 }
 
 /**
- * Calculate light deflection angle for photon grazing massive object
- * @param {number} impact_parameter
- * @param {number} mass
+ * Initialize the fusion module
+ */
+export function initFusion() {
+    wasm.initFusion();
+}
+
+/**
+ * Integrate a JavaScript function over an interval
+ *
+ * This function provides numerical integration capabilities to JavaScript.
+ *
+ * # Arguments
+ * * `f` - JavaScript function to integrate (must accept a number and return a number)
+ * * `a` - Lower bound of integration
+ * * `b` - Upper bound of integration
+ * * `points` - Number of sample points to use
+ * * `method` - Integration method to use
+ *
+ * # Returns
+ * Approximate value of the integral ∫_a^b f(x) dx
+ * @param {Function} f
+ * @param {number} a
+ * @param {number} b
+ * @param {number} points
+ * @param {WasmIntegrationMethod} method
  * @returns {number}
  */
-export function light_deflection_angle(impact_parameter, mass) {
-    const ret = wasm.light_deflection_angle(impact_parameter, mass);
-    return ret;
+export function integrate(f, a, b, points, method) {
+    const ret = wasm.integrate(f, a, b, points, method);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 
 /**
- * Initialize the WASM module
+ * Compute expectation E[f(X)] for uniform distribution on [a, b]
+ *
+ * # Arguments
+ * * `f` - JavaScript function (must accept a number and return a number)
+ * * `a` - Lower bound
+ * * `b` - Upper bound
+ * * `samples` - Number of Monte Carlo samples
+ * @param {Function} f
+ * @param {number} a
+ * @param {number} b
+ * @param {number} samples
+ * @returns {number}
  */
-export function init() {
-    wasm.init();
+export function expectation(f, a, b, samples) {
+    const ret = wasm.expectation(f, a, b, samples);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
 /**
- * Initialize the fusion module
+ * Compute KL divergence D_KL(P||Q) between two distributions
+ *
+ * # Arguments
+ * * `p_density` - First distribution
+ * * `q_density` - Second distribution
+ * * `p_params` - Parameters for P
+ * * `q_params` - Parameters for Q
+ * * `sample_points` - Points to evaluate at
+ * @param {WasmParametricDensity} p_density
+ * @param {WasmParametricDensity} q_density
+ * @param {Float64Array} p_params
+ * @param {Float64Array} q_params
+ * @param {Float64Array} sample_points
+ * @returns {number}
  */
-export function initFusion() {
-    wasm.initFusion();
+export function klDivergence(p_density, q_density, p_params, q_params, sample_points) {
+    _assertClass(p_density, WasmParametricDensity);
+    _assertClass(q_density, WasmParametricDensity);
+    const ptr0 = passArrayF64ToWasm0(p_params, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(q_params, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(sample_points, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.klDivergence(p_density.__wbg_ptr, q_density.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 
 /**
@@ -335,18 +395,66 @@ export function initAutomata() {
     wasm.initAutomata();
 }
 
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
-function wasm_bindgen__convert__closures_____invoke__h9e55f7f912fc76ac(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h9e55f7f912fc76ac(arg0, arg1, arg2);
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+function wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue_____(arg0, arg1, arg2) {
+    wasm.wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue_____(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h04878e576420376d(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h04878e576420376d(arg0, arg1, arg2, arg3);
+function wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue__wasm_bindgen_e07ba2a7d21574bf___JsValue_____(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue__wasm_bindgen_e07ba2a7d21574bf___JsValue_____(arg0, arg1, arg2, arg3);
 }
 
+/**
+ * Integration methods available in WASM
+ * @enum {0 | 1 | 2 | 3 | 4}
+ */
+export const WasmIntegrationMethod = Object.freeze({
+    /**
+     * Riemann sum approximation
+     */
+    Riemann: 0, "0": "Riemann",
+    /**
+     * Monte Carlo integration
+     */
+    MonteCarlo: 1, "1": "MonteCarlo",
+    /**
+     * Trapezoidal rule
+     */
+    Trapezoidal: 2, "2": "Trapezoidal",
+    /**
+     * Simpson's rule
+     */
+    Simpson: 3, "3": "Simpson",
+    /**
+     * Adaptive quadrature
+     */
+    Adaptive: 4, "4": "Adaptive",
+});
+
 const AutoDiffFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autodiff_free(ptr >>> 0, 1));
@@ -1216,6 +1324,97 @@ export class InfoGeomUtils {
 }
 if (Symbol.dispose) InfoGeomUtils.prototype[Symbol.dispose] = InfoGeomUtils.prototype.free;
 
+const IntegrationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_integration_free(ptr >>> 0, 1));
+/**
+ * Numerical integration operations
+ *
+ * Provides definite integrals, line integrals, and surface integrals
+ * using adaptive quadrature.
+ */
+export class Integration {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntegrationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_integration_free(ptr, 0);
+    }
+    /**
+     * Compute 1D definite integral using Simpson's rule
+     *
+     * ∫[a,b] f(x) dx
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function to integrate
+     * * `a` - Lower bound
+     * * `b` - Upper bound
+     * * `n` - Number of subdivisions (must be even)
+     *
+     * # Returns
+     *
+     * Integral value
+     *
+     * # JavaScript Example
+     *
+     * ```javascript
+     * // Integrate x^2 from 0 to 1
+     * const result = Integration.integrate1D(x => x*x, 0, 1, 100);
+     * // Returns approximately 0.333...
+     * ```
+     * @param {Function} func
+     * @param {number} a
+     * @param {number} b
+     * @param {number} n
+     * @returns {number}
+     */
+    static integrate1D(func, a, b, n) {
+        const ret = wasm.integration_integrate1D(func, a, b, n);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute 2D integral over a rectangle using Simpson's rule
+     *
+     * ∫∫[a,b]×[c,d] f(x,y) dx dy
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y) => f(x, y)
+     * * `ax` - Lower x bound
+     * * `bx` - Upper x bound
+     * * `ay` - Lower y bound
+     * * `by` - Upper y bound
+     * * `nx` - Number of x subdivisions (must be even)
+     * * `ny` - Number of y subdivisions (must be even)
+     * @param {Function} func
+     * @param {number} ax
+     * @param {number} bx
+     * @param {number} ay
+     * @param {number} by
+     * @param {number} nx
+     * @param {number} ny
+     * @returns {number}
+     */
+    static integrate2D(func, ax, bx, ay, by, nx, ny) {
+        const ret = wasm.integration_integrate2D(func, ax, bx, ay, by, nx, ny);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+}
+if (Symbol.dispose) Integration.prototype[Symbol.dispose] = Integration.prototype.free;
+
 const MLOpsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mlops_free(ptr >>> 0, 1));
@@ -1366,6 +1565,165 @@ export class NetworkUtils {
 }
 if (Symbol.dispose) NetworkUtils.prototype[Symbol.dispose] = NetworkUtils.prototype.free;
 
+const NumericalDerivativeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_numericalderivative_free(ptr >>> 0, 1));
+/**
+ * Numerical derivative operations
+ *
+ * Provides gradient, divergence, curl, and Laplacian computations
+ * using centered finite differences.
+ */
+export class NumericalDerivative {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NumericalDerivativeFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_numericalderivative_free(ptr, 0);
+    }
+    /**
+     * Compute divergence of a vector field at a point
+     *
+     * ∇·F = ∂Fx/∂x + ∂Fy/∂y + ∂Fz/∂z
+     *
+     * # Arguments
+     *
+     * * `field` - Vector field
+     * * `point` - Evaluation point
+     *
+     * # Returns
+     *
+     * Divergence (scalar)
+     * @param {VectorField} field
+     * @param {Float64Array} point
+     * @returns {number}
+     */
+    divergence(field, point) {
+        _assertClass(field, VectorField);
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.numericalderivative_divergence(this.__wbg_ptr, field.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a new numerical derivative computer
+     *
+     * # Arguments
+     *
+     * * `step_size` - Optional step size for finite differences (default: 1e-5)
+     * @param {number | null} [step_size]
+     */
+    constructor(step_size) {
+        const ret = wasm.numericalderivative_new(!isLikeNone(step_size), isLikeNone(step_size) ? 0 : step_size);
+        this.__wbg_ptr = ret >>> 0;
+        NumericalDerivativeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Compute curl of a 3D vector field at a point
+     *
+     * ∇×F = [∂Fz/∂y - ∂Fy/∂z, ∂Fx/∂z - ∂Fz/∂x, ∂Fy/∂x - ∂Fx/∂y]
+     *
+     * # Arguments
+     *
+     * * `field` - 3D vector field
+     * * `point` - Evaluation point [x, y, z]
+     *
+     * # Returns
+     *
+     * Curl vector [cx, cy, cz]
+     * @param {VectorField} field
+     * @param {Float64Array} point
+     * @returns {Float64Array}
+     */
+    curl(field, point) {
+        _assertClass(field, VectorField);
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.numericalderivative_curl(this.__wbg_ptr, field.__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 gradient of a scalar field at a point
+     *
+     * ∇f = [∂f/∂x, ∂f/∂y, ∂f/∂z]
+     *
+     * # Arguments
+     *
+     * * `field` - Scalar field
+     * * `point` - Evaluation point
+     *
+     * # Returns
+     *
+     * Gradient vector
+     *
+     * # JavaScript Example
+     *
+     * ```javascript
+     * const field = ScalarField.fromFunction2D((x, y) => x*x + y*y);
+     * const derivative = new NumericalDerivative();
+     * const grad = derivative.gradient(field, [1.0, 2.0]); // Returns [2.0, 4.0]
+     * ```
+     * @param {ScalarField} field
+     * @param {Float64Array} point
+     * @returns {Float64Array}
+     */
+    gradient(field, point) {
+        _assertClass(field, ScalarField);
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.numericalderivative_gradient(this.__wbg_ptr, field.__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 Laplacian of a scalar field at a point
+     *
+     * ∇²f = ∂²f/∂x² + ∂²f/∂y² + ∂²f/∂z²
+     *
+     * # Arguments
+     *
+     * * `field` - Scalar field
+     * * `point` - Evaluation point
+     *
+     * # Returns
+     *
+     * Laplacian (scalar)
+     * @param {ScalarField} field
+     * @param {Float64Array} point
+     * @returns {number}
+     */
+    laplacian(field, point) {
+        _assertClass(field, ScalarField);
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.numericalderivative_laplacian(this.__wbg_ptr, field.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+}
+if (Symbol.dispose) NumericalDerivative.prototype[Symbol.dispose] = NumericalDerivative.prototype.free;
+
 const PerformanceOperationsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_performanceoperations_free(ptr >>> 0, 1));
@@ -1430,23 +1788,375 @@ export class PerformanceOperations {
         return v3;
     }
     /**
-     * Fast geometric product for hot paths with memory pooling
-     * @param {Float64Array} lhs
-     * @param {Float64Array} rhs
-     * @returns {Float64Array}
+     * Fast geometric product for hot paths with memory pooling
+     * @param {Float64Array} lhs
+     * @param {Float64Array} rhs
+     * @returns {Float64Array}
+     */
+    static fastGeometricProduct(lhs, rhs) {
+        const ptr0 = passArrayF64ToWasm0(lhs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(rhs, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.performanceoperations_fastGeometricProduct(ptr0, len0, ptr1, len1);
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
+    }
+}
+if (Symbol.dispose) PerformanceOperations.prototype[Symbol.dispose] = PerformanceOperations.prototype.free;
+
+const RiemannianManifoldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_riemannianmanifold_free(ptr >>> 0, 1));
+/**
+ * Riemannian manifold with metric tensor
+ *
+ * Represents a curved space with a metric that defines distances and angles.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a 2D sphere of radius 1
+ * const sphere = RiemannianManifold.sphere(1.0);
+ *
+ * // Compute scalar curvature at the north pole
+ * const R = sphere.scalarCurvature([0.0, 0.0]); // Returns 2.0 for unit sphere
+ * ```
+ */
+export class RiemannianManifold {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RiemannianManifold.prototype);
+        obj.__wbg_ptr = ptr;
+        RiemannianManifoldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RiemannianManifoldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_riemannianmanifold_free(ptr, 0);
+    }
+    /**
+     * Create a 2D hyperbolic plane (Poincaré half-plane model)
+     *
+     * Metric: ds² = (dx² + dy²) / y²
+     * @returns {RiemannianManifold}
+     */
+    static hyperbolic() {
+        const ret = wasm.riemannianmanifold_hyperbolic();
+        return RiemannianManifold.__wrap(ret);
+    }
+    /**
+     * Compute Christoffel symbol Γ^k_ij at a point
+     *
+     * # Arguments
+     *
+     * * `k` - Upper index
+     * * `i` - First lower index
+     * * `j` - Second lower index
+     * * `coords` - Coordinates
+     * @param {number} k
+     * @param {number} i
+     * @param {number} j
+     * @param {Float64Array} coords
+     * @returns {number}
+     */
+    christoffel(k, i, j, coords) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_christoffel(this.__wbg_ptr, k, i, j, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute Ricci tensor component R_ij
+     *
+     * # Arguments
+     *
+     * * `i` - First index
+     * * `j` - Second index
+     * * `coords` - Coordinates
+     * @param {number} i
+     * @param {number} j
+     * @param {Float64Array} coords
+     * @returns {number}
+     */
+    ricciTensor(i, j, coords) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_ricciTensor(this.__wbg_ptr, i, j, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute Riemann curvature tensor component R^i_jkl
+     *
+     * # Arguments
+     *
+     * * `i` - Upper index
+     * * `j` - First lower index
+     * * `k` - Second lower index
+     * * `l` - Third lower index
+     * * `coords` - Coordinates
+     * @param {number} i
+     * @param {number} j
+     * @param {number} k
+     * @param {number} l
+     * @param {Float64Array} coords
+     * @returns {number}
+     */
+    riemannTensor(i, j, k, l, coords) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_riemannTensor(this.__wbg_ptr, i, j, k, l, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute scalar curvature R
+     *
+     * # Arguments
+     *
+     * * `coords` - Coordinates
+     *
+     * # Returns
+     *
+     * Scalar curvature value
+     * @param {Float64Array} coords
+     * @returns {number}
+     */
+    scalarCurvature(coords) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_scalarCurvature(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a 2D sphere of given radius
+     *
+     * Metric: ds² = dθ² + sin²θ dφ²
+     *
+     * # Arguments
+     *
+     * * `radius` - Sphere radius
+     * @param {number} radius
+     * @returns {RiemannianManifold}
+     */
+    static sphere(radius) {
+        const ret = wasm.riemannianmanifold_sphere(radius);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RiemannianManifold.__wrap(ret[0]);
+    }
+    /**
+     * Compute geodesic trajectory
+     *
+     * Solves the geodesic equations using RK4 integration.
+     *
+     * # Arguments
+     *
+     * * `initial_pos` - Initial position
+     * * `initial_vel` - Initial velocity
+     * * `t_max` - Maximum time
+     * * `dt` - Time step
+     *
+     * # Returns
+     *
+     * Flat array of trajectory points and velocities:
+     * [x0, y0, vx0, vy0, x1, y1, vx1, vy1, ...]
+     * @param {Float64Array} initial_pos
+     * @param {Float64Array} initial_vel
+     * @param {number} t_max
+     * @param {number} dt
+     * @returns {Float64Array}
+     */
+    geodesic(initial_pos, initial_vel, t_max, dt) {
+        const ptr0 = passArrayF64ToWasm0(initial_pos, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(initial_vel, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_geodesic(this.__wbg_ptr, ptr0, len0, ptr1, len1, t_max, dt);
+        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;
+    }
+    /**
+     * Get the dimension of the manifold
+     * @returns {number}
+     */
+    get dimension() {
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a Euclidean (flat) manifold
+     *
+     * # Arguments
+     *
+     * * `dimension` - Dimension (2 or 3)
+     * @param {number} dimension
+     * @returns {RiemannianManifold}
+     */
+    static euclidean(dimension) {
+        const ret = wasm.riemannianmanifold_euclidean(dimension);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RiemannianManifold.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) RiemannianManifold.prototype[Symbol.dispose] = RiemannianManifold.prototype.free;
+
+const ScalarFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_scalarfield_free(ptr >>> 0, 1));
+/**
+ * Scalar field f: ℝⁿ → ℝ
+ *
+ * Represents a function that maps points in n-dimensional space to real numbers.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a scalar field f(x, y) = x² + y²
+ * const field = WasmScalarField.fromFunction2D((x, y) => x*x + y*y);
+ *
+ * // Evaluate at a point
+ * const value = field.evaluate([1.0, 2.0]); // Returns 5.0
+ * ```
+ */
+export class ScalarField {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ScalarField.prototype);
+        obj.__wbg_ptr = ptr;
+        ScalarFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ScalarFieldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_scalarfield_free(ptr, 0);
+    }
+    /**
+     * Batch evaluate the field at multiple points
+     *
+     * # Arguments
+     *
+     * * `points` - Array of points as flat array [x1, y1, x2, y2, ...]
+     *
+     * # Returns
+     *
+     * Array of field values
+     * @param {Float64Array} points
+     * @returns {Float64Array}
+     */
+    batchEvaluate(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.scalarfield_batchEvaluate(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 2D scalar field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y) => f(x, y)
+     * @param {Function} func
+     * @returns {ScalarField}
+     */
+    static fromFunction2D(func) {
+        const ret = wasm.scalarfield_fromFunction2D(func);
+        return ScalarField.__wrap(ret);
+    }
+    /**
+     * Create a 3D scalar field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y, z) => f(x, y, z)
+     * @param {Function} func
+     * @returns {ScalarField}
+     */
+    static fromFunction3D(func) {
+        const ret = wasm.scalarfield_fromFunction3D(func);
+        return ScalarField.__wrap(ret);
+    }
+    /**
+     * Create a 2D scalar field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y) => f(x, y)
+     * @param {Function} func
+     * @param {number} dimension
      */
-    static fastGeometricProduct(lhs, rhs) {
-        const ptr0 = passArrayF64ToWasm0(lhs, wasm.__wbindgen_malloc);
+    constructor(func, dimension) {
+        const ret = wasm.scalarfield_new(func, dimension);
+        this.__wbg_ptr = ret >>> 0;
+        ScalarFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Evaluate the scalar field at a point
+     *
+     * # Arguments
+     *
+     * * `point` - Coordinates [x, y] or [x, y, z]
+     *
+     * # Returns
+     *
+     * Field value at the point
+     * @param {Float64Array} point
+     * @returns {number}
+     */
+    evaluate(point) {
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(rhs, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.performanceoperations_fastGeometricProduct(ptr0, len0, ptr1, len1);
-        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v3;
+        const ret = wasm.scalarfield_evaluate(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
 }
-if (Symbol.dispose) PerformanceOperations.prototype[Symbol.dispose] = PerformanceOperations.prototype.free;
+if (Symbol.dispose) ScalarField.prototype[Symbol.dispose] = ScalarField.prototype.free;
 
 const TropicalBatchFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1590,6 +2300,109 @@ export class TropicalMLOps {
 }
 if (Symbol.dispose) TropicalMLOps.prototype[Symbol.dispose] = TropicalMLOps.prototype.free;
 
+const VectorFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_vectorfield_free(ptr >>> 0, 1));
+/**
+ * Vector field F: ℝⁿ → ℝⁿ
+ *
+ * Represents a function that maps points to vectors.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a 2D vector field F(x, y) = [y, -x] (rotation)
+ * const field = WasmVectorField.fromFunction2D((x, y) => [y, -x]);
+ *
+ * // Evaluate at a point
+ * const vector = field.evaluate([1.0, 2.0]); // Returns [2.0, -1.0]
+ * ```
+ */
+export class VectorField {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(VectorField.prototype);
+        obj.__wbg_ptr = ptr;
+        VectorFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VectorFieldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_vectorfield_free(ptr, 0);
+    }
+    /**
+     * Create a 2D vector field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y) => [fx, fy]
+     * @param {Function} func
+     * @returns {VectorField}
+     */
+    static fromFunction2D(func) {
+        const ret = wasm.vectorfield_fromFunction2D(func);
+        return VectorField.__wrap(ret);
+    }
+    /**
+     * Create a 3D vector field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y, z) => [fx, fy, fz]
+     * @param {Function} func
+     * @returns {VectorField}
+     */
+    static fromFunction3D(func) {
+        const ret = wasm.vectorfield_fromFunction3D(func);
+        return VectorField.__wrap(ret);
+    }
+    /**
+     * Create a vector field from a JavaScript function
+     * @param {Function} func
+     * @param {number} dimension
+     */
+    constructor(func, dimension) {
+        const ret = wasm.vectorfield_new(func, dimension);
+        this.__wbg_ptr = ret >>> 0;
+        VectorFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Evaluate the vector field at a point
+     *
+     * # Arguments
+     *
+     * * `point` - Coordinates [x, y] or [x, y, z]
+     *
+     * # Returns
+     *
+     * Vector at the point
+     * @param {Float64Array} point
+     * @returns {Float64Array}
+     */
+    evaluate(point) {
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.vectorfield_evaluate(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;
+    }
+}
+if (Symbol.dispose) VectorField.prototype[Symbol.dispose] = VectorField.prototype.free;
+
 const WasmAlphaConnectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmalphaconnection_free(ptr >>> 0, 1));
@@ -1825,6 +2638,60 @@ export class WasmCommunity {
 }
 if (Symbol.dispose) WasmCommunity.prototype[Symbol.dispose] = WasmCommunity.prototype.free;
 
+const WasmCountingMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcountingmeasure_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for counting measure
+ *
+ * The counting measure assigns to each set the number of elements it contains.
+ */
+export class WasmCountingMeasure {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmCountingMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmcountingmeasure_free(ptr, 0);
+    }
+    /**
+     * Check if a set is measurable under counting measure
+     * (all sets are measurable under counting measure)
+     * @returns {boolean}
+     */
+    isMeasurable() {
+        const ret = wasm.wasmcountingmeasure_isMeasurable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Measure a finite set (returns its cardinality)
+     *
+     * # Arguments
+     * * `set_size` - The number of elements in the set
+     * @param {number} set_size
+     * @returns {number}
+     */
+    measureFiniteSet(set_size) {
+        const ret = wasm.wasmcountingmeasure_measureFiniteSet(this.__wbg_ptr, set_size);
+        return ret;
+    }
+    /**
+     * Create a new counting measure
+     */
+    constructor() {
+        const ret = wasm.wasmcountingmeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmCountingMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmCountingMeasure.prototype[Symbol.dispose] = WasmCountingMeasure.prototype.free;
+
 const WasmDualNumberFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmdualnumber_free(ptr >>> 0, 1));
@@ -2329,6 +3196,83 @@ export class WasmFisherInformationMatrix {
 }
 if (Symbol.dispose) WasmFisherInformationMatrix.prototype[Symbol.dispose] = WasmFisherInformationMatrix.prototype.free;
 
+const WasmFisherMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmfishermeasure_free(ptr >>> 0, 1));
+/**
+ * Fisher-Riemannian geometry on statistical manifolds
+ */
+export class WasmFisherMeasure {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmFisherMeasure.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmFisherMeasureFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmFisherMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmfishermeasure_free(ptr, 0);
+    }
+    /**
+     * Create Fisher measure from a parametric density
+     * @param {WasmParametricDensity} density
+     * @returns {WasmFisherMeasure}
+     */
+    static fromDensity(density) {
+        _assertClass(density, WasmParametricDensity);
+        var ptr0 = density.__destroy_into_raw();
+        const ret = wasm.wasmfishermeasure_fromDensity(ptr0);
+        return WasmFisherMeasure.__wrap(ret);
+    }
+    /**
+     * Compute the Fisher information metric at parameter point θ
+     * @param {Float64Array} data
+     * @param {Float64Array} params
+     * @returns {Float64Array}
+     */
+    fisherMetric(data, params) {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmfishermeasure_fisherMetric(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 the Riemannian volume element √det(g(θ))
+     * @param {Float64Array} data
+     * @param {Float64Array} params
+     * @returns {number}
+     */
+    volumeElement(data, params) {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmfishermeasure_volumeElement(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+}
+if (Symbol.dispose) WasmFisherMeasure.prototype[Symbol.dispose] = WasmFisherMeasure.prototype.free;
+
 const WasmFourVelocityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmfourvelocity_free(ptr >>> 0, 1));
@@ -3031,14 +3975,6 @@ export class WasmGpuOptimizer {
         const ret = wasm.wasmgpuoptimizer_optimizeBatch(this.__wbg_ptr, ptr0, len0, problem_size, num_problems, max_iterations, tolerance);
         return ret;
     }
-    /**
-     * Check if GPU acceleration is available
-     * @returns {boolean}
-     */
-    isGpuAvailable() {
-        const ret = wasm.wasmgpuoptimizer_isGpuAvailable(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Optimize a quadratic function with GPU acceleration
      * @param {Float64Array} coefficients
@@ -3055,11 +3991,19 @@ export class WasmGpuOptimizer {
         const ret = wasm.wasmgpuoptimizer_optimizeQuadraticGpu(this.__wbg_ptr, ptr0, len0, ptr1, len1, max_iterations, tolerance);
         return ret;
     }
+    /**
+     * Check if GPU acceleration is available
+     * @returns {boolean}
+     */
+    isGpuAvailable() {
+        const ret = wasm.wasmgpuoptimizer_isGpuAvailable(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Create a new GPU optimizer
      */
     constructor() {
-        const ret = wasm.wasmgpuoptimizer_new();
+        const ret = wasm.wasmcountingmeasure_new();
         this.__wbg_ptr = ret >>> 0;
         WasmGpuOptimizerFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -3157,43 +4101,126 @@ export class WasmInverseCADesigner {
      * @param {Float64Array} candidate
      * @returns {number}
      */
-    evaluateFitness(candidate) {
-        const ptr0 = passArrayF64ToWasm0(candidate, wasm.__wbindgen_malloc);
+    evaluateFitness(candidate) {
+        const ptr0 = passArrayF64ToWasm0(candidate, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasminversecadesigner_evaluateFitness(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a new inverse designer for finding CA seeds
+     * @param {number} target_width
+     * @param {number} target_height
+     */
+    constructor(target_width, target_height) {
+        const ret = wasm.wasminversecadesigner_new(target_width, target_height);
+        this.__wbg_ptr = ret >>> 0;
+        WasmInverseCADesignerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Find a seed configuration that produces the target after evolution (simplified)
+     * @param {number} _max_generations
+     * @param {number} max_attempts
+     * @returns {Float64Array}
+     */
+    findSeed(_max_generations, max_attempts) {
+        const ret = wasm.wasminversecadesigner_findSeed(this.__wbg_ptr, _max_generations, max_attempts);
+        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;
+    }
+}
+if (Symbol.dispose) WasmInverseCADesigner.prototype[Symbol.dispose] = WasmInverseCADesigner.prototype.free;
+
+const WasmLebesgueMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmlebesguemeasure_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Lebesgue measure
+ *
+ * The Lebesgue measure generalizes the notion of length, area, and volume
+ * to higher dimensions and more complex sets.
+ */
+export class WasmLebesgueMeasure {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmLebesgueMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlebesguemeasure_free(ptr, 0);
+    }
+    /**
+     * Compute the measure of a box (hyper-rectangle) with given side lengths
+     * @param {Float64Array} sides
+     * @returns {number}
+     */
+    measureBox(sides) {
+        const ptr0 = passArrayF64ToWasm0(sides, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmlebesguemeasure_measureBox(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Get the dimension of this measure
+     * @returns {number}
+     */
+    getDimension() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Compute the measure of an interval [a, b]
+     *
+     * For 1D: returns length (b - a)
+     * For higher dimensions: returns the product of interval lengths
+     * @param {Float64Array} lower
+     * @param {Float64Array} upper
+     * @returns {number}
+     */
+    measureInterval(lower, upper) {
+        const ptr0 = passArrayF64ToWasm0(lower, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasminversecadesigner_evaluateFitness(this.__wbg_ptr, ptr0, len0);
+        const ptr1 = passArrayF64ToWasm0(upper, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmlebesguemeasure_measureInterval(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return ret[0];
     }
     /**
-     * Create a new inverse designer for finding CA seeds
-     * @param {number} target_width
-     * @param {number} target_height
-     */
-    constructor(target_width, target_height) {
-        const ret = wasm.wasminversecadesigner_new(target_width, target_height);
-        this.__wbg_ptr = ret >>> 0;
-        WasmInverseCADesignerFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Find a seed configuration that produces the target after evolution (simplified)
-     * @param {number} _max_generations
-     * @param {number} max_attempts
-     * @returns {Float64Array}
+     * Create a new Lebesgue measure for the specified dimension
+     *
+     * # Arguments
+     * * `dimension` - The dimension of the space (1 for length, 2 for area, 3 for volume, etc.)
+     * @param {number} dimension
      */
-    findSeed(_max_generations, max_attempts) {
-        const ret = wasm.wasminversecadesigner_findSeed(this.__wbg_ptr, _max_generations, max_attempts);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
+    constructor(dimension) {
+        const ret = wasm.wasmlebesguemeasure_new(dimension);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmLebesgueMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
 }
-if (Symbol.dispose) WasmInverseCADesigner.prototype[Symbol.dispose] = WasmInverseCADesigner.prototype.free;
+if (Symbol.dispose) WasmLebesgueMeasure.prototype[Symbol.dispose] = WasmLebesgueMeasure.prototype.free;
 
 const WasmModuliSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3253,7 +4280,7 @@ export class WasmModuliSpace {
      * @returns {number}
      */
     getGenus() {
-        const ret = wasm.wasmmodulispace_getGenus(this.__wbg_ptr);
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -3454,7 +4481,7 @@ export class WasmMultiObjectiveOptimizer {
      * Create a new multi-objective optimizer
      */
     constructor() {
-        const ret = wasm.wasmgpuoptimizer_new();
+        const ret = wasm.wasmcountingmeasure_new();
         this.__wbg_ptr = ret >>> 0;
         WasmMultiObjectiveOptimizerFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -3876,7 +4903,7 @@ export class WasmOptimizationResult {
      * @returns {number}
      */
     get iterations() {
-        const ret = wasm.wasmoptimizationresult_iterations(this.__wbg_ptr);
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -3964,6 +4991,220 @@ export class WasmOptimizationUtils {
 }
 if (Symbol.dispose) WasmOptimizationUtils.prototype[Symbol.dispose] = WasmOptimizationUtils.prototype.free;
 
+const WasmParametricDensityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmparametricdensity_free(ptr >>> 0, 1));
+/**
+ * Parametric probability density families
+ */
+export class WasmParametricDensity {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmParametricDensity.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmParametricDensityFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmParametricDensityFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmparametricdensity_free(ptr, 0);
+    }
+    /**
+     * Create an Exponential density Exp(λ)
+     * @returns {WasmParametricDensity}
+     */
+    static exponential() {
+        const ret = wasm.wasmparametricdensity_exponential();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Compute log-density log p(x|θ)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {number}
+     */
+    logDensity(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_logDensity(this.__wbg_ptr, x, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute Fisher information matrix from data samples
+     * @param {Float64Array} data
+     * @param {Float64Array} params
+     * @returns {Float64Array}
+     */
+    fisherInformation(data, params) {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_fisherInformation(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;
+    }
+    /**
+     * Create a Cauchy density Cauchy(x₀, γ)
+     * @returns {WasmParametricDensity}
+     */
+    static cauchy() {
+        const ret = wasm.wasmparametricdensity_cauchy();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Create a Laplace density Laplace(μ, b)
+     * @returns {WasmParametricDensity}
+     */
+    static laplace() {
+        const ret = wasm.wasmparametricdensity_laplace();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Evaluate density at point x with parameters
+     *
+     * # Arguments
+     * * `x` - Point to evaluate
+     * * `params` - Parameters (Gaussian: [μ, σ], Exponential: [λ], etc.)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {number}
+     */
+    evaluate(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_evaluate(this.__wbg_ptr, x, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a Gaussian density N(μ, σ²)
+     * @returns {WasmParametricDensity}
+     */
+    static gaussian() {
+        const ret = wasm.wasmparametricdensity_gaussian();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Compute numerical gradient ∇_θ p(x|θ)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {Float64Array}
+     */
+    gradient(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_gradient(this.__wbg_ptr, x, 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;
+    }
+}
+if (Symbol.dispose) WasmParametricDensity.prototype[Symbol.dispose] = WasmParametricDensity.prototype.free;
+
+const WasmProbabilityMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprobabilitymeasure_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for probability measures
+ *
+ * A probability measure assigns total measure 1 to the entire space.
+ */
+export class WasmProbabilityMeasure {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmProbabilityMeasure.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmProbabilityMeasureFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmProbabilityMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmprobabilitymeasure_free(ptr, 0);
+    }
+    /**
+     * Get a description of this probability measure
+     * @returns {string}
+     */
+    getDescription() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmprobabilitymeasure_getDescription(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);
+        }
+    }
+    /**
+     * Compute P(X ∈ [a, b]) for uniform distribution
+     * @param {number} a
+     * @param {number} b
+     * @param {number} lower
+     * @param {number} upper
+     * @returns {number}
+     */
+    probabilityInterval(a, b, lower, upper) {
+        const ret = wasm.wasmprobabilitymeasure_probabilityInterval(this.__wbg_ptr, a, b, lower, upper);
+        return ret;
+    }
+    /**
+     * Create a new uniform probability measure on [0, 1]
+     */
+    constructor() {
+        const ret = wasm.wasmprobabilitymeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmProbabilityMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a uniform probability measure on [a, b]
+     * @param {number} a
+     * @param {number} b
+     * @returns {WasmProbabilityMeasure}
+     */
+    static uniform(a, b) {
+        const ret = wasm.wasmprobabilitymeasure_uniform(a, b);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmProbabilityMeasure.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) WasmProbabilityMeasure.prototype[Symbol.dispose] = WasmProbabilityMeasure.prototype.free;
+
 const WasmProjectiveSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmprojectivespace_free(ptr >>> 0, 1));
@@ -3988,7 +5229,7 @@ export class WasmProjectiveSpace {
      * @returns {number}
      */
     getDimension() {
-        const ret = wasm.wasmmodulispace_getGenus(this.__wbg_ptr);
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -4055,7 +5296,7 @@ export class WasmPropagationAnalysis {
      * @returns {number}
      */
     get convergenceTime() {
-        const ret = wasm.wasmoptimizationresult_iterations(this.__wbg_ptr);
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -4607,7 +5848,7 @@ export class WasmSimpleOptimizer {
      * Create a new simple optimizer
      */
     constructor() {
-        const ret = wasm.wasmgpuoptimizer_new();
+        const ret = wasm.wasmcountingmeasure_new();
         this.__wbg_ptr = ret >>> 0;
         WasmSimpleOptimizerFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -4787,14 +6028,6 @@ export class WasmTrajectoryPoint {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmtrajectorypoint_free(ptr, 0);
     }
-    /**
-     * Get position
-     * @returns {WasmSpacetimeVector}
-     */
-    get position() {
-        const ret = wasm.wasmfourvelocity_as_spacetime_vector(this.__wbg_ptr);
-        return WasmSpacetimeVector.__wrap(ret);
-    }
     /**
      * Time coordinate
      * @returns {number}
@@ -4810,6 +6043,14 @@ export class WasmTrajectoryPoint {
     set time(arg0) {
         wasm.__wbg_set_wasmtrajectorypoint_time(this.__wbg_ptr, arg0);
     }
+    /**
+     * Get position
+     * @returns {WasmSpacetimeVector}
+     */
+    get position() {
+        const ret = wasm.wasmfourvelocity_as_spacetime_vector(this.__wbg_ptr);
+        return WasmSpacetimeVector.__wrap(ret);
+    }
 }
 if (Symbol.dispose) WasmTrajectoryPoint.prototype[Symbol.dispose] = WasmTrajectoryPoint.prototype.free;
 
@@ -5187,6 +6428,90 @@ export class WasmTropicalDualDistribution {
 }
 if (Symbol.dispose) WasmTropicalDualDistribution.prototype[Symbol.dispose] = WasmTropicalDualDistribution.prototype.free;
 
+const WasmTropicalMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmtropicalmeasure_free(ptr >>> 0, 1));
+/**
+ * Tropical (max-plus) algebra operations for optimization
+ */
+export class WasmTropicalMeasure {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmTropicalMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtropicalmeasure_free(ptr, 0);
+    }
+    /**
+     * Tropical integration (supremum over region)
+     * @param {Function} f
+     * @param {number} a
+     * @param {number} b
+     * @param {number} samples
+     * @returns {number}
+     */
+    tropicalIntegrate(f, a, b, samples) {
+        const ret = wasm.wasmtropicalmeasure_tropicalIntegrate(this.__wbg_ptr, f, a, b, samples);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a new tropical measure
+     */
+    constructor() {
+        const ret = wasm.wasmcountingmeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmTropicalMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Compute tropical infimum (minimum) of function over sample points
+     *
+     * Returns the minimum value and the point where it occurs
+     * @param {Function} f
+     * @param {Float64Array} points
+     * @returns {Float64Array}
+     */
+    infimum(f, points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmtropicalmeasure_infimum(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;
+    }
+    /**
+     * Compute tropical supremum (maximum) of function over sample points
+     *
+     * Returns the maximum value and the point where it occurs
+     * @param {Function} f
+     * @param {Float64Array} points
+     * @returns {Float64Array}
+     */
+    supremum(f, points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmtropicalmeasure_supremum(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;
+    }
+}
+if (Symbol.dispose) WasmTropicalMeasure.prototype[Symbol.dispose] = WasmTropicalMeasure.prototype.free;
+
 const WasmTropicalNetworkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmtropicalnetwork_free(ptr >>> 0, 1));
@@ -5649,10 +6974,18 @@ function __wbg_get_imports() {
         const ret = arg0.apply(arg1, arg2);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_call_357bb72daee10695 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        const ret = arg0.call(arg1, arg2, arg3, arg4);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_call_525440f72fbfc0ea = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = arg0.call(arg1, arg2);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_call_e45d2cf9fc925fcf = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = arg0.call(arg1, arg2, arg3);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {
         const ret = arg0.call(arg1);
         return ret;
@@ -5680,12 +7013,12 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_660547816007a991 = function(arg0, arg1) {
-        console.log(getStringFromWasm0(arg0, arg1));
-    };
     imports.wbg.__wbg_log_8cec76766b8c0e33 = function(arg0) {
         console.log(arg0);
     };
+    imports.wbg.__wbg_log_bf0922dbf69432a1 = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
+    };
     imports.wbg.__wbg_new_1acc0b6eea89d040 = function() {
         const ret = new Object();
         return ret;
@@ -5697,7 +7030,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return wasm_bindgen__convert__closures_____invoke__h04878e576420376d(a, state0.b, arg0, arg1);
+                    return wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue__wasm_bindgen_e07ba2a7d21574bf___JsValue_____(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -5798,11 +7131,6 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return ret;
     };
-    imports.wbg.__wbindgen_cast_69f35aa0fcaecc47 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 37, function: Function { arguments: [Externref], shim_idx: 38, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__ha65d378aaf4b53b1, wasm_bindgen__convert__closures_____invoke__h9e55f7f912fc76ac);
-        return ret;
-    };
     imports.wbg.__wbindgen_cast_b63aeb0d85365734 = function(arg0, arg1) {
         var v0 = getArrayF64FromWasm0(arg0, arg1).slice();
         wasm.__wbindgen_free(arg0, arg1 * 8, 8);
@@ -5810,6 +7138,11 @@ function __wbg_get_imports() {
         const ret = v0;
         return ret;
     };
+    imports.wbg.__wbindgen_cast_d2d0cc24b1b6ed59 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 42, function: Function { arguments: [Externref], shim_idx: 43, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_e07ba2a7d21574bf___closure__destroy___dyn_core_a2b7f04d45112077___ops__function__FnMut__wasm_bindgen_e07ba2a7d21574bf___JsValue____Output_______, wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue_____);
+        return ret;
+    };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;