const { createEngine, SemanticBackend } = require('@aleph-ai/tinyaleph');

// Load configuration
const config = require('@aleph-ai/tinyaleph/data.json');

// Create a semantic engine
const engine = createEngine('semantic', config);

// Process a query
const result = engine.run('What is the relationship between wisdom and truth?');

console.log('Output:', result.output);
console.log('Entropy:', result.entropy);
console.log('Steps:', result.steps.length);

const backend = new SemanticBackend(config);

const primes = backend.encode('love and wisdom');
console.log(primes);  // [2, 3, 5, 7, 11, ...]

const { Hypercomplex } = require('@aleph-ai/tinyaleph');

// Create a state
const state = new Hypercomplex(16);
state.excite([2, 3, 5]);  // Excite with primes

// States support multiplication (non-commutative!)
const combined = state1.multiply(state2);
console.log(state1.multiply(state2) !== state2.multiply(state1));  // true

const engine = createEngine('semantic', config);
const result = engine.run('Confused question here');

// Watch entropy decrease through reasoning steps
for (const step of result.steps) {
  console.log(`Step ${step.step}: entropy ${step.entropyAfter.toFixed(3)}`);
}

const { SemanticBackend } = require('@aleph-ai/tinyaleph');

const backend = new SemanticBackend(config);

// Tokenize
const tokens = backend.tokenize('Love is truth');

// Encode to primes
const primes = backend.encode('Love is truth');

// Decode back
const text = backend.decode(primes);

// Compare concepts
const state1 = backend.textToOrderedState('wisdom');
const state2 = backend.textToOrderedState('knowledge');
console.log('Similarity:', state1.coherence(state2));

const { CryptographicBackend, hash, deriveKey } = require('@aleph-ai/tinyaleph');

// Quick hash
const h = hash('my secret data');

// Key derivation
const key = deriveKey('password', 'salt', 32, 10000);

// Full backend
const crypto = new CryptographicBackend(config);
const semanticHash = crypto.hash('similar meanings produce similar hashes');

const { ScientificBackend } = require('@aleph-ai/tinyaleph');

const backend = new ScientificBackend(config);

// Create quantum-like states
const state = backend.createRandomState();
const basis = backend.createBasisState(0);

// Superposition
const superposition = backend.superpose(state, 0.5, basis, 0.5);

// Measurement
const result = backend.measure(superposition, [basis]);

const { BioinformaticsBackend, DNACircuit, ANDGate, ORGate } = require('@aleph-ai/tinyaleph');

const backend = new BioinformaticsBackend();

// Encode DNA sequence
const dnaPrimes = backend.encode('ATGCGATCG');

// Transcribe DNA to RNA
const transcribed = backend.transcribe(dnaPrimes, { force: true });
console.log('mRNA primes:', transcribed.rna);

// Translate RNA to Protein
const translated = backend.translate(transcribed.rna);
console.log('Protein:', backend.decode(translated.protein));

// Full gene expression (DNA → RNA → Protein)
const expressed = backend.express(dnaPrimes);
console.log('Protein sequence:', expressed.sequence);

// Protein folding via Kuramoto oscillators
const proteinPrimes = backend.encode('MWLKFVIER');
const foldResult = backend.foldProtein(proteinPrimes);
console.log('Folding order parameter:', foldResult.orderParameter);

// Molecular binding affinity
const affinity = backend.bindingAffinity(dnaPrimes, proteinPrimes);
console.log('Binding affinity:', affinity.affinity);

const { DNACircuit, ANDGate, ORGate, NOTGate } = require('@aleph-ai/tinyaleph');

// Create logic gates
const andGate = new ANDGate({ name: 'and1' });
const orGate = new ORGate({ name: 'or1' });
const notGate = new NOTGate({ name: 'not1' });

// Evaluate gates (concentration-based)
console.log(andGate.evaluate(1, 1));  // { output: true, ... }
console.log(orGate.evaluate(0, 1));   // { output: true, ... }
console.log(notGate.evaluate(0));     // { output: true, ... }

