@justinelliottcobb/amari-wasm 0.14.0 → 0.16.0

package/amari_wasm.d.ts

@@ -1,3554 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/**
- * Initialize the WASM module
- */
-export function init(): void;
-/**
- * Initialize the enumerative geometry module
- */
-export function initEnumerative(): void;
-/**
- * Calculate light deflection angle for photon grazing massive object
- */
-export function light_deflection_angle(impact_parameter: number, mass: number): number;
-/**
- * Convert velocity to Lorentz factor
- */
-export function velocity_to_gamma(velocity_magnitude: number): number;
-/**
- * Convert Lorentz factor to velocity
- */
-export function gamma_to_velocity(gamma: number): number;
-/**
- * Validate that this module loaded correctly
- */
-export function validate_relativistic_module(): boolean;
-/**
- * Initialize the fusion module
- */
-export function initFusion(): void;
-/**
- * Initialize the holographic memory module
- */
-export function initHolographic(): void;
-/**
- * Integrate a JavaScript function over an interval
- *
- * This function provides numerical integration capabilities to JavaScript.
- *
- * # Arguments
- * * `f` - JavaScript function to integrate (must accept a number and return a number)
- * * `a` - Lower bound of integration
- * * `b` - Upper bound of integration
- * * `points` - Number of sample points to use
- * * `method` - Integration method to use
- *
- * # Returns
- * Approximate value of the integral ∫_a^b f(x) dx
- */
-export function integrate(f: Function, a: number, b: number, points: number, method: WasmIntegrationMethod): number;
-/**
- * Compute expectation E[f(X)] for uniform distribution on [a, b]
- *
- * # Arguments
- * * `f` - JavaScript function (must accept a number and return a number)
- * * `a` - Lower bound
- * * `b` - Upper bound
- * * `samples` - Number of Monte Carlo samples
- */
-export function expectation(f: Function, a: number, b: number, samples: number): number;
-/**
- * Compute KL divergence D_KL(P||Q) between two distributions
- *
- * # Arguments
- * * `p_density` - First distribution
- * * `q_density` - Second distribution
- * * `p_params` - Parameters for P
- * * `q_params` - Parameters for Q
- * * `sample_points` - Points to evaluate at
- */
-export function klDivergence(p_density: WasmParametricDensity, q_density: WasmParametricDensity, p_params: Float64Array, q_params: Float64Array, sample_points: Float64Array): number;
-/**
- * Initialize the automata module
- */
-export function initAutomata(): void;
-/**
- * Integration methods available in WASM
- */
-export enum WasmIntegrationMethod {
-  /**
-   * Riemann sum approximation
-   */
-  Riemann = 0,
-  /**
-   * Monte Carlo integration
-   */
-  MonteCarlo = 1,
-  /**
-   * Trapezoidal rule
-   */
-  Trapezoidal = 2,
-  /**
-   * Simpson's rule
-   */
-  Simpson = 3,
-  /**
-   * Adaptive quadrature
-   */
-  Adaptive = 4,
-}
-/**
- * Automatic differentiation utilities
- */
-export class AutoDiff {
-  private constructor();
-  free(): void;
-  /**
-   * Linear layer forward pass (y = Wx + b) with automatic gradients
-   */
-  static linearLayer(inputs: Float64Array, weights: Float64Array, bias: Float64Array, input_size: number, output_size: number): Float64Array;
-  /**
-   * Compute mean squared error with automatic gradients
-   */
-  static meanSquaredError(predictions: Float64Array, targets: Float64Array): WasmDualNumber;
-  /**
-   * Create a dual number and evaluate a polynomial
-   */
-  static evaluatePolynomial(x: number, coefficients: Float64Array): WasmDualNumber;
-  /**
-   * Compute numerical derivative using finite differences (fallback implementation)
-   */
-  static numericalDerivative(x: number, f: Function, h: number): number;
-}
-/**
- * High-performance batch operations for automata systems
- */
-export class AutomataBatchOperations {
-  private constructor();
-  free(): void;
-  /**
-   * Evolve multiple CA systems in parallel
-   */
-  static batchEvolve(grids: Float64Array, grid_width: number, grid_height: number, num_grids: number, generations: number): Float64Array;
-  /**
-   * Batch fitness evaluation for inverse design
-   */
-  static batchFitness(candidates: Float64Array, target: Float64Array, candidate_count: number, grid_width: number, grid_height: number): Float64Array;
-  /**
-   * Batch assembly stability check
-   */
-  static batchStabilityCheck(assemblies: Float64Array, assembly_count: number, components_per_assembly: number): Uint8Array;
-}
-/**
- * Utilities for automata systems
- */
-export class AutomataUtils {
-  private constructor();
-  free(): void;
-  /**
-   * Validate grid dimensions and format
-   */
-  static validateGrid(grid: Float64Array, width: number, height: number): boolean;
-  /**
-   * Convert between different CA rule representations
-   */
-  static parseRuleString(rule_string: string): any;
-  /**
-   * Create a standard Game of Life pattern
-   */
-  static createLifePattern(pattern_name: string, width: number, height: number): Float64Array;
-  /**
-   * Generate a random seed for inverse design
-   */
-  static generateRandomSeed(width: number, height: number, density: number): Float64Array;
-}
-/**
- * Batch operations for performance
- */
-export class BatchOperations {
-  private constructor();
-  free(): void;
-  /**
-   * Batch geometric product: compute a[i] * b[i] for all i
-   * Optimized for WebAssembly performance with reduced allocations
-   */
-  static batchGeometricProduct(a_batch: Float64Array, b_batch: Float64Array): Float64Array;
-  /**
-   * Batch addition
-   */
-  static batchAdd(a_batch: Float64Array, b_batch: Float64Array): Float64Array;
-}
-/**
- * Batch operations for efficient computation
- */
-export class BatchOps {
-  private constructor();
-  free(): void;
-  /**
-   * Matrix multiplication with automatic gradients
-   */
-  static matrixMultiply(a: Float64Array, b: Float64Array, a_rows: number, a_cols: number, b_rows: number, b_cols: number): Float64Array;
-  /**
-   * Batch evaluate polynomial with derivatives
-   */
-  static batchPolynomial(x_values: Float64Array, coefficients: Float64Array): Float64Array;
-  /**
-   * Compute Jacobian matrix for vector function
-   */
-  static computeJacobian(input_values: Float64Array, function_name: string): Float64Array;
-}
-/**
- * Batch operations for high-performance enumerative computations
- */
-export class EnumerativeBatch {
-  private constructor();
-  free(): void;
-  /**
-   * Compute multiple Bézout intersections in batch
-   */
-  static bezoutBatch(projective_space: WasmProjectiveSpace, degrees1: Int32Array, degrees2: Int32Array): Float64Array;
-  /**
-   * Compute multiple binomial coefficients in batch
-   */
-  static binomialBatch(n_values: Uint32Array, k_values: Uint32Array): Float64Array;
-  /**
-   * Get number of available batch operations
-   */
-  static getBatchOperationCount(): number;
-}
-/**
- * Utility functions for enumerative geometry
- */
-export class EnumerativeUtils {
-  private constructor();
-  free(): void;
-  /**
-   * Validate partition for Schubert calculus
-   */
-  static validatePartition(partition: Uint32Array, k: number, n: number): boolean;
-  /**
-   * Compute intersection multiplicity using Bézout's theorem
-   */
-  static bezoutMultiplicity(degree1: number, degree2: number, space_dimension: number): number;
-  /**
-   * Compute Euler characteristic of projective space
-   */
-  static eulerCharacteristic(dimension: number): number;
-  /**
-   * Compute expected number of rational curves of given degree
-   */
-  static expectedRationalCurves(degree: number, points: number): number;
-  /**
-   * Check if two curves can intersect transversely
-   */
-  static canIntersectTransversely(_degree1: number, _degree2: number, space_dimension: number): boolean;
-  /**
-   * Compute binomial coefficient C(n, k)
-   */
-  static binomial(n: number, k: number): number;
-}
-/**
- * High-performance batch operations for LLM workloads
- */
-export class FusionBatchOperations {
-  private constructor();
-  free(): void;
-  /**
-   * Optimize TDC parameters using gradient information
-   */
-  static gradientStep(tdc: WasmTropicalDualClifford, learning_rate: number): WasmTropicalDualClifford;
-  /**
-   * Batch distance computation (optimized for similarity search)
-   */
-  static batchDistance(query_logits: Float64Array, corpus_batch: Float64Array, corpus_size: number): Float64Array;
-  /**
-   * Batch evaluation of multiple TDC pairs (optimized for WASM)
-   */
-  static batchEvaluate(tdc_a_batch: Float64Array, tdc_b_batch: Float64Array, batch_size: number): Float64Array;
-  /**
-   * Batch sensitivity analysis for gradient-based optimization
-   *
-   * Note: Using simplified implementation based on gradient norms
-   */
-  static batchSensitivity(tdc_batch: Float64Array, batch_size: number): Float64Array;
-  /**
-   * Compute fusion similarity between two TDC objects
-   */
-  static fusionSimilarity(tdc1: WasmTropicalDualClifford, tdc2: WasmTropicalDualClifford): number;
-  /**
-   * Batch tropical attention across multiple queries
-   */
-  static batchTropicalAttention(queries: Float64Array, keys: Float64Array, values: Float64Array, query_dim: number): Float64Array;
-}
-/**
- * Conversion utilities for JavaScript interoperability
- */
-export class FusionUtils {
-  private constructor();
-  free(): void;
-  /**
-   * Validate logits for numerical stability
-   */
-  static validateLogits(logits: Float64Array): boolean;
-  /**
-   * Normalize logits to prevent overflow
-   */
-  static normalizeLogits(logits: Float64Array): Float64Array;
-  /**
-   * Convert softmax probabilities to tropical representation
-   *
-   * Note: Direct conversion helpers are not in v0.12.0, using manual implementation
-   */
-  static softmaxToTropical(probs: Float64Array): Float64Array;
-  /**
-   * Convert tropical numbers back to softmax probabilities
-   *
-   * Note: Direct conversion helpers are not in v0.12.0, using manual implementation
-   */
-  static tropicalToSoftmax(tropical_values: Float64Array): Float64Array;
-}
-/**
- * Information geometry utilities
- */
-export class InfoGeomUtils {
-  private constructor();
-  free(): void;
-  /**
-   * Compute cross-entropy between two distributions
-   */
-  static crossEntropy(p: Float64Array, q: Float64Array): number;
-  /**
-   * Generate points on the probability simplex for testing
-   * Note: Uses a simple deterministic sequence for reproducibility in WASM
-   */
-  static randomSimplex(dimension: number): Float64Array;
-  /**
-   * Compute mutual information between two discrete distributions
-   */
-  static mutualInformation(joint: Float64Array, marginal_x: Float64Array, marginal_y: Float64Array, dim_x: number): number;
-  /**
-   * Compute entropy of a probability distribution
-   */
-  static entropy(p: Float64Array): number;
-  /**
-   * Convert log probabilities to probabilities
-   */
-  static softmax(logits: Float64Array): Float64Array;
-  /**
-   * Normalize array to probability distribution
-   */
-  static normalize(values: Float64Array): Float64Array;
-}
-/**
- * Numerical integration operations
- *
- * Provides definite integrals, line integrals, and surface integrals
- * using adaptive quadrature.
- */
-export class Integration {
-  private constructor();
-  free(): void;
-  /**
-   * Compute 1D definite integral using Simpson's rule
-   *
-   * ∫[a,b] f(x) dx
-   *
-   * # Arguments
-   *
-   * * `func` - JavaScript function to integrate
-   * * `a` - Lower bound
-   * * `b` - Upper bound
-   * * `n` - Number of subdivisions (must be even)
-   *
-   * # Returns
-   *
-   * Integral value
-   *
-   * # JavaScript Example
-   *
-   * ```javascript
-   * // Integrate x^2 from 0 to 1
-   * const result = Integration.integrate1D(x => x*x, 0, 1, 100);
-   * // Returns approximately 0.333...
-   * ```
-   */
-  static integrate1D(func: Function, a: number, b: number, n: number): number;
-  /**
-   * Compute 2D integral over a rectangle using Simpson's rule
-   *
-   * ∫∫[a,b]×[c,d] f(x,y) dx dy
-   *
-   * # Arguments
-   *
-   * * `func` - JavaScript function (x, y) => f(x, y)
-   * * `ax` - Lower x bound
-   * * `bx` - Upper x bound
-   * * `ay` - Lower y bound
-   * * `by` - Upper y bound
-   * * `nx` - Number of x subdivisions (must be even)
-   * * `ny` - Number of y subdivisions (must be even)
-   */
-  static integrate2D(func: Function, ax: number, bx: number, ay: number, by: number, nx: number, ny: number): number;
-}
-/**
- * Advanced machine learning operations using dual numbers
- */
-export class MLOps {
-  private constructor();
-  free(): void;
-  /**
-   * Batch apply activation function with gradients
-   */
-  static batchActivation(inputs: Float64Array, activation: string): Float64Array;
-  /**
-   * Compute cross-entropy loss with automatic gradients
-   */
-  static crossEntropyLoss(predictions: Float64Array, targets: Float64Array): WasmDualNumber;
-  /**
-   * Gradient descent step
-   */
-  static gradientDescentStep(parameters: Float64Array, gradients: Float64Array, learning_rate: number): Float64Array;
-  /**
-   * Compute softmax with automatic gradients
-   */
-  static softmax(inputs: Float64Array): Float64Array;
-}
-/**
- * Utility functions for network analysis
- */
-export class NetworkUtils {
-  private constructor();
-  free(): void;
-  /**
-   * Create a random geometric network for testing
-   */
-  static createRandomNetwork(num_nodes: number, connection_probability: number): WasmGeometricNetwork;
-  /**
-   * Analyze network clustering coefficient
-   */
-  static clusteringCoefficient(network: WasmGeometricNetwork): number;
-  /**
-   * Create a small-world network (Watts-Strogatz model)
-   */
-  static createSmallWorldNetwork(num_nodes: number, k: number, beta: number): WasmGeometricNetwork;
-}
-/**
- * Numerical derivative operations
- *
- * Provides gradient, divergence, curl, and Laplacian computations
- * using centered finite differences.
- */
-export class NumericalDerivative {
-  free(): void;
-  /**
-   * Compute divergence of a vector field at a point
-   *
-   * ∇·F = ∂Fx/∂x + ∂Fy/∂y + ∂Fz/∂z
-   *
-   * # Arguments
-   *
-   * * `field` - Vector field
-   * * `point` - Evaluation point
-   *
-   * # Returns
-   *
-   * Divergence (scalar)
-   */
-  divergence(field: VectorField, point: Float64Array): number;
-  /**
-   * Create a new numerical derivative computer
-   *
-   * # Arguments
-   *
-   * * `step_size` - Optional step size for finite differences (default: 1e-5)
-   */
-  constructor(step_size?: number | null);
-  /**
-   * Compute curl of a 3D vector field at a point
-   *
-   * ∇×F = [∂Fz/∂y - ∂Fy/∂z, ∂Fx/∂z - ∂Fz/∂x, ∂Fy/∂x - ∂Fx/∂y]
-   *
-   * # Arguments
-   *
-   * * `field` - 3D vector field
-   * * `point` - Evaluation point [x, y, z]
-   *
-   * # Returns
-   *
-   * Curl vector [cx, cy, cz]
-   */
-  curl(field: VectorField, point: Float64Array): Float64Array;
-  /**
-   * Compute gradient of a scalar field at a point
-   *
-   * ∇f = [∂f/∂x, ∂f/∂y, ∂f/∂z]
-   *
-   * # Arguments
-   *
-   * * `field` - Scalar field
-   * * `point` - Evaluation point
-   *
-   * # Returns
-   *
-   * Gradient vector
-   *
-   * # JavaScript Example
-   *
-   * ```javascript
-   * const field = ScalarField.fromFunction2D((x, y) => x*x + y*y);
-   * const derivative = new NumericalDerivative();
-   * const grad = derivative.gradient(field, [1.0, 2.0]); // Returns [2.0, 4.0]
-   * ```
-   */
-  gradient(field: ScalarField, point: Float64Array): Float64Array;
-  /**
-   * Compute Laplacian of a scalar field at a point
-   *
-   * ∇²f = ∂²f/∂x² + ∂²f/∂y² + ∂²f/∂z²
-   *
-   * # Arguments
-   *
-   * * `field` - Scalar field
-   * * `point` - Evaluation point
-   *
-   * # Returns
-   *
-   * Laplacian (scalar)
-   */
-  laplacian(field: ScalarField, point: Float64Array): number;
-}
-/**
- * High-performance WASM operations with memory pooling
- */
-export class PerformanceOperations {
-  private constructor();
-  free(): void;
-  /**
-   * Batch normalize vectors for efficiency
-   */
-  static batchNormalize(vectors: Float64Array, vector_size: number): Float64Array;
-  /**
-   * Optimized vector dot product
-   */
-  static vectorDotProduct(v1: Float64Array, v2: Float64Array): number;
-  /**
-   * Optimized vector operations for 3D space
-   */
-  static vectorCrossProduct(v1: Float64Array, v2: Float64Array): Float64Array;
-  /**
-   * Fast geometric product for hot paths with memory pooling
-   */
-  static fastGeometricProduct(lhs: Float64Array, rhs: Float64Array): Float64Array;
-}
-/**
- * Riemannian manifold with metric tensor
- *
- * Represents a curved space with a metric that defines distances and angles.
- *
- * # JavaScript Example
- *
- * ```javascript
- * // Create a 2D sphere of radius 1
- * const sphere = RiemannianManifold.sphere(1.0);
- *
- * // Compute scalar curvature at the north pole
- * const R = sphere.scalarCurvature([0.0, 0.0]); // Returns 2.0 for unit sphere
- * ```
- */
-export class RiemannianManifold {
-  private constructor();
-  free(): void;
-  /**
-   * Create a 2D hyperbolic plane (Poincaré half-plane model)
-   *
-   * Metric: ds² = (dx² + dy²) / y²
-   */
-  static hyperbolic(): RiemannianManifold;
-  /**
-   * Compute Christoffel symbol Γ^k_ij at a point
-   *
-   * # Arguments
-   *
-   * * `k` - Upper index
-   * * `i` - First lower index
-   * * `j` - Second lower index
-   * * `coords` - Coordinates
-   */
-  christoffel(k: number, i: number, j: number, coords: Float64Array): number;
-  /**
-   * Compute Ricci tensor component R_ij
-   *
-   * # Arguments
-   *
-   * * `i` - First index
-   * * `j` - Second index
-   * * `coords` - Coordinates
-   */
-  ricciTensor(i: number, j: number, coords: Float64Array): number;
-  /**
-   * Compute Riemann curvature tensor component R^i_jkl
-   *
-   * # Arguments
-   *
-   * * `i` - Upper index
-   * * `j` - First lower index
-   * * `k` - Second lower index
-   * * `l` - Third lower index
-   * * `coords` - Coordinates
-   */
-  riemannTensor(i: number, j: number, k: number, l: number, coords: Float64Array): number;
-  /**
-   * Compute scalar curvature R
-   *
-   * # Arguments
-   *
-   * * `coords` - Coordinates
-   *
-   * # Returns
-   *
-   * Scalar curvature value
-   */
-  scalarCurvature(coords: Float64Array): number;
-  /**
-   * Create a 2D sphere of given radius
-   *
-   * Metric: ds² = dθ² + sin²θ dφ²
-   *
-   * # Arguments
-   *
-   * * `radius` - Sphere radius
-   */
-  static sphere(radius: number): RiemannianManifold;
-  /**
-   * Compute geodesic trajectory
-   *
-   * Solves the geodesic equations using RK4 integration.
-   *
-   * # Arguments
-   *
-   * * `initial_pos` - Initial position
-   * * `initial_vel` - Initial velocity
-   * * `t_max` - Maximum time
-   * * `dt` - Time step
-   *
-   * # Returns
-   *
-   * Flat array of trajectory points and velocities:
-   * [x0, y0, vx0, vy0, x1, y1, vx1, vy1, ...]
-   */
-  geodesic(initial_pos: Float64Array, initial_vel: Float64Array, t_max: number, dt: number): Float64Array;
-  /**
-   * Create a Euclidean (flat) manifold
-   *
-   * # Arguments
-   *
-   * * `dimension` - Dimension (2 or 3)
-   */
-  static euclidean(dimension: number): RiemannianManifold;
-  /**
-   * Get the dimension of the manifold
-   */
-  readonly dimension: number;
-}
-/**
- * Scalar field f: ℝⁿ → ℝ
- *
- * Represents a function that maps points in n-dimensional space to real numbers.
- *
- * # JavaScript Example
- *
- * ```javascript
- * // Create a scalar field f(x, y) = x² + y²
- * const field = WasmScalarField.fromFunction2D((x, y) => x*x + y*y);
- *
- * // Evaluate at a point
- * const value = field.evaluate([1.0, 2.0]); // Returns 5.0
- * ```
- */
-export class ScalarField {
-  free(): void;
-  /**
-   * Batch evaluate the field at multiple points
-   *
-   * # Arguments
-   *
-   * * `points` - Array of points as flat array [x1, y1, x2, y2, ...]
-   *
-   * # Returns
-   *
-   * Array of field values
-   */
-  batchEvaluate(points: Float64Array): Float64Array;
-  /**
-   * Create a 2D scalar field from a JavaScript function
-   *
-   * # Arguments
-   *
-   * * `func` - JavaScript function (x, y) => f(x, y)
-   */
-  static fromFunction2D(func: Function): ScalarField;
-  /**
-   * Create a 3D scalar field from a JavaScript function
-   *
-   * # Arguments
-   *
-   * * `func` - JavaScript function (x, y, z) => f(x, y, z)
-   */
-  static fromFunction3D(func: Function): ScalarField;
-  /**
-   * Create a 2D scalar field from a JavaScript function
-   *
-   * # Arguments
-   *
-   * * `func` - JavaScript function (x, y) => f(x, y)
-   */
-  constructor(func: Function, dimension: number);
-  /**
-   * Evaluate the scalar field at a point
-   *
-   * # Arguments
-   *
-   * * `point` - Coordinates [x, y] or [x, y, z]
-   *
-   * # Returns
-   *
-   * Field value at the point
-   */
-  evaluate(point: Float64Array): number;
-}
-/**
- * Batch operations for tropical numbers
- */
-export class TropicalBatch {
-  private constructor();
-  free(): void;
-  /**
-   * Convert array of log probabilities to tropical numbers and find maximum
-   */
-  static maxLogProb(log_probs: Float64Array): number;
-  /**
-   * Viterbi algorithm helper: find best path through trellis
-   */
-  static viterbiStep(prev_scores: Float64Array, transition_scores: Float64Array, emission_scores: Float64Array, num_states: number): Float64Array;
-  /**
-   * Batch tropical addition (max operation)
-   */
-  static batchTropicalAdd(values: Float64Array): number;
-  /**
-   * Batch tropical multiplication (addition)
-   */
-  static batchTropicalMul(values: Float64Array): number;
-}
-/**
- * Advanced tropical operations for machine learning and optimization
- */
-export class TropicalMLOps {
-  private constructor();
-  free(): void;
-  /**
-   * Compute shortest paths using tropical algebra (Floyd-Warshall)
-   */
-  static shortestPaths(distance_matrix: any): Array<any>;
-  /**
-   * Compute tropical matrix multiplication for pathfinding
-   */
-  static matrixMultiply(a: any, b: any): Array<any>;
-  /**
-   * Compute tropical convex combination (used in optimization)
-   */
-  static convexCombination(values: Float64Array, weights: Float64Array): number;
-}
-/**
- * Vector field F: ℝⁿ → ℝⁿ
- *
- * Represents a function that maps points to vectors.
- *
- * # JavaScript Example
- *
- * ```javascript
- * // Create a 2D vector field F(x, y) = [y, -x] (rotation)
- * const field = WasmVectorField.fromFunction2D((x, y) => [y, -x]);
- *
- * // Evaluate at a point
- * const vector = field.evaluate([1.0, 2.0]); // Returns [2.0, -1.0]
- * ```
- */
-export class VectorField {
-  free(): void;
-  /**
-   * Create a 2D vector field from a JavaScript function
-   *
-   * # Arguments
-   *
-   * * `func` - JavaScript function (x, y) => [fx, fy]
-   */
-  static fromFunction2D(func: Function): VectorField;
-  /**
-   * Create a 3D vector field from a JavaScript function
-   *
-   * # Arguments
-   *
-   * * `func` - JavaScript function (x, y, z) => [fx, fy, fz]
-   */
-  static fromFunction3D(func: Function): VectorField;
-  /**
-   * Create a vector field from a JavaScript function
-   */
-  constructor(func: Function, dimension: number);
-  /**
-   * Evaluate the vector field at a point
-   *
-   * # Arguments
-   *
-   * * `point` - Coordinates [x, y] or [x, y, z]
-   *
-   * # Returns
-   *
-   * Vector at the point
-   */
-  evaluate(point: Float64Array): Float64Array;
-}
-/**
- * WASM wrapper for AlphaConnection
- */
-export class WasmAlphaConnection {
-  free(): void;
-  /**
-   * Check if this is the mixture connection (α = -1)
-   */
-  isMixture(): boolean;
-  /**
-   * Check if this is the exponential connection (α = 1)
-   */
-  isExponential(): boolean;
-  /**
-   * Check if this is the Levi-Civita connection (α = 0)
-   */
-  isLeviCivita(): boolean;
-  /**
-   * Create a new α-connection
-   */
-  constructor(alpha: number);
-  /**
-   * Get the α parameter
-   */
-  getAlpha(): number;
-}
-/**
- * WASM wrapper for Chow classes in intersection theory
- */
-export class WasmChowClass {
-  free(): void;
-  /**
-   * Get the degree of this Chow class
-   */
-  getDegree(): number;
-  /**
-   * Create a hypersurface class of given degree
-   */
-  static hypersurface(degree: number): WasmChowClass;
-  /**
-   * Get the dimension of this Chow class
-   */
-  getDimension(): number;
-  /**
-   * Create a linear subspace class
-   */
-  static linearSubspace(codimension: number): WasmChowClass;
-  /**
-   * Create a new Chow class with given dimension and degree
-   */
-  constructor(dimension: number, degree: number);
-  /**
-   * Create a point class
-   */
-  static point(): WasmChowClass;
-  /**
-   * Raise this class to a power
-   */
-  power(n: number): WasmChowClass;
-  /**
-   * Check if this class is zero
-   */
-  isZero(): boolean;
-  /**
-   * Multiply two Chow classes
-   */
-  multiply(other: WasmChowClass): WasmChowClass;
-}
-/**
- * WASM wrapper for community detection results
- */
-export class WasmCommunity {
-  private constructor();
-  free(): void;
-  /**
-   * Get cohesion score
-   */
-  readonly cohesionScore: number;
-  /**
-   * Get geometric centroid coefficients
-   */
-  readonly centroidCoefficients: Float64Array;
-  /**
-   * Get community member nodes
-   */
-  readonly nodes: Uint32Array;
-}
-/**
- * WASM wrapper for counting measure
- *
- * The counting measure assigns to each set the number of elements it contains.
- */
-export class WasmCountingMeasure {
-  free(): void;
-  /**
-   * Check if a set is measurable under counting measure
-   * (all sets are measurable under counting measure)
-   */
-  isMeasurable(): boolean;
-  /**
-   * Measure a finite set (returns its cardinality)
-   *
-   * # Arguments
-   * * `set_size` - The number of elements in the set
-   */
-  measureFiniteSet(set_size: number): number;
-  /**
-   * Create a new counting measure
-   */
-  constructor();
-}
-/**
- * WASM wrapper for single-variable dual numbers
- */
-export class WasmDualNumber {
-  free(): void;
-  /**
-   * Natural logarithm
-   */
-  ln(): WasmDualNumber;
-  /**
-   * Addition
-   */
-  add(other: WasmDualNumber): WasmDualNumber;
-  /**
-   * Cosine function
-   */
-  cos(): WasmDualNumber;
-  /**
-   * Division
-   */
-  div(other: WasmDualNumber): WasmDualNumber;
-  /**
-   * Exponential function
-   */
-  exp(): WasmDualNumber;
-  /**
-   * Maximum of two dual numbers
-   */
-  max(other: WasmDualNumber): WasmDualNumber;
-  /**
-   * Minimum of two dual numbers
-   */
-  min(other: WasmDualNumber): WasmDualNumber;
-  /**
-   * Multiplication
-   */
-  mul(other: WasmDualNumber): WasmDualNumber;
-  /**
-   * Negation
-   */
-  neg(): WasmDualNumber;
-  /**
-   * Create a new dual number with given real and dual parts
-   */
-  constructor(real: number, dual: number);
-  /**
-   * Power function
-   */
-  pow(exponent: number): WasmDualNumber;
-  /**
-   * Sine function
-   */
-  sin(): WasmDualNumber;
-  /**
-   * Subtraction
-   */
-  sub(other: WasmDualNumber): WasmDualNumber;
-  /**
-   * Tangent function
-   */
-  tan(): WasmDualNumber;
-  /**
-   * Hyperbolic cosine
-   */
-  cosh(): WasmDualNumber;
-  /**
-   * Integer power
-   */
-  powi(n: number): WasmDualNumber;
-  /**
-   * ReLU activation function
-   *
-   * Note: Manual implementation as relu() is not in v0.12.0 DualNumber API
-   */
-  relu(): WasmDualNumber;
-  /**
-   * Hyperbolic sine
-   */
-  sinh(): WasmDualNumber;
-  /**
-   * Square root
-   */
-  sqrt(): WasmDualNumber;
-  /**
-   * Hyperbolic tangent
-   */
-  tanh(): WasmDualNumber;
-  /**
-   * Sigmoid activation function
-   */
-  sigmoid(): WasmDualNumber;
-  /**
-   * Create a constant (derivative = 0)
-   */
-  static constant(value: number): WasmDualNumber;
-  /**
-   * Get the dual part (derivative)
-   */
-  getDual(): number;
-  /**
-   * Get the real part (function value)
-   */
-  getReal(): number;
-  /**
-   * Softplus activation function
-   *
-   * Note: Manual implementation as softplus() is not in v0.12.0 DualNumber API
-   * softplus(x) = ln(1 + exp(x))
-   */
-  softplus(): WasmDualNumber;
-  /**
-   * Create a variable (derivative = 1)
-   */
-  static variable(value: number): WasmDualNumber;
-}
-/**
- * WASM wrapper for DuallyFlatManifold
- */
-export class WasmDuallyFlatManifold {
-  free(): void;
-  /**
-   * Compute JS divergence (symmetric version of KL divergence)
-   */
-  jsDivergence(p: Float64Array, q: Float64Array): number;
-  /**
-   * Compute KL divergence between two probability distributions
-   */
-  klDivergence(p: Float64Array, q: Float64Array): number;
-  /**
-   * Compute Fisher information metric at a point
-   */
-  fisherMetricAt(point: Float64Array): WasmFisherInformationMatrix;
-  /**
-   * Compute Bregman divergence (KL divergence for probability distributions)
-   */
-  bregmanDivergence(p: Float64Array, q: Float64Array): number;
-  /**
-   * Compute Wasserstein-1 distance (Earth Mover's Distance)
-   */
-  wassersteinDistance(p: Float64Array, q: Float64Array): number;
-  /**
-   * Create a new dually flat manifold
-   */
-  constructor(dimension: number, alpha: number);
-}
-/**
- * WASM wrapper for evaluation results
- */
-export class WasmEvaluationResult {
-  private constructor();
-  free(): void;
-  /**
-   * Get gradient norm from dual numbers
-   */
-  getGradientNorm(): number;
-  /**
-   * Get combined score using all three algebras
-   */
-  getCombinedScore(): number;
-  /**
-   * Get the best path score from tropical algebra
-   */
-  getBestPathScore(): number;
-  /**
-   * Get geometric distance from Clifford algebra
-   */
-  getGeometricDistance(): number;
-  /**
-   * Convert to JavaScript object for easy access
-   */
-  toObject(): any;
-}
-/**
- * WASM wrapper for FisherInformationMatrix
- */
-export class WasmFisherInformationMatrix {
-  private constructor();
-  free(): void;
-  /**
-   * Get eigenvalues of the Fisher matrix
-   */
-  getEigenvalues(): Float64Array;
-  /**
-   * Compute condition number (ratio of largest to smallest eigenvalue)
-   */
-  conditionNumber(): number;
-  /**
-   * Check if the matrix is positive definite
-   */
-  isPositiveDefinite(): boolean;
-}
-/**
- * Fisher-Riemannian geometry on statistical manifolds
- */
-export class WasmFisherMeasure {
-  private constructor();
-  free(): void;
-  /**
-   * Create Fisher measure from a parametric density
-   */
-  static fromDensity(density: WasmParametricDensity): WasmFisherMeasure;
-  /**
-   * Compute the Fisher information metric at parameter point θ
-   */
-  fisherMetric(data: Float64Array, params: Float64Array): Float64Array;
-  /**
-   * Compute the Riemannian volume element √det(g(θ))
-   */
-  volumeElement(data: Float64Array, params: Float64Array): number;
-}
-/**
- * WASM wrapper for four-velocity
- */
-export class WasmFourVelocity {
-  private constructor();
-  free(): void;
-  /**
-   * Create four-velocity from 3-velocity components
-   */
-  static from_velocity(vx: number, vy: number, vz: number): WasmFourVelocity;
-  /**
-   * Check if normalized (u·u = c²)
-   */
-  is_normalized(): boolean;
-  /**
-   * Get as spacetime vector
-   */
-  as_spacetime_vector(): WasmSpacetimeVector;
-  /**
-   * Get spatial velocity magnitude
-   */
-  spatial_velocity_magnitude(): number;
-  /**
-   * Get Lorentz factor γ
-   */
-  gamma(): number;
-  /**
-   * Get rapidity
-   */
-  rapidity(): number;
-  /**
-   * Get string representation
-   */
-  to_string(): string;
-}
-/**
- * WASM wrapper for Gaussian distribution on Cl(3,0,0) multivector space
- *
- * A Gaussian distribution over 8-dimensional multivector space with
- * configurable mean and per-component standard deviation.
- */
-export class WasmGaussianMultivector {
-  free(): void;
-  /**
-   * Get the standard deviations
-   *
-   * Returns 8 values
-   */
-  getStdDevs(): Float64Array;
-  /**
-   * Get the variance (square of std devs)
-   *
-   * Returns 8 values
-   */
-  getVariance(): Float64Array;
-  /**
-   * Draw multiple samples from this distribution
-   *
-   * Returns flat array of coefficients: num_samples * 8
-   */
-  sampleBatch(num_samples: number): Float64Array;
-  /**
-   * Get the full covariance matrix (flattened, row-major)
-   *
-   * Returns 64 values (8x8 matrix)
-   */
-  getCovariance(): Float64Array;
-  /**
-   * Create a Gaussian with specified mean and standard deviation
-   *
-   * # Arguments
-   * * `mean` - 8 coefficients for the mean multivector
-   * * `std_dev` - 8 coefficients for per-coefficient standard deviation
-   */
-  static withParameters(mean: Float64Array, std_dev: Float64Array): WasmGaussianMultivector;
-  /**
-   * Create a Gaussian concentrated on a specific grade
-   *
-   * # Arguments
-   * * `grade` - The grade to concentrate on (0=scalar, 1=vectors, 2=bivectors, 3=pseudoscalar)
-   * * `variance` - Variance for coefficients of that grade
-   */
-  static gradeConcentrated(grade: number, variance: number): WasmGaussianMultivector;
-  /**
-   * Create a standard Gaussian (zero mean, unit variance per coefficient)
-   */
-  constructor();
-  /**
-   * Draw a sample from this distribution
-   *
-   * Returns 8 coefficients for the sampled multivector
-   */
-  sample(): Float64Array;
-  /**
-   * Get the mean of this distribution
-   *
-   * Returns 8 coefficients
-   */
-  getMean(): Float64Array;
-  /**
-   * Compute log probability of a multivector
-   *
-   * # Arguments
-   * * `coefficients` - 8 coefficients of the multivector
-   */
-  logProb(coefficients: Float64Array): number;
-  /**
-   * Create an isotropic Gaussian with given mean and variance
-   *
-   * # Arguments
-   * * `mean` - 8 coefficients for the mean multivector
-   * * `variance` - Variance (same for all components)
-   */
-  static isotropic(mean: Float64Array, variance: number): WasmGaussianMultivector;
-}
-/**
- * WASM wrapper for geodesic integration
- */
-export class WasmGeodesicIntegrator {
-  private constructor();
-  free(): void;
-  /**
-   * Propagate particle through spacetime
-   */
-  propagate_particle(particle: WasmRelativisticParticle, integration_time: number, time_step: number): Array<any>;
-  /**
-   * Create integrator with Schwarzschild metric
-   */
-  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
- */
-export class WasmGeometricCA {
-  free(): void;
-  /**
-   * Add a glider pattern (if supported by the rule)
-   */
-  addGlider(x: number, y: number): void;
-  /**
-   * Get the current generation number
-   */
-  generation(): number;
-  /**
-   * Get the dimensions of the CA grid
-   */
-  getDimensions(): Uint32Array;
-  /**
-   * Get the population count (non-zero cells)
-   */
-  getPopulation(): number;
-  /**
-   * Compute statistics about the current state
-   */
-  getStatistics(): any;
-  /**
-   * Get the total energy of the system
-   */
-  getTotalEnergy(): number;
-  /**
-   * Add a random pattern to the CA
-   */
-  addRandomPattern(density: number): void;
-  /**
-   * Create a new 2D geometric cellular automaton
-   */
-  constructor(width: number, height: number);
-  /**
-   * Evolve the CA by one generation
-   */
-  step(): void;
-  /**
-   * Reset the CA to initial state
-   */
-  reset(): void;
-  /**
-   * Get a cell value using 2D coordinates
-   */
-  getCell(x: number, y: number): Float64Array;
-  /**
-   * Get the entire grid as a flattened array of coefficients
-   */
-  getGrid(): Float64Array;
-  /**
-   * Set a cell value using 2D coordinates
-   */
-  setCell(x: number, y: number, coefficients: Float64Array): void;
-  /**
-   * Set the entire grid from a flattened array of coefficients
-   */
-  setGrid(grid: Float64Array): void;
-  /**
-   * Set the CA rule type (simplified)
-   */
-  setRule(rule_type: string): void;
-}
-/**
- * WASM wrapper for network edges
- */
-export class WasmGeometricEdge {
-  free(): void;
-  /**
-   * Create a new geometric edge
-   */
-  constructor(source: number, target: number, weight: number);
-  /**
-   * Get the source node
-   */
-  readonly source: number;
-  /**
-   * Get the target node
-   */
-  readonly target: number;
-  /**
-   * Get the edge weight
-   */
-  readonly weight: number;
-}
-/**
- * WASM wrapper for geometric networks
- */
-export class WasmGeometricNetwork {
-  free(): void;
-  /**
-   * Get the degree of a node
-   */
-  getDegree(node: number): number;
-  /**
-   * Get neighbors of a node
-   */
-  getNeighbors(node: number): Uint32Array;
-  /**
-   * Find shortest path between two nodes using edge weights
-   */
-  shortestPath(source: number, target: number): any;
-  /**
-   * Create a network with pre-allocated capacity
-   */
-  static withCapacity(num_nodes: number, num_edges: number): WasmGeometricNetwork;
-  /**
-   * Detect communities using geometric clustering
-   */
-  findCommunities(num_communities: number): Array<any>;
-  /**
-   * Compute geometric distance between two nodes
-   */
-  geometricDistance(node1: number, node2: number): number;
-  /**
-   * Simulate information diffusion through the network
-   */
-  simulateDiffusion(initial_sources: Uint32Array, max_steps: number, diffusion_rate: number): WasmPropagationAnalysis;
-  /**
-   * Add an undirected edge (creates two directed edges)
-   */
-  addUndirectedEdge(a: number, b: number, weight: number): void;
-  /**
-   * Perform spectral clustering
-   */
-  spectralClustering(num_clusters: number): Array<any>;
-  /**
-   * Convert to tropical network for efficient path operations
-   */
-  toTropicalNetwork(): WasmTropicalNetwork;
-  /**
-   * Add a node with metadata
-   */
-  addNodeWithMetadata(coefficients: Float64Array, label?: string | null): number;
-  /**
-   * Find shortest path using geometric distances
-   */
-  shortestGeometricPath(source: number, target: number): any;
-  /**
-   * Compute geometric centrality for all nodes
-   */
-  computeGeometricCentrality(): Float64Array;
-  /**
-   * Compute betweenness centrality for all nodes
-   */
-  computeBetweennessCentrality(): Float64Array;
-  /**
-   * Create a new empty geometric network
-   */
-  constructor();
-  /**
-   * Add a directed edge between two nodes
-   */
-  addEdge(source: number, target: number, weight: number): void;
-  /**
-   * Add a node at the specified position (using flat coefficient array)
-   */
-  addNode(coefficients: Float64Array): number;
-  /**
-   * Get node position as coefficient array
-   */
-  getNode(index: number): Float64Array | undefined;
-  /**
-   * Get the number of edges in the network
-   */
-  numEdges(): number;
-  /**
-   * Get the number of nodes in the network
-   */
-  numNodes(): number;
-}
-/**
- * GPU-accelerated optimization wrapper for WASM
- */
-export class WasmGpuOptimizer {
-  free(): void;
-  /**
-   * Initialize GPU context for optimization
-   */
-  initializeGpu(): Promise<boolean>;
-  /**
-   * Batch optimization with parallel processing simulation
-   */
-  optimizeBatch(problems_data: Float64Array, problem_size: number, num_problems: number, max_iterations: number, tolerance: number): Promise<Float64Array>;
-  /**
-   * Optimize a quadratic function with GPU acceleration
-   */
-  optimizeQuadraticGpu(coefficients: Float64Array, initial_point: Float64Array, max_iterations: number, tolerance: number): Promise<WasmOptimizationResult>;
-  /**
-   * Check if GPU acceleration is available
-   */
-  isGpuAvailable(): boolean;
-  /**
-   * Create a new GPU optimizer
-   */
-  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
- */
-export class WasmGrassmannian {
-  free(): void;
-  /**
-   * Get the dimension of this Grassmannian
-   */
-  getDimension(): number;
-  /**
-   * Get the parameters (k, n) of this Grassmannian
-   */
-  getParameters(): Uint32Array;
-  /**
-   * Create a new Grassmannian Gr(k, n) of k-planes in n-space
-   */
-  constructor(k: number, n: number);
-}
-/**
- * WASM wrapper for HolographicMemory using ProductClifford algebra
- */
-export class WasmHolographicMemory {
-  free(): void;
-  /**
-   * Get the number of stored items
-   */
-  itemCount(): number;
-  /**
-   * Get the estimated SNR (signal-to-noise ratio)
-   */
-  estimatedSnr(): number;
-  /**
-   * Generate a random versor (for use as key/value)
-   */
-  static randomVersor(num_factors: number): Float64Array;
-  /**
-   * Check if memory is near capacity
-   */
-  isNearCapacity(): boolean;
-  /**
-   * Create with key tracking enabled (for attribution)
-   */
-  static withKeyTracking(): WasmHolographicMemory;
-  /**
-   * Get retrieval confidence for a key
-   */
-  retrieveConfidence(key: Float64Array): number;
-  /**
-   * Get capacity information
-   */
-  theoreticalCapacity(): number;
-  /**
-   * Create a new holographic memory with default settings
-   */
-  constructor();
-  /**
-   * Clear all stored items
-   */
-  clear(): void;
-  /**
-   * Store a key-value pair in memory (using flat coefficient arrays)
-   *
-   * Each array should have 256 coefficients for ProductCl3x32.
-   */
-  store(key: Float64Array, value: Float64Array): void;
-  /**
-   * Retrieve a value by key
-   *
-   * Returns the retrieved coefficients as a Float64Array.
-   */
-  retrieve(key: Float64Array): Float64Array;
-}
-/**
- * WASM wrapper for Inverse CA Designer (simplified)
- */
-export class WasmInverseCADesigner {
-  free(): void;
-  /**
-   * Set the target pattern that we want to achieve
-   */
-  setTarget(target_grid: Float64Array): void;
-  /**
-   * Evaluate fitness of a candidate configuration
-   */
-  evaluateFitness(candidate: Float64Array): number;
-  /**
-   * Create a new inverse designer for finding CA seeds
-   */
-  constructor(target_width: number, target_height: number);
-  /**
-   * Find a seed configuration that produces the target after evolution (simplified)
-   */
-  findSeed(_max_generations: number, max_attempts: number): Float64Array;
-}
-/**
- * WASM wrapper for Lebesgue measure
- *
- * The Lebesgue measure generalizes the notion of length, area, and volume
- * to higher dimensions and more complex sets.
- */
-export class WasmLebesgueMeasure {
-  free(): void;
-  /**
-   * Compute the measure of a box (hyper-rectangle) with given side lengths
-   */
-  measureBox(sides: Float64Array): number;
-  /**
-   * Get the dimension of this measure
-   */
-  getDimension(): number;
-  /**
-   * Compute the measure of an interval [a, b]
-   *
-   * For 1D: returns length (b - a)
-   * For higher dimensions: returns the product of interval lengths
-   */
-  measureInterval(lower: Float64Array, upper: Float64Array): number;
-  /**
-   * Create a new Lebesgue measure for the specified dimension
-   *
-   * # Arguments
-   * * `dimension` - The dimension of the space (1 for length, 2 for area, 3 for volume, etc.)
-   */
-  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)
- */
-export class WasmModuliSpace {
-  private constructor();
-  free(): void;
-  /**
-   * Create moduli space of stable curves
-   */
-  static ofStableCurves(genus: number, marked_points: number): WasmModuliSpace;
-  /**
-   * Get the number of marked points
-   */
-  getMarkedPoints(): number;
-  /**
-   * Get the expected dimension
-   */
-  expectedDimension(): number;
-  /**
-   * Get the genus
-   */
-  getGenus(): number;
-  /**
-   * Check if the moduli space is proper
-   */
-  isProper(): boolean;
-  /**
-   * Create moduli space of curves M_g,n
-   */
-  static ofCurves(genus: number, marked_points: number): WasmModuliSpace;
-}
-/**
- * Monte Carlo estimation utilities
- */
-export class WasmMonteCarloEstimator {
-  private constructor();
-  free(): void;
-  /**
-   * Compute sample mean from batch samples
-   *
-   * # Arguments
-   * * `samples` - Flat array of samples (num_samples * 8)
-   *
-   * # Returns
-   * 8 coefficients for the mean
-   */
-  static sampleMean(samples: Float64Array): Float64Array;
-  /**
-   * Compute sample variance from batch samples
-   *
-   * # Arguments
-   * * `samples` - Flat array of samples (num_samples * 8)
-   *
-   * # Returns
-   * 8 values for per-coefficient variance
-   */
-  static sampleVariance(samples: Float64Array): Float64Array;
-  /**
-   * Compute sample covariance matrix from batch samples
-   *
-   * # Arguments
-   * * `samples` - Flat array of samples (num_samples * 8)
-   *
-   * # Returns
-   * 64 values for 8x8 covariance matrix (row-major)
-   */
-  static sampleCovariance(samples: Float64Array): Float64Array;
-  /**
-   * Monte Carlo estimate of expectation E[f(X)] where f is the geometric product
-   *
-   * Estimates E[X * Y] for independent X ~ dist_x, Y ~ dist_y
-   */
-  static expectationGeometricProduct(dist_x: WasmGaussianMultivector, dist_y: WasmGaussianMultivector, num_samples: number): Float64Array;
-}
-/**
- * WASM wrapper for multi-variable dual numbers
- */
-export class WasmMultiDualNumber {
-  free(): void;
-  /**
-   * Get a specific partial derivative
-   */
-  getPartial(index: number): number;
-  /**
-   * Get the gradient (all partial derivatives)
-   */
-  getGradient(): Float64Array;
-  /**
-   * Get number of variables
-   */
-  getNumVars(): number;
-  /**
-   * Addition
-   */
-  add(other: WasmMultiDualNumber): WasmMultiDualNumber;
-  /**
-   * Multiplication
-   */
-  mul(other: WasmMultiDualNumber): WasmMultiDualNumber;
-  /**
-   * Create a new multi-dual number
-   */
-  constructor(real: number, duals: Float64Array);
-  /**
-   * Square root
-   */
-  sqrt(): WasmMultiDualNumber;
-  /**
-   * Create a constant (all derivatives are zero)
-   */
-  static constant(value: number, num_vars: number): WasmMultiDualNumber;
-  /**
-   * Get the real part (function value)
-   */
-  getReal(): number;
-  /**
-   * Create a variable with derivative 1 at the specified index
-   */
-  static variable(value: number, num_vars: number, var_index: number): WasmMultiDualNumber;
-}
-/**
- * Simple multi-objective optimizer for WASM
- */
-export class WasmMultiObjectiveOptimizer {
-  free(): void;
-  /**
-   * Optimize a simple bi-objective problem
-   * f1 = sum(x_i^2), f2 = sum((x_i - 1)^2)
-   */
-  optimizeBiObjective(dimension: number, population_size: number, generations: number): WasmMultiObjectiveResult;
-  /**
-   * Create a new multi-objective optimizer
-   */
-  constructor();
-}
-/**
- * Multi-objective optimization result
- */
-export class WasmMultiObjectiveResult {
-  private constructor();
-  free(): void;
-  /**
-   * Get number of generations
-   */
-  readonly generations: number;
-  /**
-   * Get Pareto front as flattened array
-   */
-  readonly pareto_front: Float64Array;
-  /**
-   * Check if optimization converged
-   */
-  readonly converged: boolean;
-}
-/**
- * WASM wrapper for Multivector with TypedArray support
- */
-export class WasmMultivector {
-  free(): void;
-  /**
-   * Create a basis vector (0-indexed)
-   */
-  static basisVector(index: number): WasmMultivector;
-  /**
-   * Inner product (dot product for vectors)
-   */
-  innerProduct(other: WasmMultivector): WasmMultivector;
-  /**
-   * Outer product (wedge product)
-   */
-  outerProduct(other: WasmMultivector): WasmMultivector;
-  /**
-   * Scalar product
-   */
-  scalarProduct(other: WasmMultivector): number;
-  /**
-   * Get a specific coefficient
-   */
-  getCoefficient(index: number): number;
-  /**
-   * Set a specific coefficient
-   */
-  setCoefficient(index: number, value: number): void;
-  /**
-   * Get coefficients as a Float64Array
-   */
-  getCoefficients(): Float64Array;
-  /**
-   * Grade projection
-   */
-  gradeProjection(grade: number): WasmMultivector;
-  /**
-   * Create from a Float64Array of coefficients
-   */
-  static fromCoefficients(coefficients: Float64Array): WasmMultivector;
-  /**
-   * Geometric product
-   */
-  geometricProduct(other: WasmMultivector): WasmMultivector;
-  /**
-   * Add two multivectors
-   */
-  add(other: WasmMultivector): WasmMultivector;
-  /**
-   * Exponential (for bivectors to create rotors)
-   */
-  exp(): WasmMultivector;
-  /**
-   * Create a new zero multivector
-   */
-  constructor();
-  /**
-   * Subtract two multivectors
-   */
-  sub(other: WasmMultivector): WasmMultivector;
-  /**
-   * Compute norm (alias for magnitude, maintained for compatibility)
-   */
-  norm(): number;
-  /**
-   * Scale by a scalar
-   */
-  scale(scalar: number): WasmMultivector;
-  /**
-   * Create a scalar multivector
-   */
-  static scalar(value: number): WasmMultivector;
-  /**
-   * Compute inverse
-   */
-  inverse(): WasmMultivector;
-  /**
-   * Reverse
-   */
-  reverse(): WasmMultivector;
-  /**
-   * Compute magnitude
-   */
-  magnitude(): number;
-  /**
-   * Normalize
-   */
-  normalize(): WasmMultivector;
-}
-/**
- * WASM wrapper for node metadata
- */
-export class WasmNodeMetadata {
-  free(): void;
-  /**
-   * Create metadata with label
-   */
-  static withLabel(label: string): WasmNodeMetadata;
-  /**
-   * Get a numerical property
-   */
-  getProperty(key: string): number | undefined;
-  /**
-   * Add a numerical property
-   */
-  setProperty(key: string, value: number): void;
-  /**
-   * Create new empty metadata
-   */
-  constructor();
-  /**
-   * Get the label
-   */
-  get label(): string | undefined;
-  /**
-   * Set the label
-   */
-  set label(value: string | null | undefined);
-}
-/**
- * WASM wrapper for optimization results
- */
-export class WasmOptimizationResult {
-  private constructor();
-  free(): void;
-  /**
-   * Get number of iterations
-   */
-  readonly iterations: number;
-  /**
-   * Get final objective value
-   */
-  readonly objective_value: number;
-  /**
-   * Get solution vector
-   */
-  readonly solution: Float64Array;
-  /**
-   * Check if optimization converged
-   */
-  readonly converged: boolean;
-}
-/**
- * Utility functions for optimization
- */
-export class WasmOptimizationUtils {
-  private constructor();
-  free(): void;
-  /**
-   * Compute numerical gradient
-   */
-  static numericalGradient(coefficients: Float64Array, point: Float64Array, epsilon: number): Float64Array;
-  /**
-   * Check if a point dominates another in multi-objective optimization
-   */
-  static dominates(objectives1: Float64Array, objectives2: Float64Array): boolean;
-}
-/**
- * Parametric probability density families
- */
-export class WasmParametricDensity {
-  private constructor();
-  free(): void;
-  /**
-   * Create an Exponential density Exp(λ)
-   */
-  static exponential(): WasmParametricDensity;
-  /**
-   * Compute log-density log p(x|θ)
-   */
-  logDensity(x: number, params: Float64Array): number;
-  /**
-   * Compute Fisher information matrix from data samples
-   */
-  fisherInformation(data: Float64Array, params: Float64Array): Float64Array;
-  /**
-   * Create a Cauchy density Cauchy(x₀, γ)
-   */
-  static cauchy(): WasmParametricDensity;
-  /**
-   * Create a Laplace density Laplace(μ, b)
-   */
-  static laplace(): WasmParametricDensity;
-  /**
-   * Evaluate density at point x with parameters
-   *
-   * # Arguments
-   * * `x` - Point to evaluate
-   * * `params` - Parameters (Gaussian: [μ, σ], Exponential: [λ], etc.)
-   */
-  evaluate(x: number, params: Float64Array): number;
-  /**
-   * Create a Gaussian density N(μ, σ²)
-   */
-  static gaussian(): WasmParametricDensity;
-  /**
-   * Compute numerical gradient ∇_θ p(x|θ)
-   */
-  gradient(x: number, params: Float64Array): Float64Array;
-}
-/**
- * WASM wrapper for probability measures
- *
- * A probability measure assigns total measure 1 to the entire space.
- */
-export class WasmProbabilityMeasure {
-  free(): void;
-  /**
-   * Get a description of this probability measure
-   */
-  getDescription(): string;
-  /**
-   * Compute P(X ∈ [a, b]) for uniform distribution
-   */
-  probabilityInterval(a: number, b: number, lower: number, upper: number): number;
-  /**
-   * Create a new uniform probability measure on [0, 1]
-   */
-  constructor();
-  /**
-   * Create a uniform probability measure on [a, b]
-   */
-  static uniform(a: number, b: number): WasmProbabilityMeasure;
-}
-/**
- * WASM wrapper for projective spaces
- */
-export class WasmProjectiveSpace {
-  free(): void;
-  /**
-   * Get the dimension of this projective space
-   */
-  getDimension(): number;
-  /**
-   * Check if the projective space has given dimension
-   */
-  hasDimension(dim: number): boolean;
-  /**
-   * Compute Bézout intersection number for two curves
-   */
-  bezoutIntersection(degree1: number, degree2: number): number;
-  /**
-   * Create a new projective space of given dimension
-   */
-  constructor(dimension: number);
-}
-/**
- * WASM wrapper for propagation analysis
- */
-export class WasmPropagationAnalysis {
-  private constructor();
-  free(): void;
-  /**
-   * Get convergence time
-   */
-  readonly convergenceTime: number;
-  /**
-   * Get influence scores for each node
-   */
-  readonly influenceScores: Float64Array;
-  /**
-   * Get coverage over time
-   */
-  readonly coverage: Uint32Array;
-}
-/**
- * Physical constants
- */
-export class WasmRelativisticConstants {
-  private constructor();
-  free(): void;
-  /**
-   * Earth mass (kg)
-   */
-  static readonly earth_mass: number;
-  /**
-   * Solar mass (kg)
-   */
-  static readonly solar_mass: number;
-  /**
-   * Speed of light in vacuum (m/s)
-   */
-  static readonly speed_of_light: number;
-  /**
-   * Gravitational constant (m³/kg·s²)
-   */
-  static readonly gravitational_constant: number;
-}
-/**
- * WASM wrapper for relativistic particles
- */
-export class WasmRelativisticParticle {
-  free(): void;
-  /**
-   * Get 3D position components
-   */
-  position_3d(): Array<any>;
-  /**
-   * Get position as spacetime vector
-   */
-  position_4d(): WasmSpacetimeVector;
-  /**
-   * Create particle with specified energy
-   */
-  static with_energy(x: number, y: number, z: number, direction_x: number, direction_y: number, direction_z: number, kinetic_energy: number, mass: number, charge: number): WasmRelativisticParticle;
-  /**
-   * Get total energy
-   */
-  total_energy(): number;
-  /**
-   * Get four-velocity
-   */
-  four_velocity(): WasmFourVelocity;
-  /**
-   * Get kinetic energy
-   */
-  kinetic_energy(): number;
-  /**
-   * Get momentum magnitude
-   */
-  momentum_magnitude(): number;
-  /**
-   * Create a new relativistic particle
-   */
-  constructor(x: number, y: number, z: number, vx: number, vy: number, vz: number, spin: number, mass: number, charge: number);
-  /**
-   * Get rest mass
-   */
-  mass(): number;
-  /**
-   * Get electric charge
-   */
-  charge(): number;
-  /**
-   * Get string representation
-   */
-  to_string(): string;
-}
-/**
- * WASM wrapper for Resonator using ProductClifford algebra
- */
-export class WasmResonator {
-  free(): void;
-  /**
-   * Get the codebook size
-   */
-  codebookSize(): number;
-  /**
-   * Get cleanup result with metadata
-   */
-  cleanupWithInfo(input: Float64Array): any;
-  /**
-   * Create a resonator from a flat codebook array
-   *
-   * Each item should have 256 coefficients for ProductCl3x32.
-   */
-  constructor(codebook_flat: Float64Array);
-  /**
-   * Clean up a noisy input to find the closest codebook item
-   */
-  cleanup(input: Float64Array): Float64Array;
-}
-/**
- * Rotor operations for WASM
- */
-export class WasmRotor {
-  private constructor();
-  free(): void;
-  /**
-   * Create a rotor from a bivector and angle
-   */
-  static fromBivector(bivector: WasmMultivector, angle: number): WasmRotor;
-  /**
-   * Apply rotor to a multivector
-   */
-  apply(mv: WasmMultivector): WasmMultivector;
-  /**
-   * Compose two rotors
-   */
-  compose(other: WasmRotor): WasmRotor;
-  /**
-   * Get inverse rotor
-   */
-  inverse(): WasmRotor;
-}
-/**
- * WASM wrapper for Schwarzschild metric
- */
-export class WasmSchwarzschildMetric {
-  private constructor();
-  free(): void;
-  /**
-   * Check for singularity at given position
-   */
-  has_singularity(position: WasmSpacetimeVector): boolean;
-  /**
-   * Compute effective potential for circular orbits
-   */
-  effective_potential(r: number, angular_momentum: number): number;
-  /**
-   * Get Schwarzschild radius
-   */
-  schwarzschild_radius(): number;
-  /**
-   * Create Schwarzschild metric for the Sun
-   */
-  static sun(): WasmSchwarzschildMetric;
-  /**
-   * Get central mass
-   */
-  mass(): number;
-  /**
-   * Create Schwarzschild metric for Earth
-   */
-  static earth(): WasmSchwarzschildMetric;
-  /**
-   * Create Schwarzschild metric for custom mass
-   */
-  static from_mass(mass: number): WasmSchwarzschildMetric;
-}
-/**
- * Simplified WASM wrapper for basic self-assembly concepts
- */
-export class WasmSelfAssembler {
-  free(): void;
-  /**
-   * Add a component to the system
-   */
-  addComponent(type_name: string, position: Float64Array): number;
-  /**
-   * Check basic stability (simplified: no overlapping components)
-   */
-  checkStability(): boolean;
-  /**
-   * Get component count
-   */
-  getComponentCount(): number;
-  /**
-   * Create a new simplified self-assembler
-   */
-  constructor();
-}
-/**
- * WASM wrapper for sensitivity analysis results
- */
-export class WasmSensitivityMap {
-  private constructor();
-  free(): void;
-  /**
-   * Get components with highest sensitivity (for optimization)
-   */
-  getMostSensitive(n: number): Uint32Array;
-  /**
-   * Get all sensitivities as JavaScript arrays
-   */
-  getAllSensitivities(): any;
-  /**
-   * Get total sensitivity across all components
-   */
-  getTotalSensitivity(): number;
-}
-/**
- * Simple quadratic optimization problem for WASM demonstration
- */
-export class WasmSimpleOptimizer {
-  free(): void;
-  /**
-   * Optimize a simple quadratic function: minimize sum(c_i * x_i^2)
-   */
-  optimizeQuadratic(coefficients: Float64Array, initial_point: Float64Array): WasmOptimizationResult;
-  /**
-   * Create a new simple optimizer
-   */
-  constructor();
-}
-/**
- * WASM wrapper for spacetime vectors
- */
-export class WasmSpacetimeVector {
-  free(): void;
-  /**
-   * Check if vector is timelike (massive particle)
-   */
-  is_timelike(): boolean;
-  /**
-   * Check if vector is spacelike
-   */
-  is_spacelike(): boolean;
-  /**
-   * Compute Minkowski norm squared
-   */
-  norm_squared(): number;
-  /**
-   * Compute Minkowski inner product with another spacetime vector
-   */
-  minkowski_dot(other: WasmSpacetimeVector): number;
-  /**
-   * Create a new spacetime vector with components (ct, x, y, z)
-   */
-  constructor(t: number, x: number, y: number, z: number);
-  /**
-   * Check if vector is null (lightlike)
-   */
-  is_null(): boolean;
-  /**
-   * Create a timelike vector
-   */
-  static timelike(t: number): WasmSpacetimeVector;
-  /**
-   * Create a spacelike vector
-   */
-  static spacelike(x: number, y: number, z: number): WasmSpacetimeVector;
-  /**
-   * Get string representation
-   */
-  to_string(): string;
-  /**
-   * Get temporal component
-   */
-  readonly t: number;
-  /**
-   * Get x component
-   */
-  readonly x: number;
-  /**
-   * Get y component
-   */
-  readonly y: number;
-  /**
-   * Get z component
-   */
-  readonly z: number;
-}
-/**
- * Trajectory point for particle propagation
- */
-export class WasmTrajectoryPoint {
-  private constructor();
-  free(): void;
-  /**
-   * Time coordinate
-   */
-  time: number;
-  /**
-   * Get position
-   */
-  readonly position: WasmSpacetimeVector;
-}
-/**
- * WASM wrapper for tropical curves (simplified)
- */
-export class WasmTropicalCurve {
-  free(): void;
-  /**
-   * Get the degree of this tropical curve
-   */
-  getDegree(): number;
-  /**
-   * Compute expected number of vertices using Euler characteristic
-   */
-  expectedVertices(): number;
-  /**
-   * Create a new tropical curve with given degree and genus
-   */
-  constructor(degree: number, genus: number);
-  /**
-   * Get the genus of this tropical curve
-   */
-  getGenus(): number;
-}
-/**
- * WASM wrapper for TropicalDualClifford fusion system
- */
-export class WasmTropicalDualClifford {
-  free(): void;
-  /**
-   * Compute similarity between two TDC objects
-   *
-   * Uses the proper Clifford inner product with reverse: <A B̃>₀ / (|A| |B|)
-   * Returns a value in [-1, 1].
-   */
-  similarity(other: WasmTropicalDualClifford): number;
-  /**
-   * Create a random unit vector TDC (grade 1 only)
-   *
-   * Unit vectors are guaranteed invertible and useful for
-   * proper VSA (Vector Symbolic Architecture) operations.
-   */
-  static randomVector(): WasmTropicalDualClifford;
-  /**
-   * Compute binding inverse
-   *
-   * If successful, `x.bind(x.bindingInverse()) ≈ identity`
-   */
-  bindingInverse(): WasmTropicalDualClifford;
-  /**
-   * Get the binding identity element
-   *
-   * `x.bind(identity) = x` for any x
-   */
-  static bindingIdentity(): WasmTropicalDualClifford;
-  /**
-   * Normalize the TDC to unit norm
-   */
-  normalizeToUnit(): WasmTropicalDualClifford;
-  /**
-   * Compute Clifford similarity (proper inner product with reverse)
-   */
-  cliffordSimilarity(other: WasmTropicalDualClifford): number;
-  /**
-   * Bind two TDC objects using geometric product (creates associations)
-   *
-   * The result is dissimilar to both inputs - useful for creating
-   * key-value associations in holographic memory.
-   */
-  bind(other: WasmTropicalDualClifford): WasmTropicalDualClifford;
-  /**
-   * Bundle two TDC objects (superposition/aggregation)
-   *
-   * The result is similar to both inputs - useful for storing
-   * multiple associations in the same memory trace.
-   * `beta` controls soft (1.0) vs hard (∞) bundling.
-   */
-  bundle(other: WasmTropicalDualClifford, beta: number): WasmTropicalDualClifford;
-  /**
-   * Unbind: retrieve associated value
-   *
-   * If `bound = key.bind(value)`, then `key.unbind(bound) ≈ value`
-   */
-  unbind(other: WasmTropicalDualClifford): WasmTropicalDualClifford;
-  /**
-   * Create from logits (array of log-probabilities)
-   */
-  static fromLogits(logits: Float64Array): WasmTropicalDualClifford;
-  /**
-   * Compute fusion norm (combined measure across all systems)
-   */
-  fusionNorm(): number;
-  /**
-   * Interpolate between two TDC systems (useful for animation)
-   */
-  interpolate(other: WasmTropicalDualClifford, t: number): WasmTropicalDualClifford;
-  /**
-   * Extract dual features as array of real parts
-   */
-  getDualReals(): Float64Array;
-  /**
-   * Create random TDC with specific scale
-   */
-  static randomWithScale(scale: number): WasmTropicalDualClifford;
-  /**
-   * Create from probability distribution
-   *
-   * Note: Converts probabilities to log space for tropical representation
-   */
-  static fromProbabilities(probs: Float64Array): WasmTropicalDualClifford;
-  /**
-   * Perform tropical attention operation
-   */
-  tropicalAttention(keys: Float64Array, values: Float64Array): Float64Array;
-  /**
-   * Extract dual features as array of dual parts (derivatives)
-   */
-  getDualDerivatives(): Float64Array;
-  /**
-   * Perform sensitivity analysis for gradient-based optimization
-   *
-   * Note: This feature is not yet available in v0.12.0
-   * TODO: Re-enable when sensitivity_analysis is added to TropicalDualClifford
-   */
-  sensitivityAnalysis(): WasmSensitivityMap;
-  /**
-   * Extract tropical features as array
-   */
-  getTropicalFeatures(): Float64Array;
-  /**
-   * Get Clifford coefficients
-   */
-  getCliffordCoefficients(): Float64Array;
-  /**
-   * Extract geometric features using Clifford operations
-   */
-  extractGeometricFeatures(): Float64Array;
-  /**
-   * Add two TDC objects
-   */
-  add(other: WasmTropicalDualClifford): WasmTropicalDualClifford;
-  /**
-   * Create a zero TDC object
-   */
-  constructor();
-  /**
-   * Scale TDC object
-   */
-  scale(factor: number): WasmTropicalDualClifford;
-  /**
-   * Create random TDC for testing
-   */
-  static random(): WasmTropicalDualClifford;
-  /**
-   * Check if TDC is zero
-   */
-  isZero(): boolean;
-  /**
-   * Compute distance between two TDC systems
-   */
-  distance(other: WasmTropicalDualClifford): number;
-  /**
-   * Evaluate two TDC systems (core LLM comparison operation)
-   */
-  evaluate(other: WasmTropicalDualClifford): WasmEvaluationResult;
-  /**
-   * Transform using another TDC (advanced operation)
-   */
-  transform(transformation: WasmTropicalDualClifford): WasmTropicalDualClifford;
-}
-/**
- * Tropical (max-plus) algebra operations for optimization
- */
-export class WasmTropicalMeasure {
-  free(): void;
-  /**
-   * Tropical integration (supremum over region)
-   */
-  tropicalIntegrate(f: Function, a: number, b: number, samples: number): number;
-  /**
-   * Create a new tropical measure
-   */
-  constructor();
-  /**
-   * Compute tropical infimum (minimum) of function over sample points
-   *
-   * Returns the minimum value and the point where it occurs
-   */
-  infimum(f: Function, points: Float64Array): Float64Array;
-  /**
-   * Compute tropical supremum (maximum) of function over sample points
-   *
-   * Returns the maximum value and the point where it occurs
-   */
-  supremum(f: Function, points: Float64Array): Float64Array;
-}
-/**
- * WASM wrapper for tropical networks
- */
-export class WasmTropicalNetwork {
-  free(): void;
-  /**
-   * Create tropical network from weight matrix
-   */
-  static fromWeights(weights: Float64Array, size: number): WasmTropicalNetwork;
-  /**
-   * Compute tropical betweenness centrality
-   */
-  tropicalBetweenness(): Float64Array;
-  /**
-   * Find shortest path using tropical algebra
-   */
-  shortestPathTropical(source: number, target: number): any;
-  /**
-   * Create a new tropical network with given size
-   */
-  constructor(size: number);
-  /**
-   * Get the number of nodes
-   */
-  getSize(): number;
-  /**
-   * Set edge weight between two nodes
-   */
-  setEdge(source: number, target: number, weight: number): void;
-}
-/**
- * WASM wrapper for TropicalNumber
- */
-export class WasmTropicalNumber {
-  free(): void;
-  /**
-   * Check if this is infinite
-   *
-   * Note: Manual implementation as is_infinity() not in v0.12.0 API
-   */
-  isInfinity(): boolean;
-  /**
-   * Tropical addition (max operation)
-   */
-  tropicalAdd(other: WasmTropicalNumber): WasmTropicalNumber;
-  /**
-   * Tropical multiplication (addition)
-   */
-  tropicalMul(other: WasmTropicalNumber): WasmTropicalNumber;
-  /**
-   * Tropical power (scalar multiplication)
-   */
-  tropicalPow(n: number): WasmTropicalNumber;
-  /**
-   * Create from log probability
-   *
-   * Note: Manual implementation as from_log_prob() not in v0.12.0 API
-   */
-  static fromLogProb(log_p: number): WasmTropicalNumber;
-  /**
-   * Standard addition (for convenience)
-   */
-  add(other: WasmTropicalNumber): WasmTropicalNumber;
-  /**
-   * Standard multiplication (for convenience)
-   */
-  mul(other: WasmTropicalNumber): WasmTropicalNumber;
-  /**
-   * Negation
-   *
-   * Note: Manual implementation as Neg trait not implemented in v0.12.0 API
-   */
-  neg(): WasmTropicalNumber;
-  /**
-   * Create a new tropical number from a regular number
-   */
-  constructor(value: number);
-  /**
-   * Create tropical one (regular zero)
-   */
-  static one(): WasmTropicalNumber;
-  /**
-   * Create tropical zero (negative infinity)
-   */
-  static zero(): WasmTropicalNumber;
-  /**
-   * Check if this is tropical one (zero)
-   */
-  isOne(): boolean;
-  /**
-   * Check if this is tropical zero (negative infinity)
-   */
-  isZero(): boolean;
-  /**
-   * Convert to probability (via exp)
-   *
-   * Note: Manual implementation as to_prob() not in v0.12.0 API
-   */
-  toProb(): number;
-  /**
-   * Get the underlying value
-   */
-  getValue(): number;
-}
-/**
- * WASM wrapper for TropicalPolynomial - polynomial operations in tropical algebra
- */
-export class WasmTropicalPolynomial {
-  free(): void;
-  /**
-   * Find tropical roots of the polynomial
-   */
-  tropical_roots(): Array<any>;
-  /**
-   * Get the number of coefficients
-   */
-  coefficients_count(): number;
-  /**
-   * Create a new tropical polynomial from coefficients
-   */
-  constructor(coefficients: Float64Array);
-  /**
-   * Evaluate the polynomial at a given tropical number
-   */
-  evaluate(x: WasmTropicalNumber): WasmTropicalNumber;
-}
-/**
- * WASM wrapper for TropicalViterbi - Hidden Markov Model decoding
- */
-export class WasmTropicalViterbi {
-  free(): void;
-  /**
-   * Compute forward probabilities for all states
-   */
-  forward_probabilities(observations: Uint32Array): Array<any>;
-  /**
-   * Create a new Viterbi decoder
-   *
-   * # Arguments
-   * * `transitions` - Transition probability matrix (2D array)
-   * * `emissions` - Emission probability matrix (2D array)
-   */
-  constructor(transitions: any, emissions: any);
-  /**
-   * Decode the most likely state sequence for given observations
-   *
-   * Returns an object with `states` (array of state indices) and `probability` (log probability)
-   */
-  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
- *
- * A uniform distribution over a hyperrectangle in 8-dimensional multivector space.
- */
-export class WasmUniformMultivector {
-  free(): void;
-  /**
-   * Create a uniform distribution with specified bounds
-   *
-   * # Arguments
-   * * `lower` - 8 coefficients for lower bounds
-   * * `upper` - 8 coefficients for upper bounds
-   */
-  static withBounds(lower: Float64Array, upper: Float64Array): WasmUniformMultivector;
-  /**
-   * Get the variance of this distribution
-   */
-  getVariance(): Float64Array;
-  /**
-   * Draw multiple samples from this distribution
-   *
-   * Returns flat array of coefficients: num_samples * 8
-   */
-  sampleBatch(num_samples: number): Float64Array;
-  /**
-   * Create a standard uniform distribution on [-1, 1]^8
-   */
-  constructor();
-  /**
-   * Draw a sample from this distribution
-   *
-   * Returns 8 coefficients for the sampled multivector
-   */
-  sample(): Float64Array;
-  /**
-   * Get the mean of this distribution
-   */
-  getMean(): Float64Array;
-  /**
-   * Compute log probability of a multivector
-   *
-   * Returns log(1/volume) if inside bounds, error otherwise
-   */
-  logProb(coefficients: Float64Array): number;
-  /**
-   * Get the lower bounds
-   */
-  getLower(): Float64Array;
-  /**
-   * Get the upper bounds
-   */
-  getUpper(): Float64Array;
-  /**
-   * Create a uniform distribution on a hypercube [min, max]^8
-   */
-  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_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_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;
-  readonly __wbg_wasmevaluationresult_free: (a: number, b: number) => void;
-  readonly __wbg_wasmfisherinformationmatrix_free: (a: number, b: number) => void;
-  readonly __wbg_wasmfishermeasure_free: (a: number, b: number) => void;
-  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_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_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_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;
-  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];
-  readonly autodiff_meanSquaredError: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly autodiff_numericalDerivative: (a: number, b: any, c: number) => [number, number, number];
-  readonly automatabatchoperations_batchEvolve: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
-  readonly automatabatchoperations_batchFitness: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
-  readonly automatabatchoperations_batchStabilityCheck: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  readonly automatautils_createLifePattern: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  readonly automatautils_generateRandomSeed: (a: number, b: number, c: number) => [number, number];
-  readonly automatautils_parseRuleString: (a: number, b: number) => [number, number, number];
-  readonly automatautils_validateGrid: (a: number, b: number, c: number, d: number) => number;
-  readonly batchoperations_batchAdd: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  readonly batchoperations_batchGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  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 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;
-  readonly enumerativeutils_bezoutMultiplicity: (a: number, b: number, c: number) => number;
-  readonly enumerativeutils_binomial: (a: number, b: number) => [number, number, number];
-  readonly enumerativeutils_canIntersectTransversely: (a: number, b: number, c: number) => number;
-  readonly enumerativeutils_eulerCharacteristic: (a: number) => number;
-  readonly enumerativeutils_expectedRationalCurves: (a: number, b: number) => [number, number, number];
-  readonly enumerativeutils_validatePartition: (a: number, b: number, c: number, d: number) => number;
-  readonly expectation: (a: any, b: number, c: number, d: number) => [number, number, number];
-  readonly fusionbatchoperations_batchDistance: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
-  readonly fusionbatchoperations_batchEvaluate: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
-  readonly fusionbatchoperations_batchSensitivity: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly fusionbatchoperations_batchTropicalAttention: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
-  readonly fusionbatchoperations_fusionSimilarity: (a: number, b: number) => number;
-  readonly fusionbatchoperations_gradientStep: (a: number, b: number) => number;
-  readonly fusionutils_normalizeLogits: (a: number, b: number) => [number, number];
-  readonly fusionutils_softmaxToTropical: (a: number, b: number) => [number, number];
-  readonly fusionutils_tropicalToSoftmax: (a: number, b: number) => [number, number];
-  readonly fusionutils_validateLogits: (a: number, b: number) => number;
-  readonly gamma_to_velocity: (a: number) => [number, number, number];
-  readonly infogeomutils_crossEntropy: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly infogeomutils_entropy: (a: number, b: number) => [number, number, number];
-  readonly infogeomutils_mutualInformation: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
-  readonly infogeomutils_normalize: (a: number, b: number) => [number, number, number, number];
-  readonly infogeomutils_randomSimplex: (a: number) => [number, number];
-  readonly init: () => void;
-  readonly initAutomata: () => void;
-  readonly initEnumerative: () => void;
-  readonly initFusion: () => void;
-  readonly initHolographic: () => void;
-  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 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];
-  readonly mlops_crossEntropyLoss: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly mlops_gradientDescentStep: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
-  readonly mlops_softmax: (a: number, b: number) => [number, number];
-  readonly networkutils_clusteringCoefficient: (a: number) => number;
-  readonly networkutils_createRandomNetwork: (a: number, b: number) => [number, number, number];
-  readonly networkutils_createSmallWorldNetwork: (a: number, b: number, c: number) => [number, number, number];
-  readonly numericalderivative_curl: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  readonly numericalderivative_divergence: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly numericalderivative_gradient: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  readonly numericalderivative_laplacian: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly numericalderivative_new: (a: number, b: number) => number;
-  readonly performanceoperations_batchNormalize: (a: number, b: number, c: number) => [number, number];
-  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 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];
-  readonly riemannianmanifold_geodesic: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
-  readonly riemannianmanifold_hyperbolic: () => number;
-  readonly riemannianmanifold_ricciTensor: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-  readonly riemannianmanifold_riemannTensor: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
-  readonly riemannianmanifold_scalarCurvature: (a: number, b: number, c: number) => [number, number, number];
-  readonly riemannianmanifold_sphere: (a: number) => [number, number, number];
-  readonly scalarfield_batchEvaluate: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly scalarfield_evaluate: (a: number, b: number, c: number) => [number, number, number];
-  readonly scalarfield_fromFunction2D: (a: any) => number;
-  readonly scalarfield_fromFunction3D: (a: any) => number;
-  readonly scalarfield_new: (a: any, b: number) => number;
-  readonly tropicalbatch_batchTropicalAdd: (a: number, b: number) => number;
-  readonly tropicalbatch_batchTropicalMul: (a: number, b: number) => number;
-  readonly tropicalbatch_maxLogProb: (a: number, b: number) => number;
-  readonly tropicalbatch_viterbiStep: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
-  readonly tropicalmlops_convexCombination: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly tropicalmlops_matrixMultiply: (a: any, b: any) => [number, number, number];
-  readonly tropicalmlops_shortestPaths: (a: any) => [number, number, number];
-  readonly validate_relativistic_module: () => number;
-  readonly vectorfield_evaluate: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly velocity_to_gamma: (a: number) => [number, number, number];
-  readonly wasmalphaconnection_getAlpha: (a: number) => number;
-  readonly wasmalphaconnection_isExponential: (a: number) => number;
-  readonly wasmalphaconnection_isLeviCivita: (a: number) => number;
-  readonly wasmalphaconnection_isMixture: (a: number) => number;
-  readonly wasmalphaconnection_new: (a: number) => [number, number, number];
-  readonly wasmchowclass_getDegree: (a: number) => number;
-  readonly wasmchowclass_getDimension: (a: number) => number;
-  readonly wasmchowclass_hypersurface: (a: number) => number;
-  readonly wasmchowclass_isZero: (a: number) => number;
-  readonly wasmchowclass_linearSubspace: (a: number) => number;
-  readonly wasmchowclass_multiply: (a: number, b: number) => number;
-  readonly wasmchowclass_new: (a: number, b: number) => number;
-  readonly wasmchowclass_point: () => number;
-  readonly wasmchowclass_power: (a: number, b: number) => number;
-  readonly wasmcommunity_centroid_coefficients: (a: number) => [number, number];
-  readonly wasmcommunity_nodes: (a: number) => [number, number];
-  readonly wasmcountingmeasure_isMeasurable: (a: number) => number;
-  readonly wasmcountingmeasure_measureFiniteSet: (a: number, b: number) => number;
-  readonly wasmcountingmeasure_new: () => number;
-  readonly wasmduallyflatmanifold_bregmanDivergence: (a: number, b: number, c: number, d: number, e: number) => number;
-  readonly wasmduallyflatmanifold_fisherMetricAt: (a: number, b: number, c: number) => number;
-  readonly wasmduallyflatmanifold_jsDivergence: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-  readonly wasmduallyflatmanifold_klDivergence: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-  readonly wasmduallyflatmanifold_new: (a: number, b: number) => number;
-  readonly wasmduallyflatmanifold_wassersteinDistance: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-  readonly wasmdualnumber_add: (a: number, b: number) => number;
-  readonly wasmdualnumber_constant: (a: number) => number;
-  readonly wasmdualnumber_cos: (a: number) => number;
-  readonly wasmdualnumber_cosh: (a: number) => number;
-  readonly wasmdualnumber_div: (a: number, b: number) => [number, number, number];
-  readonly wasmdualnumber_exp: (a: number) => number;
-  readonly wasmdualnumber_getDual: (a: number) => number;
-  readonly wasmdualnumber_ln: (a: number) => [number, number, number];
-  readonly wasmdualnumber_max: (a: number, b: number) => number;
-  readonly wasmdualnumber_min: (a: number, b: number) => number;
-  readonly wasmdualnumber_mul: (a: number, b: number) => number;
-  readonly wasmdualnumber_neg: (a: number) => number;
-  readonly wasmdualnumber_new: (a: number, b: number) => number;
-  readonly wasmdualnumber_pow: (a: number, b: number) => number;
-  readonly wasmdualnumber_powi: (a: number, b: number) => number;
-  readonly wasmdualnumber_relu: (a: number) => number;
-  readonly wasmdualnumber_sigmoid: (a: number) => number;
-  readonly wasmdualnumber_sin: (a: number) => number;
-  readonly wasmdualnumber_sinh: (a: number) => number;
-  readonly wasmdualnumber_softplus: (a: number) => number;
-  readonly wasmdualnumber_sqrt: (a: number) => [number, number, number];
-  readonly wasmdualnumber_sub: (a: number, b: number) => number;
-  readonly wasmdualnumber_tan: (a: number) => number;
-  readonly wasmdualnumber_tanh: (a: number) => number;
-  readonly wasmdualnumber_variable: (a: number) => number;
-  readonly wasmevaluationresult_getCombinedScore: (a: number) => number;
-  readonly wasmevaluationresult_getGeometricDistance: (a: number) => number;
-  readonly wasmevaluationresult_toObject: (a: number) => [number, number, number];
-  readonly wasmfisherinformationmatrix_conditionNumber: (a: number) => number;
-  readonly wasmfisherinformationmatrix_getEigenvalues: (a: number) => [number, number];
-  readonly wasmfisherinformationmatrix_isPositiveDefinite: (a: number) => number;
-  readonly wasmfishermeasure_fisherMetric: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
-  readonly wasmfishermeasure_fromDensity: (a: number) => number;
-  readonly wasmfishermeasure_volumeElement: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-  readonly wasmfourvelocity_as_spacetime_vector: (a: number) => number;
-  readonly wasmfourvelocity_from_velocity: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmfourvelocity_gamma: (a: number) => number;
-  readonly wasmfourvelocity_is_normalized: (a: number) => number;
-  readonly wasmfourvelocity_rapidity: (a: number) => number;
-  readonly wasmfourvelocity_spatial_velocity_magnitude: (a: number) => number;
-  readonly wasmfourvelocity_to_string: (a: number) => [number, number];
-  readonly wasmgaussianmultivector_getCovariance: (a: number) => [number, number];
-  readonly wasmgaussianmultivector_getMean: (a: number) => [number, number];
-  readonly wasmgaussianmultivector_getStdDevs: (a: number) => [number, number];
-  readonly wasmgaussianmultivector_getVariance: (a: number) => [number, number];
-  readonly wasmgaussianmultivector_gradeConcentrated: (a: number, b: number) => [number, number, number];
-  readonly wasmgaussianmultivector_isotropic: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmgaussianmultivector_logProb: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmgaussianmultivector_new: () => number;
-  readonly wasmgaussianmultivector_sample: (a: number) => [number, number];
-  readonly wasmgaussianmultivector_sampleBatch: (a: number, b: number) => [number, number];
-  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;
-  readonly wasmgeometricca_getCell: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly wasmgeometricca_getDimensions: (a: number) => [number, number];
-  readonly wasmgeometricca_getGrid: (a: number) => [number, number];
-  readonly wasmgeometricca_getPopulation: (a: number) => number;
-  readonly wasmgeometricca_getStatistics: (a: number) => [number, number, number];
-  readonly wasmgeometricca_getTotalEnergy: (a: number) => number;
-  readonly wasmgeometricca_new: (a: number, b: number) => number;
-  readonly wasmgeometricca_reset: (a: number) => void;
-  readonly wasmgeometricca_setCell: (a: number, b: number, c: number, d: number, e: number) => [number, number];
-  readonly wasmgeometricca_setGrid: (a: number, b: number, c: number) => [number, number];
-  readonly wasmgeometricca_setRule: (a: number, b: number, c: number) => [number, number];
-  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 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];
-  readonly wasmgeometricnetwork_addUndirectedEdge: (a: number, b: number, c: number, d: number) => [number, number];
-  readonly wasmgeometricnetwork_computeBetweennessCentrality: (a: number) => [number, number, number, number];
-  readonly wasmgeometricnetwork_computeGeometricCentrality: (a: number) => [number, number, number, number];
-  readonly wasmgeometricnetwork_findCommunities: (a: number, b: number) => [number, number, number];
-  readonly wasmgeometricnetwork_geometricDistance: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmgeometricnetwork_getDegree: (a: number, b: number) => number;
-  readonly wasmgeometricnetwork_getNeighbors: (a: number, b: number) => [number, number];
-  readonly wasmgeometricnetwork_getNode: (a: number, b: number) => [number, number];
-  readonly wasmgeometricnetwork_new: () => number;
-  readonly wasmgeometricnetwork_numEdges: (a: number) => number;
-  readonly wasmgeometricnetwork_numNodes: (a: number) => number;
-  readonly wasmgeometricnetwork_shortestGeometricPath: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmgeometricnetwork_shortestPath: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmgeometricnetwork_simulateDiffusion: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-  readonly wasmgeometricnetwork_spectralClustering: (a: number, b: number) => [number, number, number];
-  readonly wasmgeometricnetwork_toTropicalNetwork: (a: number) => [number, number, number];
-  readonly wasmgeometricnetwork_withCapacity: (a: number, b: number) => number;
-  readonly wasmgpuoptimizer_initializeGpu: (a: number) => any;
-  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 wasmholographicmemory_clear: (a: number) => void;
-  readonly wasmholographicmemory_estimatedSnr: (a: number) => number;
-  readonly wasmholographicmemory_isNearCapacity: (a: number) => number;
-  readonly wasmholographicmemory_itemCount: (a: number) => number;
-  readonly wasmholographicmemory_new: () => number;
-  readonly wasmholographicmemory_randomVersor: (a: number) => [number, number];
-  readonly wasmholographicmemory_retrieve: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly wasmholographicmemory_retrieveConfidence: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmholographicmemory_store: (a: number, b: number, c: number, d: number, e: number) => [number, number];
-  readonly wasmholographicmemory_theoreticalCapacity: (a: number) => number;
-  readonly wasmholographicmemory_withKeyTracking: () => number;
-  readonly wasminversecadesigner_evaluateFitness: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasminversecadesigner_findSeed: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly wasminversecadesigner_new: (a: number, b: number) => number;
-  readonly wasminversecadesigner_setTarget: (a: number, b: number, c: number) => [number, number];
-  readonly wasmlebesguemeasure_getDimension: (a: number) => number;
-  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;
-  readonly wasmmodulispace_ofCurves: (a: number, b: number) => number;
-  readonly wasmmodulispace_ofStableCurves: (a: number, b: number) => number;
-  readonly wasmmontecarloestimator_expectationGeometricProduct: (a: number, b: number, c: number) => [number, number];
-  readonly wasmmontecarloestimator_sampleCovariance: (a: number, b: number) => [number, number, number, number];
-  readonly wasmmontecarloestimator_sampleMean: (a: number, b: number) => [number, number, number, number];
-  readonly wasmmontecarloestimator_sampleVariance: (a: number, b: number) => [number, number, number, number];
-  readonly wasmmultidualnumber_add: (a: number, b: number) => [number, number, number];
-  readonly wasmmultidualnumber_constant: (a: number, b: number) => number;
-  readonly wasmmultidualnumber_getGradient: (a: number) => [number, number];
-  readonly wasmmultidualnumber_getNumVars: (a: number) => number;
-  readonly wasmmultidualnumber_getPartial: (a: number, b: number) => [number, number, number];
-  readonly wasmmultidualnumber_mul: (a: number, b: number) => [number, number, number];
-  readonly wasmmultidualnumber_new: (a: number, b: number, c: number) => number;
-  readonly wasmmultidualnumber_sqrt: (a: number) => [number, number, number];
-  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];
-  readonly wasmmultivector_exp: (a: number) => number;
-  readonly wasmmultivector_fromCoefficients: (a: number, b: number) => [number, number, number];
-  readonly wasmmultivector_geometricProduct: (a: number, b: number) => number;
-  readonly wasmmultivector_getCoefficient: (a: number, b: number) => number;
-  readonly wasmmultivector_getCoefficients: (a: number) => [number, number];
-  readonly wasmmultivector_gradeProjection: (a: number, b: number) => number;
-  readonly wasmmultivector_innerProduct: (a: number, b: number) => number;
-  readonly wasmmultivector_inverse: (a: number) => [number, number, number];
-  readonly wasmmultivector_magnitude: (a: number) => number;
-  readonly wasmmultivector_new: () => number;
-  readonly wasmmultivector_normalize: (a: number) => [number, number, number];
-  readonly wasmmultivector_outerProduct: (a: number, b: number) => number;
-  readonly wasmmultivector_reverse: (a: number) => number;
-  readonly wasmmultivector_scalar: (a: number) => number;
-  readonly wasmmultivector_scalarProduct: (a: number, b: number) => number;
-  readonly wasmmultivector_scale: (a: number, b: number) => number;
-  readonly wasmmultivector_setCoefficient: (a: number, b: number, c: number) => void;
-  readonly wasmmultivector_sub: (a: number, b: number) => number;
-  readonly wasmnodemetadata_getProperty: (a: number, b: number, c: number) => [number, number];
-  readonly wasmnodemetadata_label: (a: number) => [number, number];
-  readonly wasmnodemetadata_new: () => number;
-  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 wasmoptimizationresult_converged: (a: number) => number;
-  readonly wasmoptimizationresult_solution: (a: number) => [number, number];
-  readonly wasmoptimizationutils_dominates: (a: number, b: number, c: number, d: number) => number;
-  readonly wasmoptimizationutils_numericalGradient: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
-  readonly wasmparametricdensity_cauchy: () => number;
-  readonly wasmparametricdensity_evaluate: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly wasmparametricdensity_exponential: () => number;
-  readonly wasmparametricdensity_fisherInformation: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
-  readonly wasmparametricdensity_gaussian: () => number;
-  readonly wasmparametricdensity_gradient: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  readonly wasmparametricdensity_laplace: () => number;
-  readonly wasmparametricdensity_logDensity: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly wasmprobabilitymeasure_getDescription: (a: number) => [number, number];
-  readonly wasmprobabilitymeasure_new: () => number;
-  readonly wasmprobabilitymeasure_probabilityInterval: (a: number, b: number, c: number, d: number, e: number) => number;
-  readonly wasmprobabilitymeasure_uniform: (a: number, b: number) => [number, number, number];
-  readonly wasmprojectivespace_bezoutIntersection: (a: number, b: number, c: number) => number;
-  readonly wasmprojectivespace_hasDimension: (a: number, b: number) => number;
-  readonly wasmprojectivespace_new: (a: number) => number;
-  readonly wasmpropagationanalysis_coverage: (a: number) => [number, number];
-  readonly wasmpropagationanalysis_influence_scores: (a: number) => [number, number];
-  readonly wasmrelativisticconstants_earth_mass: () => number;
-  readonly wasmrelativisticconstants_gravitational_constant: () => number;
-  readonly wasmrelativisticconstants_solar_mass: () => number;
-  readonly wasmrelativisticconstants_speed_of_light: () => number;
-  readonly wasmrelativisticparticle_charge: (a: number) => number;
-  readonly wasmrelativisticparticle_four_velocity: (a: number) => number;
-  readonly wasmrelativisticparticle_kinetic_energy: (a: number) => number;
-  readonly wasmrelativisticparticle_mass: (a: number) => number;
-  readonly wasmrelativisticparticle_momentum_magnitude: (a: number) => number;
-  readonly wasmrelativisticparticle_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
-  readonly wasmrelativisticparticle_position_3d: (a: number) => any;
-  readonly wasmrelativisticparticle_position_4d: (a: number) => number;
-  readonly wasmrelativisticparticle_to_string: (a: number) => [number, number];
-  readonly wasmrelativisticparticle_total_energy: (a: number) => number;
-  readonly wasmrelativisticparticle_with_energy: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
-  readonly wasmresonator_cleanup: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly wasmresonator_cleanupWithInfo: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmresonator_codebookSize: (a: number) => number;
-  readonly wasmresonator_new: (a: number, b: number) => [number, number, number];
-  readonly wasmrotor_apply: (a: number, b: number) => number;
-  readonly wasmrotor_compose: (a: number, b: number) => number;
-  readonly wasmrotor_fromBivector: (a: number, b: number) => number;
-  readonly wasmschwarzschildmetric_earth: () => number;
-  readonly wasmschwarzschildmetric_effective_potential: (a: number, b: number, c: number) => number;
-  readonly wasmschwarzschildmetric_from_mass: (a: number) => number;
-  readonly wasmschwarzschildmetric_has_singularity: (a: number, b: number) => number;
-  readonly wasmschwarzschildmetric_schwarzschild_radius: (a: number) => number;
-  readonly wasmschwarzschildmetric_sun: () => number;
-  readonly wasmselfassembler_addComponent: (a: number, b: number, c: number, d: number, e: number) => number;
-  readonly wasmselfassembler_checkStability: (a: number) => number;
-  readonly wasmselfassembler_getComponentCount: (a: number) => number;
-  readonly wasmselfassembler_new: () => number;
-  readonly wasmsensitivitymap_getAllSensitivities: (a: number) => [number, number, number];
-  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 wasmspacetimevector_is_null: (a: number) => number;
-  readonly wasmspacetimevector_is_spacelike: (a: number) => number;
-  readonly wasmspacetimevector_is_timelike: (a: number) => number;
-  readonly wasmspacetimevector_minkowski_dot: (a: number, b: number) => number;
-  readonly wasmspacetimevector_new: (a: number, b: number, c: number, d: number) => number;
-  readonly wasmspacetimevector_norm_squared: (a: number) => number;
-  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 wasmtropicalcurve_expectedVertices: (a: number) => number;
-  readonly wasmtropicalcurve_getDegree: (a: number) => number;
-  readonly wasmtropicalcurve_new: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_add: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_bind: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_bindingIdentity: () => number;
-  readonly wasmtropicaldualclifford_bindingInverse: (a: number) => [number, number, number];
-  readonly wasmtropicaldualclifford_bundle: (a: number, b: number, c: number) => number;
-  readonly wasmtropicaldualclifford_cliffordSimilarity: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_distance: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_evaluate: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_extractGeometricFeatures: (a: number) => [number, number];
-  readonly wasmtropicaldualclifford_fromLogits: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_fromProbabilities: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_fusionNorm: (a: number) => number;
-  readonly wasmtropicaldualclifford_getCliffordCoefficients: (a: number) => [number, number];
-  readonly wasmtropicaldualclifford_getDualDerivatives: (a: number) => [number, number];
-  readonly wasmtropicaldualclifford_getDualReals: (a: number) => [number, number];
-  readonly wasmtropicaldualclifford_getTropicalFeatures: (a: number) => [number, number];
-  readonly wasmtropicaldualclifford_interpolate: (a: number, b: number, c: number) => number;
-  readonly wasmtropicaldualclifford_isZero: (a: number) => number;
-  readonly wasmtropicaldualclifford_new: () => number;
-  readonly wasmtropicaldualclifford_normalizeToUnit: (a: number) => number;
-  readonly wasmtropicaldualclifford_random: () => number;
-  readonly wasmtropicaldualclifford_randomVector: () => number;
-  readonly wasmtropicaldualclifford_randomWithScale: (a: number) => number;
-  readonly wasmtropicaldualclifford_scale: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_sensitivityAnalysis: (a: number) => number;
-  readonly wasmtropicaldualclifford_similarity: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_transform: (a: number, b: number) => number;
-  readonly wasmtropicaldualclifford_tropicalAttention: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
-  readonly wasmtropicaldualclifford_unbind: (a: number, b: number) => number;
-  readonly wasmtropicalmeasure_infimum: (a: number, b: any, c: number, d: number) => [number, number, number, number];
-  readonly wasmtropicalmeasure_supremum: (a: number, b: any, c: number, d: number) => [number, number, number, number];
-  readonly wasmtropicalmeasure_tropicalIntegrate: (a: number, b: any, c: number, d: number, e: number) => [number, number, number];
-  readonly wasmtropicalnetwork_fromWeights: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmtropicalnetwork_new: (a: number) => number;
-  readonly wasmtropicalnetwork_setEdge: (a: number, b: number, c: number, d: number) => [number, number];
-  readonly wasmtropicalnetwork_shortestPathTropical: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmtropicalnetwork_tropicalBetweenness: (a: number) => [number, number, number, number];
-  readonly wasmtropicalnumber_add: (a: number, b: number) => number;
-  readonly wasmtropicalnumber_fromLogProb: (a: number) => number;
-  readonly wasmtropicalnumber_isInfinity: (a: number) => number;
-  readonly wasmtropicalnumber_isOne: (a: number) => number;
-  readonly wasmtropicalnumber_mul: (a: number, b: number) => number;
-  readonly wasmtropicalnumber_neg: (a: number) => number;
-  readonly wasmtropicalnumber_one: () => number;
-  readonly wasmtropicalnumber_toProb: (a: number) => number;
-  readonly wasmtropicalnumber_tropicalPow: (a: number, b: 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];
-  readonly wasmuniformmultivector_getVariance: (a: number) => [number, number];
-  readonly wasmuniformmultivector_hypercube: (a: number, b: number) => [number, number, number];
-  readonly wasmuniformmultivector_logProb: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmuniformmultivector_new: () => [number, number, number];
-  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;
-  readonly wasmtropicalnumber_tropicalMul: (a: number, b: number) => number;
-  readonly wasmtrajectorypoint_position: (a: number) => number;
-  readonly wasmtropicalpolynomial_coefficients_count: (a: number) => number;
-  readonly infogeomutils_softmax: (a: number, b: number) => [number, number];
-  readonly __wbg_wasmparametricdensity_free: (a: number, b: number) => void;
-  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;
-  readonly wasmoptimizationresult_objective_value: (a: number) => number;
-  readonly wasmprojectivespace_getDimension: (a: number) => number;
-  readonly wasmpropagationanalysis_convergence_time: (a: number) => number;
-  readonly wasmschwarzschildmetric_mass: (a: number) => number;
-  readonly wasmspacetimevector_x: (a: number) => number;
-  readonly wasmspacetimevector_y: (a: number) => number;
-  readonly wasmspacetimevector_z: (a: number) => number;
-  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;
-  readonly __wbg_batchops_free: (a: number, b: number) => void;
-  readonly __wbg_enumerativebatch_free: (a: number, b: number) => void;
-  readonly __wbg_enumerativeutils_free: (a: number, b: number) => void;
-  readonly __wbg_fusionbatchoperations_free: (a: number, b: number) => void;
-  readonly __wbg_fusionutils_free: (a: number, b: number) => void;
-  readonly __wbg_infogeomutils_free: (a: number, b: number) => void;
-  readonly __wbg_integration_free: (a: number, b: number) => void;
-  readonly __wbg_mlops_free: (a: number, b: number) => void;
-  readonly __wbg_networkutils_free: (a: number, b: number) => void;
-  readonly __wbg_performanceoperations_free: (a: number, b: number) => void;
-  readonly __wbg_tropicalbatch_free: (a: number, b: number) => void;
-  readonly __wbg_tropicalmlops_free: (a: number, b: number) => void;
-  readonly __wbg_wasmalphaconnection_free: (a: number, b: number) => void;
-  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;
-  readonly __wbg_wasmmultiobjectiveoptimizer_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_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;
-  readonly wasmgpuoptimizer_new: () => number;
-  readonly wasmmultiobjectiveoptimizer_new: () => number;
-  readonly wasmsimpleoptimizer_new: () => number;
-  readonly wasmtropicalmeasure_new: () => number;
-  readonly __wbindgen_exn_store: (a: number) => void;
-  readonly __externref_table_alloc: () => number;
-  readonly __wbindgen_export_2: WebAssembly.Table;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_malloc: (a: number, b: number) => number;
-  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 __wbindgen_start: () => void;
-}
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-/**
-* Instantiates the given `module`, which can either be bytes or
-* a precompiled `WebAssembly.Module`.
-*
-* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
-*
-* @returns {InitOutput}
-*/
-export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
-
-/**
-* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
-* for everything else, calls `WebAssembly.instantiate` directly.
-*
-* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
-*
-* @returns {Promise<InitOutput>}
-*/
-export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;