@ruvector/edge-net 0.1.0 → 0.1.2

package/node/ruvector_edge_net.d.ts

@@ -0,0 +1,2289 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class AdaptiveSecurity {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Choose action using epsilon-greedy policy
+   */
+  chooseAction(state: string, available_actions: string): string;
+  /**
+   * Detect if request matches known attack pattern
+   */
+  detectAttack(features: Float32Array): number;
+  /**
+   * Export learned patterns for persistence
+   */
+  exportPatterns(): Uint8Array;
+  /**
+   * Import learned patterns
+   */
+  importPatterns(data: Uint8Array): void;
+  getMinReputation(): number;
+  getRateLimitMax(): number;
+  getSecurityLevel(): number;
+  /**
+   * Get current adaptive thresholds
+   */
+  getRateLimitWindow(): bigint;
+  /**
+   * Record attack pattern for learning
+   */
+  recordAttackPattern(pattern_type: string, features: Float32Array, severity: number): void;
+  /**
+   * Update network health metrics
+   */
+  updateNetworkHealth(active_nodes: number, suspicious_nodes: number, attacks_hour: number, false_positives: number, avg_response_ms: number): void;
+  getSpotCheckProbability(): number;
+  constructor();
+  /**
+   * Learn from security event outcome (batched for better performance)
+   */
+  learn(state: string, action: string, reward: number, next_state: string): void;
+  /**
+   * Get learning statistics
+   */
+  getStats(): string;
+}
+
+export class AdversarialSimulator {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Simulate DDoS attack
+   */
+  simulateDDoS(requests_per_second: number, duration_ms: bigint): string;
+  /**
+   * Simulate Sybil attack
+   */
+  simulateSybil(fake_nodes: number, same_fingerprint: boolean): string;
+  /**
+   * Enable chaos mode for continuous testing
+   */
+  enableChaosMode(enabled: boolean): void;
+  /**
+   * Run comprehensive security audit
+   */
+  runSecurityAudit(): string;
+  /**
+   * Simulate Byzantine node behavior
+   */
+  simulateByzantine(byzantine_nodes: number, total_nodes: number): string;
+  /**
+   * Get defence metrics
+   */
+  getDefenceMetrics(): string;
+  /**
+   * Get recommendations based on testing
+   */
+  getRecommendations(): string;
+  /**
+   * Generate chaos event
+   */
+  generateChaosEvent(): string | undefined;
+  /**
+   * Simulate free-riding attack
+   */
+  simulateFreeRiding(consumption_rate: number, contribution_rate: number): string;
+  /**
+   * Simulate double-spend attempt
+   */
+  simulateDoubleSpend(amount: bigint, concurrent_targets: number): string;
+  /**
+   * Simulate result tampering
+   */
+  simulateResultTampering(tamper_percentage: number): string;
+  constructor();
+}
+
+export class AuditLog {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Export events as JSON
+   */
+  exportEvents(): string;
+  /**
+   * Get events for a node
+   */
+  getEventsForNode(node_id: string): number;
+  /**
+   * Get events by severity
+   */
+  getEventsBySeverity(min_severity: number): number;
+  /**
+   * Log an event
+   */
+  log(event_type: string, node_id: string, details: string, severity: number): void;
+  constructor();
+}
+
+export class BrowserFingerprint {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Generate anonymous uniqueness score
+   * This doesn't track users, just ensures one node per browser
+   */
+  static generate(): Promise<string>;
+}
+
+export class ByzantineDetector {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get maximum allowed magnitude
+   */
+  getMaxMagnitude(): number;
+  /**
+   * Create a new Byzantine detector
+   */
+  constructor(max_magnitude: number, zscore_threshold: number);
+}
+
+export class CoherenceEngine {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get event log length
+   */
+  eventCount(): number;
+  /**
+   * Check if context has drifted
+   */
+  hasDrifted(context_hex: string): boolean;
+  /**
+   * Check if a claim can be used in decisions
+   */
+  canUseClaim(claim_id: string): boolean;
+  /**
+   * Get witness count for a claim
+   */
+  witnessCount(claim_id: string): number;
+  /**
+   * Get conflict count
+   */
+  conflictCount(): number;
+  /**
+   * Get current Merkle root
+   */
+  getMerkleRoot(): string;
+  /**
+   * Get quarantined claim count
+   */
+  quarantinedCount(): number;
+  /**
+   * Check quarantine level for a claim
+   */
+  getQuarantineLevel(claim_id: string): number;
+  /**
+   * Check if claim has sufficient witnesses
+   */
+  hasSufficientWitnesses(claim_id: string): boolean;
+  /**
+   * Create a new coherence engine
+   */
+  constructor();
+  /**
+   * Get drift for a context
+   */
+  getDrift(context_hex: string): number;
+  /**
+   * Get statistics as JSON
+   */
+  getStats(): string;
+}
+
+export class CollectiveMemory {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get queue size
+   */
+  queueSize(): number;
+  /**
+   * Run consolidation (call during idle periods)
+   */
+  consolidate(): number;
+  /**
+   * Check if a pattern ID exists
+   */
+  hasPattern(pattern_id: string): boolean;
+  /**
+   * Get pattern count in shared index
+   */
+  patternCount(): number;
+  /**
+   * Create new collective memory with default config
+   */
+  constructor(node_id: string);
+  /**
+   * Search for similar patterns
+   */
+  search(query_json: string, k: number): string;
+  /**
+   * Get statistics as JSON
+   */
+  getStats(): string;
+}
+
+export class ContributionStream {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if streams are healthy
+   */
+  isHealthy(): boolean;
+  /**
+   * Process network fee distribution
+   */
+  processFees(total_fees: bigint, epoch: bigint): bigint;
+  /**
+   * Get total distributed
+   */
+  getTotalDistributed(): bigint;
+  constructor();
+}
+
+export class DifferentialPrivacy {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if DP is enabled
+   */
+  isEnabled(): boolean;
+  /**
+   * Get epsilon value
+   */
+  getEpsilon(): number;
+  /**
+   * Enable/disable differential privacy
+   */
+  setEnabled(enabled: boolean): void;
+  /**
+   * Create a new differential privacy module
+   */
+  constructor(epsilon: number, sensitivity: number);
+}
+
+export class DriftTracker {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if context has drifted beyond threshold
+   */
+  hasDrifted(context_hex: string): boolean;
+  /**
+   * Get contexts with significant drift
+   */
+  getDriftedContexts(): string;
+  /**
+   * Create a new drift tracker
+   */
+  constructor(drift_threshold: number);
+  /**
+   * Get drift for a context
+   */
+  getDrift(context_hex: string): number;
+}
+
+export class EconomicEngine {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get economic health status
+   */
+  getHealth(): EconomicHealth;
+  /**
+   * Get treasury balance
+   */
+  getTreasury(): bigint;
+  /**
+   * Advance to next epoch
+   */
+  advanceEpoch(): void;
+  /**
+   * Process task completion and distribute rewards
+   */
+  processReward(base_amount: bigint, multiplier: number): RewardDistribution;
+  /**
+   * Get protocol fund balance (for development sustainability)
+   */
+  getProtocolFund(): bigint;
+  /**
+   * Check if network can sustain itself
+   */
+  isSelfSustaining(active_nodes: number, daily_tasks: bigint): boolean;
+  constructor();
+}
+
+export class EconomicHealth {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Velocity of rUv (transactions per period)
+   */
+  velocity: number;
+  /**
+   * Network utilization rate
+   */
+  utilization: number;
+  /**
+   * Supply growth rate
+   */
+  growth_rate: number;
+  /**
+   * Stability index (0-1)
+   */
+  stability: number;
+}
+
+export class EdgeNetConfig {
+  free(): void;
+  [Symbol.dispose](): void;
+  memoryLimit(bytes: number): EdgeNetConfig;
+  minIdleTime(ms: number): EdgeNetConfig;
+  respectBattery(respect: boolean): EdgeNetConfig;
+  constructor(site_id: string);
+  build(): EdgeNetNode;
+  addRelay(url: string): EdgeNetConfig;
+  cpuLimit(limit: number): EdgeNetConfig;
+}
+
+export class EdgeNetNode {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Disconnect from the network
+   */
+  disconnect(): void;
+  /**
+   * Enable HDC for hyperdimensional computing
+   */
+  enableHDC(): boolean;
+  /**
+   * Enable Neural Autonomous Organization for governance
+   */
+  enableNAO(quorum: number): boolean;
+  /**
+   * Enable WTA for instant decisions
+   */
+  enableWTA(num_neurons: number): boolean;
+  /**
+   * Enable BTSP for one-shot learning
+   */
+  enableBTSP(input_dim: number): boolean;
+  /**
+   * Propose an action in the NAO
+   */
+  proposeNAO(action: string): string;
+  /**
+   * Alias for creditBalance - returns rUv balance
+   */
+  ruvBalance(): bigint;
+  /**
+   * Submit a task to the network
+   */
+  submitTask(task_type: string, payload: Uint8Array, max_credits: bigint): Promise<any>;
+  /**
+   * Check for active celebration events
+   */
+  checkEvents(): string;
+  /**
+   * Get current throttle level (0.0 - 1.0)
+   */
+  getThrottle(): number;
+  /**
+   * Get treasury balance for operations
+   */
+  getTreasury(): bigint;
+  /**
+   * Check if a claim can be used (not quarantined)
+   */
+  canUseClaim(claim_id: string): boolean;
+  /**
+   * Process epoch for economic distribution
+   */
+  processEpoch(): void;
+  /**
+   * Store a learned pattern in the reasoning bank
+   */
+  storePattern(pattern_json: string): number;
+  /**
+   * Get current rUv (Resource Utility Voucher) balance
+   */
+  creditBalance(): bigint;
+  /**
+   * Get motivational message (subtle Easter egg)
+   */
+  getMotivation(): string;
+  /**
+   * Get current contribution multiplier based on network size
+   */
+  getMultiplier(): number;
+  /**
+   * Prune low-quality learned patterns
+   */
+  prunePatterns(min_usage: number, min_confidence: number): number;
+  /**
+   * Get current Merkle root for audit (Axiom 11: Equivocation detectable)
+   */
+  getMerkleRoot(): string;
+  /**
+   * Lookup similar patterns for task optimization
+   */
+  lookupPatterns(query_json: string, k: number): string;
+  /**
+   * Get all available exotic capabilities and their status
+   */
+  getCapabilities(): any;
+  /**
+   * Check if this node should replicate (high performer)
+   */
+  shouldReplicate(): boolean;
+  /**
+   * Enable MicroLoRA for self-learning
+   */
+  enableMicroLoRA(rank: number): boolean;
+  /**
+   * Get founding contributor count
+   */
+  getFounderCount(): number;
+  /**
+   * Get optimal peers for task routing
+   */
+  getOptimalPeers(count: number): string[];
+  /**
+   * Get stored pattern count
+   */
+  getPatternCount(): number;
+  /**
+   * Get protocol development fund balance
+   */
+  getProtocolFund(): bigint;
+  /**
+   * Get themed network status
+   */
+  getThemedStatus(node_count: number): string;
+  /**
+   * Get contribution stream health
+   */
+  isStreamHealthy(): boolean;
+  /**
+   * Process the next available task (called by worker)
+   */
+  processNextTask(): Promise<boolean>;
+  /**
+   * Step all exotic capabilities forward
+   */
+  stepCapabilities(dt: number): void;
+  /**
+   * Get active conflict count (Axiom 6: Disagreement is signal)
+   */
+  getConflictCount(): number;
+  /**
+   * Get learning statistics
+   */
+  getLearningStats(): string;
+  /**
+   * Check if network is self-sustaining
+   */
+  isSelfSustaining(active_nodes: number, daily_tasks: bigint): boolean;
+  /**
+   * Record node performance for evolution
+   */
+  recordPerformance(success_rate: number, throughput: number): void;
+  /**
+   * Run security audit (adversarial testing)
+   */
+  runSecurityAudit(): string;
+  /**
+   * Enable Time Crystal for P2P synchronization
+   */
+  enableTimeCrystal(oscillators: number): boolean;
+  /**
+   * Get coherence statistics
+   */
+  getCoherenceStats(): string;
+  /**
+   * Get economic health metrics
+   */
+  getEconomicHealth(): string;
+  /**
+   * Get network fitness score (0-1)
+   */
+  getNetworkFitness(): number;
+  /**
+   * Record task routing outcome for optimization
+   */
+  recordTaskRouting(task_type: string, node_id: string, latency_ms: bigint, success: boolean): void;
+  /**
+   * Enable Morphogenetic Network for emergent topology
+   */
+  enableMorphogenetic(size: number): boolean;
+  /**
+   * Get trajectory count for learning analysis
+   */
+  getTrajectoryCount(): number;
+  /**
+   * Get energy efficiency ratio from spike-driven attention
+   */
+  getEnergyEfficiency(seq_len: number, hidden_dim: number): number;
+  /**
+   * Get quarantined claim count (Axiom 9: Quarantine is mandatory)
+   */
+  getQuarantinedCount(): number;
+  /**
+   * Get Time Crystal synchronization level (0.0 - 1.0)
+   */
+  getTimeCrystalSync(): number;
+  /**
+   * Get optimization statistics
+   */
+  getOptimizationStats(): string;
+  /**
+   * Get recommended configuration for new nodes
+   */
+  getRecommendedConfig(): string;
+  /**
+   * Enable Global Workspace for attention
+   */
+  enableGlobalWorkspace(capacity: number): boolean;
+  /**
+   * Record peer interaction for topology optimization
+   */
+  recordPeerInteraction(peer_id: string, success_rate: number): void;
+  /**
+   * Get capabilities summary as JSON
+   */
+  getCapabilitiesSummary(): any;
+  /**
+   * Get coherence engine event count
+   */
+  getCoherenceEventCount(): number;
+  /**
+   * Get quarantine level for a claim
+   */
+  getClaimQuarantineLevel(claim_id: string): number;
+  /**
+   * Record a task execution trajectory for learning
+   */
+  recordLearningTrajectory(trajectory_json: string): boolean;
+  /**
+   * Create a new EdgeNet node
+   */
+  constructor(site_id: string, config?: NodeConfig | null);
+  /**
+   * Pause contribution
+   */
+  pause(): void;
+  /**
+   * Start contributing to the network
+   */
+  start(): void;
+  /**
+   * Resume contribution
+   */
+  resume(): void;
+  /**
+   * Check if user is currently idle
+   */
+  isIdle(): boolean;
+  /**
+   * Get the node's unique identifier
+   */
+  nodeId(): string;
+  /**
+   * Vote on a NAO proposal
+   */
+  voteNAO(proposal_id: string, weight: number): boolean;
+  /**
+   * Get node statistics
+   */
+  getStats(): NodeStats;
+}
+
+export class EntropyConsensus {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get belief probability for a decision
+   */
+  getBelief(decision_id: bigint): number;
+  /**
+   * Get number of negotiation rounds completed
+   */
+  getRounds(): number;
+  /**
+   * Set initial belief for a decision
+   */
+  setBelief(decision_id: bigint, probability: number): void;
+  /**
+   * Get the winning decision (if converged)
+   */
+  getDecision(): bigint | undefined;
+  /**
+   * Get number of decision options
+   */
+  optionCount(): number;
+  /**
+   * Check if negotiation has timed out
+   */
+  hasTimedOut(): boolean;
+  /**
+   * Set belief without normalizing (for batch updates)
+   * Call normalize_beliefs() after all set_belief_raw calls
+   */
+  set_belief_raw(decision_id: bigint, probability: number): void;
+  /**
+   * Create with custom entropy threshold
+   */
+  static withThreshold(threshold: number): EntropyConsensus;
+  /**
+   * Get current temperature (for annealing)
+   */
+  getTemperature(): number;
+  /**
+   * Manually trigger normalization (for use after set_belief_raw)
+   */
+  finalize_beliefs(): void;
+  /**
+   * Get entropy history as JSON
+   */
+  getEntropyHistory(): string;
+  /**
+   * Get the entropy threshold for convergence
+   */
+  getEntropyThreshold(): number;
+  /**
+   * Create new entropy consensus with default configuration
+   */
+  constructor();
+  /**
+   * Reset consensus state for new decision
+   */
+  reset(): void;
+  /**
+   * Get current entropy of belief distribution
+   */
+  entropy(): number;
+  /**
+   * Check if consensus has been reached
+   */
+  converged(): boolean;
+  /**
+   * Get consensus statistics as JSON
+   */
+  getStats(): string;
+}
+
+export class EventLog {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get total event count
+   */
+  totalEvents(): number;
+  /**
+   * Get current event count (includes all events)
+   */
+  len(): number;
+  /**
+   * Create a new event log
+   */
+  constructor();
+  /**
+   * Get current Merkle root as hex string
+   */
+  getRoot(): string;
+  /**
+   * Check if log is empty
+   */
+  isEmpty(): boolean;
+}
+
+export class EvolutionEngine {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if node should replicate (spawn similar node)
+   */
+  shouldReplicate(node_id: string): boolean;
+  /**
+   * Record node performance for fitness evaluation
+   */
+  recordPerformance(node_id: string, success_rate: number, throughput: number): void;
+  /**
+   * Get network fitness score
+   */
+  getNetworkFitness(): number;
+  /**
+   * Get recommended configuration for new nodes
+   */
+  getRecommendedConfig(): string;
+  constructor();
+  /**
+   * Evolve patterns for next generation
+   */
+  evolve(): void;
+}
+
+export class FederatedModel {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get parameter dimension
+   */
+  getDimension(): number;
+  /**
+   * Get parameters as array
+   */
+  getParameters(): Float32Array;
+  /**
+   * Set parameters from array
+   */
+  setParameters(params: Float32Array): void;
+  /**
+   * Apply aggregated gradients to update model
+   */
+  applyGradients(gradients: Float32Array): void;
+  /**
+   * Set local epochs per round
+   */
+  setLocalEpochs(epochs: number): void;
+  /**
+   * Set learning rate
+   */
+  setLearningRate(lr: number): void;
+  /**
+   * Create a new federated model
+   */
+  constructor(dimension: number, learning_rate: number, momentum: number);
+  /**
+   * Get current round
+   */
+  getRound(): bigint;
+}
+
+export class FoundingRegistry {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Process epoch distribution
+   */
+  processEpoch(current_epoch: bigint, available_amount: bigint): any[];
+  /**
+   * Calculate vested amount for current epoch
+   */
+  calculateVested(current_epoch: bigint, pool_balance: bigint): bigint;
+  /**
+   * Get founding contributor count
+   */
+  getFounderCount(): number;
+  /**
+   * Register additional founding contributor
+   */
+  registerContributor(id: string, category: string, weight: number): void;
+  constructor();
+}
+
+export class GenesisKey {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get ID as hex
+   */
+  getIdHex(): string;
+  /**
+   * Export ultra-compact genesis key (21 bytes only)
+   */
+  exportUltraCompact(): Uint8Array;
+  /**
+   * Create a new genesis key
+   */
+  constructor(creator: PiKey, epoch: number);
+  /**
+   * Get the φ-sized genesis ID
+   */
+  getId(): Uint8Array;
+  /**
+   * Verify this genesis key was created by a specific Pi-Key
+   */
+  verify(creator_public_key: Uint8Array): boolean;
+  /**
+   * Get epoch
+   */
+  getEpoch(): number;
+}
+
+export class GenesisSunset {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if it's safe to retire genesis nodes
+   */
+  canRetire(): boolean;
+  /**
+   * Get sunset status
+   */
+  getStatus(): string;
+  /**
+   * Check if genesis nodes should be read-only
+   */
+  isReadOnly(): boolean;
+  /**
+   * Get current sunset phase
+   * 0 = Active (genesis required)
+   * 1 = Transition (stop new connections)
+   * 2 = Read-only (genesis read-only)
+   * 3 = Retired (genesis can be removed)
+   */
+  getCurrentPhase(): number;
+  /**
+   * Update network node count
+   */
+  updateNodeCount(count: number): number;
+  /**
+   * Check if network is self-sustaining
+   */
+  isSelfSustaining(): boolean;
+  /**
+   * Register a genesis node
+   */
+  registerGenesisNode(node_id: string): void;
+  /**
+   * Check if genesis nodes should accept new connections
+   */
+  shouldAcceptConnections(): boolean;
+  constructor();
+}
+
+export class GradientGossip {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get number of active peers
+   */
+  peerCount(): number;
+  /**
+   * Prune stale peer gradients
+   */
+  pruneStale(): number;
+  /**
+   * Configure differential privacy
+   */
+  configureDifferentialPrivacy(epsilon: number, sensitivity: number): void;
+  /**
+   * Advance to next consensus round
+   */
+  advanceRound(): bigint;
+  /**
+   * Get gradient dimension
+   */
+  getDimension(): number;
+  /**
+   * Enable/disable differential privacy
+   */
+  setDPEnabled(enabled: boolean): void;
+  /**
+   * Set model hash for version compatibility
+   */
+  setModelHash(hash: Uint8Array): void;
+  /**
+   * Get current consensus round
+   */
+  getCurrentRound(): bigint;
+  /**
+   * Set local gradients from JavaScript
+   */
+  setLocalGradients(gradients: Float32Array): void;
+  /**
+   * Get compression ratio achieved
+   */
+  getCompressionRatio(): number;
+  /**
+   * Get aggregated gradients as JavaScript array
+   */
+  getAggregatedGradients(): Float32Array;
+  /**
+   * Create a new GradientGossip instance
+   *
+   * # Arguments
+   * * `local_peer_id` - 32-byte peer identifier
+   * * `dimension` - Gradient vector dimension
+   * * `k_ratio` - TopK sparsification ratio (0.1 = keep top 10%)
+   */
+  constructor(local_peer_id: Uint8Array, dimension: number, k_ratio: number);
+  /**
+   * Get statistics as JSON
+   */
+  getStats(): string;
+}
+
+export class ModelConsensusManager {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get number of tracked models
+   */
+  modelCount(): number;
+  /**
+   * Get number of active disputes
+   */
+  disputeCount(): number;
+  /**
+   * Get number of quarantined updates
+   */
+  quarantinedUpdateCount(): number;
+  /**
+   * Create a new model consensus manager
+   */
+  constructor(min_witnesses: number);
+  /**
+   * Get statistics as JSON
+   */
+  getStats(): string;
+}
+
+export class MultiHeadAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get embedding dimension
+   */
+  dim(): number;
+  /**
+   * Create new multi-head attention
+   */
+  constructor(dim: number, num_heads: number);
+  /**
+   * Get number of heads
+   */
+  numHeads(): number;
+}
+
+export class NetworkEvents {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get a subtle motivational message
+   */
+  getMotivation(balance: bigint): string;
+  /**
+   * Check for discovery triggers (Easter eggs)
+   */
+  checkDiscovery(action: string, node_id: string): string | undefined;
+  /**
+   * Get ASCII art for special occasions
+   */
+  getSpecialArt(): string | undefined;
+  /**
+   * Check milestone achievements
+   */
+  checkMilestones(balance: bigint, node_id: string): string;
+  /**
+   * Set current time (for testing)
+   */
+  setCurrentTime(timestamp: bigint): void;
+  /**
+   * Get network status with thematic flair
+   */
+  getThemedStatus(node_count: number, total_ruv: bigint): string;
+  /**
+   * Check for active special events
+   */
+  checkActiveEvents(): string;
+  /**
+   * Get celebration multiplier boost
+   */
+  getCelebrationBoost(): number;
+  constructor();
+}
+
+export class NetworkLearning {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get pattern count
+   */
+  patternCount(): number;
+  /**
+   * Store a learned pattern
+   */
+  storePattern(pattern_json: string): number;
+  /**
+   * Look up similar patterns
+   */
+  lookupPatterns(query_json: string, k: number): string;
+  /**
+   * Get energy savings ratio for spike-driven attention
+   */
+  getEnergyRatio(seq_len: number, hidden_dim: number): number;
+  /**
+   * Get trajectory count
+   */
+  trajectoryCount(): number;
+  /**
+   * Record a task execution trajectory
+   */
+  recordTrajectory(trajectory_json: string): boolean;
+  /**
+   * Create new network learning intelligence
+   */
+  constructor();
+  /**
+   * Prune low-quality patterns
+   */
+  prune(min_usage: number, min_confidence: number): number;
+  /**
+   * Get combined statistics
+   */
+  getStats(): string;
+}
+
+export class NetworkTopology {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Register a node in the topology
+   */
+  registerNode(node_id: string, capabilities: Float32Array): void;
+  /**
+   * Get optimal peers for a node
+   */
+  getOptimalPeers(node_id: string, count: number): string[];
+  /**
+   * Update connection strength between nodes
+   */
+  updateConnection(from: string, to: string, success_rate: number): void;
+  constructor();
+}
+
+export class NodeConfig {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Maximum CPU usage when idle (0.0 - 1.0)
+   */
+  cpu_limit: number;
+  /**
+   * Maximum memory usage in bytes
+   */
+  memory_limit: number;
+  /**
+   * Maximum bandwidth in bytes/sec
+   */
+  bandwidth_limit: number;
+  /**
+   * Minimum idle time before contributing (ms)
+   */
+  min_idle_time: number;
+  /**
+   * Whether to reduce contribution on battery
+   */
+  respect_battery: boolean;
+}
+
+export class NodeStats {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Total rUv (Resource Utility Vouchers) earned
+   */
+  ruv_earned: bigint;
+  /**
+   * Total rUv spent
+   */
+  ruv_spent: bigint;
+  /**
+   * Tasks completed
+   */
+  tasks_completed: bigint;
+  /**
+   * Tasks submitted
+   */
+  tasks_submitted: bigint;
+  /**
+   * Total uptime in seconds
+   */
+  uptime_seconds: bigint;
+  /**
+   * Current reputation score (0.0 - 1.0)
+   */
+  reputation: number;
+  /**
+   * Current contribution multiplier
+   */
+  multiplier: number;
+  /**
+   * Active lifecycle events
+   */
+  celebration_boost: number;
+}
+
+export class OptimizationEngine {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Record task routing outcome
+   */
+  recordRouting(task_type: string, node_id: string, latency_ms: bigint, success: boolean): void;
+  /**
+   * Get optimal node for a task type
+   */
+  selectOptimalNode(task_type: string, candidates: string[]): string;
+  constructor();
+  /**
+   * Get optimization stats
+   */
+  getStats(): string;
+}
+
+export class PiKey {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get the Pi-sized identity (40 bytes)
+   */
+  getIdentity(): Uint8Array;
+  /**
+   * Get short identity (first 8 bytes as hex)
+   */
+  getShortId(): string;
+  /**
+   * Export minimal key representation (Pi + Phi sized = 61 bytes total)
+   */
+  exportCompact(): Uint8Array;
+  /**
+   * Get public key for verification
+   */
+  getPublicKey(): Uint8Array;
+  /**
+   * Verify this key has Pi magic marker
+   */
+  verifyPiMagic(): boolean;
+  /**
+   * Get identity as hex string
+   */
+  getIdentityHex(): string;
+  /**
+   * Restore from encrypted backup (supports both v1 legacy and v2 Argon2id)
+   */
+  static restoreFromBackup(backup: Uint8Array, password: string): PiKey;
+  /**
+   * Create encrypted backup of private key using Argon2id KDF
+   */
+  createEncryptedBackup(password: string): Uint8Array;
+  /**
+   * Get the Phi-sized genesis fingerprint (21 bytes)
+   */
+  getGenesisFingerprint(): Uint8Array;
+  /**
+   * Sign data with this key
+   */
+  sign(data: Uint8Array): Uint8Array;
+  /**
+   * Verify signature from another Pi-Key
+   */
+  verify(data: Uint8Array, signature: Uint8Array, public_key: Uint8Array): boolean;
+  /**
+   * Generate a new Pi-Key with genesis linking
+   */
+  constructor(genesis_seed?: Uint8Array | null);
+  /**
+   * Get key statistics
+   */
+  getStats(): string;
+}
+
+export class QDAGLedger {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Export ledger state for sync
+   */
+  exportState(): Uint8Array;
+  /**
+   * Import ledger state from sync
+   */
+  importState(state_bytes: Uint8Array): number;
+  /**
+   * Get total supply
+   */
+  totalSupply(): bigint;
+  /**
+   * Get staked amount for a node
+   */
+  stakedAmount(node_id: string): bigint;
+  /**
+   * Create genesis transaction (called once at network start)
+   */
+  createGenesis(initial_supply: bigint, founder_pubkey: Uint8Array): Uint8Array;
+  /**
+   * Get transaction count
+   */
+  transactionCount(): number;
+  /**
+   * Create and validate a new transaction
+   */
+  createTransaction(sender_id: string, recipient_id: string, amount: bigint, tx_type: number, sender_privkey: Uint8Array, sender_pubkey: Uint8Array): Uint8Array;
+  /**
+   * Create a new QDAG ledger
+   */
+  constructor();
+  /**
+   * Get balance for a node
+   */
+  balance(node_id: string): bigint;
+  /**
+   * Get tip count
+   */
+  tipCount(): number;
+}
+
+export class QuarantineManager {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get number of quarantined claims
+   */
+  quarantinedCount(): number;
+  /**
+   * Create a new quarantine manager
+   */
+  constructor();
+  /**
+   * Check if claim can be used in decisions
+   */
+  canUse(claim_id: string): boolean;
+  /**
+   * Check quarantine level for a claim
+   */
+  getLevel(claim_id: string): number;
+  /**
+   * Set quarantine level
+   */
+  setLevel(claim_id: string, level: number): void;
+}
+
+export class RacEconomicEngine {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get summary statistics as JSON
+   */
+  getSummary(): string;
+  /**
+   * Check if node can participate (has stake + reputation)
+   */
+  canParticipate(node_id: Uint8Array): boolean;
+  /**
+   * Get combined score (stake-weighted reputation)
+   */
+  getCombinedScore(node_id: Uint8Array): number;
+  /**
+   * Create a new RAC economic engine
+   */
+  constructor();
+}
+
+export class RacSemanticRouter {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get peer count
+   */
+  peerCount(): number;
+  /**
+   * Create a new semantic router
+   */
+  constructor();
+}
+
+export class RateLimiter {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if request is allowed
+   */
+  checkAllowed(node_id: string): boolean;
+  constructor(window_ms: bigint, max_requests: number);
+  /**
+   * Reset rate limiter
+   */
+  reset(): void;
+  /**
+   * Get current count for a node
+   */
+  getCount(node_id: string): number;
+}
+
+export class ReasoningBank {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new ReasoningBank
+   */
+  constructor();
+  /**
+   * Get total pattern count
+   */
+  count(): number;
+  /**
+   * Prune low-quality patterns
+   */
+  prune(min_usage: number, min_confidence: number): number;
+  /**
+   * Store a new pattern (JSON format)
+   */
+  store(pattern_json: string): number;
+  /**
+   * Lookup most similar patterns (OPTIMIZED with spatial indexing)
+   */
+  lookup(query_json: string, k: number): string;
+  /**
+   * Get bank statistics
+   */
+  getStats(): string;
+}
+
+export class ReputationManager {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get number of tracked nodes
+   */
+  nodeCount(): number;
+  /**
+   * Get effective reputation for a node (with decay applied)
+   */
+  getReputation(node_id: Uint8Array): number;
+  /**
+   * Get average network reputation
+   */
+  averageReputation(): number;
+  /**
+   * Check if node has sufficient reputation
+   */
+  hasSufficientReputation(node_id: Uint8Array): boolean;
+  /**
+   * Create a new reputation manager
+   */
+  constructor(decay_rate: number, decay_interval_ms: bigint);
+}
+
+export class ReputationSystem {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get reputation score for a node
+   */
+  getReputation(node_id: string): number;
+  /**
+   * Record failed task completion
+   */
+  recordFailure(node_id: string): void;
+  /**
+   * Record penalty (fraud, invalid result)
+   */
+  recordPenalty(node_id: string, severity: number): void;
+  /**
+   * Record successful task completion
+   */
+  recordSuccess(node_id: string): void;
+  /**
+   * Check if node can participate
+   */
+  canParticipate(node_id: string): boolean;
+  constructor();
+}
+
+export class RewardDistribution {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  total: bigint;
+  contributor_share: bigint;
+  treasury_share: bigint;
+  protocol_share: bigint;
+  founder_share: bigint;
+}
+
+export class RewardManager {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get number of pending rewards
+   */
+  pendingCount(): number;
+  /**
+   * Get total pending reward amount
+   */
+  pendingAmount(): bigint;
+  /**
+   * Get claimable rewards for a node
+   */
+  claimableAmount(node_id: Uint8Array): bigint;
+  /**
+   * Create a new reward manager
+   */
+  constructor(default_vesting_ms: bigint);
+}
+
+export class SemanticRouter {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get peer count
+   */
+  peerCount(): number;
+  /**
+   * Get topic count
+   */
+  topicCount(): number;
+  /**
+   * Create with custom parameters
+   */
+  static withParams(embedding_dim: number, semantic_neighbors: number, random_sample: number): SemanticRouter;
+  /**
+   * Set my peer identity
+   */
+  setMyPeerId(peer_id: Uint8Array): void;
+  /**
+   * Get active peer count (seen in last 60 seconds)
+   */
+  activePeerCount(): number;
+  /**
+   * Set my capabilities and update my centroid
+   */
+  setMyCapabilities(capabilities: string[]): void;
+  /**
+   * Create a new semantic router
+   */
+  constructor();
+  /**
+   * Get statistics as JSON
+   */
+  getStats(): string;
+}
+
+export class SessionKey {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get ID as hex
+   */
+  getIdHex(): string;
+  /**
+   * Check if session is expired
+   */
+  isExpired(): boolean;
+  /**
+   * Get parent identity fingerprint
+   */
+  getParentIdentity(): Uint8Array;
+  /**
+   * Create a new session key linked to a Pi-Key identity
+   */
+  constructor(parent: PiKey, ttl_seconds: number);
+  /**
+   * Get the e-sized session ID
+   */
+  getId(): Uint8Array;
+  /**
+   * Decrypt data with this session key
+   */
+  decrypt(data: Uint8Array): Uint8Array;
+  /**
+   * Encrypt data with this session key
+   */
+  encrypt(plaintext: Uint8Array): Uint8Array;
+}
+
+export class SpikeDrivenAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create with custom parameters
+   */
+  static withConfig(threshold: number, steps: number, refractory: number): SpikeDrivenAttention;
+  /**
+   * Estimate energy savings ratio compared to standard attention
+   */
+  energyRatio(seq_len: number, hidden_dim: number): number;
+  /**
+   * Create new spike-driven attention with default config
+   */
+  constructor();
+}
+
+export class SpotChecker {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if a task should include a spot-check
+   */
+  shouldCheck(): boolean;
+  /**
+   * Add a known challenge-response pair
+   */
+  addChallenge(task_type: string, input: Uint8Array, expected_output: Uint8Array): void;
+  /**
+   * Get a random challenge for a task type
+   */
+  getChallenge(task_type: string): Uint8Array | undefined;
+  /**
+   * Verify a challenge response
+   */
+  verifyResponse(input_hash: Uint8Array, output: Uint8Array): boolean;
+  constructor(check_probability: number);
+}
+
+export class StakeManager {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get number of stakers
+   */
+  stakerCount(): number;
+  /**
+   * Get total staked amount in network
+   */
+  totalStaked(): bigint;
+  /**
+   * Get minimum stake requirement
+   */
+  getMinStake(): bigint;
+  /**
+   * Check if node has sufficient stake
+   */
+  hasSufficientStake(node_id: Uint8Array): boolean;
+  /**
+   * Create a new stake manager
+   */
+  constructor(min_stake: bigint);
+  /**
+   * Get staked amount for a node
+   */
+  getStake(node_id: Uint8Array): bigint;
+}
+
+export class SwarmIntelligence {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get queue size
+   */
+  queueSize(): number;
+  /**
+   * Set belief for a topic's decision
+   */
+  setBelief(topic: string, decision_id: bigint, probability: number): void;
+  /**
+   * Add pattern to collective memory
+   */
+  addPattern(pattern_json: string): boolean;
+  /**
+   * Run memory consolidation
+   */
+  consolidate(): number;
+  /**
+   * Check if topic has reached consensus
+   */
+  hasConsensus(topic: string): boolean;
+  /**
+   * Get collective memory pattern count
+   */
+  patternCount(): number;
+  /**
+   * Search collective memory
+   */
+  searchPatterns(query_json: string, k: number): string;
+  /**
+   * Start a new consensus round for a topic
+   */
+  startConsensus(topic: string, threshold: number): void;
+  /**
+   * Negotiate beliefs for a topic
+   */
+  negotiateBeliefs(topic: string, beliefs_json: string): boolean;
+  /**
+   * Get consensus decision for topic
+   */
+  getConsensusDecision(topic: string): bigint | undefined;
+  /**
+   * Create new swarm intelligence coordinator
+   */
+  constructor(node_id: string);
+  /**
+   * Run hippocampal replay
+   */
+  replay(): number;
+  /**
+   * Get node ID
+   */
+  nodeId(): string;
+  /**
+   * Get combined statistics as JSON
+   */
+  getStats(): string;
+}
+
+export class SybilDefense {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Register a node with its fingerprint
+   */
+  registerNode(node_id: string, fingerprint: string): boolean;
+  /**
+   * Get sybil score (0.0 = likely unique, 1.0 = likely sybil)
+   */
+  getSybilScore(node_id: string): number;
+  /**
+   * Check if node is likely a sybil
+   */
+  isSuspectedSybil(node_id: string): boolean;
+  constructor();
+}
+
+/**
+ * Task priority levels
+ */
+export enum TaskPriority {
+  Low = 0,
+  Normal = 1,
+  High = 2,
+}
+
+/**
+ * Task types supported by the network
+ */
+export enum TaskType {
+  /**
+   * Vector search in HNSW index
+   */
+  VectorSearch = 0,
+  /**
+   * Vector insertion
+   */
+  VectorInsert = 1,
+  /**
+   * Generate embeddings
+   */
+  Embedding = 2,
+  /**
+   * Semantic task-to-agent matching
+   */
+  SemanticMatch = 3,
+  /**
+   * Neural network inference
+   */
+  NeuralInference = 4,
+  /**
+   * AES encryption/decryption
+   */
+  Encryption = 5,
+  /**
+   * Data compression
+   */
+  Compression = 6,
+  /**
+   * Custom WASM module (requires verification)
+   */
+  CustomWasm = 7,
+}
+
+export class TopKSparsifier {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Reset error feedback buffer
+   */
+  resetErrorFeedback(): void;
+  /**
+   * Get compression ratio
+   */
+  getCompressionRatio(): number;
+  /**
+   * Get error feedback buffer size
+   */
+  getErrorBufferSize(): number;
+  /**
+   * Create a new TopK sparsifier
+   *
+   * # Arguments
+   * * `k_ratio` - Fraction of gradients to keep (0.1 = top 10%)
+   */
+  constructor(k_ratio: number);
+}
+
+export class TrajectoryTracker {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new trajectory tracker
+   */
+  constructor(max_size: number);
+  /**
+   * Get count of trajectories
+   */
+  count(): number;
+  /**
+   * Record a new trajectory
+   */
+  record(trajectory_json: string): boolean;
+  /**
+   * Get statistics as JSON
+   */
+  getStats(): string;
+}
+
+export class WasmAdapterPool {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get or create an adapter for a task type
+   */
+  getAdapter(task_type: string): any;
+  /**
+   * Get adapter count
+   */
+  adapterCount(): number;
+  /**
+   * Export adapter to bytes for P2P sharing
+   */
+  exportAdapter(task_type: string): Uint8Array;
+  /**
+   * Import adapter from bytes
+   */
+  importAdapter(task_type: string, bytes: Uint8Array): boolean;
+  /**
+   * Route to best adapter by task embedding
+   */
+  routeToAdapter(task_embedding: Float32Array): any;
+  /**
+   * Create a new adapter pool
+   */
+  constructor(hidden_dim: number, max_slots: number);
+  /**
+   * Apply adapter to input
+   */
+  forward(task_type: string, input: Float32Array): Float32Array;
+  /**
+   * Get pool statistics
+   */
+  getStats(): any;
+}
+
+export class WasmCapabilities {
+  free(): void;
+  [Symbol.dispose](): void;
+  enableHDC(): boolean;
+  enableNAO(_quorum: number): boolean;
+  enableWTA(_num_neurons: number, _inhibition: number, _threshold: number): boolean;
+  competeWTA(_activations: Float32Array): number;
+  enableBTSP(_input_dim: number, _time_constant: number): boolean;
+  executeNAO(_proposal_id: string): boolean;
+  /**
+   * Get a summary of all enabled capabilities
+   */
+  getSummary(): any;
+  proposeNAO(_action: string): string;
+  forwardBTSP(_input: Float32Array): number;
+  getNAOSync(): number;
+  retrieveHDC(_key: string, _threshold: number): any;
+  addNAOMember(_member_id: string, _stake: bigint): boolean;
+  adaptMicroLoRA(_operator_type: string, _gradient: Float32Array): boolean;
+  applyMicroLoRA(_operator_type: string, input: Float32Array): Float32Array;
+  /**
+   * List all available exotic capabilities
+   */
+  getCapabilities(): any;
+  enableMicroLoRA(_dim: number, _rank: number): boolean;
+  tickTimeCrystal(): any;
+  growMorphogenetic(_rate: number): void;
+  oneShotAssociate(_pattern: Float32Array, _target: number): boolean;
+  enableTimeCrystal(_oscillators: number, _period_ms: number): boolean;
+  pruneMorphogenetic(_threshold: number): void;
+  enableMorphogenetic(_width: number, _height: number): boolean;
+  getTimeCrystalSync(): number;
+  broadcastToWorkspace(_content: Float32Array, _salience: number, _source_module: number): boolean;
+  getWorkspaceContents(): any;
+  isTimeCrystalStable(): boolean;
+  enableGlobalWorkspace(_capacity: number): boolean;
+  getMorphogeneticStats(): any;
+  differentiateMorphogenetic(): void;
+  getMorphogeneticCellCount(): number;
+  /**
+   * Create a new capabilities manager for a node
+   */
+  constructor(node_id: string);
+  /**
+   * Step all enabled capabilities forward (for main loop integration)
+   */
+  step(dt: number): void;
+  tickNAO(_dt: number): void;
+  voteNAO(_proposal_id: string, _weight: number): boolean;
+  storeHDC(_key: string): boolean;
+}
+
+export class WasmCreditLedger {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get total spent
+   */
+  totalSpent(): bigint;
+  /**
+   * Export spent counter for sync
+   */
+  exportSpent(): Uint8Array;
+  /**
+   * Get total earned (before spending)
+   */
+  totalEarned(): bigint;
+  /**
+   * Export earned counter for sync
+   */
+  exportEarned(): Uint8Array;
+  /**
+   * Get staked amount
+   */
+  stakedAmount(): bigint;
+  /**
+   * Get network compute hours (for multiplier)
+   */
+  networkCompute(): number;
+  /**
+   * Get current multiplier
+   */
+  currentMultiplier(): number;
+  /**
+   * Update network compute (from P2P sync)
+   */
+  updateNetworkCompute(hours: number): void;
+  /**
+   * Create a new credit ledger
+   */
+  constructor(node_id: string);
+  /**
+   * Merge with another ledger (CRDT merge) - optimized batch processing
+   */
+  merge(other_earned: Uint8Array, other_spent: Uint8Array): void;
+  /**
+   * Slash staked credits (penalty for bad behavior)
+   */
+  slash(amount: bigint): bigint;
+  /**
+   * Stake credits for participation
+   */
+  stake(amount: bigint): void;
+  /**
+   * Credit the ledger (earn credits)
+   */
+  credit(amount: bigint, reason: string): void;
+  /**
+   * Deduct from the ledger (spend credits)
+   */
+  deduct(amount: bigint): void;
+  /**
+   * Get current balance
+   */
+  balance(): bigint;
+  /**
+   * Unstake credits
+   */
+  unstake(amount: bigint): void;
+}
+
+export class WasmIdleDetector {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get status summary
+   */
+  getStatus(): any;
+  /**
+   * Update FPS measurement
+   */
+  updateFps(fps: number): void;
+  /**
+   * Check if we should be working
+   */
+  shouldWork(): boolean;
+  /**
+   * Get current throttle level (0.0 - max_cpu)
+   */
+  getThrottle(): number;
+  /**
+   * Record user interaction
+   */
+  recordInteraction(): void;
+  /**
+   * Set battery status (called from JS)
+   */
+  setBatteryStatus(on_battery: boolean): void;
+  /**
+   * Create a new idle detector
+   */
+  constructor(max_cpu: number, min_idle_time: number);
+  /**
+   * Stop monitoring
+   */
+  stop(): void;
+  /**
+   * Pause contribution (user-initiated)
+   */
+  pause(): void;
+  /**
+   * Start monitoring
+   */
+  start(): void;
+  /**
+   * Resume contribution
+   */
+  resume(): void;
+  /**
+   * Check if user is idle
+   */
+  isIdle(): boolean;
+}
+
+export class WasmMcpBroadcast {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Set as server mode (responds to requests)
+   */
+  setServer(server: WasmMcpServer): void;
+  /**
+   * Create a broadcast transport
+   */
+  constructor(channel_name: string);
+  /**
+   * Send a request (client mode)
+   */
+  send(request_json: string): void;
+  /**
+   * Close the channel
+   */
+  close(): void;
+  /**
+   * Start listening for requests (server mode)
+   */
+  listen(): void;
+}
+
+export class WasmMcpServer {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create with custom configuration
+   */
+  static withConfig(config: any): WasmMcpServer;
+  /**
+   * Set identity for authenticated operations
+   */
+  setIdentity(identity: WasmNodeIdentity): void;
+  /**
+   * Initialize learning engine
+   */
+  initLearning(): void;
+  /**
+   * Handle an MCP request (JSON string)
+   */
+  handleRequest(request_json: string): Promise<string>;
+  /**
+   * Get server info
+   */
+  getServerInfo(): any;
+  /**
+   * Handle MCP request from JsValue (for direct JS calls)
+   */
+  handleRequestJs(request: any): Promise<any>;
+  /**
+   * Create a new MCP server with default configuration
+   */
+  constructor();
+}
+
+export class WasmMcpTransport {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create transport from a Worker
+   */
+  constructor(worker: Worker);
+  /**
+   * Initialize transport (set up message handler)
+   */
+  init(): void;
+  /**
+   * Send an MCP request and get a Promise for the response
+   */
+  send(request: any): Promise<any>;
+  /**
+   * Close the transport
+   */
+  close(): void;
+  /**
+   * Create transport from existing MessagePort
+   */
+  static fromPort(port: MessagePort): WasmMcpTransport;
+}
+
+export class WasmMcpWorkerHandler {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create handler with MCP server
+   */
+  constructor(server: WasmMcpServer);
+  /**
+   * Start handling messages (call in worker)
+   */
+  start(): void;
+}
+
+export class WasmNetworkManager {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get peer count
+   */
+  peerCount(): number;
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean;
+  /**
+   * Register a peer
+   */
+  registerPeer(node_id: string, pubkey: Uint8Array, capabilities: string[], stake: bigint): void;
+  /**
+   * Select workers for task execution (reputation-weighted random)
+   */
+  selectWorkers(capability: string, count: number): string[];
+  /**
+   * Get active peer count (seen in last 60s)
+   */
+  activePeerCount(): number;
+  /**
+   * Update peer reputation
+   */
+  updateReputation(node_id: string, delta: number): void;
+  /**
+   * Get peers with specific capability
+   */
+  getPeersWithCapability(capability: string): string[];
+  constructor(node_id: string);
+  /**
+   * Add a relay URL
+   */
+  addRelay(url: string): void;
+}
+
+export class WasmNodeIdentity {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Verify a signature from another node
+   */
+  static verifyFrom(public_key: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
+  /**
+   * Get the public key as hex string
+   */
+  publicKeyHex(): string;
+  /**
+   * Restore identity from secret key bytes
+   */
+  static fromSecretKey(secret_key: Uint8Array, site_id: string): WasmNodeIdentity;
+  /**
+   * Get browser fingerprint
+   */
+  getFingerprint(): string | undefined;
+  /**
+   * Set browser fingerprint for anti-sybil
+   */
+  setFingerprint(fingerprint: string): void;
+  /**
+   * Get the public key as bytes
+   */
+  publicKeyBytes(): Uint8Array;
+  /**
+   * Export secret key encrypted with password (secure backup)
+   * Uses Argon2id for key derivation and AES-256-GCM for encryption
+   */
+  exportSecretKey(password: string): Uint8Array;
+  /**
+   * Import secret key from encrypted backup
+   */
+  static importSecretKey(encrypted: Uint8Array, password: string, site_id: string): WasmNodeIdentity;
+  /**
+   * Sign a message
+   */
+  sign(message: Uint8Array): Uint8Array;
+  /**
+   * Verify a signature
+   */
+  verify(message: Uint8Array, signature: Uint8Array): boolean;
+  /**
+   * Get the node's unique identifier
+   */
+  nodeId(): string;
+  /**
+   * Get the site ID
+   */
+  siteId(): string;
+  /**
+   * Generate a new node identity
+   */
+  static generate(site_id: string): WasmNodeIdentity;
+}
+
+export class WasmStigmergy {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create with custom parameters
+   */
+  static withParams(decay_rate: number, deposit_rate: number, evaporation_hours: number): WasmStigmergy;
+  /**
+   * Export current state for P2P sharing
+   */
+  exportState(): string;
+  /**
+   * Get raw pheromone intensity
+   */
+  getIntensity(task_type: string): number;
+  /**
+   * Set minimum stake for anti-sybil
+   */
+  setMinStake(min_stake: bigint): void;
+  /**
+   * Should this node accept a task? (combined decision)
+   */
+  shouldAccept(task_type: string): number;
+  /**
+   * Check and run evaporation if due
+   */
+  maybeEvaporate(): boolean;
+  /**
+   * Get all task types ranked by attractiveness
+   */
+  getRankedTasks(): string;
+  /**
+   * Get success rate for a task type
+   */
+  getSuccessRate(task_type: string): number;
+  /**
+   * Get node's specialization score
+   */
+  getSpecialization(task_type: string): number;
+  /**
+   * Deposit with success/failure outcome
+   */
+  depositWithOutcome(task_type: string, peer_id: string, success: boolean, stake: bigint): void;
+  /**
+   * Update node specialization based on outcome
+   */
+  updateSpecialization(task_type: string, success: boolean): void;
+  /**
+   * Get best specialization recommendation
+   */
+  getBestSpecialization(): string | undefined;
+  /**
+   * Create a new stigmergy engine
+   */
+  constructor();
+  /**
+   * Merge peer pheromone state (JSON format)
+   */
+  merge(peer_state_json: string): boolean;
+  /**
+   * Get acceptance probability for a task type
+   */
+  follow(task_type: string): number;
+  /**
+   * Deposit pheromone after task completion
+   */
+  deposit(task_type: string, peer_id: string, success_rate: number, stake: bigint): void;
+  /**
+   * Run evaporation (call periodically)
+   */
+  evaporate(): void;
+  /**
+   * Get statistics as JSON
+   */
+  getStats(): string;
+}
+
+export class WasmTaskExecutor {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Set encryption key for payload decryption
+   */
+  setTaskKey(key: Uint8Array): void;
+  /**
+   * Create a new task executor
+   */
+  constructor(max_memory: number);
+}
+
+export class WasmTaskQueue {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class WasmWorkScheduler {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Calculate how many tasks to run this frame
+   */
+  tasksThisFrame(throttle: number): number;
+  /**
+   * Set pending task count
+   */
+  setPendingTasks(count: number): void;
+  /**
+   * Record task completion for averaging
+   */
+  recordTaskDuration(duration_ms: number): void;
+  constructor();
+}
+
+export class WitnessTracker {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get witness count for a claim
+   */
+  witnessCount(claim_id: string): number;
+  /**
+   * Get confidence score based on witness diversity
+   */
+  witnessConfidence(claim_id: string): number;
+  /**
+   * Check if claim has sufficient independent witnesses
+   */
+  hasSufficientWitnesses(claim_id: string): boolean;
+  /**
+   * Create a new witness tracker
+   */
+  constructor(min_witnesses: number);
+}
+
+/**
+ * Initialize panic hook for better error messages in console
+ */
+export function init_panic_hook(): void;