@justinelliottcobb/amari-wasm 0.13.0 → 0.15.1

package/amari_wasm.d.ts

@@ -4,6 +4,37 @@
  * Initialize the WASM module
  */
 export function init(): void;
+/**
+ * Power method for computing dominant eigenvalue
+ *
+ * # Arguments
+ * * `matrix` - The matrix operator
+ * * `initial` - Initial guess (optional, uses random if not provided)
+ * * `max_iterations` - Maximum iterations
+ * * `tolerance` - Convergence tolerance
+ *
+ * # Returns
+ * [eigenvalue, eigenvector...] flattened array
+ */
+export function powerMethod(matrix: WasmMatrixOperator, initial: Float64Array | null | undefined, max_iterations: number, tolerance: number): Float64Array;
+/**
+ * Inverse iteration for computing eigenvalue near a shift
+ *
+ * # Arguments
+ * * `matrix` - The matrix operator
+ * * `shift` - Value near the desired eigenvalue
+ * * `initial` - Initial guess (optional)
+ * * `max_iterations` - Maximum iterations
+ * * `tolerance` - Convergence tolerance
+ *
+ * # Returns
+ * [eigenvalue, eigenvector...] flattened array
+ */
+export function inverseIteration(matrix: WasmMatrixOperator, shift: number, initial: Float64Array | null | undefined, max_iterations: number, tolerance: number): Float64Array;
+/**
+ * Compute all eigenvalues of a symmetric matrix
+ */
+export function computeEigenvalues(matrix: WasmMatrixOperator, max_iterations: number, tolerance: number): Float64Array;
 /**
  * Initialize the enumerative geometry module
  */
@@ -835,6 +866,82 @@ export class WasmAlphaConnection {
    */
   getAlpha(): number;
 }
+/**
+ * WASM wrapper for BinaryHologram.
+ *
+ * Bit-packed binary pattern for DMD display, the output of Lee encoding.
+ */
+export class WasmBinaryHologram {
+  free(): void;
+  /**
+   * Fill factor (fraction of "on" pixels, 0 to 1).
+   */
+  fillFactor(): number;
+  /**
+   * Compute Hamming distance between two holograms.
+   */
+  hammingDistance(other: WasmBinaryHologram): number;
+  /**
+   * Compute normalized Hamming distance (0 to 1).
+   */
+  normalizedHammingDistance(other: WasmBinaryHologram): number;
+  /**
+   * Get pixel value at (x, y).
+   */
+  get(x: number, y: number): boolean;
+  /**
+   * Create from boolean array (as u8: 0 = false, non-zero = true).
+   */
+  constructor(pattern: Uint8Array, width: number, height: number);
+  /**
+   * Set pixel value at (x, y).
+   */
+  set(x: number, y: number, value: boolean): void;
+  /**
+   * XOR two holograms.
+   */
+  xor(other: WasmBinaryHologram): WasmBinaryHologram;
+  /**
+   * Create an all-ones hologram.
+   */
+  static ones(width: number, height: number): WasmBinaryHologram;
+  /**
+   * Create an all-zeros hologram.
+   */
+  static zeros(width: number, height: number): WasmBinaryHologram;
+  /**
+   * Toggle pixel at (x, y).
+   */
+  toggle(x: number, y: number): void;
+  /**
+   * Get packed binary data (for hardware interface).
+   */
+  asBytes(): Uint8Array;
+  /**
+   * Create an inverted copy.
+   */
+  inverted(): WasmBinaryHologram;
+  /**
+   * Count of "on" pixels.
+   */
+  popcount(): number;
+  /**
+   * Convert to boolean array (as u8: 0 = false, 1 = true).
+   */
+  toBools(): Uint8Array;
+  /**
+   * Get grid width.
+   */
+  readonly width: number;
+  /**
+   * Get grid height.
+   */
+  readonly height: number;
+  /**
+   * Get total number of pixels.
+   */
+  readonly length: number;
+}
 /**
  * WASM wrapper for Chow classes in intersection theory
  */
@@ -1260,6 +1367,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
  */
@@ -1348,6 +1505,56 @@ export class WasmGeometricEdge {
    */
   readonly weight: number;
 }
+/**
+ * WASM wrapper for GeometricLeeEncoder.
+ *
+ * Encodes optical rotor fields to binary holograms using Lee's method.
+ */
+export class WasmGeometricLeeEncoder {
+  free(): void;
+  /**
+   * Create encoder with horizontal carrier (angle = 0).
+   */
+  static withFrequency(width: number, height: number, carrier_frequency: number): WasmGeometricLeeEncoder;
+  /**
+   * Theoretical diffraction efficiency for the given field.
+   */
+  theoreticalEfficiency(field: WasmOpticalRotorField): number;
+  /**
+   * Create encoder with configuration.
+   *
+   * # Arguments
+   * * `width` - Grid width
+   * * `height` - Grid height
+   * * `carrier_frequency` - Carrier frequency in cycles per pixel
+   * * `carrier_angle` - Carrier direction angle (radians, 0 = horizontal)
+   */
+  constructor(width: number, height: number, carrier_frequency: number, carrier_angle: number);
+  /**
+   * Encode a rotor field to binary hologram.
+   */
+  encode(field: WasmOpticalRotorField): WasmBinaryHologram;
+  /**
+   * Compute the modulated rotor field (before thresholding).
+   */
+  modulate(field: WasmOpticalRotorField): WasmOpticalRotorField;
+  /**
+   * Get carrier angle.
+   */
+  readonly carrierAngle: number;
+  /**
+   * Get carrier frequency.
+   */
+  readonly carrierFrequency: number;
+  /**
+   * Get encoder width.
+   */
+  readonly width: number;
+  /**
+   * Get encoder height.
+   */
+  readonly height: number;
+}
 /**
  * WASM wrapper for geometric networks
  */
