@justinelliottcobb/amari-wasm 0.13.0 → 0.14.0

package/amari_wasm.d.ts

@@ -1260,6 +1260,56 @@ export class WasmGeodesicIntegrator {
    */
   static with_schwarzschild(metric: WasmSchwarzschildMetric): WasmGeodesicIntegrator;
 }
+/**
+ * WASM wrapper for Geometric Brownian Motion on multivector space
+ *
+ * dX = μX dt + σX dW
+ *
+ * Useful for modeling multiplicative noise processes in geometric algebra.
+ */
+export class WasmGeometricBrownianMotion {
+  free(): void;
+  /**
+   * Sample a single path of the process
+   *
+   * # Arguments
+   * * `initial` - Initial multivector (8 coefficients)
+   * * `t_end` - End time
+   * * `num_steps` - Number of time steps
+   *
+   * Returns flat array: (num_steps + 1) * 9 values
+   * Each point is [time, coeff0, coeff1, ..., coeff7]
+   */
+  samplePath(initial: Float64Array, t_end: number, num_steps: number): Float64Array;
+  /**
+   * Compute expected value at time t given initial value
+   *
+   * E[X(t)] = X(0) * exp(μt)
+   */
+  expectedValue(initial: Float64Array, t: number): Float64Array;
+  /**
+   * Create a new Geometric Brownian Motion process
+   *
+   * # Arguments
+   * * `mu` - Drift coefficient (expected growth rate)
+   * * `sigma` - Diffusion coefficient (volatility)
+   */
+  constructor(mu: number, sigma: number);
+  /**
+   * Get drift coefficient
+   */
+  getMu(): number;
+  /**
+   * Compute variance at time t given initial value
+   *
+   * Var(X(t)) = X(0)² * exp(2μt) * (exp(σ²t) - 1)
+   */
+  variance(initial: Float64Array, t: number): Float64Array;
+  /**
+   * Get diffusion coefficient
+   */
+  getSigma(): number;
+}
 /**
  * WASM wrapper for Geometric Cellular Automaton
  */
@@ -1460,6 +1510,50 @@ export class WasmGpuOptimizer {
    */
   constructor();
 }
+/**
+ * WASM wrapper for grade-projected distribution
+ *
+ * A distribution that only operates on components of a specific grade.
+ */
+export class WasmGradeProjectedDistribution {
+  free(): void;
+  /**
+   * Sample and embed into full multivector (other grades are zero)
+   *
+   * Returns 8 coefficients
+   */
+  sampleFull(): Float64Array;
+  /**
+   * Get standard deviations
+   */
+  getStdDevs(): Float64Array;
+  /**
+   * Get number of components in this grade
+   */
+  getNumComponents(): number;
+  /**
+   * Create a grade-projected distribution from a Gaussian
+   *
+   * # Arguments
+   * * `gaussian` - Source Gaussian distribution
+   * * `grade` - Grade to project onto (0, 1, 2, or 3 for Cl(3,0,0))
+   */
+  constructor(gaussian: WasmGaussianMultivector, grade: number);
+  /**
+   * Sample from this grade-projected distribution
+   *
+   * Returns components for just this grade
+   */
+  sample(): Float64Array;
+  /**
+   * Get the mean for this grade's components
+   */
+  getMean(): Float64Array;
+  /**
+   * Get the grade
+   */
+  getGrade(): number;
+}
 /**
  * WASM wrapper for Grassmannian varieties
  */
@@ -1585,6 +1679,77 @@ export class WasmLebesgueMeasure {
    */
   constructor(dimension: number);
 }