// Build a circuit
const circuit = new DNACircuit('logic-circuit');
circuit.addGate('and1', new ANDGate({ name: 'and1' }));
circuit.addGate('not1', new NOTGate({ name: 'not1' }));
circuit.addGate('or1', new ORGate({ name: 'or1' }));
circuit.connect('and1', 'or1', 1);
circuit.connect('not1', 'or1', 2);

// Evaluate circuit
const result = circuit.evaluate();

const { Oscillator, OscillatorBank, KuramotoModel } = require('@aleph-ai/tinyaleph');

// Create oscillator bank
const bank = new OscillatorBank(16);

// Excite with primes
bank.excite([2, 3, 5, 7]);

// Kuramoto synchronization
const kuramoto = new KuramotoModel(bank, { coupling: 0.1 });
kuramoto.step(0.01);

console.log('Order parameter:', kuramoto.orderParameter());

const {
  NetworkKuramoto,      // Topology-aware coupling
  AdaptiveKuramoto,     // Hebbian plasticity
  SakaguchiKuramoto,    // Phase frustration (chimera states)
  SmallWorldKuramoto,   // Watts-Strogatz topology
  MultiSystemCoupling   // Cross-system synchronization
} = require('@aleph-ai/tinyaleph');

// Network Kuramoto with custom topology
const network = new NetworkKuramoto(frequencies, adjacencyMatrix, 0.5);
network.setFromEntanglementGraph(entanglementGraph, primeList);

// Adaptive Kuramoto with Hebbian learning
const adaptive = new AdaptiveKuramoto(frequencies, 0.3, 0.02);
// Coupling evolves: "concepts that sync together link together"

// Sakaguchi-Kuramoto with phase frustration
const sakaguchi = new SakaguchiKuramoto(frequencies, 0.5, Math.PI/4);
console.log('State:', sakaguchi.classifyState()); // synchronized/chimera/incoherent

// Small-world topology
const smallWorld = new SmallWorldKuramoto(frequencies, 4, 0.1, 0.5);
console.log('Small-world coefficient:', smallWorld.smallWorldCoefficient());

// Multi-system coupling (hierarchical or peer-to-peer)
const multi = new MultiSystemCoupling([system1, system2, system3]);
console.log('Inter-system coherence:', multi.interSystemCoherence());

const {
  StochasticKuramoto,      // White noise Langevin dynamics
  ColoredNoiseKuramoto,    // Ornstein-Uhlenbeck noise
  ThermalKuramoto          // Temperature-dependent coupling
} = require('@aleph-ai/tinyaleph');

// White noise model
const stochastic = new StochasticKuramoto(frequencies, {
  coupling: 0.5,
  noiseIntensity: 0.1
});

stochastic.evolve(100, 0.01);
const { mean, stdDev } = stochastic.orderParameterWithUncertainty(50, 0.01);

// Colored noise (Ornstein-Uhlenbeck process)
const colored = new ColoredNoiseKuramoto(frequencies, {
  correlationTime: 2.0,
  noiseIntensity: 0.1
});

// Thermal model with temperature-dependent noise
const thermal = new ThermalKuramoto(frequencies, { temperature: 2.0 });
thermal.setTemperature(4.0);  // Higher temp = more noise
const Tc = thermal.estimateCriticalTemperature();

const { PrimeEntanglementGraph } = require('@aleph-ai/tinyaleph');

const graph = new PrimeEntanglementGraph([2, 3, 5, 7, 11]);

// Record co-occurrences
graph.observe([2, 3], [5, 7], 0.8);
graph.observe([5, 7], [11], 0.6);

// Query relationships
const neighbors = graph.neighbors(7, 2);  // 2-hop neighborhood
const path = graph.shortestPath(2, 11);

// Graph metrics
const cc = graph.clusteringCoefficient(5);
const stats = graph.stats();

// Convert to Kuramoto network
const adjacency = graph.toAdjacencyMatrix([2, 3, 5, 7, 11]);