@@ -1460,6 +1667,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
  */
@@ -1478,6 +1729,57 @@ export class WasmGrassmannian {
    */
   constructor(k: number, n: number);
 }
+/**
+ * WASM wrapper for MultivectorHilbertSpace over Cl(2,0,0)
+ *
+ * Provides finite-dimensional Hilbert space operations on multivectors.
+ */
+export class WasmHilbertSpace {
+  free(): void;
+  /**
+   * Compute inner product <x, y>
+   */
+  innerProduct(x: Float64Array, y: Float64Array): number;
+  /**
+   * Check if two vectors are orthogonal
+   */
+  isOrthogonal(x: Float64Array, y: Float64Array, tolerance: number): boolean;
+  /**
+   * Create a multivector from coefficients
+   *
+   * # Arguments
+   * * `coefficients` - Array of 4 coefficients [scalar, e1, e2, e12]
+   */
+  fromCoefficients(coefficients: Float64Array): Float64Array;
+  /**
+   * Create a new Hilbert space Cl(2,0,0) ~ R^4
+   */
+  constructor();
+  /**
+   * Compute the norm ||x||
+   */
+  norm(x: Float64Array): number;
+  /**
+   * Orthogonal projection of x onto y
+   */
+  project(x: Float64Array, y: Float64Array): Float64Array;
+  /**
+   * Compute distance d(x, y) = ||x - y||
+   */
+  distance(x: Float64Array, y: Float64Array): number;
+  /**
+   * Get the dimension of the space (4 for Cl(2,0,0))
+   */
+  dimension(): number;
+  /**
+   * Normalize a vector to unit length
+   */
+  normalize(x: Float64Array): Float64Array;
+  /**
+   * Get the Clifford algebra signature (p, q, r)
+   */
+  signature(): Uint32Array;
+}
 /**
  * WASM wrapper for HolographicMemory using ProductClifford algebra
  */
@@ -1585,6 +1887,148 @@ 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 matrix operators on Hilbert spaces
+ *
+ * Represents bounded linear operators as matrices.
+ */
+export class WasmMatrixOperator {
+  free(): void;
+  /**
+   * Get the matrix entries as a flat array (row-major)
+   */
+  getEntries(): Float64Array;
+  /**
+   * Check if the matrix is symmetric
+   */
+  isSymmetric(tolerance: number): boolean;
+  /**
+   * Compute operator norm ||T||
+   */
+  operatorNorm(): number;
+  /**
+   * Add two operators
+   */
+  add(other: WasmMatrixOperator): WasmMatrixOperator;
+  /**
+   * Create a matrix operator from a flattened row-major matrix
+   *
+   * # Arguments
+   * * `entries` - 16 entries for a 4x4 matrix in row-major order
+   */
+  constructor(entries: Float64Array);
+  /**
+   * Create a zero operator
+   */
+  static zero(): WasmMatrixOperator;
+  /**
+   * Apply the operator to a vector: T(x)
+   */
+  apply(x: Float64Array): Float64Array;
+  /**
+   * Scale operator by scalar
+   */
+  scale(lambda: number): WasmMatrixOperator;
+  /**
+   * Compute the trace
+   */
+  trace(): number;
+  /**
+   * Compose two operators (matrix multiplication)
+   */
+  compose(other: WasmMatrixOperator): WasmMatrixOperator;
+  /**
+   * Create a scaling operator (λI)
+   */
+  static scaling(lambda: number): WasmMatrixOperator;
+  /**
+   * Create a diagonal matrix from diagonal entries
+   */
+  static diagonal(entries: Float64Array): WasmMatrixOperator;
+  /**
+   * Create the identity operator
+   */
+  static identity(): WasmMatrixOperator;
+  /**
+   * Get a single matrix entry at (i, j)
+   */
+  getEntry(i: number, j: number): number;
+  /**
+   * Compute the transpose
+   */
+  transpose(): WasmMatrixOperator;
+}
+/**
+ * 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)
  */
@@ -1859,6 +2303,234 @@ export class WasmNodeMetadata {
    */
   set label(value: string | null | undefined);
 }
