@justinelliottcobb/amari-wasm 0.9.2 → 0.9.4

package/amari_wasm.d.ts

@@ -1,25 +1,105 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Initialize the enumerative geometry module
+ */
+export function initEnumerative(): void;
 /**
  * Convert Lorentz factor to velocity
  */
 export function gamma_to_velocity(gamma: number): number;
 /**
- * Convert velocity to Lorentz factor
+ * Validate that this module loaded correctly
  */
-export function velocity_to_gamma(velocity_magnitude: number): number;
+export function validate_relativistic_module(): boolean;
 /**
  * Calculate light deflection angle for photon grazing massive object
  */
 export function light_deflection_angle(impact_parameter: number, mass: number): number;
 /**
- * Validate that this module loaded correctly
+ * Convert velocity to Lorentz factor
  */
-export function validate_relativistic_module(): boolean;
+export function velocity_to_gamma(velocity_magnitude: number): number;
 /**
  * Initialize the WASM module
  */
 export function init(): void;
+/**
+ * Initialize the fusion module
+ */
+export function initFusion(): void;
+/**
+ * Initialize the automata module
+ */
+export function initAutomata(): void;
+/**
+ * Automatic differentiation utilities
+ */
+export class AutoDiff {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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
  */
@@ -38,20 +118,209 @@ export class BatchOperations {
   static batchAdd(a_batch: Float64Array, b_batch: Float64Array): Float64Array;
 }
 /**
- * Batch network operations for performance
+ * Batch operations for efficient computation
+ */
+export class BatchOps {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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 NetworkBatchOperations {
+export class EnumerativeUtils {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Fast geometric clustering using k-means in 3D space
+   * 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;
+  [Symbol.dispose](): 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
+   */
+  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;
+  [Symbol.dispose](): 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
    */
-  static geometricKMeansClustering(positions: Float64Array, num_nodes: number, k: number, max_iterations: number): Uint32Array;
+  static softmaxToTropical(probs: Float64Array): Float64Array;
   /**
-   * Compute all pairwise distances in a network
+   * Convert tropical numbers back to softmax probabilities
    */
-  static computeAllPairwiseDistances(positions: Float64Array, num_nodes: number): Float64Array;
+  static tropicalToSoftmax(tropical_values: Float64Array): Float64Array;
+}
+/**
+ * Information geometry utilities
+ */
+export class InfoGeomUtils {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): 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;
+}
+/**
+ * Advanced machine learning operations using dual numbers
+ */
+export class MLOps {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
 }
 /**
  * High-performance WASM operations with memory pooling
@@ -77,6 +346,330 @@ export class PerformanceOperations {
    */
   static fastGeometricProduct(lhs: Float64Array, rhs: Float64Array): Float64Array;
 }
+/**
+ * Batch operations for tropical numbers
+ */
+export class TropicalBatch {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
+}
+/**
+ * WASM wrapper for AlphaConnection
+ */
+export class WasmAlphaConnection {
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): void;
+  /**
+   * Get cohesion score
+   */
+  readonly cohesionScore: number;
+  /**
+   * Get geometric centroid coefficients
+   */
+  readonly centroidCoefficients: Float64Array;
+  /**
+   * Get community member nodes
+   */
+  readonly nodes: Uint32Array;
+}
+/**
+ * WASM wrapper for single-variable dual numbers
+ */
+export class WasmDualNumber {
+  free(): void;
+  [Symbol.dispose](): 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
+   */
+  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
+   */
+  softplus(): WasmDualNumber;
+  /**
+   * Create a variable (derivative = 1)
+   */
+  static variable(value: number): WasmDualNumber;
+}
+/**
+ * WASM wrapper for DuallyFlatManifold
+ */
+export class WasmDuallyFlatManifold {
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
+}
 /**
  * WASM wrapper for four-velocity
  */