const {
  AlephEventEmitter,
  AlephMonitor,
  EvolutionStream
} = require('@aleph-ai/tinyaleph');

// Event emitter with throttling
const emitter = new AlephEventEmitter();
emitter.throttle('tick', 100);  // Max once per 100ms

emitter.on('collapse', ({ from, to, probability }) => {
  console.log(`Collapsed with p=${probability}`);
});

emitter.on('sync', ({ orderParameter }) => {
  console.log(`Synchronized: r=${orderParameter}`);
});

// Promise-based waiting
const data = await emitter.waitFor('ready', 5000);

// Async iteration over evolution
const stream = EvolutionStream.fromEvolvable(kuramoto);

for await (const state of stream.take(100)) {
  console.log(state.orderParameter);
}

// Stream operators
const filtered = stream
  .filter(s => s.entropy < 2.0)
  .map(s => s.orderParameter)
  .take(50);

const { shannonEntropy, estimateLyapunov, stateEntropy } = require('@aleph-ai/tinyaleph');

// Calculate entropy
const entropy = stateEntropy(state);

// Estimate Lyapunov exponent for stability
const lambda = estimateLyapunov(entropyTimeSeries);
console.log('Stable:', lambda < 0);

const { Hypercomplex } = require('@aleph-ai/tinyaleph');

const q1 = Hypercomplex.fromArray([1, 0, 0, 0]);
const q2 = Hypercomplex.fromAxisAngle(4, [0, 0, 1], Math.PI/2);

// Exponential and logarithm
const expQ = q1.exp();
const logQ = q2.log();

// Smooth interpolation (slerp)
for (let t = 0; t <= 1; t += 0.1) {
  const interpolated = q1.slerp(q2, t);
}

// Rotation operations
const rotated = q2.sandwich(vector);
const axis = q2.toAxisAngle();

// Power operations
const squared = q1.pow(2);
const cubed = q1.powInt(3);

const { PrimeonZLadderMulti, createAdiabaticSchedule } = require('@aleph-ai/tinyaleph');

const ladder = new PrimeonZLadderMulti({
  N: 32,
  zChannels: [
    { name: 'fast', dz: 1, leak: 0.2, decay: 0.1 },
    { name: 'slow', dz: 1, leak: 0.01, decay: 0.001 },
    { name: 'permanent', dz: 1, leak: 0.0, decay: 0.0 }
  ],
  J: 0.25
});

// Per-channel metrics
const metrics = ladder.channelMetrics();
console.log('Fast entropy:', metrics.fast.entropy);
console.log('Slow Z-flux:', metrics.slow.totalFlux);

// Adiabatic parameter schedules
const Jt = createAdiabaticSchedule(0.1, 0.5, 100, 'sinusoidal');
const ladder2 = new PrimeonZLadderMulti({ N: 16, Jt });

const {
  TWIST_108,
  Knot,
  TREFOIL,
  PhysicalConstants,
  GaugeSymmetry,
  FreeEnergyDynamics,
  OBSERVER_HIERARCHY
} = require('@aleph-ai/tinyaleph/core/topology');

// 108 Invariant: 2² × 3³ = 108
console.log(TWIST_108.value);           // 108
console.log(TWIST_108.factorization);   // { twos: 2, threes: 3 }

// Twist angle κ(p) = 360°/p
const twistAngle = TWIST_108.twistAngle(7);  // 51.43°

// Find minimum primes for closed twist (sum to 360°)
const closingPrimes = TWIST_108.findClosingPrimes(3);

// Trefoil Knot with complexity T = s·c - b + u = 17
console.log(TREFOIL.strands);      // 1
console.log(TREFOIL.crossings);    // 3
console.log(TREFOIL.bridges);      // 2
console.log(TREFOIL.unknotting);   // 1
console.log(TREFOIL.complexity);   // 17

// Physical constants from 108 + Trefoil
console.log(PhysicalConstants.PROTON_ELECTRON_RATIO);  // 1836 (17 × 108)
console.log(PhysicalConstants.FINE_STRUCTURE_INV);     // 137 (108 + 29)
console.log(PhysicalConstants.ALPHA);                  // 1/137