+/**
+ * WASM wrapper for OpticalCodebook.
+ *
+ * Maps symbols to deterministically-generated rotor fields.
+ */
+export class WasmOpticalCodebook {
+  free(): void;
+  /**
+   * Clear the field cache (seeds retained).
+   */
+  clearCache(): void;
+  /**
+   * Register multiple symbols at once.
+   */
+  registerAll(symbols: string[]): void;
+  /**
+   * Register a symbol with specific seed.
+   */
+  registerWithSeed(symbol: string, seed: bigint): void;
+  /**
+   * Get or generate field for a symbol.
+   */
+  get(symbol: string): WasmOpticalRotorField | undefined;
+  /**
+   * Create a new codebook.
+   *
+   * # Arguments
+   * * `width` - Field grid width
+   * * `height` - Field grid height
+   * * `base_seed` - Base seed for deterministic generation
+   */
+  constructor(width: number, height: number, base_seed: bigint);
+  /**
+   * Remove a symbol from the codebook.
+   */
+  remove(symbol: string): boolean;
+  /**
+   * Get all registered symbol names.
+   */
+  symbols(): string[];
+  /**
+   * Check if a symbol is registered.
+   */
+  contains(symbol: string): boolean;
+  /**
+   * Generate field without caching.
+   */
+  generate(symbol: string): WasmOpticalRotorField | undefined;
+  /**
+   * Get the seed for a registered symbol.
+   */
+  getSeed(symbol: string): bigint | undefined;
+  /**
+   * Check if codebook is empty.
+   */
+  isEmpty(): boolean;
+  /**
+   * Register a symbol with auto-generated seed.
+   */
+  register(symbol: string): void;
+  /**
+   * Number of registered symbols.
+   */
+  readonly length: number;
+}
+/**
+ * WASM wrapper for OpticalFieldAlgebra.
+ *
+ * Provides VSA operations on rotor fields: bind, bundle, similarity, inverse.
+ */
+export class WasmOpticalFieldAlgebra {
+  free(): void;
+  /**
+   * Compute the average phase (circular mean) of a field.
+   */
+  meanPhase(field: WasmOpticalRotorField): number;
+  /**
+   * Compute similarity between two fields.
+   *
+   * Returns normalized inner product.
+   * Range: [-1, 1], where 1 = identical phase.
+   */
+  similarity(a: WasmOpticalRotorField, b: WasmOpticalRotorField): number;
+  /**
+   * Bundle with uniform weights (1/n).
+   */
+  bundleUniform(fields: WasmOpticalRotorField[]): WasmOpticalRotorField;
+  /**
+   * Compute phase variance (circular variance) of a field.
+   */
+  phaseVariance(field: WasmOpticalRotorField): number;
+  /**
+   * Create new algebra instance for fields of the given dimensions.
+   */
+  constructor(width: number, height: number);
+  /**
+   * Bind two fields (pointwise rotor product).
+   *
+   * Creates an association: bound = A ⊗ B.
+   * Unbind with: B ≈ inverse(A) ⊗ bound.
+   */
+  bind(a: WasmOpticalRotorField, b: WasmOpticalRotorField): WasmOpticalRotorField;
+  /**
+   * Scale a field's amplitude by a constant factor.
+   */
+  scale(field: WasmOpticalRotorField, factor: number): WasmOpticalRotorField;
+  /**
+   * Bundle multiple fields (weighted superposition).
+   *
+   * # Arguments
+   * * `fields` - Flattened array of field data (scalars, bivectors, amplitudes for each field)
+   * * `weights` - Weights for each field
+   * * `field_count` - Number of fields
+   */
+  bundle(fields: WasmOpticalRotorField[], weights: Float32Array): WasmOpticalRotorField;
+  /**
+   * Create random field.
+   */
+  random(seed: bigint): WasmOpticalRotorField;
+  /**
+   * Unbind operation: retrieve associated value.
+   *
+   * Given `bound = bind(key, value)`, calling `unbind(key, bound)`
+   * returns (approximately) `value`.
+   */
+  unbind(key: WasmOpticalRotorField, bound: WasmOpticalRotorField): WasmOpticalRotorField;
+  /**
+   * Compute inverse field (rotor reverse).
+   *
+   * For rotors: R^(-1) = R^† = cos(φ) - sin(φ)·e₁₂
+   */
+  inverse(field: WasmOpticalRotorField): WasmOpticalRotorField;
+  /**
+   * Create identity field (phase = 0, amplitude = 1).
+   */
+  identity(): WasmOpticalRotorField;
+  /**
+   * Add a constant phase to all pixels.
+   */
+  addPhase(field: WasmOpticalRotorField, phase: number): WasmOpticalRotorField;
+  /**
+   * Get algebra width.
+   */
+  readonly width: number;
+  /**
+   * Get algebra height.
+   */
+  readonly height: number;
+}
+/**
+ * WASM wrapper for OpticalRotorField.
+ *
+ * Represents an optical wavefront as a grid of rotors in Cl(2,0).
+ * Each point has phase (rotor angle) and amplitude components.
+ */
+export class WasmOpticalRotorField {
+  free(): void;
+  /**
+   * Create from phase array with uniform amplitude of 1.0.
+   */
+  static fromPhase(phase: Float32Array, width: number, height: number): WasmOpticalRotorField;
+  /**
+   * Create a normalized copy (total energy = 1).
+   */
+  normalized(): WasmOpticalRotorField;
+  /**
+   * Clone this field.
+   */
+  clone(): WasmOpticalRotorField;
+  /**
+   * Get all scalar (cos φ) components.
+   */
+  getScalars(): Float32Array;
+  /**
+   * Get amplitude at a point.
+   */
+  amplitudeAt(x: number, y: number): number;
+  /**
+   * Compute total energy (sum of squared amplitudes).
+   */
+  totalEnergy(): number;
+  /**
+   * Get all bivector (sin φ) components.
+   */
+  getBivectors(): Float32Array;
+  /**
+   * Get all amplitude components.
+   */
+  getAmplitudes(): Float32Array;
+  /**
+   * Create from phase and amplitude arrays.
+   *
+   * # Arguments
+   * * `phase` - Phase values in radians (length = width * height)
+   * * `amplitude` - Amplitude values (length = width * height)
+   * * `width` - Grid width
+   * * `height` - Grid height
+   */
+  constructor(phase: Float32Array, amplitude: Float32Array, width: number, height: number);
+  /**
+   * Create with random phase (deterministic from seed).
+   */
+  static random(width: number, height: number, seed: bigint): WasmOpticalRotorField;
+  /**
+   * Create uniform field (constant phase and amplitude).
+   */
+  static uniform(phase: number, amplitude: number, width: number, height: number): WasmOpticalRotorField;
+  /**
+   * Create identity field (phase = 0, amplitude = 1).
+   */
+  static identity(width: number, height: number): WasmOpticalRotorField;
+  /**
+   * Get phase at a point (in radians, range [-π, π]).
+   */
+  phaseAt(x: number, y: number): number;
+  /**
+   * Get grid width.
+   */
+  readonly width: number;
+  /**
+   * Get grid height.
+   */
+  readonly height: number;
+  /**
+   * Get total number of points.
+   */
+  readonly length: number;
+}
 /**
  * WASM wrapper for optimization results
  */