@@ -130,73 +723,302 @@ export class WasmGeodesicIntegrator {
   static with_schwarzschild(metric: WasmSchwarzschildMetric): WasmGeodesicIntegrator;
 }
 /**
- * WASM wrapper for GeometricNetwork
+ * WASM wrapper for Geometric Cellular Automaton
+ */
+export class WasmGeometricCA {
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
+}
+/**
+ * WASM wrapper for Grassmannian varieties
+ */
+export class WasmGrassmannian {
+  free(): void;
+  [Symbol.dispose](): 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 Inverse CA Designer (simplified)
+ */
+export class WasmInverseCADesigner {
+  free(): void;
+  [Symbol.dispose](): 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 moduli spaces (simplified)
  */
-export class WasmGeometricNetwork {
+export class WasmModuliSpace {
+  private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Get degree of a node
+   * Create moduli space of stable curves
    */
-  getDegree(node: number): number;
+  static ofStableCurves(genus: number, marked_points: number): WasmModuliSpace;
   /**
-   * Get neighbors of a node
+   * Get the number of marked points
    */
-  getNeighbors(node: number): Uint32Array;
+  getMarkedPoints(): number;
   /**
-   * Find shortest path between two nodes
-   * Returns the path as an array of node indices, or null if no path exists
+   * Get the expected dimension
    */
-  shortestPath(source: number, target: number): Uint32Array | undefined;
+  expectedDimension(): number;
   /**
-   * Add a labeled node
+   * Get the genus
    */
-  addLabeledNode(x: number, y: number, z: number, label: string): number;
+  getGenus(): number;
   /**
-   * Find communities using geometric clustering
+   * Check if the moduli space is proper
    */
-  findCommunities(num_communities: number): Uint32Array;
+  isProper(): boolean;
   /**
-   * Get node position as [x, y, z]
+   * Create moduli space of curves M_g,n
    */
-  getNodePosition(node: number): Float64Array | undefined;
+  static ofCurves(genus: number, marked_points: number): WasmModuliSpace;
+}
+/**
+ * WASM wrapper for multi-variable dual numbers
+ */
+export class WasmMultiDualNumber {
+  free(): void;
+  [Symbol.dispose](): void;
   /**
-   * Compute geometric distance between two nodes
+   * Get a specific partial derivative
    */
-  geometricDistance(node1: number, node2: number): number;
+  getPartial(index: number): number;
   /**
-   * Add an undirected edge
+   * Get the gradient (all partial derivatives)
    */
-  addUndirectedEdge(a: number, b: number, weight: number): void;
+  getGradient(): Float64Array;
   /**
-   * Find shortest path with distance between two nodes
-   * Returns an object with path and distance, or null if no path exists
+   * Get number of variables
    */
-  shortestPathWithDistance(source: number, target: number): any;
+  getNumVars(): number;
   /**
-   * Compute geometric centrality for all nodes
+   * Addition
    */
-  computeGeometricCentrality(): Float64Array;
+  add(other: WasmMultiDualNumber): WasmMultiDualNumber;
   /**
-   * Create a new geometric network
+   * Multiplication
    */
-  constructor();
+  mul(other: WasmMultiDualNumber): WasmMultiDualNumber;
   /**
-   * Add an edge between two nodes
+   * Create a new multi-dual number
    */
-  addEdge(source: number, target: number, weight: number): void;
+  constructor(real: number, duals: Float64Array);
   /**
-   * Add a node at the given position
+   * Square root
    */
-  addNode(x: number, y: number, z: number): number;
+  sqrt(): WasmMultiDualNumber;
   /**
-   * Get number of edges
+   * Create a constant (all derivatives are zero)
    */
-  numEdges(): number;
+  static constant(value: number, num_vars: number): WasmMultiDualNumber;
   /**
-   * Get number of nodes
+   * Get the real part (function value)
    */
-  numNodes(): number;
+  getReal(): number;
+  /**
+   * Create a variable with derivative 1 at the specified index
+   */
+  static variable(value: number, num_vars: number, var_index: number): WasmMultiDualNumber;
 }
 /**
  * WASM wrapper for Multivector with TypedArray support
@@ -289,6 +1111,80 @@ export class WasmMultivector {
    */
   normalize(): WasmMultivector;
 }
+/**
+ * WASM wrapper for node metadata
+ */
+export class WasmNodeMetadata {
+  free(): void;
+  [Symbol.dispose](): 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 projective spaces
+ */
+export class WasmProjectiveSpace {
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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
  */
@@ -424,6 +1320,49 @@ export class WasmSchwarzschildMetric {
    */
   static from_mass(mass: number): WasmSchwarzschildMetric;
 }
+/**
+ * Simplified WASM wrapper for basic self-assembly concepts
+ */
+export class WasmSelfAssembler {
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
+}
 /**
  * WASM wrapper for spacetime vectors
  */
@@ -499,34 +1438,448 @@ export class WasmTrajectoryPoint {
    */
   time: number;
 }
+/**
+ * WASM wrapper for tropical curves (simplified)
+ */
+export class WasmTropicalCurve {
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): void;
+  /**
+   * 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
+   */
+  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
+   */
+  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;
+}
+/**
+ * WASM wrapper for LLM token distributions
+ */
+export class WasmTropicalDualDistribution {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute KL divergence with automatic gradients
+   */
+  klDivergence(other: WasmTropicalDualDistribution): any;
+  /**
+   * Get vocabulary size
+   */
+  getVocabSize(): number;
+  /**
+   * Get attention pattern as tropical polytope vertices
+   */
+  attentionPolytope(): Float64Array;
+  /**
+   * Compute geometric alignment with reference distribution
+   */
+  geometricAlignment(reference: WasmTropicalDualDistribution): number;
+  /**
+   * Generate most likely sequence using tropical algebra (Viterbi-like)
+   */
+  mostLikelySequence(length: number): Uint32Array;
+  /**
+   * Create from logit vector (typical LLM output)
+   */
+  constructor(logits: Float64Array);
+}
+/**
+ * WASM wrapper for tropical networks
+ */
+export class WasmTropicalNetwork {
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): void;
+  /**
+   * Check if this is infinite
+   */
+  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
+   */
+  static fromLogProb(log_p: number): WasmTropicalNumber;
+  /**
+   * Standard addition (for convenience)
+   */
+  add(other: WasmTropicalNumber): WasmTropicalNumber;
+  /**
+   * Standard multiplication (for convenience)
+   */
+  mul(other: WasmTropicalNumber): WasmTropicalNumber;
+  /**
+   * Negation
+   */
+  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)
+   */
+  toProb(): number;
+  /**
+   * Get the underlying value
+   */
+  getValue(): number;
+}
+/**
+ * WASM wrapper for TropicalPolynomial - polynomial operations in tropical algebra
+ */
+export class WasmTropicalPolynomial {
+  free(): void;
+  [Symbol.dispose](): 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;
+  [Symbol.dispose](): 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;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly __wbg_batchoperations_free: (a: number, b: number) => void;
+  readonly __wbg_autodiff_free: (a: number, b: number) => void;
   readonly __wbg_get_wasmtrajectorypoint_time: (a: number) => number;
   readonly __wbg_set_wasmtrajectorypoint_time: (a: number, b: number) => void;
-  readonly __wbg_wasmfourvelocity_free: (a: number, b: number) => void;
+  readonly __wbg_wasmalphaconnection_free: (a: number, b: number) => void;
+  readonly __wbg_wasmchowclass_free: (a: number, b: number) => void;
+  readonly __wbg_wasmcommunity_free: (a: number, b: number) => void;
+  readonly __wbg_wasmduallyflatmanifold_free: (a: number, b: number) => void;
+  readonly __wbg_wasmevaluationresult_free: (a: number, b: number) => void;
+  readonly __wbg_wasmfisherinformationmatrix_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_wasmgrassmannian_free: (a: number, b: number) => void;
+  readonly __wbg_wasminversecadesigner_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_wasmprojectivespace_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_wasmschwarzschildmetric_free: (a: number, b: number) => void;
+  readonly __wbg_wasmselfassembler_free: (a: number, b: number) => void;
+  readonly __wbg_wasmsensitivitymap_free: (a: number, b: number) => void;
   readonly __wbg_wasmtrajectorypoint_free: (a: number, b: number) => void;
+  readonly __wbg_wasmtropicaldualclifford_free: (a: number, b: number) => void;
+  readonly __wbg_wasmtropicaldualdistribution_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 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 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 infogeomutils_softmax: (a: number, b: number) => [number, number];
   readonly init: () => void;
+  readonly initAutomata: () => void;
+  readonly initEnumerative: () => void;
+  readonly initFusion: () => void;
   readonly light_deflection_angle: (a: number, b: number) => number;
-  readonly networkbatchoperations_computeAllPairwiseDistances: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly networkbatchoperations_geometricKMeansClustering: (a: number, b: number, c: number, d: number, e: number) => [number, number, 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 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 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 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 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 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;
@@ -536,21 +1889,66 @@ export interface InitOutput {
   readonly wasmfourvelocity_to_string: (a: 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 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_addLabeledNode: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
-  readonly wasmgeometricnetwork_addNode: (a: number, b: number, c: number, d: 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, 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_getNodePosition: (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_shortestPath: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly wasmgeometricnetwork_shortestPathWithDistance: (a: number, b: number, c: number) => [number, 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 wasmgrassmannian_getDimension: (a: number) => number;
+  readonly wasmgrassmannian_getParameters: (a: number) => [number, number];
+  readonly wasmgrassmannian_new: (a: number, b: number) => [number, number, 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 wasmmodulispace_expectedDimension: (a: number) => number;
+  readonly wasmmodulispace_getGenus: (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 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 wasmmultivector_add: (a: number, b: number) => number;
   readonly wasmmultivector_basisVector: (a: number) => [number, number, number];
   readonly wasmmultivector_exp: (a: number) => number;
@@ -571,6 +1969,18 @@ export interface InitOutput {
   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 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_convergence_time: (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;
@@ -593,9 +2003,15 @@ export interface InitOutput {
   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_mass: (a: 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 wasmspacetimevector_is_null: (a: number) => number;
   readonly wasmspacetimevector_is_spacelike: (a: number) => number;
   readonly wasmspacetimevector_is_timelike: (a: number) => number;
@@ -605,25 +2021,108 @@ export interface InitOutput {
   readonly wasmspacetimevector_spacelike: (a: number, b: number, c: number) => number;
   readonly wasmspacetimevector_timelike: (a: number) => number;
   readonly wasmspacetimevector_to_string: (a: number) => [number, number];
-  readonly wasmspacetimevector_x: (a: number) => number;
-  readonly wasmspacetimevector_y: (a: number) => number;
-  readonly wasmspacetimevector_z: (a: 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_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_random: () => number;
+  readonly wasmtropicaldualclifford_randomWithScale: (a: number) => number;
+  readonly wasmtropicaldualclifford_scale: (a: number, b: number) => number;
+  readonly wasmtropicaldualclifford_sensitivityAnalysis: (a: 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 wasmtropicaldualdistribution_attentionPolytope: (a: number) => [number, number];
+  readonly wasmtropicaldualdistribution_geometricAlignment: (a: number, b: number) => number;
+  readonly wasmtropicaldualdistribution_getVocabSize: (a: number) => number;
+  readonly wasmtropicaldualdistribution_klDivergence: (a: number, b: number) => [number, number, number];
+  readonly wasmtropicaldualdistribution_mostLikelySequence: (a: number, b: number) => [number, number];
+  readonly wasmtropicaldualdistribution_new: (a: number, b: number) => number;
+  readonly wasmtropicalnetwork_fromWeights: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmtropicalnetwork_getSize: (a: 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_isZero: (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 wasmtropicalnumber_zero: () => number;
+  readonly wasmtropicalpolynomial_coefficients_count: (a: 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 wasmtropicalnumber_new: (a: number) => number;
   readonly wasmmultivector_norm: (a: number) => number;
   readonly wasmspacetimevector_t: (a: number) => number;
+  readonly wasmtropicalnumber_tropicalMul: (a: number, b: number) => number;
   readonly wasmtrajectorypoint_position: (a: number) => number;
-  readonly __wbg_networkbatchoperations_free: (a: number, b: number) => void;
+  readonly wasmtropicalnumber_tropicalAdd: (a: number, b: 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 wasmgeometricedge_weight: (a: number) => number;
+  readonly wasmmultidualnumber_getReal: (a: number) => number;
+  readonly wasmprojectivespace_getDimension: (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 wasmtropicalnumber_getValue: (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_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_wasmdualnumber_free: (a: number, b: number) => void;
+  readonly __wbg_wasmfourvelocity_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgeometricedge_free: (a: number, b: number) => void;
   readonly __wbg_wasmrelativisticconstants_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_wasmtropicalnumber_free: (a: number, b: number) => void;
   readonly wasmrotor_inverse: (a: number) => number;
   readonly __wbg_wasmrotor_free: (a: number, b: number) => void;
   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 __externref_table_dealloc: (a: number) => void;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_start: () => void;
 }