// Gauge symmetry from 108 factorization
const gauge = new GaugeSymmetry();
console.log(gauge.generators);       // { SU3: 8, SU2: 3, U1: 1 }
console.log(gauge.totalDimension);   // 12
console.log(gauge.isStandardModel);  // true

// Free Energy Dynamics (cubic FEP)
// dψ/dt = αψ + βψ² + γψ³
const fep = new FreeEnergyDynamics({ alpha: 0.1, beta: -0.3, gamma: 0.2 });
const energy = fep.freeEnergy(0.5);   // F(ψ)
const gradient = fep.gradient(0.5);   // dF/dψ
const minima = fep.findMinima();      // Stable states

// Observer Hierarchy (quantum to cosmic scales)
OBSERVER_HIERARCHY.forEach(level => {
  console.log(`${level.name}: scale=${level.scale}, capacity=${level.capacity}`);
});
// cellular: scale=1e-6, capacity=1e6
// neural: scale=1e-3, capacity=1e9
// cognitive: scale=1, capacity=1e12
// collective: scale=1e6, capacity=1e15
// cosmic: scale=1e26, capacity=1e21

const { INT_SINE_TABLE, computeHistogramCoherence } = require('@aleph-ai/tinyaleph/apps/sentient/lib/prsc');
const { SMF_CODEBOOK, nearestCodebookAttractor, codebookTunnel } = require('@aleph-ai/tinyaleph/apps/sentient/lib/smf');
const { canonicalTriad, canonicalFusion, verifyCanonical } = require('@aleph-ai/tinyaleph/apps/sentient/lib/prime-calculus');
const { TickGate } = require('@aleph-ai/tinyaleph/apps/sentient/lib/hqe');

// Integer Sine Table (M=256 discretization)
console.log(INT_SINE_TABLE.M);            // 256
const sinValue = INT_SINE_TABLE.sin(64);  // Integer sine at phase 64
const cosValue = INT_SINE_TABLE.cos(128); // Integer cosine at phase 128

// Histogram Coherence C_bin(t) = max_k(b_k(t))/|P|
const phases = [10, 12, 11, 50, 52, 51, 100, 102, 101];
const coherence = computeHistogramCoherence(phases, { numBins: 16 });
// coherence ≈ 0.33 (three clusters of 3 phases each)

// 64-Attractor SMF Codebook
console.log(SMF_CODEBOOK.length);         // 64
console.log(SMF_CODEBOOK[0]);             // { index: 0, phase: 0, label: '0x00' }

// Find nearest codebook attractor
const nearest = nearestCodebookAttractor(130);  // phase 130
console.log(nearest.index);               // Nearest codebook index
console.log(nearest.distance);            // Distance to attractor

// Controlled tunneling to codebook attractor
const tunneled = codebookTunnel(130, { force: 0.5 });
console.log(tunneled.original);           // 130
console.log(tunneled.target);             // Nearest attractor phase
console.log(tunneled.result);             // Tunneled phase (interpolated)

// Canonical Fusion FUSE(p,q,r) selection
const triad = canonicalTriad(19);  // Find canonical triad for sum 19
console.log(triad);                // [3, 5, 11] (lexicographically first)

// Verify canonical property
console.log(verifyCanonical(3, 5, 11, 19));  // true

// Fuse with automatic triad selection
const fused = canonicalFusion(19);
console.log(fused.triad);          // [3, 5, 11]
console.log(fused.sum);            // 19

// Tick-Only HQE Gate
const tickGate = new TickGate({ threshold: 0.7 });
const gateResult = tickGate.evaluate({ coherence: 0.8, tickValid: true });
console.log(gateResult.passed);    // true (coherence > threshold && tick valid)
console.log(gateResult.reason);    // 'TICK_VALID'

const { SymbolicObserver } = require('@aleph-ai/tinyaleph/apps/sentient/lib/symbolic-observer');