@@ -2215,6 +2887,69 @@ export class WasmSimpleOptimizer {
    */
   constructor();
 }
+/**
+ * WASM wrapper for Sobolev spaces H^k
+ *
+ * Provides function spaces with weak derivatives.
+ */
+export class WasmSobolevSpace {
+  free(): void;
+  /**
+   * Compute the H^1 seminorm |f|_{H^1} = ||f'||_{L^2}
+   */
+  h1Seminorm(df: Function): number;
+  /**
+   * Create H^1 over the unit interval [0, 1]
+   */
+  static h1UnitInterval(): WasmSobolevSpace;
+  /**
+   * Create H^2 over the unit interval [0, 1]
+   */
+  static h2UnitInterval(): WasmSobolevSpace;
+  /**
+   * Compute L^2 inner product <f, g>
+   */
+  l2InnerProduct(f: Function, g: Function): number;
+  /**
+   * Compute the Poincare constant estimate for the domain
+   *
+   * For [a,b], this is (b-a)/π
+   */
+  poincareConstant(): number;
+  /**
+   * Set the number of quadrature points
+   */
+  setQuadraturePoints(n: number): void;
+  /**
+   * Create a Sobolev space H^k over an interval [a, b]
+   *
+   * # Arguments
+   * * `order` - The Sobolev regularity (1 for H^1, 2 for H^2)
+   * * `lower` - Lower bound of the interval
+   * * `upper` - Upper bound of the interval
+   */
+  constructor(order: number, lower: number, upper: number);
+  /**
+   * Get the domain bounds [lower, upper]
+   */
+  bounds(): Float64Array;
+  /**
+   * Compute the H^k norm of a function using numerical integration
+   *
+   * # Arguments
+   * * `f` - JavaScript function f(x) to evaluate
+   * * `df` - JavaScript function f'(x) (first derivative)
+   */
+  h1Norm(f: Function, df: Function): number;
+  /**
+   * Compute L^2 norm of a function
+   */
+  l2Norm(f: Function): number;
+  /**
+   * Get the Sobolev order k
+   */
+  order(): number;
+}
 /**
  * WASM wrapper for spacetime vectors
  */
@@ -2273,6 +3008,66 @@ export class WasmSpacetimeVector {
    */
   readonly z: number;
 }
+/**
+ * WASM wrapper for spectral decomposition
+ *
+ * Provides eigenvalue decomposition for symmetric matrices.
+ */
+export class WasmSpectralDecomposition {
+  private constructor();
+  free(): void;
+  /**
+   * Get the eigenvalues
+   */
+  eigenvalues(): Float64Array;
+  /**
+   * Check if the decomposition is complete
+   */
+  isComplete(): boolean;
+  /**
+   * Get the eigenvectors as a flattened array
+   *
+   * Returns 4 eigenvectors of 4 components each (16 total)
+   */
+  eigenvectors(): Float64Array;
+  /**
+   * Apply f(T) = Σᵢ f(λᵢ) Pᵢ to a vector using functional calculus
+   *
+   * # Arguments
+   * * `f` - JavaScript function to apply to eigenvalues
+   * * `x` - Input vector
+   */
+  applyFunction(f: Function, x: Float64Array): Float64Array;
+  /**
+   * Get the spectral radius (largest |eigenvalue|)
+   */
+  spectralRadius(): number;
+  /**
+   * Get the condition number
+   */
+  conditionNumber(): number | undefined;
+  /**
+   * Check if the operator is positive definite
+   */
+  isPositiveDefinite(): boolean;
+  /**
+   * Check if the operator is positive semi-definite
+   */
+  isPositiveSemidefinite(): boolean;
+  /**
+   * Apply the reconstructed operator T = Σᵢ λᵢ Pᵢ to a vector
+   */
+  apply(x: Float64Array): Float64Array;
+  /**
+   * Compute spectral decomposition of a symmetric matrix
+   *
+   * # Arguments
+   * * `matrix` - The symmetric matrix operator to decompose
+   * * `max_iterations` - Maximum iterations for eigenvalue computation
+   * * `tolerance` - Convergence tolerance
+   */
+  static compute(matrix: WasmMatrixOperator, max_iterations: number, tolerance: number): WasmSpectralDecomposition;
+}
 /**
  * Trajectory point for particle propagation
  */
