@aleph-ai/tinyaleph 1.5.1 → 1.5.3

package/backends/bioinformatics/binding.js

@@ -492,4 +492,10 @@ export {
     BindingAffinityCalculator,
     MolecularDocker,
     ProteinProteinDocker
+};
+
+export default {
+    BindingAffinityCalculator,
+    MolecularDocker,
+    ProteinProteinDocker
 };

package/backends/bioinformatics/dna-computing.js

@@ -652,4 +652,18 @@ export {
     DNACircuit,
     createHalfAdder,
     createFullAdder
+};
+
+export default {
+    DNAStrand,
+    DNADuplex,
+    ANDGate,
+    ORGate,
+    NOTGate,
+    NANDGate,
+    SeesawGate,
+    StrandDisplacementReaction,
+    DNACircuit,
+    createHalfAdder,
+    createFullAdder
 };

package/backends/bioinformatics/encoding.js

@@ -328,4 +328,27 @@ export {
     getAminoAcidProperties,
     getChargeFromPrime,
     getHydrophobicityFromPrime
+};
+
+export default {
+    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

@@ -443,4 +443,8 @@ class FoldingTransform {
 
 export {
     FoldingTransform
+};
+
+export default {
+    FoldingTransform
 };

package/backends/bioinformatics/genetic-code.js

@@ -262,4 +262,22 @@ export {
     calculateCAI,
     getSynonymousCodons,
     classifyMutation
+};
+
+export default {
+    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/transcription.js

@@ -220,4 +220,8 @@ class TranscriptionOperator {
 
 export {
     TranscriptionOperator
+};
+
+export default {
+    TranscriptionOperator
 };

package/backends/bioinformatics/translation.js

@@ -263,4 +263,8 @@ class TranslationOperator {
 
 export {
     TranslationOperator
+};
+
+export default {
+    TranslationOperator
 };

package/backends/cryptographic/index.js

@@ -647,4 +647,11 @@ export {
     PrimeStateKeyGenerator,
     EntropySensitiveEncryptor,
     HolographicKeyDistributor
+};
+
+export default {
+    CryptographicBackend,
+    PrimeStateKeyGenerator,
+    EntropySensitiveEncryptor,
+    HolographicKeyDistributor
 };

package/backends/scientific/index.js

@@ -272,4 +272,8 @@ class ScientificBackend extends Backend {
 
 export {
     ScientificBackend
+};
+
+export default {
+    ScientificBackend
 };

package/backends/semantic/index.js

@@ -527,4 +527,8 @@ class SemanticBackend extends Backend {
 
 export {
     SemanticBackend
+};
+
+export default {
+    SemanticBackend
 };

package/backends/semantic/two-layer.js

@@ -374,4 +374,8 @@ class TwoLayerEngine {
 
 export {
     TwoLayerEngine
+};
+
+export default {
+    TwoLayerEngine
 };

package/core/compound.js

@@ -514,19 +514,37 @@ class CompoundBuilder {
 // Singleton instance
 const defaultBuilder = new CompoundBuilder();
 
+// Named exports for ESM compatibility
+const compoundBuilder = defaultBuilder;
+const createCompound = (id, components, meaning, tags) =>
+    defaultBuilder.createCompound(id, components, meaning, tags);
+const getCompound = (id) => defaultBuilder.getCompound(id);
+const createSequence = (id, symbols, type, desc) =>
+    defaultBuilder.createSequence(id, symbols, type, desc);
+const getSequence = (id) => defaultBuilder.getSequence(id);
+const findCompoundsContaining = (symbolId) =>
+    defaultBuilder.findCompoundsContaining(symbolId);
+
+export {
+  CompoundBuilder,
+  CompoundSymbol,
+  SymbolSequence,
+  compoundBuilder,
+  createCompound,
+  getCompound,
+  createSequence,
+  getSequence,
+  findCompoundsContaining
+};
+
 export default {
   CompoundBuilder,
   CompoundSymbol,
   SymbolSequence,
-  compoundBuilder: defaultBuilder,
-  
-  // Convenience functions
-  createCompound: (id, components, meaning, tags) => 
-    defaultBuilder.createCompound(id, components, meaning, tags),
-  getCompound: (id) => defaultBuilder.getCompound(id),
-  createSequence: (id, symbols, type, desc) => 
-    defaultBuilder.createSequence(id, symbols, type, desc),
-  getSequence: (id) => defaultBuilder.getSequence(id),
-  findCompoundsContaining: (symbolId) => 
-    defaultBuilder.findCompoundsContaining(symbolId)
+  compoundBuilder,
+  createCompound,
+  getCompound,
+  createSequence,
+  getSequence,
+  findCompoundsContaining
 };

package/core/crt-homology.js

@@ -974,6 +974,36 @@ class CoprimeSelector {
 // EXPORTS
 // ============================================================================
 
+// Named exports for ESM compatibility
+export {
+    // Modular arithmetic utilities
+    extendedGCD,
+    modInverse,
+    areCoprime,
+    softmax,
+    
+    // Core classes
+    ResidueEncoder,
+    CRTReconstructor,
+    BirkhoffProjector,
+    HomologyLoss,
+    CRTModularLayer,
+    CRTFusedAttention,
+    CoprimeSelector
+};
+
+// Factory functions as named exports
+export const createCRTLayer = (primes, hiddenDim, options = {}) =>
+    new CRTModularLayer(primes, hiddenDim, options);
+
+export const createFusedAttention = (primes, hiddenDim, headDim, options = {}) =>
+    new CRTFusedAttention(primes, hiddenDim, headDim, options);
+
+// Default configurations
+export const DEFAULT_PRIMES_SMALL = [2, 3, 5, 7];
+export const DEFAULT_PRIMES_MEDIUM = [5, 7, 11, 13];
+export const DEFAULT_PRIMES_SEMANTIC = [2, 3, 5, 7, 11];
+
 export default {
     // Modular arithmetic utilities
     extendedGCD,
@@ -991,14 +1021,11 @@ export default {
     CoprimeSelector,
     
     // Factory functions
-    createCRTLayer: (primes, hiddenDim, options = {}) =>
-        new CRTModularLayer(primes, hiddenDim, options),
-    
-    createFusedAttention: (primes, hiddenDim, headDim, options = {}) =>
-        new CRTFusedAttention(primes, hiddenDim, headDim, options),
+    createCRTLayer,
+    createFusedAttention,
     
     // Default configurations
-    DEFAULT_PRIMES_SMALL: [2, 3, 5, 7],
-    DEFAULT_PRIMES_MEDIUM: [5, 7, 11, 13],
-    DEFAULT_PRIMES_SEMANTIC: [2, 3, 5, 7, 11]
+    DEFAULT_PRIMES_SMALL,
+    DEFAULT_PRIMES_MEDIUM,
+    DEFAULT_PRIMES_SEMANTIC
 };

package/core/index.js

@@ -166,6 +166,216 @@ let rformerTF = null;
 // Dynamic import for optional TensorFlow.js support
 // Use: const tf = await import('./rformer-tf.js') when needed
 
+// Named exports for ESM compatibility
+export {
+  // Hypercomplex algebra
+  Hypercomplex,
+  
+  // Fano plane / multiplication
+  FANO_LINES,
+  octonionMultiplyIndex,
+  sedenionMultiplyIndex,
+  multiplyIndices,
+  buildMultiplicationTable,
+  
+  // Prime utilities
+  primeGenerator,
+  nthPrime,
+  primesUpTo,
+  isPrime,
+  factorize,
+  primeSignature,
+  firstNPrimes,
+  GaussianInteger,
+  EisensteinInteger,
+  primeToFrequency,
+  primeToAngle,
+  sumOfTwoSquares,
+  DEFAULT_PRIMES,
+  
+  // LLM client
+  LLM,
+  
+  // Prime Hilbert Space
+  Complex,
+  PrimeState,
+  ResonanceOperators,
+  EntropyDrivenEvolution,
+  encodeMemory,
+  symbolicCompute,
+  QuaternionPrime,
+  PrimeResonanceIdentity,
+  PhaseLockedRing,
+  HolographicField,
+  EntangledNode,
+  ResonantFragment,
+  DELTA_S,
+  
+  // Golden Ratio Resonance
+  PHI,
+  PHI_THRESHOLD,
+  PHI_BONUS,
+  ResonanceCalculator,
+  resonanceSignature,
+  findFibonacciSequences,
+  calculateResonance,
+  findGoldenPairs,
+  findMostResonant,
+  
+  // Symbol Database
+  SymbolDatabase,
+  SymbolCategory,
+  PrimeGenerator,
+  symbolDatabase,
+  getSymbol,
+  getSymbolByPrime,
+  searchSymbols,
+  encodeSymbols,
+  decodeSymbols,
+  
+  // Semantic Inference
+  SemanticInference,
+  EntityExtractor,
+  InferenceMethod,
+  semanticInference,
+  entityExtractor,
+  inferSymbol,
+  inferSymbols,
+  extractEntities,
+  extractAndInfer,
+  inferWithResonance,
+  inferMostResonant,
+  
+  // Compound Builder
+  CompoundBuilder,
+  CompoundSymbol,
+  SymbolSequence,
+  compoundBuilder,
+  createCompound,
+  getCompound,
+  createSequence,
+  getSequence,
+  findCompoundsContaining,
+  
+  // ResoFormer ML Primitives
+  Quaternion,
+  SparsePrimeState,
+  resonanceScore,
+  resonantAttention,
+  hamiltonCompose,
+  measureNonCommutativity,
+  computeCoherence,
+  haltingDecision,
+  coherenceGatedCompute,
+  EntropyCollapseHead,
+  generateAttractorCodebook,
+  PRGraphMemory,
+  applyResonanceOperator,
+  
+  // ResoFormer Complete Layers
+  ResonantMultiHeadAttention,
+  PrimeFFN,
+  PrimeLayerNorm,
+  PositionalPrimeEncoding,
+  ResoFormerBlock,
+  ResoFormer,
+  
+  // CRT-enhanced ResoFormer
+  CRTResonantAttention,
+  HomologyRegularizedBlock,
+  CRTResoFormer,
+  createCRTResoFormer,
+  
+  // Prime Entanglement Graph
+  EntanglementEdge,
+  PrimeEntanglementGraph,
+  createEntanglementGraph,
+  
+  // Event System
+  AlephEventEmitter,
+  AlephMonitor,
+  EvolutionStream,
+  createEvolutionStream,
+  createMonitor,
+  
+  // Formal Type System
+  NounType,
+  AdjType,
+  SentenceType,
+  NounTerm,
+  AdjTerm,
+  ChainTerm,
+  FusionTerm,
+  NounSentence,
+  SeqSentence,
+  ImplSentence,
+  TypingContext,
+  TypingJudgment,
+  TypeChecker,
+  N,
+  A,
+  FUSE,
+  CHAIN,
+  SENTENCE,
+  SEQ,
+  IMPL,
+  
+  // Reduction Semantics
+  PrimeOperator,
+  NextPrimeOperator,
+  ModularPrimeOperator,
+  ResonancePrimeOperator,
+  IdentityPrimeOperator,
+  DEFAULT_OPERATOR,
+  ReductionStep,
+  ReductionTrace,
+  ReductionSystem,
+  isNormalForm,
+  isReducible,
+  termSize,
+  FusionCanonicalizer,
+  NormalFormVerifier,
+  demonstrateStrongNormalization,
+  testLocalConfluence,
+  
+  // Lambda Calculus
+  LambdaExpr,
+  VarExpr,
+  ConstExpr,
+  LamExpr,
+  AppExpr,
+  PairExpr,
+  ImplExpr,
+  PrimOpExpr,
+  Translator,
+  TypeDirectedTranslator,
+  LambdaEvaluator,
+  Semantics,
+  ConceptInterpreter,
+  
+  // Enochian
+  enochian,
+  enochianVocabulary,
+  
+  // CRT-Homology
+  extendedGCD,
+  modInverse,
+  areCoprime,
+  softmax,
+  ResidueEncoder,
+  CRTReconstructor,
+  BirkhoffProjector,
+  HomologyLoss,
+  CRTModularLayer,
+  CRTFusedAttention,
+  CoprimeSelector,
+  createCRTLayer,
+  createFusedAttention,
+  DEFAULT_PRIMES_SMALL,
+  DEFAULT_PRIMES_MEDIUM,
+  DEFAULT_PRIMES_SEMANTIC
+};
+
 export default {
   // Hypercomplex algebra
   Hypercomplex,

package/core/inference.js

@@ -584,22 +584,47 @@ class EntityExtractor {
 const defaultInference = new SemanticInference();
 const defaultExtractor = new EntityExtractor();
 
+// Convenience function aliases
+const semanticInference = defaultInference;
+const entityExtractor = defaultExtractor;
+const inferSymbol = (text) => defaultInference.inferSymbol(text);
+const inferSymbols = (entities) => defaultInference.inferSymbols(entities);
+const inferWithResonance = (text, options) => defaultInference.inferWithResonance(text, options);
+const inferMostResonant = (text, contextSymbols) => defaultInference.inferMostResonant(text, contextSymbols);
+const extractEntities = (text) => defaultExtractor.extract(text);
+const extractAndInfer = (text) => defaultExtractor.extractAndInfer(text, defaultInference);
+
+// Named exports for ESM compatibility
+export {
+  SemanticInference,
+  EntityExtractor,
+  InferenceMethod,
+  semanticInference,
+  entityExtractor,
+  inferSymbol,
+  inferSymbols,
+  inferWithResonance,
+  inferMostResonant,
+  extractEntities,
+  extractAndInfer
+};
+
 export default {
   SemanticInference,
   EntityExtractor,
   InferenceMethod,
   
   // Singleton instances
-  semanticInference: defaultInference,
-  entityExtractor: defaultExtractor,
+  semanticInference,
+  entityExtractor,
   
   // Convenience functions
-  inferSymbol: (text) => defaultInference.inferSymbol(text),
-  inferSymbols: (entities) => defaultInference.inferSymbols(entities),
+  inferSymbol,
+  inferSymbols,
   
   // Resonance-enhanced inference
-  inferWithResonance: (text, options) => defaultInference.inferWithResonance(text, options),
-  inferMostResonant: (text, contextSymbols) => defaultInference.inferMostResonant(text, contextSymbols),
-  extractEntities: (text) => defaultExtractor.extract(text),
-  extractAndInfer: (text) => defaultExtractor.extractAndInfer(text, defaultInference)
+  inferWithResonance,
+  inferMostResonant,
+  extractEntities,
+  extractAndInfer
 };

package/core/resonance.js

@@ -310,6 +310,21 @@ function findFibonacciSequences(primes, minLength = 3) {
 // Singleton instance for convenience
 const defaultCalculator = new ResonanceCalculator();
 
+// Named exports for ESM compatibility
+export {
+  ResonanceCalculator,
+  resonanceSignature,
+  findFibonacciSequences,
+  PHI,
+  PHI_THRESHOLD,
+  PHI_BONUS
+};
+
+// Convenience functions using default calculator
+export const calculateResonance = (p1, p2) => defaultCalculator.calculateResonance(p1, p2);
+export const findGoldenPairs = (primes) => defaultCalculator.findGoldenPairs(primes);
+export const findMostResonant = (target, candidates) => defaultCalculator.findMostResonant(target, candidates);
+
 export default {
   ResonanceCalculator,
   resonanceSignature,
@@ -317,9 +332,7 @@ export default {
   PHI,
   PHI_THRESHOLD,
   PHI_BONUS,
-  
-  // Convenience functions using default calculator
-  calculateResonance: (p1, p2) => defaultCalculator.calculateResonance(p1, p2),
-  findGoldenPairs: (primes) => defaultCalculator.findGoldenPairs(primes),
-  findMostResonant: (target, candidates) => defaultCalculator.findMostResonant(target, candidates)
+  calculateResonance,
+  findGoldenPairs,
+  findMostResonant
 };

package/core/symbols/elements.js

@@ -478,10 +478,13 @@ const abstractSymbols = [
   }
 ];
 
+// Named export for allElementSymbols (used by index.js)
+export const allElementSymbols = [...elementSymbols, ...placeSymbols, ...objectSymbols, ...abstractSymbols];
+
 export default {
   elementSymbols,
   placeSymbols,
   objectSymbols,
   abstractSymbols,
-  allElementSymbols: [...elementSymbols, ...placeSymbols, ...objectSymbols, ...abstractSymbols]
+  allElementSymbols
 };

package/core/symbols/tarot.js

@@ -204,8 +204,11 @@ const tarotMinorSuits = [
   }
 ];
 
+// Named export for tarotSymbols (used by index.js)
+export const tarotSymbols = [...tarotMajorArcana, ...tarotMinorSuits];
+
 export default {
   tarotMajorArcana,
   tarotMinorSuits,
-  tarotSymbols: [...tarotMajorArcana, ...tarotMinorSuits]
+  tarotSymbols
 };

package/core/symbols.js

@@ -1,23 +1,44 @@
 /**
  * Symbol Database
- * 
+ *
  * Comprehensive database of 400+ symbols with:
  * - Unicode emoji representation
  * - Prime number assignment (unique per symbol)
  * - Category organization
  * - Cultural tags for cross-cultural mapping
  * - Rich, detailed meanings
- * 
+ *
  * Includes:
  * - Jungian archetypes and mythological figures
  * - Tarot Major and Minor Arcana
  * - I-Ching 64 hexagrams
  * - Egyptian hieroglyphs
  * - Natural elements, places, objects, abstracts
- * 
+ *
  * Refactored to use modular symbol definition files.
  */
 
 // Re-export everything from the modular structure
+export {
+  symbolDatabase,
+  SymbolDatabase,
+  SymbolCategory,
+  PrimeGenerator,
+  archetypeSymbols,
+  tarotSymbols,
+  ichingHexagrams,
+  egyptianHieroglyphs,
+  allElementSymbols,
+  getSymbol,
+  getSymbolByPrime,
+  getSymbolsByCategory,
+  getSymbolsByTag,
+  search,
+  encode,
+  decode,
+  getAllSymbols,
+  getStats
+} from './symbols/index.js';
 
-module.exports = require('./symbols/index');
+// Default export
+export { default } from './symbols/index.js';

package/core/types.js

@@ -878,8 +878,16 @@ function IMPL(s1, s2) {
 // EXPORTS
 // ============================================================================
 
+// Type aliases for compatibility with core/index.js
+const NounType = Types.NOUN;
+const AdjType = Types.ADJECTIVE;
+const SentenceType = Types.SENTENCE;
+
 export {
     Types,
+    NounType,
+    AdjType,
+    SentenceType,
     Term,
     NounTerm,
     AdjTerm,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aleph-ai/tinyaleph",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "Prime-resonant semantic computing framework - hypercomplex algebra, oscillator dynamics, and entropy-minimizing reasoning",
   "type": "module",
   "main": "index.js",

package/physics/oscillator.js

@@ -93,4 +93,7 @@ class OscillatorBank {
   }
 }
 
+// Named exports for ESM compatibility
+export { Oscillator, OscillatorBank };
+
 export default { Oscillator, OscillatorBank };