const observer = new SymbolicObserver();

// Add oscillator bank for N_osc
observer.addOscillatorBank(bank);

// Calculate observer capacity
const capacity = observer.calculateObserverCapacity({
  alpha: 1/137,           // Fine structure constant
  meanCoupling: 0.5,      // K̄ average coupling
  coherenceTime: 0.1      // τ coherence time
});

console.log(capacity.value);       // Capacity in bits/second
console.log(capacity.numOscillators);
console.log(capacity.formula);     // 'α × N_osc × K̄ × τ⁻¹'

const { FreeEnergyCuriosity } = require('@aleph-ai/tinyaleph/apps/sentient/lib/learning/curiosity');

const curiosity = new FreeEnergyCuriosity({
  alpha: 0.1,    // Linear coefficient
  beta: -0.3,    // Quadratic coefficient
  gamma: 0.2     // Cubic coefficient
});

// Evaluate free energy at belief state ψ
const energy = curiosity.freeEnergy(0.5);

// Get gradient for belief update
const grad = curiosity.gradient(0.5);

// Find stable belief states (local minima)
const stableStates = curiosity.findMinima();

// Check if current state is at equilibrium
const isStable = curiosity.isStable(0.5, { tolerance: 0.01 });

const { ObserverScaleManager } = require('@aleph-ai/tinyaleph/apps/sentient/lib/collective');

const manager = new ObserverScaleManager();

// Assign node to appropriate hierarchy level based on capacity
const level = manager.assignNode(nodeId, observerCapacity);
console.log(level.name);       // 'neural', 'cognitive', etc.
console.log(level.scale);      // Physical scale
console.log(level.capacity);   // Information capacity

// Get all nodes at a level
const cognitiveNodes = manager.getNodesAtLevel('cognitive');

// Get hierarchy statistics
const stats = manager.getHierarchyStats();
console.log(stats.totalNodes);
console.log(stats.levelDistribution);

const {
  ResoFormer,
  ResoFormerBlock,
  ResonantMultiHeadAttention,
  PrimeFFN,
  SparsePrimeState
} = require('@aleph-ai/tinyaleph');

// Create sparse prime states
const state1 = SparsePrimeState.fromPrimes([2, 3, 5]);
const state2 = SparsePrimeState.fromPrimes([7, 11, 13]);

// Multi-head attention
const attention = new ResonantMultiHeadAttention({
  numHeads: 8,
  numPrimes: 4096
});

const result = attention.forward(state1, [state2], [state2]);

// Full ResoFormer model
const model = new ResoFormer({
  numLayers: 6,
  numHeads: 8,
  hiddenDim: 256
});

const outputs = model.forward([state1, state2]);

const {
    CRTResonantAttention,
    HomologyRegularizedBlock,
    CRTResoFormer,
    createCRTResoFormer
} = require('@aleph-ai/tinyaleph');

// Create CRT-enhanced model
const model = createCRTResoFormer({
    numLayers: 3,
    numHeads: 4,        // Maps to coprime moduli [2, 3, 5, 7]
    homologyWeight: 0.1
});

// Process sequence with homology detection
const sequence = [
    SparsePrimeState.fromHash('the'),
    SparsePrimeState.fromHash('quick'),
    SparsePrimeState.fromHash('fox')
];

const result = model.forward(sequence);

console.log('Total homology loss:', result.totalLoss);
console.log('Holes detected:', result.homologyReport.hasHoles);
console.log('Betti numbers:', result.homologyReport.maxBettiNumber);

const {
    ResidueEncoder,
    CRTReconstructor,
    BirkhoffProjector,
    HomologyLoss,
    DEFAULT_PRIMES_SMALL
} = require('@aleph-ai/tinyaleph');

// Use first 4 primes: [2, 3, 5, 7], P = 210
const primes = DEFAULT_PRIMES_SMALL;
const encoder = new ResidueEncoder(primes, 16);
const crt = new CRTReconstructor(primes);

