@justinelliottcobb/amari-wasm 0.9.3 → 0.9.4

package/amari_wasm.d.ts

@@ -1,25 +1,37 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
- * Convert velocity to Lorentz factor
+ * Initialize the enumerative geometry module
  */
-export function velocity_to_gamma(velocity_magnitude: number): number;
+export function initEnumerative(): void;
 /**
  * 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;
 /**
  * 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
  */
@@ -44,6 +56,50 @@ export class AutoDiff {
    */
   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
  */
@@ -81,6 +137,147 @@ export class BatchOps {
    */
   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 EnumerativeUtils {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): 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;
+  [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 softmaxToTropical(probs: Float64Array): Float64Array;
+  /**
+   * Convert tropical numbers back to softmax probabilities
+   */
+  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
  */
@@ -106,20 +303,24 @@ export class MLOps {
   static softmax(inputs: Float64Array): Float64Array;
 }
 /**
- * Batch network operations for performance
+ * Utility functions for network analysis
  */
-export class NetworkBatchOperations {
+export class NetworkUtils {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Fast geometric clustering using k-means in 3D space
+   * Create a random geometric network for testing
+   */
+  static createRandomNetwork(num_nodes: number, connection_probability: number): WasmGeometricNetwork;
+  /**
+   * Analyze network clustering coefficient
    */
-  static geometricKMeansClustering(positions: Float64Array, num_nodes: number, k: number, max_iterations: number): Uint32Array;
+  static clusteringCoefficient(network: WasmGeometricNetwork): number;
   /**
-   * Compute all pairwise distances in a network
+   * Create a small-world network (Watts-Strogatz model)
    */
-  static computeAllPairwiseDistances(positions: Float64Array, num_nodes: number): Float64Array;
+  static createSmallWorldNetwork(num_nodes: number, k: number, beta: number): WasmGeometricNetwork;
 }
 /**
  * High-performance WASM operations with memory pooling
@@ -189,6 +390,96 @@ export class TropicalMLOps {
    */
   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
  */
@@ -300,6 +591,85 @@ export class WasmDualNumber {
    */
   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
  */
@@ -353,13 +723,103 @@ 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 degree of a node
+   * Get the degree of a node
    */
   getDegree(node: number): number;
   /**
@@ -367,60 +827,152 @@ export class WasmGeometricNetwork {
    */
   getNeighbors(node: number): Uint32Array;
   /**
-   * Find shortest path between two nodes
-   * Returns the path as an array of node indices, or null if no path exists
+   * Find shortest path between two nodes using edge weights
    */
-  shortestPath(source: number, target: number): Uint32Array | undefined;
+  shortestPath(source: number, target: number): any;
   /**
-   * Add a labeled node
+   * Create a network with pre-allocated capacity
    */
-  addLabeledNode(x: number, y: number, z: number, label: string): number;
+  static withCapacity(num_nodes: number, num_edges: number): WasmGeometricNetwork;
   /**
-   * Find communities using geometric clustering
+   * Detect communities using geometric clustering
    */
-  findCommunities(num_communities: number): Uint32Array;
-  /**
-   * Get node position as [x, y, z]
-   */
-  getNodePosition(node: number): Float64Array | undefined;
+  findCommunities(num_communities: number): Array<any>;
   /**
    * Compute geometric distance between two nodes
    */
   geometricDistance(node1: number, node2: number): number;
   /**
-   * Add an undirected edge
+   * 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;
   /**
-   * Find shortest path with distance between two nodes
-   * Returns an object with path and distance, or null if no path exists
+   * Perform spectral clustering
+   */
+  spectralClustering(num_clusters: number): Array<any>;
+  /**
+   * Convert to tropical network for efficient path operations
+   */
+  toTropicalNetwork(): WasmTropicalNetwork;
+  /**
+   * Add a node with metadata
    */
-  shortestPathWithDistance(source: number, target: number): any;
+  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;
   /**
-   * Create a new geometric network
+   * Compute betweenness centrality for all nodes
+   */
+  computeBetweennessCentrality(): Float64Array;
+  /**
+   * Create a new empty geometric network
    */
   constructor();
   /**
-   * Add an edge between two nodes
+   * Add a directed edge between two nodes
    */
   addEdge(source: number, target: number, weight: number): void;
   /**
-   * Add a node at the given position
+   * Add a node at the specified position (using flat coefficient array)
    */
-  addNode(x: number, y: number, z: number): number;
+  addNode(coefficients: Float64Array): number;
   /**
-   * Get number of edges
+   * Get node position as coefficient array
+   */
+  getNode(index: number): Float64Array | undefined;
+  /**
+   * Get the number of edges in the network
    */
   numEdges(): number;
   /**
-   * Get number of nodes
+   * 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 WasmModuliSpace {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): 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;
+}
 /**
  * WASM wrapper for multi-variable dual numbers
  */
@@ -559,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
  */
@@ -694,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
  */
@@ -769,6 +1438,178 @@ 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
  */
@@ -892,36 +1733,87 @@ export interface InitOutput {
   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_wasmdualnumber_free: (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_wasmtropicalnumber_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 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 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 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];
@@ -935,6 +1827,28 @@ export interface InitOutput {
   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;
@@ -942,7 +1856,6 @@ export interface InitOutput {
   readonly wasmdualnumber_div: (a: number, b: number) => [number, number, number];
   readonly wasmdualnumber_exp: (a: number) => number;
   readonly wasmdualnumber_getDual: (a: number) => number;
-  readonly wasmdualnumber_getReal: (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;
@@ -961,6 +1874,12 @@ export interface InitOutput {
   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;
@@ -970,21 +1889,57 @@ 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];
@@ -1014,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;
@@ -1038,6 +2005,13 @@ export interface InitOutput {
   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 wasmspacetimevector_is_null: (a: number) => number;
   readonly wasmspacetimevector_is_spacelike: (a: number) => number;
   readonly wasmspacetimevector_is_timelike: (a: number) => number;
@@ -1047,8 +2021,41 @@ 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_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;
@@ -1073,28 +2080,49 @@ export interface InitOutput {
   readonly wasmtropicalnumber_tropicalMul: (a: number, b: number) => number;
   readonly wasmtrajectorypoint_position: (a: number) => number;
   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_networkbatchoperations_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;
 }