+/**
+ * WASM wrapper for MCMC diagnostics
+ */
+export class WasmMCMCDiagnostics {
+  private constructor();
+  free(): void;
+  /**
+   * Check if the sampler has converged (R-hat < 1.1)
+   */
+  isConverged(): boolean;
+  /**
+   * Get effective sample size (or -1 if not computed)
+   */
+  getEffectiveSampleSize(): number;
+  /**
+   * Get R-hat statistic (or -1 if not computed)
+   */
+  getRHat(): number;
+  /**
+   * Total number of steps
+   */
+  num_steps: number;
+  /**
+   * Acceptance rate
+   */
+  acceptance_rate: number;
+}
+/**
+ * WASM wrapper for Metropolis-Hastings MCMC sampler
+ *
+ * Samples from a target distribution using random-walk proposals.
+ */
+export class WasmMetropolisHastings {
+  free(): void;
+  /**
+   * Get sampling diagnostics
+   */
+  diagnostics(): WasmMCMCDiagnostics;
+  /**
+   * Get current sample
+   */
+  getCurrent(): Float64Array;
+  /**
+   * Get current acceptance rate
+   */
+  getAcceptanceRate(): number;
+  /**
+   * Create a new Metropolis-Hastings sampler for a Gaussian target
+   *
+   * # Arguments
+   * * `target` - The target Gaussian distribution to sample from
+   * * `proposal_std` - Standard deviation for the proposal distribution
+   */
+  constructor(target: WasmGaussianMultivector, proposal_std: number);
+  /**
+   * Run the sampler for multiple steps
+   *
+   * # Arguments
+   * * `num_samples` - Number of samples to collect
+   * * `burnin` - Number of burn-in steps to discard
+   *
+   * Returns flat array of samples (num_samples * 8)
+   */
+  run(num_samples: number, burnin: number): Float64Array;
+  /**
+   * Take a single MCMC step
+   *
+   * Returns the new sample (8 coefficients)
+   */
+  step(): Float64Array;
+}
 /**
  * WASM wrapper for moduli spaces (simplified)
  */
@@ -2632,6 +2797,67 @@ export class WasmTropicalViterbi {
    */
   decode(observations: Uint32Array): any;
 }
+/**
+ * WASM wrapper for uncertain multivector (mean + covariance)
+ *
+ * Represents a multivector with associated uncertainty, useful for
+ * error propagation through geometric operations.
+ */
+export class WasmUncertainMultivector {
+  free(): void;
+  /**
+   * Get standard deviations
+   */
+  getStdDevs(): Float64Array;
+  /**
+   * Create a deterministic (zero variance) uncertain multivector
+   */
+  static deterministic(value: Float64Array): WasmUncertainMultivector;
+  /**
+   * Get variances (diagonal of covariance)
+   */
+  getVariances(): Float64Array;
+  /**
+   * Get the covariance matrix (64 values, row-major)
+   */
+  getCovariance(): Float64Array;
+  /**
+   * Create with full covariance matrix
+   *
+   * # Arguments
+   * * `mean` - 8 coefficients for the mean
+   * * `covariance` - 64 values for 8x8 covariance matrix (row-major)
+   */
+  static withCovariance(mean: Float64Array, covariance: Float64Array): WasmUncertainMultivector;
+  /**
+   * Get total variance (trace of covariance)
+   */
+  getTotalVariance(): number;
+  /**
+   * Add two uncertain multivectors (assuming independence)
+   *
+   * For Z = X + Y: E[Z] = E[X] + E[Y], Var(Z) = Var(X) + Var(Y)
+   */
+  add(other: WasmUncertainMultivector): WasmUncertainMultivector;
+  /**
+   * Create an uncertain multivector with diagonal covariance
+   *
+   * # Arguments
+   * * `mean` - 8 coefficients for the mean
+   * * `variances` - 8 values for per-coefficient variance
+   */
+  constructor(mean: Float64Array, variances: Float64Array);
+  /**
+   * Linear propagation: scale by a constant
+   *
+   * For Y = aX: E[Y] = aE[X], Var(Y) = a²Var(X)
+   */
+  scale(scalar: number): WasmUncertainMultivector;
+  /**
+   * Get the mean
+   */
+  getMean(): Float64Array;
+}
 /**
  * WASM wrapper for Uniform distribution on Cl(3,0,0) multivector space
  *
@@ -2690,17 +2916,49 @@ export class WasmUniformMultivector {
    */
   static hypercube(min: number, max: number): WasmUniformMultivector;
 }
