@aleph-ai/tinyaleph 1.4.4 → 1.5.1

package/backends/bioinformatics/binding.js

@@ -1,64 +1,56 @@
 /**
  * Molecular Binding - Protein-Ligand and Protein-Protein Interactions
- * 
+ *
  * Models molecular binding using prime resonance:
  * - Binding affinity correlates with golden ratio resonance
  * - Docking uses multi-system Kuramoto coupling
  * - Affinity scoring combines electrostatic, hydrophobic, and resonance terms
  */
 
-const { 
-  AMINO_ACID_PRIMES, 
-  getChargeFromPrime, 
-  getHydrophobicityFromPrime 
-} = require('./encoding');
+import { AMINO_ACID_PRIMES,
+  getChargeFromPrime,
+  getHydrophobicityFromPrime } from './encoding.js';
 
-// Import core modules with fallback
-let calculateResonance, findGoldenPairs, resonanceSignature, primeToFrequency, KuramotoModel;
+// Golden ratio constant
+const PHI = 1.618033988749895;
 
-try {
-  const core = require('../../core');
-  const physics = require('../../physics');
-  
-  calculateResonance = core.calculateResonance;
-  findGoldenPairs = core.findGoldenPairs;
-  resonanceSignature = core.resonanceSignature;
-  primeToFrequency = core.primeToFrequency;
-  KuramotoModel = physics.KuramotoModel;
-} catch (e) {
-  // Fallback implementations
-  const PHI = 1.618033988749895;
-  
-  calculateResonance = (p1, p2) => {
-    const ratio = Math.max(p1, p2) / Math.min(p1, p2);
-    return 1 / (1 + Math.abs(ratio - PHI));
-  };
-  
-  findGoldenPairs = (primes) => {
-    const pairs = [];
-    for (let i = 0; i < primes.length; i++) {
-      for (let j = i + 1; j < primes.length; j++) {
-        if (calculateResonance(primes[i], primes[j]) > 0.8) {
-          pairs.push([primes[i], primes[j]]);
-        }
+// Fallback implementations (used if core modules don't provide these)
+const fallbackCalculateResonance = (p1, p2) => {
+  const ratio = Math.max(p1, p2) / Math.min(p1, p2);
+  return 1 / (1 + Math.abs(ratio - PHI));
+};
+
+const fallbackFindGoldenPairs = (primes) => {
+  const pairs = [];
+  for (let i = 0; i < primes.length; i++) {
+    for (let j = i + 1; j < primes.length; j++) {
+      if (fallbackCalculateResonance(primes[i], primes[j]) > 0.8) {
+        pairs.push([primes[i], primes[j]]);
       }
     }
-    return pairs;
-  };
-  
-  resonanceSignature = (primes) => {
-    let sum = 0, count = 0;
-    for (let i = 0; i < primes.length; i++) {
-      for (let j = i + 1; j < primes.length; j++) {
-        sum += calculateResonance(primes[i], primes[j]);
-        count++;
-      }
+  }
+  return pairs;
+};
+
+const fallbackResonanceSignature = (primes) => {
+  let sum = 0, count = 0;
+  for (let i = 0; i < primes.length; i++) {
+    for (let j = i + 1; j < primes.length; j++) {
+      sum += fallbackCalculateResonance(primes[i], primes[j]);
+      count++;
     }
-    return { mean: sum / Math.max(count, 1), count };
-  };
-  
-  primeToFrequency = (p, base = 1, logScale = 10) => base + Math.log(p) / logScale;
-}
+  }
+  return { mean: sum / Math.max(count, 1), count };
+};
+
+const fallbackPrimeToFrequency = (p, base = 1, logScale = 10) => base + Math.log(p) / logScale;
+
+// Export calculation functions - fallbacks are used directly
+// Core module integration can be done by consumers if needed
+const calculateResonance = fallbackCalculateResonance;
+const findGoldenPairs = fallbackFindGoldenPairs;
+const resonanceSignature = fallbackResonanceSignature;
+const primeToFrequency = fallbackPrimeToFrequency;
 
 /**
  * BindingAffinityCalculator
@@ -496,8 +488,8 @@ class ProteinProteinDocker extends MolecularDocker {
   }
 }
 
-module.exports = {
-  BindingAffinityCalculator,
-  MolecularDocker,
-  ProteinProteinDocker
+export {
+    BindingAffinityCalculator,
+    MolecularDocker,
+    ProteinProteinDocker
 };

package/backends/bioinformatics/dna-computing.js

@@ -15,12 +15,10 @@
  * - Qian & Winfree (2011) - Seesaw gates
  */
 
-const { 
-  NUCLEOTIDE_PRIMES, 
+import {  NUCLEOTIDE_PRIMES, 
   PRIME_COMPLEMENTS, 
   encodeDNA, 
-  decodeDNA 
-} = require('./encoding');
+  decodeDNA  } from './encoding.js';
 
 // ============================================================================
 // DNA Strand Representation
@@ -642,23 +640,16 @@ class SeesawGate {
   }
 }
 
-module.exports = {
-  // Strand classes
-  DNAStrand,
-  DNADuplex,
-  
-  // Logic gates
-  ANDGate,
-  ORGate,
-  NOTGate,
-  NANDGate,
-  SeesawGate,
-  
-  // Reactions
-  StrandDisplacementReaction,
-  
-  // Circuits
-  DNACircuit,
-  createHalfAdder,
-  createFullAdder,
+export {
+    DNAStrand,
+    DNADuplex,
+    ANDGate,
+    ORGate,
+    NOTGate,
+    NANDGate,
+    SeesawGate,
+    StrandDisplacementReaction,
+    DNACircuit,
+    createHalfAdder,
+    createFullAdder
 };

package/backends/bioinformatics/encoding.js

@@ -20,6 +20,7 @@
  * - Pyrimidines (T, C): smaller primes (2, 3)
  * - Watson-Crick pairs have symmetric products: A-T=14, G-C=33
  */
+
 const NUCLEOTIDE_PRIMES = {
   'A': 7,   // Adenine (purine)
   'T': 2,   // Thymine (pyrimidine) - pairs with A
@@ -306,34 +307,25 @@ function getHydrophobicityFromPrime(prime) {
   return AMINO_ACID_PROPERTIES[aa]?.hydrophobicity || 0;
 }
 
-module.exports = {
-  // Nucleotide mappings
-  NUCLEOTIDE_PRIMES,
-  PRIME_TO_NUCLEOTIDE,
-  DNA_COMPLEMENTS,
-  PRIME_COMPLEMENTS,
-  
-  // Amino acid mappings
-  AMINO_ACID_PRIMES,
-  PRIME_TO_AMINO_ACID,
-  AMINO_ACID_PROPERTIES,
-  
-  // Codon functions
-  encodeCodon,
-  decodeCodon,
-  
-  // Sequence encoding/decoding
-  encodeDNA,
-  decodeDNA,
-  encodeRNA,
-  decodeRNA,
-  encodeProtein,
-  decodeProtein,
-  
-  // Utilities
-  detectSequenceType,
-  parseFASTA,
-  getAminoAcidProperties,
-  getChargeFromPrime,
-  getHydrophobicityFromPrime,
+export {
+    NUCLEOTIDE_PRIMES,
+    PRIME_TO_NUCLEOTIDE,
+    DNA_COMPLEMENTS,
+    PRIME_COMPLEMENTS,
+    AMINO_ACID_PRIMES,
+    PRIME_TO_AMINO_ACID,
+    AMINO_ACID_PROPERTIES,
+    encodeCodon,
+    decodeCodon,
+    encodeDNA,
+    decodeDNA,
+    encodeRNA,
+    decodeRNA,
+    encodeProtein,
+    decodeProtein,
+    detectSequenceType,
+    parseFASTA,
+    getAminoAcidProperties,
+    getChargeFromPrime,
+    getHydrophobicityFromPrime
 };

package/backends/bioinformatics/folding.js

@@ -1,45 +1,35 @@
 /**
  * Protein Folding via Kuramoto Oscillator Dynamics
- * 
+ *
  * Models protein folding as entropy minimization through coupled oscillator synchronization.
  * Each amino acid residue is an oscillator with:
  * - Natural frequency derived from its prime value
  * - Coupling strength from contact propensity (hydrophobic, electrostatic, resonance)
- * 
+ *
  * Folded state = synchronized oscillators = low entropy configuration
  */
 
-const { AMINO_ACID_PRIMES, AMINO_ACID_PROPERTIES, getChargeFromPrime, getHydrophobicityFromPrime } = require('./encoding');
+// Import encoding module
+import { AMINO_ACID_PRIMES, AMINO_ACID_PROPERTIES, getChargeFromPrime, getHydrophobicityFromPrime } from './encoding.js';
 
-// Import physics modules - with fallback for standalone testing
-let KuramotoModel, NetworkKuramoto, AdaptiveKuramoto, shannonEntropy, primeToFrequency, calculateResonance;
+// Golden ratio constant
+const PHI = 1.618033988749895;
 
-try {
-  const physics = require('../../physics');
-  const core = require('../../core');
-  
-  KuramotoModel = physics.KuramotoModel;
-  NetworkKuramoto = physics.NetworkKuramoto || physics.KuramotoModel;
-  AdaptiveKuramoto = physics.AdaptiveKuramoto || physics.KuramotoModel;
-  shannonEntropy = physics.shannonEntropy;
-  primeToFrequency = core.primeToFrequency;
-  calculateResonance = core.calculateResonance;
-} catch (e) {
-  // Fallback implementations for standalone testing
-  primeToFrequency = (p, base = 1, logScale = 10) => base + Math.log(p) / logScale;
-  calculateResonance = (p1, p2) => {
-    const ratio = Math.max(p1, p2) / Math.min(p1, p2);
-    const PHI = 1.618033988749895;
-    return 1 / (1 + Math.abs(ratio - PHI));
-  };
-  shannonEntropy = (probs) => {
-    let H = 0;
-    for (const p of probs) {
-      if (p > 1e-10) H -= p * Math.log2(p);
-    }
-    return H;
-  };
-}
+// Fallback implementations for standalone operation
+const primeToFrequency = (p, base = 1, logScale = 10) => base + Math.log(p) / logScale;
+
+const calculateResonance = (p1, p2) => {
+  const ratio = Math.max(p1, p2) / Math.min(p1, p2);
+  return 1 / (1 + Math.abs(ratio - PHI));
+};
+
+const shannonEntropy = (probs) => {
+  let H = 0;
+  for (const p of probs) {
+    if (p > 1e-10) H -= p * Math.log2(p);
+  }
+  return H;
+};
 
 /**
  * FoldingTransform
@@ -451,4 +441,6 @@ class FoldingTransform {
   }
 }
 
-module.exports = { FoldingTransform };
+export {
+    FoldingTransform
+};

package/backends/bioinformatics/genetic-code.js

@@ -13,6 +13,7 @@
  * Standard (universal) genetic code
  * Maps RNA codons to single-letter amino acid codes
  */
+
 const STANDARD_GENETIC_CODE = {
   // UUX codons
   'UUU': 'F', 'UUC': 'F',  // Phenylalanine
@@ -245,25 +246,20 @@ function classifyMutation(originalCodon, mutatedCodon, geneticCode = STANDARD_GE
   return 'missense';
 }
 
-module.exports = {
-  // Genetic codes
-  STANDARD_GENETIC_CODE,
-  VERTEBRATE_MITOCHONDRIAL_CODE,
-  YEAST_MITOCHONDRIAL_CODE,
-  
-  // Codon lists
-  START_CODONS,
-  STOP_CODONS,
-  CODON_USAGE_ECOLI,
-  
-  // Functions
-  translateCodon,
-  getCodonsForAminoAcid,
-  getCodonDegeneracy,
-  isStartCodon,
-  isStopCodon,
-  calculateGCContent,
-  calculateCAI,
-  getSynonymousCodons,
-  classifyMutation,
+export {
+    STANDARD_GENETIC_CODE,
+    VERTEBRATE_MITOCHONDRIAL_CODE,
+    YEAST_MITOCHONDRIAL_CODE,
+    START_CODONS,
+    STOP_CODONS,
+    CODON_USAGE_ECOLI,
+    translateCodon,
+    getCodonsForAminoAcid,
+    getCodonDegeneracy,
+    isStartCodon,
+    isStopCodon,
+    calculateGCContent,
+    calculateCAI,
+    getSynonymousCodons,
+    classifyMutation
 };

package/backends/bioinformatics/index.js

@@ -12,18 +12,18 @@
  * - DNA computing (logic gates, strand displacement)
  */
 
-const { Backend } = require('../interface');
-const { Hypercomplex } = require('../../core/hypercomplex');
-const { primeToFrequency } = require('../../core/prime');
-
 // Import all submodules
-const encoding = require('./encoding');
-const geneticCode = require('./genetic-code');
-const { TranscriptionOperator } = require('./transcription');
-const { TranslationOperator } = require('./translation');
-const { FoldingTransform } = require('./folding');
-const dnaComputing = require('./dna-computing');
-const binding = require('./binding');
+import { Backend } from '../interface.js';
+import { Hypercomplex } from '../../core/hypercomplex.js';
+import { primeToFrequency } from '../../core/prime.js';
+import { TranscriptionOperator } from './transcription.js';
+import { TranslationOperator } from './translation.js';
+import { FoldingTransform } from './folding.js';
+
+import encoding from './encoding.js';
+import geneticCode from './genetic-code.js';
+import dnaComputing from './dna-computing.js';
+import binding from './binding.js';
 
 /**
  * BioinformaticsBackend
@@ -487,7 +487,7 @@ class BioinformaticsBackend extends Backend {
 }
 
 // Export everything
-module.exports = {
+export default {
   // Main backend
   BioinformaticsBackend,
   

package/backends/bioinformatics/transcription.js

@@ -7,14 +7,14 @@
  * In prime space: T(2) → U(5) substitution
  */
 
-const { NUCLEOTIDE_PRIMES, PRIME_COMPLEMENTS, PRIME_TO_NUCLEOTIDE } = require('./encoding');
-
 /**
  * TranscriptionOperator
  * 
  * Transforms DNA prime sequences to RNA prime sequences.
  * Models the biological process of transcription.
  */
+import { NUCLEOTIDE_PRIMES, PRIME_COMPLEMENTS, PRIME_TO_NUCLEOTIDE } from './encoding.js';
+
 class TranscriptionOperator {
   constructor(options = {}) {
     this.options = {
@@ -218,4 +218,6 @@ class TranscriptionOperator {
   }
 }
 
-module.exports = { TranscriptionOperator };
+export {
+    TranscriptionOperator
+};

package/backends/bioinformatics/translation.js

@@ -8,15 +8,15 @@
  * (64 codons → 21 amino acids = significant information compression)
  */
 
-const { NUCLEOTIDE_PRIMES, AMINO_ACID_PRIMES, PRIME_TO_NUCLEOTIDE } = require('./encoding');
-const { STANDARD_GENETIC_CODE, isStartCodon, isStopCodon, translateCodon } = require('./genetic-code');
-
 /**
  * TranslationOperator
  * 
  * Transforms RNA prime sequences to protein prime sequences.
  * Models ribosome-mediated translation.
  */
+import { NUCLEOTIDE_PRIMES, AMINO_ACID_PRIMES, PRIME_TO_NUCLEOTIDE } from './encoding.js';
+import { STANDARD_GENETIC_CODE, isStartCodon, isStopCodon, translateCodon } from './genetic-code.js';
+
 class TranslationOperator {
   constructor(geneticCode = STANDARD_GENETIC_CODE) {
     this.geneticCode = geneticCode;
@@ -261,4 +261,6 @@ class TranslationOperator {
   }
 }
 
-module.exports = { TranslationOperator };
+export {
+    TranslationOperator
+};

package/backends/cryptographic/index.js

@@ -6,10 +6,11 @@
  * - Holographic Key Distribution
  * - Entropy-Sensitive Encryption
  */
-const { Backend } = require('../interface');
-const { Hypercomplex } = require('../../core/hypercomplex');
-const { GaussianInteger, primeToFrequency, isPrime, firstNPrimes, factorize } = require('../../core/prime');
-const { Complex, PrimeState } = require('../../core/hilbert');
+
+import { Backend } from '../interface.js';
+import { Hypercomplex } from '../../core/hypercomplex.js';
+import { GaussianInteger, primeToFrequency, isPrime, firstNPrimes, factorize } from '../../core/prime.js';
+import { Complex, PrimeState } from '../../core/hilbert.js';
 
 class CryptographicBackend extends Backend {
   constructor(config) {
@@ -641,9 +642,9 @@ class HolographicKeyDistributor {
   }
 }
 
-module.exports = {
-  CryptographicBackend,
-  PrimeStateKeyGenerator,
-  EntropySensitiveEncryptor,
-  HolographicKeyDistributor
+export {
+    CryptographicBackend,
+    PrimeStateKeyGenerator,
+    EntropySensitiveEncryptor,
+    HolographicKeyDistributor
 };

package/backends/index.js

@@ -2,13 +2,14 @@
  * Backends - exports all domain backends
  */
 
-const { Backend } = require('./interface');
-const { SemanticBackend } = require('./semantic');
-const { CryptographicBackend } = require('./cryptographic');
-const { ScientificBackend } = require('./scientific');
-const bioinformatics = require('./bioinformatics');
+import { Backend } from './interface.js';
+import SemanticBackend from './semantic/index.js';
+import CryptographicBackend from './cryptographic/index.js';
+import ScientificBackend from './scientific/index.js';
 
-module.exports = {
+import bioinformatics from './bioinformatics/index.js';
+
+export default {
   Backend,
   SemanticBackend,
   CryptographicBackend,

package/backends/interface.js

@@ -1,6 +1,7 @@
 /**
  * Common interface for all domain backends
  */
+
 class Backend {
   constructor(config) {
     this.config = config;
@@ -86,4 +87,6 @@ class Backend {
   }
 }
 
-module.exports = { Backend };
+export {
+    Backend
+};

package/backends/scientific/index.js

@@ -1,9 +1,10 @@
 /**
  * Scientific Backend - Quantum simulation, particle physics, molecular dynamics
  */
-const { Backend } = require('../interface');
-const { Hypercomplex } = require('../../core/hypercomplex');
-const { primeToFrequency, factorize, firstNPrimes, DEFAULT_PRIMES } = require('../../core/prime');
+
+import { Backend } from '../interface.js';
+import { Hypercomplex } from '../../core/hypercomplex.js';
+import { primeToFrequency, factorize, firstNPrimes, DEFAULT_PRIMES } from '../../core/prime.js';
 
 class ScientificBackend extends Backend {
   constructor(config) {
@@ -269,4 +270,6 @@ class ScientificBackend extends Backend {
   }
 }
 
-module.exports = { ScientificBackend };
+export {
+    ScientificBackend
+};

package/backends/semantic/index.js

@@ -10,9 +10,10 @@
  * - Reading frames: 6 frames (3 forward + 3 reverse offsets)
  * - Sense/Antisense: Dual representations via conjugation
  */
-const { Backend } = require('../interface');
-const { Hypercomplex } = require('../../core/hypercomplex');
-const { primeToFrequency, primeToAngle, DEFAULT_PRIMES, nthPrime } = require('../../core/prime');
+
+import { Backend } from '../interface.js';
+import { Hypercomplex } from '../../core/hypercomplex.js';
+import { primeToFrequency, primeToAngle, DEFAULT_PRIMES, nthPrime } from '../../core/prime.js';
 
 class SemanticBackend extends Backend {
   constructor(config) {
@@ -524,4 +525,6 @@ class SemanticBackend extends Backend {
   }
 }
 
-module.exports = { SemanticBackend };
+export {
+    SemanticBackend
+};

package/backends/semantic/surface.js

@@ -11,6 +11,7 @@
  * A Surface represents a specific vocabulary/style mapping
  * Multiple words can map to the same prime signature with different biases
  */
+
 class Surface {
   constructor(config = {}) {
     this.name = config.name || 'default';
@@ -390,4 +391,4 @@ class BiasEngine {
   }
 }
 
-module.exports = { Surface, SurfaceManager, BiasEngine };
+export default { Surface, SurfaceManager, BiasEngine };

package/backends/semantic/two-layer.js

@@ -12,8 +12,8 @@
  *   - Handles context-dependent vocabulary
  */
 
-const { SemanticBackend } = require('./index');
-const { Surface, SurfaceManager, BiasEngine } = require('./surface');
+import { SemanticBackend } from './index.js';
+import { Surface, SurfaceManager, BiasEngine } from './surface.js';
 
 class TwoLayerEngine {
   constructor(config = {}) {
@@ -372,4 +372,6 @@ class TwoLayerEngine {
   }
 }
 
-module.exports = { TwoLayerEngine };
+export {
+    TwoLayerEngine
+};

package/core/beacon.js

@@ -13,9 +13,10 @@
  * - Hilbert space mapping
  */
 
-const crypto = require('crypto');
-const { isPrime, primesUpTo, factorize } = require('./prime');
-const { Complex, PrimeState } = require('./hilbert');
+import { isPrime, primesUpTo, factorize } from './prime.js';
+import { Complex, PrimeState } from './hilbert.js';
+
+import crypto from 'crypto';
 
 /**
  * Resonant Fragment
@@ -726,10 +727,10 @@ class DataSummoner {
   }
 }
 
-module.exports = {
-  ResonantFragment,
-  Beacon,
-  BeaconCache,
-  CRTReconstructor,
-  DataSummoner
+export {
+    ResonantFragment,
+    Beacon,
+    BeaconCache,
+    CRTReconstructor,
+    DataSummoner
 };

package/core/compound.js

@@ -14,9 +14,6 @@
  * Ported from symprime's CompoundBuilder system.
  */
 
-const { symbolDatabase, SymbolCategory } = require('./symbols');
-const { ResonanceCalculator } = require('./resonance');
-
 // ═══════════════════════════════════════════════════════════════════
 // Compound Symbol Type
 // ═══════════════════════════════════════════════════════════════════
@@ -25,6 +22,9 @@ const { ResonanceCalculator } = require('./resonance');
  * A compound symbol is a combination of multiple base symbols
  * with a unified meaning and cultural context.
  */
+import { symbolDatabase, SymbolCategory } from './symbols.js';
+import { ResonanceCalculator } from './resonance.js';
+
 class CompoundSymbol {
   constructor(id, components, meaning, culturalTags = []) {
     this.id = id;
@@ -514,7 +514,7 @@ class CompoundBuilder {
 // Singleton instance
 const defaultBuilder = new CompoundBuilder();
 
-module.exports = {
+export default {
   CompoundBuilder,
   CompoundSymbol,
   SymbolSequence,