@aleph-ai/tinyaleph 1.5.2 → 1.5.4

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/errors.js

@@ -576,4 +576,21 @@ export {
     withErrorHandling,
     errorBoundary,
     withTimeout
+};
+
+// Default export for compatibility with modular.js
+export default {
+    LogLevel,
+    LogLevelNames,
+    ErrorCategory,
+    AlephError,
+    NetworkError,
+    LLMError,
+    ValidationError,
+    TimeoutError,
+    SimpleEventEmitter,
+    ErrorHandler,
+    withErrorHandling,
+    errorBoundary,
+    withTimeout
 };

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/logger.js

@@ -346,4 +346,12 @@ export {
     createLogger,
     LogLevel,
     LogLevelNames
+};
+
+// Default export for compatibility with modular.js
+export default {
+    Logger,
+    createLogger,
+    LogLevel,
+    LogLevelNames
 };

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/engine/index.js

@@ -6,4 +6,9 @@ import { AlephEngine } from './aleph.js';
 
 export {
     AlephEngine
+};
+
+// Default export for compatibility with modular.js
+export default {
+    AlephEngine
 };

package/modular.js

@@ -23,27 +23,7 @@
  * - Safety Layer - Ethical constraints and emergency shutdown
  */
 
-// Core mathematical foundation
-import core from './core/index.js';
 
-// Enochian Packet Layer (Section 7.4 of whitepaper)
-import enochian from './core/enochian.js';
-import enochianVocabulary from './core/enochian-vocabulary.js';
-
-// Browser-compatible utilities (extracted from apps/sentient)
-import errors from './core/errors.js';
-import logger from './core/logger.js';
-import metrics from './telemetry/metrics.js';
-
-// Observer architecture (Sentient Observer core modules)
-import smf from './observer/smf.js';
-import prsc from './observer/prsc.js';
-import temporal from './observer/temporal.js';
-import entanglement from './observer/entanglement.js';
-import agency from './observer/agency.js';
-import boundary from './observer/boundary.js';
-import safety from './observer/safety.js';
-import hqe from './observer/hqe.js';
 const {
   Hypercomplex,
   FANO_LINES,

package/package.json

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

package/physics/index.js

@@ -112,4 +112,57 @@ export {
     bornMeasurement,
     partialCollapse,
     applyDecoherence
+};
+
+// Default export for compatibility with modular.js
+export default {
+    Oscillator,
+    OscillatorBank,
+    KuramotoModel,
+    NetworkKuramoto,
+    AdaptiveKuramoto,
+    SakaguchiKuramoto,
+    SmallWorldKuramoto,
+    MultiSystemCoupling,
+    createHierarchicalCoupling,
+    createPeerCoupling,
+    StochasticKuramoto,
+    ColoredNoiseKuramoto,
+    ThermalKuramoto,
+    gaussianRandom,
+    PrimeonZLadderU,
+    createPrimeonLadder,
+    shannonEntropyNats,
+    probsOf,
+    normalizeComplex,
+    Complex,
+    ZChannel,
+    PrimeonZLadderMulti,
+    createMultiChannelLadder,
+    createAdiabaticSchedule,
+    KuramotoCoupledLadder,
+    createKuramotoLadder,
+    runCollapsePressureExperiment,
+    kuramotoOrderParameter,
+    getPhase,
+    shannonEntropy,
+    stateEntropy,
+    coherence,
+    mutualInformation,
+    relativeEntropy,
+    jointEntropy,
+    oscillatorEntropy,
+    estimateLyapunov,
+    classifyStability,
+    adaptiveCoupling,
+    localLyapunov,
+    delayEmbedding,
+    stabilityMargin,
+    collapseProbability,
+    shouldCollapse,
+    measureState,
+    collapseToIndex,
+    bornMeasurement,
+    partialCollapse,
+    applyDecoherence
 };

package/telemetry/metrics.js

@@ -700,4 +700,15 @@ export {
     Histogram,
     Summary,
     MetricRegistry
+};
+
+// Default export for compatibility with modular.js
+export default {
+    MetricType,
+    Metric,
+    Counter,
+    Gauge,
+    Histogram,
+    Summary,
+    MetricRegistry
 };