// Encode hidden vector to residue distributions
const h = new Float64Array(16).fill(0.5);
const residues = encoder.encode(h);
const expectedResidues = encoder.expectedResidues(residues);

// CRT reconstruction
const L = crt.reconstruct(expectedResidues);
console.log('Reconstructed:', L);

// Detect kernel (consistency failures)
const inKernel = crt.detectKernel(expectedResidues, 0.1);
console.log('In kernel:', inKernel);

// Birkhoff attention (doubly-stochastic)
const birkhoff = new BirkhoffProjector(20);
const attentionMatrix = [[0.8, 0.2], [0.3, 0.7]];
const projected = birkhoff.project(attentionMatrix);
// Row sums ≈ 1, column sums ≈ 1

const { HomologyLoss, CRTReconstructor } = require('@aleph-ai/tinyaleph');

const crt = new CRTReconstructor([2, 3, 5, 7]);
const homology = new HomologyLoss({ tau: 0.1 });

// Batch of residue tuples
const residueBatch = [
    [0.5, 1.2, 2.8, 4.1],
    [0.99, 0.01, 2.5, 3.99],
    [0.1, 0.2, 0.3, 0.4]
];

// Compute homology loss
const result = homology.compute(residueBatch, crt);
console.log('Homology loss:', result.loss);
console.log('Cycles detected:', result.cycles);

// Betti numbers (topological invariants)
const betti = homology.computeBettiNumbers(residueBatch, crt);
console.log('β₀ (components):', betti.beta0);
console.log('β₁ (holes):', betti.beta1);

const { getSymbol, symbolDatabase } = require('@aleph-ai/tinyaleph');

// Get a symbol
const hero = getSymbol('hero');
console.log(hero);
// { id: 'hero', unicode: '🦸', prime: 1013, meaning: 'Hero archetype', culturalTags: ['universal'] }

// Find Greek mythology symbols
const greekSymbols = symbolDatabase.getSymbolsByTag('greek');

// Encode/decode concepts to prime signatures
const signature = symbolDatabase.encode(['hero', 'journey', 'mountain']);
const symbols = symbolDatabase.decode(signature);

const { inferSymbol, inferWithResonance, inferMostResonant } = require('@aleph-ai/tinyaleph');

// Basic inference
const result = inferSymbol('brave knight');
// { symbol: ⚔️, method: 'regex', confidence: 0.85 }

// Resonance-enhanced inference - symbols ranked by harmony
const symbols = inferWithResonance('The hero fought the shadow in the temple');
// Symbols sorted by attention weight based on resonance scores

// Context-aware selection
const context = [getSymbol('warrior'), getSymbol('temple')];
const best = inferMostResonant('weapon', context);
// → 🗡️ sword (high resonance with warrior/temple context)

const { createCompound, getCompound, compoundBuilder } = require('@aleph-ai/tinyaleph');

// Pre-built compound
const greekWarrior = getCompound('greek_warrior');
// { unicode: '⚔️⛩️🦉', meaning: 'Greek Warrior: Temple guardian blessed by Athena' }

// Create custom compound
const fireMage = createCompound('fire_mage',
  ['magician', 'fire', 'staff'],
  'Fire Mage - Wielder of flame magic'
);

// Calculate internal harmony
const harmony = compoundBuilder.calculateCompoundResonance(fireMage);

const { calculateResonance, findGoldenPairs, resonanceSignature } = require('@aleph-ai/tinyaleph');

// Check resonance between primes
calculateResonance(3, 5);   // 0.9 (Fibonacci pair!)
calculateResonance(7, 11);  // 0.936 (close to φ)

// Find golden pairs
const pairs = findGoldenPairs([2, 3, 5, 7, 11, 13]);

// Get signature for symbol set
const sig = resonanceSignature([2, 3, 5, 7]);
console.log(`Mean resonance: ${sig.mean}, Golden pairs: ${sig.goldenCount}`);

const { N, A, FUSE, CHAIN, SENTENCE, TypeChecker } = require('@aleph-ai/tinyaleph');