+/**
+ * WASM wrapper for Wiener process (Brownian motion)
+ *
+ * Standard Brownian motion W(t) with W(0) = 0
+ */
+export class WasmWienerProcess {
+  free(): void;
+  /**
+   * Sample a path of the Wiener process
+   *
+   * # Arguments
+   * * `t_end` - End time
+   * * `num_steps` - Number of time steps
+   *
+   * Returns flat array: (num_steps + 1) * (dim + 1) values
+   * Each point is [time, w0, w1, ...]
+   */
+  samplePath(t_end: number, num_steps: number): Float64Array;
+  /**
+   * Create a new Wiener process
+   *
+   * # Arguments
+   * * `dim` - Dimension of the process (default 8 for multivector space)
+   */
+  constructor(dim?: number | null);
+  /**
+   * Get dimension
+   */
+  getDim(): number;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_autodiff_free: (a: number, b: number) => void;
-  readonly __wbg_get_wasmtrajectorypoint_time: (a: number) => number;
+  readonly __wbg_get_wasmmcmcdiagnostics_acceptance_rate: (a: number) => number;
+  readonly __wbg_get_wasmmcmcdiagnostics_num_steps: (a: number) => number;
   readonly __wbg_numericalderivative_free: (a: number, b: number) => void;
   readonly __wbg_riemannianmanifold_free: (a: number, b: number) => void;
   readonly __wbg_scalarfield_free: (a: number, b: number) => void;
-  readonly __wbg_set_wasmtrajectorypoint_time: (a: number, b: number) => void;
+  readonly __wbg_set_wasmmcmcdiagnostics_acceptance_rate: (a: number, b: number) => void;
+  readonly __wbg_set_wasmmcmcdiagnostics_num_steps: (a: number, b: number) => void;
   readonly __wbg_wasmchowclass_free: (a: number, b: number) => void;
   readonly __wbg_wasmcommunity_free: (a: number, b: number) => void;
   readonly __wbg_wasmduallyflatmanifold_free: (a: number, b: number) => void;
@@ -2711,10 +2969,13 @@ export interface InitOutput {
   readonly __wbg_wasmgeodesicintegrator_free: (a: number, b: number) => void;
   readonly __wbg_wasmgeometricca_free: (a: number, b: number) => void;
   readonly __wbg_wasmgeometricnetwork_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgradeprojecteddistribution_free: (a: number, b: number) => void;
   readonly __wbg_wasmgrassmannian_free: (a: number, b: number) => void;
   readonly __wbg_wasmholographicmemory_free: (a: number, b: number) => void;
   readonly __wbg_wasminversecadesigner_free: (a: number, b: number) => void;
   readonly __wbg_wasmlebesguemeasure_free: (a: number, b: number) => void;
+  readonly __wbg_wasmmcmcdiagnostics_free: (a: number, b: number) => void;
+  readonly __wbg_wasmmetropolishastings_free: (a: number, b: number) => void;
   readonly __wbg_wasmmodulispace_free: (a: number, b: number) => void;
   readonly __wbg_wasmmultidualnumber_free: (a: number, b: number) => void;
   readonly __wbg_wasmmultivector_free: (a: number, b: number) => void;
@@ -2723,7 +2984,6 @@ export interface InitOutput {
   readonly __wbg_wasmpropagationanalysis_free: (a: number, b: number) => void;
   readonly __wbg_wasmrelativisticparticle_free: (a: number, b: number) => void;
   readonly __wbg_wasmresonator_free: (a: number, b: number) => void;
-  readonly __wbg_wasmschwarzschildmetric_free: (a: number, b: number) => void;
   readonly __wbg_wasmselfassembler_free: (a: number, b: number) => void;
   readonly __wbg_wasmsensitivitymap_free: (a: number, b: number) => void;
   readonly __wbg_wasmtrajectorypoint_free: (a: number, b: number) => void;
@@ -2731,6 +2991,7 @@ export interface InitOutput {
   readonly __wbg_wasmtropicalnetwork_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalpolynomial_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalviterbi_free: (a: number, b: number) => void;
+  readonly __wbg_wasmuncertainmultivector_free: (a: number, b: number) => void;
   readonly __wbg_wasmuniformmultivector_free: (a: number, b: number) => void;
   readonly autodiff_evaluatePolynomial: (a: number, b: number, c: number) => number;
   readonly autodiff_linearLayer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
@@ -2903,6 +3164,9 @@ export interface InitOutput {
   readonly wasmgaussianmultivector_withParameters: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly wasmgeodesicintegrator_propagate_particle: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly wasmgeodesicintegrator_with_schwarzschild: (a: number) => number;
+  readonly wasmgeometricbrownianmotion_expectedValue: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly wasmgeometricbrownianmotion_samplePath: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly wasmgeometricbrownianmotion_variance: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly wasmgeometricca_addGlider: (a: number, b: number, c: number) => [number, number];
   readonly wasmgeometricca_addRandomPattern: (a: number, b: number) => [number, number];
   readonly wasmgeometricca_generation: (a: number) => number;
@@ -2945,6 +3209,12 @@ export interface InitOutput {
   readonly wasmgpuoptimizer_isGpuAvailable: (a: number) => number;
   readonly wasmgpuoptimizer_optimizeBatch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
   readonly wasmgpuoptimizer_optimizeQuadraticGpu: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+  readonly wasmgradeprojecteddistribution_getMean: (a: number) => [number, number];
+  readonly wasmgradeprojecteddistribution_getNumComponents: (a: number) => number;
+  readonly wasmgradeprojecteddistribution_getStdDevs: (a: number) => [number, number];
+  readonly wasmgradeprojecteddistribution_new: (a: number, b: number) => [number, number, number];
+  readonly wasmgradeprojecteddistribution_sample: (a: number) => [number, number];
+  readonly wasmgradeprojecteddistribution_sampleFull: (a: number) => [number, number];
   readonly wasmgrassmannian_getDimension: (a: number) => number;
   readonly wasmgrassmannian_getParameters: (a: number) => [number, number];
   readonly wasmgrassmannian_new: (a: number, b: number) => [number, number, number];
@@ -2967,6 +3237,15 @@ export interface InitOutput {
   readonly wasmlebesguemeasure_measureBox: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmlebesguemeasure_measureInterval: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly wasmlebesguemeasure_new: (a: number) => [number, number, number];
+  readonly wasmmcmcdiagnostics_getEffectiveSampleSize: (a: number) => number;
+  readonly wasmmcmcdiagnostics_getRHat: (a: number) => number;
+  readonly wasmmcmcdiagnostics_isConverged: (a: number) => number;
+  readonly wasmmetropolishastings_diagnostics: (a: number) => number;
+  readonly wasmmetropolishastings_getAcceptanceRate: (a: number) => number;
+  readonly wasmmetropolishastings_getCurrent: (a: number) => [number, number];
+  readonly wasmmetropolishastings_new: (a: number, b: number) => number;
+  readonly wasmmetropolishastings_run: (a: number, b: number, c: number) => [number, number];
+  readonly wasmmetropolishastings_step: (a: number) => [number, number];
   readonly wasmmodulispace_expectedDimension: (a: number) => number;
   readonly wasmmodulispace_getMarkedPoints: (a: number) => number;
   readonly wasmmodulispace_isProper: (a: number) => number;
@@ -3136,6 +3415,16 @@ export interface InitOutput {
   readonly wasmtropicalviterbi_decode: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmtropicalviterbi_forward_probabilities: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmtropicalviterbi_new: (a: any, b: any) => [number, number, number];
+  readonly wasmuncertainmultivector_add: (a: number, b: number) => number;
+  readonly wasmuncertainmultivector_deterministic: (a: number, b: number) => [number, number, number];
+  readonly wasmuncertainmultivector_getCovariance: (a: number) => [number, number];
+  readonly wasmuncertainmultivector_getMean: (a: number) => [number, number];
+  readonly wasmuncertainmultivector_getStdDevs: (a: number) => [number, number];
+  readonly wasmuncertainmultivector_getTotalVariance: (a: number) => number;
+  readonly wasmuncertainmultivector_getVariances: (a: number) => [number, number];
+  readonly wasmuncertainmultivector_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmuncertainmultivector_scale: (a: number, b: number) => number;
+  readonly wasmuncertainmultivector_withCovariance: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly wasmuniformmultivector_getLower: (a: number) => [number, number];
   readonly wasmuniformmultivector_getMean: (a: number) => [number, number];
   readonly wasmuniformmultivector_getUpper: (a: number) => [number, number];
@@ -3146,9 +3435,12 @@ export interface InitOutput {
   readonly wasmuniformmultivector_sample: (a: number) => [number, number];
   readonly wasmuniformmultivector_sampleBatch: (a: number, b: number) => [number, number];
   readonly wasmuniformmultivector_withBounds: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmwienerprocess_new: (a: number) => number;
+  readonly wasmwienerprocess_samplePath: (a: number, b: number, c: number) => [number, number];
   readonly wasmtropicalnumber_new: (a: number) => number;
   readonly vectorfield_fromFunction2D: (a: any) => number;
   readonly vectorfield_fromFunction3D: (a: any) => number;
+  readonly __wbg_set_wasmtrajectorypoint_time: (a: number, b: number) => void;
   readonly wasmmultivector_norm: (a: number) => number;
   readonly wasmspacetimevector_t: (a: number) => number;
   readonly wasmtropicalnumber_zero: () => number;
@@ -3160,13 +3452,18 @@ export interface InitOutput {
   readonly __wbg_wasmprobabilitymeasure_free: (a: number, b: number) => void;
   readonly __wbg_vectorfield_free: (a: number, b: number) => void;
   readonly vectorfield_new: (a: any, b: number) => number;
+  readonly wasmgeometricbrownianmotion_new: (a: number, b: number) => number;
   readonly wasmtropicalnumber_isZero: (a: number) => number;
   readonly wasmtropicalnumber_tropicalAdd: (a: number, b: number) => number;
+  readonly __wbg_get_wasmtrajectorypoint_time: (a: number) => number;
   readonly wasmcommunity_cohesion_score: (a: number) => number;
   readonly wasmdualnumber_getReal: (a: number) => number;
   readonly wasmevaluationresult_getBestPathScore: (a: number) => number;
   readonly wasmevaluationresult_getGradientNorm: (a: number) => number;
+  readonly wasmgeometricbrownianmotion_getMu: (a: number) => number;
+  readonly wasmgeometricbrownianmotion_getSigma: (a: number) => number;
   readonly wasmgeometricedge_weight: (a: number) => number;
+  readonly wasmgradeprojecteddistribution_getGrade: (a: number) => number;
   readonly wasmmodulispace_getGenus: (a: number) => number;
   readonly wasmmultidualnumber_getReal: (a: number) => number;
   readonly wasmoptimizationresult_iterations: (a: number) => number;
@@ -3180,6 +3477,7 @@ export interface InitOutput {
   readonly wasmtropicalcurve_getGenus: (a: number) => number;
   readonly wasmtropicalnetwork_getSize: (a: number) => number;
   readonly wasmtropicalnumber_getValue: (a: number) => number;
+  readonly wasmwienerprocess_getDim: (a: number) => number;
   readonly __wbg_automatabatchoperations_free: (a: number, b: number) => void;
   readonly __wbg_automatautils_free: (a: number, b: number) => void;
   readonly __wbg_batchoperations_free: (a: number, b: number) => void;
@@ -3199,6 +3497,7 @@ export interface InitOutput {
   readonly __wbg_wasmcountingmeasure_free: (a: number, b: number) => void;
   readonly __wbg_wasmdualnumber_free: (a: number, b: number) => void;
   readonly __wbg_wasmfourvelocity_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgeometricbrownianmotion_free: (a: number, b: number) => void;
   readonly __wbg_wasmgeometricedge_free: (a: number, b: number) => void;
   readonly __wbg_wasmgpuoptimizer_free: (a: number, b: number) => void;
   readonly __wbg_wasmmontecarloestimator_free: (a: number, b: number) => void;
@@ -3206,11 +3505,13 @@ export interface InitOutput {
   readonly __wbg_wasmoptimizationutils_free: (a: number, b: number) => void;
   readonly __wbg_wasmprojectivespace_free: (a: number, b: number) => void;
   readonly __wbg_wasmrelativisticconstants_free: (a: number, b: number) => void;
+  readonly __wbg_wasmschwarzschildmetric_free: (a: number, b: number) => void;
   readonly __wbg_wasmsimpleoptimizer_free: (a: number, b: number) => void;
   readonly __wbg_wasmspacetimevector_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalcurve_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalmeasure_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalnumber_free: (a: number, b: number) => void;
+  readonly __wbg_wasmwienerprocess_free: (a: number, b: number) => void;
   readonly __wbg_wasmmultiobjectiveresult_free: (a: number, b: number) => void;
   readonly wasmrotor_inverse: (a: number) => number;
   readonly __wbg_wasmrotor_free: (a: number, b: number) => void;

package/amari_wasm.js

@@ -432,7 +432,7 @@ function __wbg_adapter_28(arg0, arg1, arg2) {
     wasm.closure41_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_511(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_550(arg0, arg1, arg2, arg3) {
     wasm.closure34_externref_shim(arg0, arg1, arg2, arg3);
 }
 
@@ -3604,6 +3604,126 @@ export class WasmGeodesicIntegrator {
     }
 }
 
+const WasmGeometricBrownianMotionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgeometricbrownianmotion_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Geometric Brownian Motion on multivector space
+ *
+ * dX = μX dt + σX dW
+ *
+ * Useful for modeling multiplicative noise processes in geometric algebra.
+ */
+export class WasmGeometricBrownianMotion {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGeometricBrownianMotionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgeometricbrownianmotion_free(ptr, 0);
+    }
+    /**
+     * Sample a single path of the process
+     *
+     * # Arguments
+     * * `initial` - Initial multivector (8 coefficients)
+     * * `t_end` - End time
+     * * `num_steps` - Number of time steps
+     *
+     * Returns flat array: (num_steps + 1) * 9 values
+     * Each point is [time, coeff0, coeff1, ..., coeff7]
+     * @param {Float64Array} initial
+     * @param {number} t_end
+     * @param {number} num_steps
+     * @returns {Float64Array}
+     */
+    samplePath(initial, t_end, num_steps) {
+        const ptr0 = passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgeometricbrownianmotion_samplePath(this.__wbg_ptr, ptr0, len0, t_end, num_steps);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Compute expected value at time t given initial value
+     *
+     * E[X(t)] = X(0) * exp(μt)
+     * @param {Float64Array} initial
+     * @param {number} t
+     * @returns {Float64Array}
+     */
+    expectedValue(initial, t) {
+        const ptr0 = passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgeometricbrownianmotion_expectedValue(this.__wbg_ptr, ptr0, len0, t);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Create a new Geometric Brownian Motion process
+     *
+     * # Arguments
+     * * `mu` - Drift coefficient (expected growth rate)
+     * * `sigma` - Diffusion coefficient (volatility)
+     * @param {number} mu
+     * @param {number} sigma
+     */
+    constructor(mu, sigma) {
+        const ret = wasm.wasmdualnumber_new(mu, sigma);
+        this.__wbg_ptr = ret >>> 0;
+        WasmGeometricBrownianMotionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get drift coefficient
+     * @returns {number}
+     */
+    getMu() {
+        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compute variance at time t given initial value
+     *
+     * Var(X(t)) = X(0)² * exp(2μt) * (exp(σ²t) - 1)
+     * @param {Float64Array} initial
+     * @param {number} t
+     * @returns {Float64Array}
+     */
+    variance(initial, t) {
+        const ptr0 = passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgeometricbrownianmotion_variance(this.__wbg_ptr, ptr0, len0, t);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Get diffusion coefficient
+     * @returns {number}
+     */
+    getSigma() {
+        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
+        return ret;
+    }
+}
+
 const WasmGeometricCAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgeometricca_free(ptr >>> 0, 1));
@@ -4183,6 +4303,108 @@ export class WasmGpuOptimizer {
     }
 }
 
+const WasmGradeProjectedDistributionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgradeprojecteddistribution_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for grade-projected distribution
+ *
+ * A distribution that only operates on components of a specific grade.
+ */
+export class WasmGradeProjectedDistribution {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGradeProjectedDistributionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgradeprojecteddistribution_free(ptr, 0);
+    }
+    /**
+     * Sample and embed into full multivector (other grades are zero)
+     *
+     * Returns 8 coefficients
+     * @returns {Float64Array}
+     */
+    sampleFull() {
+        const ret = wasm.wasmgradeprojecteddistribution_sampleFull(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get standard deviations
+     * @returns {Float64Array}
+     */
+    getStdDevs() {
+        const ret = wasm.wasmgradeprojecteddistribution_getStdDevs(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get number of components in this grade
+     * @returns {number}
+     */
+    getNumComponents() {
+        const ret = wasm.wasmgradeprojecteddistribution_getNumComponents(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a grade-projected distribution from a Gaussian
+     *
+     * # Arguments
+     * * `gaussian` - Source Gaussian distribution
+     * * `grade` - Grade to project onto (0, 1, 2, or 3 for Cl(3,0,0))
+     * @param {WasmGaussianMultivector} gaussian
+     * @param {number} grade
+     */
+    constructor(gaussian, grade) {
+        _assertClass(gaussian, WasmGaussianMultivector);
+        const ret = wasm.wasmgradeprojecteddistribution_new(gaussian.__wbg_ptr, grade);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmGradeProjectedDistributionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sample from this grade-projected distribution
+     *
+     * Returns components for just this grade
+     * @returns {Float64Array}
+     */
+    sample() {
+        const ret = wasm.wasmgradeprojecteddistribution_sample(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the mean for this grade's components
+     * @returns {Float64Array}
+     */
+    getMean() {
+        const ret = wasm.wasmgradeprojecteddistribution_getMean(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the grade
+     * @returns {number}
+     */
+    getGrade() {
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const WasmGrassmannianFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgrassmannian_free(ptr >>> 0, 1));
@@ -4535,6 +4757,184 @@ export class WasmLebesgueMeasure {
     }
 }
 
+const WasmMCMCDiagnosticsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmcmcdiagnostics_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for MCMC diagnostics
+ */
+export class WasmMCMCDiagnostics {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmMCMCDiagnostics.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmMCMCDiagnosticsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMCMCDiagnosticsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmcmcdiagnostics_free(ptr, 0);
+    }
+    /**
+     * Total number of steps
+     * @returns {number}
+     */
+    get num_steps() {
+        const ret = wasm.__wbg_get_wasmmcmcdiagnostics_num_steps(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Total number of steps
+     * @param {number} arg0
+     */
+    set num_steps(arg0) {
+        wasm.__wbg_set_wasmmcmcdiagnostics_num_steps(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Acceptance rate
+     * @returns {number}
+     */
+    get acceptance_rate() {
+        const ret = wasm.__wbg_get_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Acceptance rate
+     * @param {number} arg0
+     */
+    set acceptance_rate(arg0) {
+        wasm.__wbg_set_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Check if the sampler has converged (R-hat < 1.1)
+     * @returns {boolean}
+     */
+    isConverged() {
+        const ret = wasm.wasmmcmcdiagnostics_isConverged(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get effective sample size (or -1 if not computed)
+     * @returns {number}
+     */
+    getEffectiveSampleSize() {
+        const ret = wasm.wasmmcmcdiagnostics_getEffectiveSampleSize(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get R-hat statistic (or -1 if not computed)
+     * @returns {number}
+     */
+    getRHat() {
+        const ret = wasm.wasmmcmcdiagnostics_getRHat(this.__wbg_ptr);
+        return ret;
+    }
+}
+
+const WasmMetropolisHastingsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmetropolishastings_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Metropolis-Hastings MCMC sampler
+ *
+ * Samples from a target distribution using random-walk proposals.
+ */
+export class WasmMetropolisHastings {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMetropolisHastingsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmetropolishastings_free(ptr, 0);
+    }
+    /**
+     * Get sampling diagnostics
+     * @returns {WasmMCMCDiagnostics}
+     */
+    diagnostics() {
+        const ret = wasm.wasmmetropolishastings_diagnostics(this.__wbg_ptr);
+        return WasmMCMCDiagnostics.__wrap(ret);
+    }
+    /**
+     * Get current sample
+     * @returns {Float64Array}
+     */
+    getCurrent() {
+        const ret = wasm.wasmmetropolishastings_getCurrent(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get current acceptance rate
+     * @returns {number}
+     */
+    getAcceptanceRate() {
+        const ret = wasm.wasmmetropolishastings_getAcceptanceRate(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a new Metropolis-Hastings sampler for a Gaussian target
+     *
+     * # Arguments
+     * * `target` - The target Gaussian distribution to sample from
+     * * `proposal_std` - Standard deviation for the proposal distribution
+     * @param {WasmGaussianMultivector} target
+     * @param {number} proposal_std
+     */
+    constructor(target, proposal_std) {
+        _assertClass(target, WasmGaussianMultivector);
+        const ret = wasm.wasmmetropolishastings_new(target.__wbg_ptr, proposal_std);
+        this.__wbg_ptr = ret >>> 0;
+        WasmMetropolisHastingsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Run the sampler for multiple steps
+     *
+     * # Arguments
+     * * `num_samples` - Number of samples to collect
+     * * `burnin` - Number of burn-in steps to discard
+     *
+     * Returns flat array of samples (num_samples * 8)
+     * @param {number} num_samples
+     * @param {number} burnin
+     * @returns {Float64Array}
+     */
+    run(num_samples, burnin) {
+        const ret = wasm.wasmmetropolishastings_run(this.__wbg_ptr, num_samples, burnin);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Take a single MCMC step
+     *
+     * Returns the new sample (8 coefficients)
+     * @returns {Float64Array}
+     */
+    step() {
+        const ret = wasm.wasmmetropolishastings_step(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+
 const WasmModuliSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmmodulispace_free(ptr >>> 0, 1));
@@ -6506,7 +6906,7 @@ export class WasmTrajectoryPoint {
      * @returns {number}
      */
     get time() {
-        const ret = wasm.__wbg_get_wasmtrajectorypoint_time(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -6514,7 +6914,7 @@ export class WasmTrajectoryPoint {
      * @param {number} arg0
      */
     set time(arg0) {
-        wasm.__wbg_set_wasmtrajectorypoint_time(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr, arg0);
     }
     /**
      * Get position
@@ -7402,6 +7802,166 @@ export class WasmTropicalViterbi {
     }
 }
 
+const WasmUncertainMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmuncertainmultivector_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for uncertain multivector (mean + covariance)
+ *
+ * Represents a multivector with associated uncertainty, useful for
+ * error propagation through geometric operations.
+ */
+export class WasmUncertainMultivector {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmUncertainMultivector.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmUncertainMultivectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmUncertainMultivectorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmuncertainmultivector_free(ptr, 0);
+    }
+    /**
+     * Get standard deviations
+     * @returns {Float64Array}
+     */
+    getStdDevs() {
+        const ret = wasm.wasmuncertainmultivector_getStdDevs(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a deterministic (zero variance) uncertain multivector
+     * @param {Float64Array} value
+     * @returns {WasmUncertainMultivector}
+     */
+    static deterministic(value) {
+        const ptr0 = passArrayF64ToWasm0(value, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuncertainmultivector_deterministic(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmUncertainMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Get variances (diagonal of covariance)
+     * @returns {Float64Array}
+     */
+    getVariances() {
+        const ret = wasm.wasmuncertainmultivector_getVariances(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the covariance matrix (64 values, row-major)
+     * @returns {Float64Array}
+     */
+    getCovariance() {
+        const ret = wasm.wasmuncertainmultivector_getCovariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create with full covariance matrix
+     *
+     * # Arguments
+     * * `mean` - 8 coefficients for the mean
+     * * `covariance` - 64 values for 8x8 covariance matrix (row-major)
+     * @param {Float64Array} mean
+     * @param {Float64Array} covariance
+     * @returns {WasmUncertainMultivector}
+     */
+    static withCovariance(mean, covariance) {
+        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(covariance, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuncertainmultivector_withCovariance(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmUncertainMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Get total variance (trace of covariance)
+     * @returns {number}
+     */
+    getTotalVariance() {
+        const ret = wasm.wasmuncertainmultivector_getTotalVariance(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Add two uncertain multivectors (assuming independence)
+     *
+     * For Z = X + Y: E[Z] = E[X] + E[Y], Var(Z) = Var(X) + Var(Y)
+     * @param {WasmUncertainMultivector} other
+     * @returns {WasmUncertainMultivector}
+     */
+    add(other) {
+        _assertClass(other, WasmUncertainMultivector);
+        const ret = wasm.wasmuncertainmultivector_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmUncertainMultivector.__wrap(ret);
+    }
+    /**
+     * Create an uncertain multivector with diagonal covariance
+     *
+     * # Arguments
+     * * `mean` - 8 coefficients for the mean
+     * * `variances` - 8 values for per-coefficient variance
+     * @param {Float64Array} mean
+     * @param {Float64Array} variances
+     */
+    constructor(mean, variances) {
+        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(variances, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuncertainmultivector_new(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmUncertainMultivectorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Linear propagation: scale by a constant
+     *
+     * For Y = aX: E[Y] = aE[X], Var(Y) = a²Var(X)
+     * @param {number} scalar
+     * @returns {WasmUncertainMultivector}
+     */
+    scale(scalar) {
+        const ret = wasm.wasmuncertainmultivector_scale(this.__wbg_ptr, scalar);
+        return WasmUncertainMultivector.__wrap(ret);
+    }
+    /**
+     * Get the mean
+     * @returns {Float64Array}
+     */
+    getMean() {
+        const ret = wasm.wasmuncertainmultivector_getMean(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+
 const WasmUniformMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmuniformmultivector_free(ptr >>> 0, 1));
@@ -7560,6 +8120,69 @@ export class WasmUniformMultivector {
     }
 }
 
+const WasmWienerProcessFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmwienerprocess_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Wiener process (Brownian motion)
+ *
+ * Standard Brownian motion W(t) with W(0) = 0
+ */
+export class WasmWienerProcess {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmWienerProcessFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmwienerprocess_free(ptr, 0);
+    }
+    /**
+     * Sample a path of the Wiener process
+     *
+     * # Arguments
+     * * `t_end` - End time
+     * * `num_steps` - Number of time steps
+     *
+     * Returns flat array: (num_steps + 1) * (dim + 1) values
+     * Each point is [time, w0, w1, ...]
+     * @param {number} t_end
+     * @param {number} num_steps
+     * @returns {Float64Array}
+     */
+    samplePath(t_end, num_steps) {
+        const ret = wasm.wasmwienerprocess_samplePath(this.__wbg_ptr, t_end, num_steps);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a new Wiener process
+     *
+     * # Arguments
+     * * `dim` - Dimension of the process (default 8 for multivector space)
+     * @param {number | null} [dim]
+     */
+    constructor(dim) {
+        const ret = wasm.wasmwienerprocess_new(isLikeNone(dim) ? 0x100000001 : (dim) >>> 0);
+        this.__wbg_ptr = ret >>> 0;
+        WasmWienerProcessFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get dimension
+     * @returns {number}
+     */
+    getDim() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
@@ -7641,12 +8264,12 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_7696259bf4d9d36d = 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;
@@ -7666,7 +8289,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_511(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_550(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -7766,7 +8389,7 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper1647 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper1708 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 40, __wbg_adapter_28);
         return ret;
     };

package/package.json

@@ -5,7 +5,7 @@
     "Amari Contributors"
   ],
   "description": "WebAssembly bindings for Amari mathematical computing library - geometric algebra, tropical algebra, automatic differentiation, measure theory, fusion systems, and information geometry",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",