@@ -2586,6 +3381,70 @@ export class WasmTropicalNumber {
    */
   getValue(): number;
 }
+/**
+ * WASM wrapper for TropicalOpticalAlgebra.
+ *
+ * Tropical (min, +) operations on optical fields for attractor dynamics.
+ */
+export class WasmTropicalOpticalAlgebra {
+  free(): void;
+  /**
+   * Tropical addition: pointwise minimum of phase magnitudes.
+   *
+   * For each pixel, selects the rotor with smaller absolute phase.
+   */
+  tropicalAdd(a: WasmOpticalRotorField, b: WasmOpticalRotorField): WasmOpticalRotorField;
+  /**
+   * Tropical maximum: pointwise maximum of phase magnitudes.
+   */
+  tropicalMax(a: WasmOpticalRotorField, b: WasmOpticalRotorField): WasmOpticalRotorField;
+  /**
+   * Tropical multiplication: binding operation (phase addition).
+   */
+  tropicalMul(a: WasmOpticalRotorField, b: WasmOpticalRotorField): WasmOpticalRotorField;
+  /**
+   * Compute phase distance between two fields.
+   *
+   * Returns the sum of absolute phase differences.
+   */
+  phaseDistance(a: WasmOpticalRotorField, b: WasmOpticalRotorField): number;
+  /**
+   * Soft tropical addition using logsumexp-style smoothing.
+   *
+   * # Arguments
+   * * `a`, `b` - Fields to combine
+   * * `beta` - Temperature parameter (large = hard min, small = soft average)
+   */
+  softTropicalAdd(a: WasmOpticalRotorField, b: WasmOpticalRotorField, beta: number): WasmOpticalRotorField;
+  /**
+   * Iterate attractor dynamics until convergence.
+   *
+   * # Arguments
+   * * `initial` - Starting state
+   * * `attractors` - Set of attractor fields
+   * * `max_iterations` - Maximum iterations
+   * * `tolerance` - Convergence tolerance
+   *
+   * Returns (final_state, iterations_taken).
+   */
+  attractorConverge(initial: WasmOpticalRotorField, attractors: WasmOpticalRotorField[], max_iterations: number, tolerance: number): WasmOpticalRotorField;
+  /**
+   * Compute normalized phase distance (average per pixel).
+   */
+  normalizedPhaseDistance(a: WasmOpticalRotorField, b: WasmOpticalRotorField): number;
+  /**
+   * Create new tropical algebra instance for fields of the given dimensions.
+   */
+  constructor(width: number, height: number);
+  /**
+   * Get algebra width.
+   */
+  readonly width: number;
+  /**
+   * Get algebra height.
+   */
+  readonly height: number;
+}
 /**
  * WASM wrapper for TropicalPolynomial - polynomial operations in tropical algebra
  */