// Create typed terms
const noun7 = N(7);      // N(7) - noun indexed by prime 7
const adj3 = A(3);       // A(3) - adjective indexed by prime 3

// Adjective application with ordering constraint (p < q)
const chain = adj3.apply(noun7);  // A(3)N(7) is valid since 3 < 7

// Triadic fusion where p+q+r is prime
const fused = FUSE(3, 5, 11);  // 3+5+11 = 19 (prime) ✓

// Sentence composition
const s1 = SENTENCE(7);
const s2 = SENTENCE(11);
const compound = SEQ(s1, s2);  // s₁ ◦ s₂

// Type checking
const checker = new TypeChecker();
console.log(checker.inferType(noun7));  // 'N'
console.log(checker.checkApplication(adj3, noun7));  // { valid: true }

const {
    ReductionSystem,
    ResonanceOperator,
    NextPrimeOperator,
    demonstrateStrongNormalization
} = require('@aleph-ai/tinyaleph');

// Create reduction system
const reduction = new ReductionSystem();

// Add prime-preserving operators
reduction.addOperator(new ResonanceOperator(2));    // Resonance at p=2
reduction.addOperator(new NextPrimeOperator());      // Map to next prime

// Normalize a term sequence
const result = reduction.normalize([7, 11, 13]);
console.log(result.normalForm);    // Canonical form
console.log(result.steps);         // Reduction trace

// Demonstrate strong normalization
const proof = demonstrateStrongNormalization([3, 5, 7], reduction);
console.log(proof.terminates);     // true (guaranteed!)

const {
    Translator,
    LambdaEvaluator,
    Semantics
} = require('@aleph-ai/tinyaleph');

// Translate prime terms to λ-expressions
const translator = new Translator();
const lambda = translator.translateNoun(N(7));  // Constant 7
const appLambda = translator.translateChain(chain);

// Evaluate λ-expressions
const evaluator = new LambdaEvaluator();
const normal = evaluator.normalize(appLambda);

// Model-theoretic interpretation
const semantics = new Semantics();
semantics.domain = [2, 3, 5, 7, 11, 13];  // Prime domain
const value = semantics.interpret(N(7));   // 7

const {
    EnochianEngine,
    ENOCHIAN_ALPHABET,
    PRIME_BASIS,
    CORE_VOCABULARY,
    SedenionElement
} = require('@aleph-ai/tinyaleph/apps/sentient/lib/enochian-vocabulary');

// 21-letter alphabet with prime mappings
console.log(ENOCHIAN_ALPHABET['A']);  // { prime: 3, value: 1, angle: 51.43 }
console.log(PRIME_BASIS);  // [7, 11, 13, 17, 19, 23, 29]

// Enochian engine for word processing
const engine = new EnochianEngine();

// Parse and compute word prime value
const parsed = engine.parseWord('MADRIAX');  // "O ye heavens"
console.log(parsed.primeValue);
console.log(parsed.letters);

// Sedenion operations (16-dimensional)
const s1 = new SedenionElement([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
const s2 = new SedenionElement([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
const product = s1.multiply(s2);  // Non-commutative!

// Access core vocabulary (35+ Enochian words)
console.log(CORE_VOCABULARY['OL']);     // "I" (first person)
console.log(CORE_VOCABULARY['ZORGE']);  // "be friendly unto"

const observer = require('@aleph-ai/tinyaleph/observer');
// Or destructure specific exports:
const {
    SedenionMemoryField,
    PRSCLayer,
    TemporalLayer,
    SymbolicSMF,
    SymbolicTemporalLayer,
    AssaySuite
} = require('@aleph-ai/tinyaleph/observer');

// Direct module access
const { core, physics, backends, engine } = require('@aleph-ai/tinyaleph');

// Or import sub-modules directly
const core = require('@aleph-ai/tinyaleph/core');
const physics = require('@aleph-ai/tinyaleph/physics');
const backends = require('@aleph-ai/tinyaleph/backends');
const engine = require('@aleph-ai/tinyaleph/engine');