@@ -2632,6 +3491,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 +3610,50 @@ 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_wasmbinaryhologram_free: (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;
@@ -2710,27 +3663,35 @@ export interface InitOutput {
   readonly __wbg_wasmgaussianmultivector_free: (a: number, b: number) => void;
   readonly __wbg_wasmgeodesicintegrator_free: (a: number, b: number) => void;
   readonly __wbg_wasmgeometricca_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgeometricleeencoder_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;
   readonly __wbg_wasmnodemetadata_free: (a: number, b: number) => void;
+  readonly __wbg_wasmopticalcodebook_free: (a: number, b: number) => void;
+  readonly __wbg_wasmopticalrotorfield_free: (a: number, b: number) => void;
   readonly __wbg_wasmoptimizationresult_free: (a: number, b: number) => void;
   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_wasmsobolevspace_free: (a: number, b: number) => void;
+  readonly __wbg_wasmspectraldecomposition_free: (a: number, b: number) => void;
   readonly __wbg_wasmtrajectorypoint_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicaldualclifford_free: (a: number, b: number) => void;
   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];
@@ -2748,6 +3709,7 @@ export interface InitOutput {
   readonly batchops_batchPolynomial: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly batchops_computeJacobian: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly batchops_matrixMultiply: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
+  readonly computeEigenvalues: (a: number, b: number, c: number) => [number, number, number, number];
   readonly enumerativebatch_bezoutBatch: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
   readonly enumerativebatch_binomialBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly enumerativebatch_getBatchOperationCount: () => number;
@@ -2782,6 +3744,7 @@ export interface InitOutput {
   readonly integrate: (a: any, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly integration_integrate1D: (a: any, b: number, c: number, d: number) => [number, number, number];
   readonly integration_integrate2D: (a: any, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+  readonly inverseIteration: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
   readonly klDivergence: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
   readonly light_deflection_angle: (a: number, b: number) => number;
   readonly mlops_batchActivation: (a: number, b: number, c: number, d: number) => [number, number, number, number];
@@ -2800,6 +3763,7 @@ export interface InitOutput {
   readonly performanceoperations_fastGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number];
   readonly performanceoperations_vectorCrossProduct: (a: number, b: number, c: number, d: number) => [number, number];
   readonly performanceoperations_vectorDotProduct: (a: number, b: number, c: number, d: number) => number;
+  readonly powerMethod: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
   readonly riemannianmanifold_christoffel: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
   readonly riemannianmanifold_dimension: (a: number) => number;
   readonly riemannianmanifold_euclidean: (a: number) => [number, number, number];
@@ -2829,6 +3793,23 @@ export interface InitOutput {
   readonly wasmalphaconnection_isLeviCivita: (a: number) => number;
   readonly wasmalphaconnection_isMixture: (a: number) => number;
   readonly wasmalphaconnection_new: (a: number) => [number, number, number];
+  readonly wasmbinaryhologram_asBytes: (a: number) => [number, number];
+  readonly wasmbinaryhologram_fillFactor: (a: number) => number;
+  readonly wasmbinaryhologram_get: (a: number, b: number, c: number) => number;
+  readonly wasmbinaryhologram_hammingDistance: (a: number, b: number) => number;
+  readonly wasmbinaryhologram_height: (a: number) => number;
+  readonly wasmbinaryhologram_inverted: (a: number) => number;
+  readonly wasmbinaryhologram_length: (a: number) => number;
+  readonly wasmbinaryhologram_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmbinaryhologram_normalizedHammingDistance: (a: number, b: number) => number;
+  readonly wasmbinaryhologram_ones: (a: number, b: number) => number;
+  readonly wasmbinaryhologram_popcount: (a: number) => number;
+  readonly wasmbinaryhologram_set: (a: number, b: number, c: number, d: number) => void;
+  readonly wasmbinaryhologram_toBools: (a: number) => [number, number];
+  readonly wasmbinaryhologram_toggle: (a: number, b: number, c: number) => void;
+  readonly wasmbinaryhologram_width: (a: number) => number;
+  readonly wasmbinaryhologram_xor: (a: number, b: number) => number;
+  readonly wasmbinaryhologram_zeros: (a: number, b: number) => number;
   readonly wasmchowclass_getDegree: (a: number) => number;
   readonly wasmchowclass_getDimension: (a: number) => number;
   readonly wasmchowclass_hypersurface: (a: number) => number;
@@ -2903,6 +3884,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;
@@ -2920,7 +3904,14 @@ export interface InitOutput {
   readonly wasmgeometricca_step: (a: number) => [number, number];
   readonly wasmgeometricedge_new: (a: number, b: number, c: number) => number;
   readonly wasmgeometricedge_source: (a: number) => number;
-  readonly wasmgeometricedge_target: (a: number) => number;
+  readonly wasmgeometricleeencoder_carrierAngle: (a: number) => number;
+  readonly wasmgeometricleeencoder_carrierFrequency: (a: number) => number;
+  readonly wasmgeometricleeencoder_encode: (a: number, b: number) => number;
+  readonly wasmgeometricleeencoder_height: (a: number) => number;
+  readonly wasmgeometricleeencoder_modulate: (a: number, b: number) => number;
+  readonly wasmgeometricleeencoder_new: (a: number, b: number, c: number, d: number) => number;
+  readonly wasmgeometricleeencoder_theoreticalEfficiency: (a: number, b: number) => number;
+  readonly wasmgeometricleeencoder_withFrequency: (a: number, b: number, c: number) => number;
   readonly wasmgeometricnetwork_addEdge: (a: number, b: number, c: number, d: number) => [number, number];
   readonly wasmgeometricnetwork_addNode: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmgeometricnetwork_addNodeWithMetadata: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
@@ -2945,9 +3936,24 @@ 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];
+  readonly wasmhilbertspace_dimension: (a: number) => number;
+  readonly wasmhilbertspace_distance: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly wasmhilbertspace_fromCoefficients: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmhilbertspace_innerProduct: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly wasmhilbertspace_isOrthogonal: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly wasmhilbertspace_norm: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmhilbertspace_normalize: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmhilbertspace_project: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly wasmhilbertspace_signature: (a: number) => [number, number];
   readonly wasmholographicmemory_clear: (a: number) => void;
   readonly wasmholographicmemory_estimatedSnr: (a: number) => number;
   readonly wasmholographicmemory_isNearCapacity: (a: number) => number;
@@ -2967,6 +3973,30 @@ 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 wasmmatrixoperator_add: (a: number, b: number) => [number, number, number];
+  readonly wasmmatrixoperator_apply: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmmatrixoperator_compose: (a: number, b: number) => [number, number, number];
+  readonly wasmmatrixoperator_diagonal: (a: number, b: number) => [number, number, number];
+  readonly wasmmatrixoperator_getEntries: (a: number) => [number, number];
+  readonly wasmmatrixoperator_getEntry: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmmatrixoperator_identity: () => number;
+  readonly wasmmatrixoperator_isSymmetric: (a: number, b: number) => number;
+  readonly wasmmatrixoperator_new: (a: number, b: number) => [number, number, number];
+  readonly wasmmatrixoperator_operatorNorm: (a: number) => number;
+  readonly wasmmatrixoperator_scale: (a: number, b: number) => number;
+  readonly wasmmatrixoperator_scaling: (a: number) => number;
+  readonly wasmmatrixoperator_trace: (a: number) => number;
+  readonly wasmmatrixoperator_transpose: (a: number) => number;
+  readonly wasmmatrixoperator_zero: () => 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;
@@ -2987,7 +4017,6 @@ export interface InitOutput {
   readonly wasmmultidualnumber_variable: (a: number, b: number, c: number) => number;
   readonly wasmmultiobjectiveoptimizer_optimizeBiObjective: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly wasmmultiobjectiveresult_converged: (a: number) => number;
-  readonly wasmmultiobjectiveresult_generations: (a: number) => number;
   readonly wasmmultiobjectiveresult_pareto_front: (a: number) => [number, number];
   readonly wasmmultivector_add: (a: number, b: number) => number;
   readonly wasmmultivector_basisVector: (a: number) => [number, number, number];
@@ -3015,6 +4044,48 @@ export interface InitOutput {
   readonly wasmnodemetadata_setProperty: (a: number, b: number, c: number, d: number) => void;
   readonly wasmnodemetadata_set_label: (a: number, b: number, c: number) => void;
   readonly wasmnodemetadata_withLabel: (a: number, b: number) => number;
+  readonly wasmopticalcodebook_clearCache: (a: number) => void;
+  readonly wasmopticalcodebook_contains: (a: number, b: number, c: number) => number;
+  readonly wasmopticalcodebook_generate: (a: number, b: number, c: number) => number;
+  readonly wasmopticalcodebook_get: (a: number, b: number, c: number) => number;
+  readonly wasmopticalcodebook_getSeed: (a: number, b: number, c: number) => [number, bigint];
+  readonly wasmopticalcodebook_isEmpty: (a: number) => number;
+  readonly wasmopticalcodebook_length: (a: number) => number;
+  readonly wasmopticalcodebook_new: (a: number, b: number, c: bigint) => number;
+  readonly wasmopticalcodebook_register: (a: number, b: number, c: number) => void;
+  readonly wasmopticalcodebook_registerAll: (a: number, b: number, c: number) => void;
+  readonly wasmopticalcodebook_registerWithSeed: (a: number, b: number, c: number, d: bigint) => void;
+  readonly wasmopticalcodebook_remove: (a: number, b: number, c: number) => number;
+  readonly wasmopticalcodebook_symbols: (a: number) => [number, number];
+  readonly wasmopticalfieldalgebra_addPhase: (a: number, b: number, c: number) => number;
+  readonly wasmopticalfieldalgebra_bind: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmopticalfieldalgebra_bundle: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly wasmopticalfieldalgebra_bundleUniform: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmopticalfieldalgebra_identity: (a: number) => number;
+  readonly wasmopticalfieldalgebra_inverse: (a: number, b: number) => number;
+  readonly wasmopticalfieldalgebra_meanPhase: (a: number, b: number) => number;
+  readonly wasmopticalfieldalgebra_new: (a: number, b: number) => number;
+  readonly wasmopticalfieldalgebra_phaseVariance: (a: number, b: number) => number;
+  readonly wasmopticalfieldalgebra_random: (a: number, b: bigint) => number;
+  readonly wasmopticalfieldalgebra_scale: (a: number, b: number, c: number) => number;
+  readonly wasmopticalfieldalgebra_similarity: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmopticalfieldalgebra_unbind: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmopticalrotorfield_amplitudeAt: (a: number, b: number, c: number) => number;
+  readonly wasmopticalrotorfield_clone: (a: number) => number;
+  readonly wasmopticalrotorfield_fromPhase: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmopticalrotorfield_getAmplitudes: (a: number) => [number, number];
+  readonly wasmopticalrotorfield_getBivectors: (a: number) => [number, number];
+  readonly wasmopticalrotorfield_getScalars: (a: number) => [number, number];
+  readonly wasmopticalrotorfield_height: (a: number) => number;
+  readonly wasmopticalrotorfield_identity: (a: number, b: number) => number;
+  readonly wasmopticalrotorfield_length: (a: number) => number;
+  readonly wasmopticalrotorfield_new: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly wasmopticalrotorfield_normalized: (a: number) => number;
+  readonly wasmopticalrotorfield_phaseAt: (a: number, b: number, c: number) => number;
+  readonly wasmopticalrotorfield_random: (a: number, b: number, c: bigint) => number;
+  readonly wasmopticalrotorfield_totalEnergy: (a: number) => number;
+  readonly wasmopticalrotorfield_uniform: (a: number, b: number, c: number, d: number) => number;
+  readonly wasmopticalrotorfield_width: (a: number) => number;
   readonly wasmoptimizationresult_converged: (a: number) => number;
   readonly wasmoptimizationresult_solution: (a: number) => [number, number];
   readonly wasmoptimizationutils_dominates: (a: number, b: number, c: number, d: number) => number;
@@ -3072,6 +4143,17 @@ export interface InitOutput {
   readonly wasmsensitivitymap_getMostSensitive: (a: number, b: number) => [number, number];
   readonly wasmsensitivitymap_getTotalSensitivity: (a: number) => number;
   readonly wasmsimpleoptimizer_optimizeQuadratic: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly wasmsobolevspace_bounds: (a: number) => [number, number];
+  readonly wasmsobolevspace_h1Norm: (a: number, b: any, c: any) => [number, number, number];
+  readonly wasmsobolevspace_h1Seminorm: (a: number, b: any) => [number, number, number];
+  readonly wasmsobolevspace_h1UnitInterval: () => number;
+  readonly wasmsobolevspace_h2UnitInterval: () => number;
+  readonly wasmsobolevspace_l2InnerProduct: (a: number, b: any, c: any) => [number, number, number];
+  readonly wasmsobolevspace_l2Norm: (a: number, b: any) => [number, number, number];
+  readonly wasmsobolevspace_new: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmsobolevspace_order: (a: number) => number;
+  readonly wasmsobolevspace_poincareConstant: (a: number) => number;
+  readonly wasmsobolevspace_setQuadraturePoints: (a: number, b: number) => void;
   readonly wasmspacetimevector_is_null: (a: number) => number;
   readonly wasmspacetimevector_is_spacelike: (a: number) => number;
   readonly wasmspacetimevector_is_timelike: (a: number) => number;
@@ -3081,6 +4163,16 @@ export interface InitOutput {
   readonly wasmspacetimevector_spacelike: (a: number, b: number, c: number) => number;
   readonly wasmspacetimevector_timelike: (a: number) => number;
   readonly wasmspacetimevector_to_string: (a: number) => [number, number];
+  readonly wasmspectraldecomposition_apply: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmspectraldecomposition_applyFunction: (a: number, b: any, c: number, d: number) => [number, number, number, number];
+  readonly wasmspectraldecomposition_compute: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmspectraldecomposition_conditionNumber: (a: number) => [number, number];
+  readonly wasmspectraldecomposition_eigenvalues: (a: number) => [number, number];
+  readonly wasmspectraldecomposition_eigenvectors: (a: number) => [number, number];
+  readonly wasmspectraldecomposition_isComplete: (a: number) => number;
+  readonly wasmspectraldecomposition_isPositiveDefinite: (a: number) => number;
+  readonly wasmspectraldecomposition_isPositiveSemidefinite: (a: number) => number;
+  readonly wasmspectraldecomposition_spectralRadius: (a: number) => number;
   readonly wasmtropicalcurve_expectedVertices: (a: number) => number;
   readonly wasmtropicalcurve_getDegree: (a: number) => number;
   readonly wasmtropicalcurve_new: (a: number, b: number) => number;
@@ -3130,12 +4222,29 @@ export interface InitOutput {
   readonly wasmtropicalnumber_one: () => number;
   readonly wasmtropicalnumber_toProb: (a: number) => number;
   readonly wasmtropicalnumber_tropicalPow: (a: number, b: number) => number;
+  readonly wasmtropicalopticalalgebra_attractorConverge: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly wasmtropicalopticalalgebra_normalizedPhaseDistance: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmtropicalopticalalgebra_phaseDistance: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmtropicalopticalalgebra_softTropicalAdd: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmtropicalopticalalgebra_tropicalAdd: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmtropicalopticalalgebra_tropicalMax: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmtropicalopticalalgebra_tropicalMul: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmtropicalpolynomial_evaluate: (a: number, b: number) => number;
   readonly wasmtropicalpolynomial_new: (a: number, b: number) => number;
   readonly wasmtropicalpolynomial_tropical_roots: (a: number) => any;
   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 +4255,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,15 +4272,26 @@ 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 wasmtropicalopticalalgebra_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_target: (a: number) => number;
   readonly wasmgeometricedge_weight: (a: number) => number;
+  readonly wasmgeometricleeencoder_width: (a: number) => number;
+  readonly wasmgradeprojecteddistribution_getGrade: (a: number) => number;
   readonly wasmmodulispace_getGenus: (a: number) => number;
   readonly wasmmultidualnumber_getReal: (a: number) => number;
+  readonly wasmmultiobjectiveresult_generations: (a: number) => number;
+  readonly wasmopticalfieldalgebra_height: (a: number) => number;
+  readonly wasmopticalfieldalgebra_width: (a: number) => number;
   readonly wasmoptimizationresult_iterations: (a: number) => number;
   readonly wasmoptimizationresult_objective_value: (a: number) => number;
   readonly wasmprojectivespace_getDimension: (a: number) => number;
@@ -3180,6 +4303,9 @@ export interface InitOutput {
   readonly wasmtropicalcurve_getGenus: (a: number) => number;
   readonly wasmtropicalnetwork_getSize: (a: number) => number;
   readonly wasmtropicalnumber_getValue: (a: number) => number;
+  readonly wasmtropicalopticalalgebra_height: (a: number) => number;
+  readonly wasmtropicalopticalalgebra_width: (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,22 +4325,30 @@ 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_wasmhilbertspace_free: (a: number, b: number) => void;
   readonly __wbg_wasmmontecarloestimator_free: (a: number, b: number) => void;
   readonly __wbg_wasmmultiobjectiveoptimizer_free: (a: number, b: number) => void;
+  readonly __wbg_wasmopticalfieldalgebra_free: (a: number, b: number) => void;
   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_wasmtropicalopticalalgebra_free: (a: number, b: number) => void;
+  readonly __wbg_wasmwienerprocess_free: (a: number, b: number) => void;
+  readonly __wbg_wasmmatrixoperator_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;
   readonly wasmgpuoptimizer_new: () => number;
+  readonly wasmhilbertspace_new: () => number;
   readonly wasmmultiobjectiveoptimizer_new: () => number;
   readonly wasmsimpleoptimizer_new: () => number;
   readonly wasmtropicalmeasure_new: () => number;
@@ -3226,8 +4360,9 @@ export interface InitOutput {
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_export_6: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
-  readonly closure41_externref_shim: (a: number, b: number, c: any) => void;
-  readonly closure34_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly __externref_drop_slice: (a: number, b: number) => void;
+  readonly closure44_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure37_externref_shim: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_start: () => void;
 }