@stevenvo780/st-lang 2.6.0 → 2.6.1

package/dist/runtime/interpreter.js

@@ -13,6 +13,7 @@ const fallacies_1 = require("./fallacies");
 require("../profiles");
 const compiler_1 = require("../text-layer/compiler");
 const formula_classifier_1 = require("./formula-classifier");
+const MAX_CALL_DEPTH = 500;
 class Interpreter {
     theory;
     profile = null;
@@ -40,6 +41,8 @@ class Interpreter {
     exportedTheorems = new Map();
     exportedFunctions = new Map();
     exportedTheories = new Map();
+    /** Profundidad de llamadas a funciones (anti-recursión infinita) */
+    callDepth = 0;
     constructor() {
         this.theory = this.createEmptyTheory();
         this.textLayer = (0, compiler_1.createTextLayerState)();
@@ -300,6 +303,10 @@ class Interpreter {
      * Soporta notación con punto: Theory.member resuelve desde el scope de la teoría.
      */
     resolveFormula(f, visited = new Set()) {
+        const resolved = this.resolveFormulaRecursive(f, visited);
+        return this.tryConstantFold(resolved);
+    }
+    resolveFormulaRecursive(f, visited = new Set()) {
         if (!f)
             return f;
         // Si es un átomo, intentar resolver
@@ -308,11 +315,9 @@ class Interpreter {
             if (f.name.includes('.')) {
                 const [prefix, memberName] = f.name.split('.', 2);
                 // 1. Intentar resolver el prefijo como una variable local (instancia)
-                // Ej: let f1 = Familia("Socrates") -> f1.amor
                 if (this.letBindings.has(prefix)) {
                     const resolvedPrefix = this.letBindings.get(prefix);
                     if (resolvedPrefix.kind === 'atom' && resolvedPrefix.name) {
-                        // Si el prefijo se resuelve a un nombre de teoría/instancia
                         const actualInstanceName = resolvedPrefix.name;
                         const scope = this.theories.get(actualInstanceName);
                         if (scope) {
@@ -320,11 +325,11 @@ class Interpreter {
                                 this.currentTheoryName !== actualInstanceName)
                                 return f;
                             if (scope.letBindings.has(memberName))
-                                return this.resolveFormula(scope.letBindings.get(memberName), new Set(visited));
+                                return this.resolveFormulaRecursive(scope.letBindings.get(memberName), new Set(visited));
                             if (scope.axioms.has(memberName))
-                                return this.resolveFormula(scope.axioms.get(memberName), new Set(visited));
+                                return this.resolveFormulaRecursive(scope.axioms.get(memberName), new Set(visited));
                             if (scope.theorems.has(memberName))
-                                return this.resolveFormula(scope.theorems.get(memberName), new Set(visited));
+                                return this.resolveFormulaRecursive(scope.theorems.get(memberName), new Set(visited));
                         }
                     }
                 }
@@ -334,34 +339,36 @@ class Interpreter {
                     if (scope.privateMembers.has(memberName) && this.currentTheoryName !== prefix)
                         return f;
                     if (scope.letBindings.has(memberName))
-                        return this.resolveFormula(scope.letBindings.get(memberName), new Set(visited));
+                        return this.resolveFormulaRecursive(scope.letBindings.get(memberName), new Set(visited));
                     if (scope.axioms.has(memberName))
-                        return this.resolveFormula(scope.axioms.get(memberName), new Set(visited));
+                        return this.resolveFormulaRecursive(scope.axioms.get(memberName), new Set(visited));
                     if (scope.theorems.has(memberName))
-                        return this.resolveFormula(scope.theorems.get(memberName), new Set(visited));
+                        return this.resolveFormulaRecursive(scope.theorems.get(memberName), new Set(visited));
                 }
                 return f;
             }
             // Binding local normal
             if (this.letBindings.has(f.name)) {
-                if (visited.has(f.name)) {
+                if (visited.has(f.name))
                     return f;
-                }
-                visited.add(f.name);
-                return this.resolveFormula(this.letBindings.get(f.name), new Set(visited));
+                const newVisited = new Set(visited);
+                newVisited.add(f.name);
+                return this.resolveFormulaRecursive(this.letBindings.get(f.name), newVisited);
             }
             // También resolver axiomas/teoremas del theory actual por nombre
             if (this.theory.axioms.has(f.name)) {
                 if (visited.has(f.name))
                     return f;
-                visited.add(f.name);
-                return this.resolveFormula(this.theory.axioms.get(f.name), new Set(visited));
+                const newVisited = new Set(visited);
+                newVisited.add(f.name);
+                return this.resolveFormulaRecursive(this.theory.axioms.get(f.name), newVisited);
             }
             if (this.theory.theorems.has(f.name)) {
                 if (visited.has(f.name))
                     return f;
-                visited.add(f.name);
-                return this.resolveFormula(this.theory.theorems.get(f.name), new Set(visited));
+                const newVisited = new Set(visited);
+                newVisited.add(f.name);
+                return this.resolveFormulaRecursive(this.theory.theorems.get(f.name), newVisited);
             }
         }
         // Llamada a función como expresión
@@ -371,12 +378,8 @@ class Interpreter {
         }
         // Recorrer hijos recursivamente
         if (f.args && f.args.length > 0) {
-            const newArgs = f.args.map((a) => (a ? this.resolveFormula(a, new Set(visited)) : a));
-            const oldArgs = f.args;
-            const changed = newArgs.some((a, i) => a !== oldArgs[i]);
-            if (changed) {
-                return { ...f, args: newArgs };
-            }
+            const newArgs = f.args.map((a) => a ? this.resolveFormulaRecursive(a, new Set(visited)) : a);
+            return { ...f, args: newArgs };
         }
         return f;
     }
@@ -482,18 +485,13 @@ class Interpreter {
             this.emit(`Formalizacion ${stmt.name}: ${stmt.passageName} -> ${(0, propositional_1.formulaToString)(formula)}`);
         }
         else if (stmt.letType === 'description') {
-            // Solo descripción textual: P es un átomo con significado semántico
             this.letDescriptions.set(stmt.name, stmt.description);
             this.emit(`Let ${stmt.name} = "${stmt.description}"`);
         }
         else if (stmt.letType === 'formula' && stmt.formula) {
-            // Resolver posibles variables anidadas en la propia definición
             const resolved = this.resolveFormula(stmt.formula);
-            // Registrar como binding para sustitución futura
             this.letBindings.set(stmt.name, resolved);
-            // También como axioma implícito para derivaciones
             this.theory.axioms.set(stmt.name, resolved);
-            // Si tiene descripción textual (let X = "desc" : formula), guardarla
             if ('description' in stmt && stmt.description) {
                 this.letDescriptions.set(stmt.name, stmt.description);
                 this.emit(`Let ${stmt.name} = "${stmt.description}" : ${(0, format_1.formulaToUnicode)(resolved)}`);
@@ -508,7 +506,6 @@ class Interpreter {
         const formalization = stmt.formalization;
         const diags = (0, compiler_1.registerClaim)(this.textLayer, stmt.name, formula, formalization);
         this.diagnostics.push(...diags);
-        // También agregar al theory.claims
         const claim = {
             name: stmt.name,
             formula: formula,
@@ -533,7 +530,6 @@ class Interpreter {
         this.emit(`Context: ${stmt.claimName} = "${stmt.text}"`);
     }
     execRenderCmd(stmt) {
-        // Compilar claims y renderizar
         const diags = (0, compiler_1.compileClaimsToTheory)(this.textLayer, this.theory);
         this.diagnostics.push(...diags);
         if (stmt.target === 'claims' || stmt.target === 'all') {
@@ -541,19 +537,15 @@ class Interpreter {
             for (const [name, claim] of this.theory.claims) {
                 const fStr = claim.formula ? (0, format_1.formulaToUnicode)(claim.formula) : '(sin fórmula)';
                 this.emit(`  Claim "${name}": ${fStr}`);
-                if (claim.support) {
+                if (claim.support)
                     this.emit(`    Soporte: ${claim.support}`);
-                }
-                if (claim.confidence !== undefined) {
+                if (claim.confidence !== undefined)
                     this.emit(`    Confianza: ${claim.confidence}`);
-                }
-                if (claim.context) {
+                if (claim.context)
                     this.emit(`    Contexto: ${claim.context}`);
-                }
             }
-            if (this.theory.claims.size === 0) {
+            if (this.theory.claims.size === 0)
                 this.emit('  (sin claims registrados)');
-            }
         }
         else if (stmt.target === 'theory') {
             this.emit(`── Render: theory (${stmt.format}) ──`);
@@ -569,7 +561,6 @@ class Interpreter {
             this.emit(`  Claims: ${this.theory.claims.size}`);
         }
         else {
-            // Render un claim o axioma específico por nombre
             const axiom = this.theory.axioms.get(stmt.target);
             if (axiom) {
                 this.emit(`  ${stmt.target} = ${(0, format_1.formulaToUnicode)(axiom)}`);
@@ -592,7 +583,6 @@ class Interpreter {
         const pStr = premises.map((p) => (0, format_1.formulaToUnicode)(p)).join(', ');
         const cStr = (0, format_1.formulaToUnicode)(conclusion);
         if (fallacies.length === 0) {
-            // Check if the inference is valid
             const conj = premises.length === 0
                 ? conclusion
                 : premises.length === 1
@@ -608,13 +598,12 @@ class Interpreter {
                 this.emit(`⚠ [analyze] {${pStr}} → ${cStr}`);
                 this.emit('  Inferencia NO VÁLIDA — pero no corresponde a un patrón de falacia conocido');
             }
-            const result2 = {
+            this.results.push({
                 status: result.status,
                 output: result.output,
                 diagnostics: [],
                 formula: conclusion,
-            };
-            this.results.push(result2);
+            });
         }
         else {
             this.emit(`⚠ [analyze] {${pStr}} → ${cStr}`);
@@ -624,7 +613,7 @@ class Interpreter {
                 if (f.pattern)
                     this.emit(`    Patrón: ${f.pattern}`);
             }
-            const result = {
+            this.results.push({
                 status: 'invalid',
                 output: `Falacias detectadas: ${fallacies.map((f) => f.name).join(', ')}`,
                 diagnostics: fallacies.map((f) => ({
@@ -632,17 +621,14 @@ class Interpreter {
                     message: `Falacia: ${f.name} — ${f.description}`,
                 })),
                 formula: conclusion,
-            };
-            this.results.push(result);
+            });
         }
     }
     execProofBlock(stmt) {
         const profile = this.requireProfile();
-        // Guardar axiomas, letBindings y descriptions antes del bloque
         const savedAxioms = new Map(this.theory.axioms);
         const savedLetBindings = new Map(this.letBindings);
         const savedLetDescriptions = new Map(this.letDescriptions);
-        // Registrar las asunciones como axiomas temporales (con resolución de variables)
         this.emit('── Proof Block ──');
         for (const assumption of stmt.assumptions) {
             const resolved = this.resolveFormula(assumption.formula);
@@ -651,7 +637,6 @@ class Interpreter {
         }
         const resolvedGoal = this.resolveFormula(stmt.goal);
         this.emit(`  show ${(0, format_1.formulaToUnicode)(resolvedGoal)}`);
-        // Ejecutar body statements
         for (const bodyStmt of stmt.body) {
             try {
                 this.executeStatement(bodyStmt);
@@ -667,48 +652,36 @@ class Interpreter {
                 });
             }
         }
-        // Verificar que el goal es derivable de las asunciones
         const premiseNames = stmt.assumptions.map((a) => a.name);
         const result = profile.derive(resolvedGoal, premiseNames, this.theory);
         this.results.push(result);
         if (result.status === 'valid' || result.status === 'provable') {
             this.emit(`  ✓ QED — ${(0, format_1.formulaToUnicode)(resolvedGoal)} demostrado`);
-            // Registrar como teorema
             const theoremName = `proof_${this.theory.theorems.size + 1}`;
-            // La implicación assumptions -> goal es un teorema
             let implication = resolvedGoal;
             for (let i = stmt.assumptions.length - 1; i >= 0; i--) {
-                implication = {
-                    kind: 'implies',
-                    args: [stmt.assumptions[i].formula, implication],
-                };
+                implication = { kind: 'implies', args: [stmt.assumptions[i].formula, implication] };
             }
             this.theory.theorems.set(theoremName, implication);
         }
         else {
             this.emit(`  ✗ QED fallido — no se pudo demostrar ${(0, format_1.formulaToUnicode)(resolvedGoal)}`);
         }
-        // Restaurar axiomas, letBindings y descriptions (quitar las asunciones temporales)
         this.theory.axioms = savedAxioms;
         this.letBindings = savedLetBindings;
         this.letDescriptions = savedLetDescriptions;
         this.emit('── End Proof Block ──');
     }
     execTheoryDecl(stmt) {
-        const theoryName = stmt.name;
-        // Si tiene parámetros, es una plantilla (Clase)
         if (stmt.params && stmt.params.length > 0) {
-            this.theoryTemplates.set(theoryName, { node: stmt, parent: stmt.parent });
-            this.emit(`Teoría (plantilla) ${theoryName}(${stmt.params.join(', ')}) declarada`);
+            this.theoryTemplates.set(stmt.name, { node: stmt, parent: stmt.parent });
+            this.emit(`Teoría (plantilla) ${stmt.name}(${stmt.params.join(', ')}) declarada`);
             return;
         }
-        // Si no tiene parámetros, ejecutar como singleton/objeto inmediato
         this.instantiateTheory(stmt);
     }
-    /** Crea una instancia de una teoría y la registra en this.theories */
     instantiateTheory(node, instanceName, args = []) {
         const theoryName = instanceName || node.name;
-        // Crear scope vacío
         const scope = {
             name: theoryName,
             parent: node.parent,
@@ -718,14 +691,10 @@ class Interpreter {
             theorems: new Map(),
             privateMembers: new Set(),
         };
-        // HERENCIA: Si extends Parent, copiar bindings/axiomas/teoremas del padre
-        // El padre puede ser otra plantilla o un singleton ya instanciado
         if (node.parent) {
             const parentScope = this.theories.get(node.parent);
-            if (!parentScope) {
-                throw new Error(`Teoría padre '${node.parent}' no encontrada. Debe declararse antes de '${theoryName}'.`);
-            }
-            // Copiar todo del padre (no los miembros privados del padre al hijo)
+            if (!parentScope)
+                throw new Error(`Teoría padre '${node.parent}' no encontrada.`);
             for (const [k, v] of parentScope.letBindings)
                 if (!parentScope.privateMembers.has(k))
                     scope.letBindings.set(k, v);
@@ -739,13 +708,11 @@ class Interpreter {
                 if (!parentScope.privateMembers.has(k))
                     scope.theorems.set(k, v);
         }
-        // Guardar estado global antes de entrar al scope de la teoría
         const savedLetBindings = new Map(this.letBindings);
         const savedLetDescriptions = new Map(this.letDescriptions);
         const savedAxioms = new Map(this.theory.axioms);
         const savedTheorems = new Map(this.theory.theorems);
         const savedTheoryName = this.currentTheoryName;
-        // Inyectar argumentos en el scope local de la teoría
         if (node.params && args.length > 0) {
             for (let i = 0; i < node.params.length; i++) {
                 if (i < args.length) {
@@ -755,7 +722,6 @@ class Interpreter {
                 }
             }
         }
-        // Inyectar bindings heredados al scope local para que los statements internos los vean
         for (const [k, v] of scope.letBindings)
             this.letBindings.set(k, v);
         for (const [k, v] of scope.letDescriptions)
@@ -766,7 +732,6 @@ class Interpreter {
             this.theory.theorems.set(k, v);
         this.currentTheoryName = theoryName;
         this.emit(`── Instanciando Theory ${theoryName} ──`);
-        // Ejecutar los miembros del body
         for (const member of node.members) {
             const memberStmt = member.statement;
             const memberName = 'name' in memberStmt ? memberStmt.name : null;
@@ -786,7 +751,6 @@ class Interpreter {
                 });
             }
         }
-        // Capturar lo producido
         for (const [k, v] of this.letBindings)
             if (!savedLetBindings.has(k))
                 scope.letBindings.set(k, v);
@@ -799,25 +763,18 @@ class Interpreter {
         for (const [k, v] of this.theory.theorems)
             if (!savedTheorems.has(k))
                 scope.theorems.set(k, v);
-        // Restaurar estado global
         this.letBindings = savedLetBindings;
         this.letDescriptions = savedLetDescriptions;
         this.theory.axioms = savedAxioms;
         this.theory.theorems = savedTheorems;
         this.currentTheoryName = savedTheoryName;
-        // Registrar la instancia
         this.theories.set(theoryName, scope);
         this.emit(`── End Theory Instance ${theoryName} ──`);
         return theoryName;
     }
-    // =============================================
-    // Control flow & funciones (v1.5.8)
-    // =============================================
     execPrintCmd(stmt) {
-        if (stmt.value !== null) {
-            // String literal
+        if (stmt.value !== null)
             this.emit(stmt.value);
-        }
         else if (stmt.formula) {
             const resolved = this.resolveFormula(stmt.formula);
             this.emit((0, format_1.formulaToUnicode)(resolved));
@@ -826,7 +783,6 @@ class Interpreter {
     execSetCmd(stmt) {
         const resolved = this.resolveFormula(stmt.formula);
         this.letBindings.set(stmt.name, resolved);
-        // También actualizar en la teoría global para que derive/prove lo vean
         this.theory.axioms.set(stmt.name, resolved);
         this.emit(`Set ${stmt.name} = ${(0, format_1.formulaToUnicode)(resolved)}`);
     }
@@ -841,7 +797,6 @@ class Interpreter {
                     branch.condition === 'valid' ? result.status === 'valid' : result.status !== 'valid';
             }
             else {
-                // satisfiable / unsatisfiable
                 const result = profile.checkSatisfiable(resolved);
                 matched =
                     branch.condition === 'satisfiable'
@@ -854,10 +809,9 @@ class Interpreter {
                         return;
                     this.executeStatement(bodyStmt);
                 }
-                return; // solo ejecuta la primera rama que matchea
+                return;
             }
         }
-        // else branch
         if (stmt.elseBranch) {
             for (const bodyStmt of stmt.elseBranch) {
                 if (this.returnSignal)
@@ -879,13 +833,10 @@ class Interpreter {
                 this.executeStatement(bodyStmt);
             }
         }
-        // Restaurar binding previo
-        if (savedBinding !== undefined) {
+        if (savedBinding !== undefined)
             this.letBindings.set(stmt.variable, savedBinding);
-        }
-        else {
+        else
             this.letBindings.delete(stmt.variable);
-        }
     }
     execWhileStmt(stmt) {
         const profile = this.requireProfile();
@@ -930,150 +881,155 @@ class Interpreter {
     execFnDecl(stmt) {
         const name = this.currentTheoryName ? `${this.currentTheoryName}.${stmt.name}` : stmt.name;
         this.functions.set(name, stmt);
-        if (this.currentTheoryName) {
+        if (this.currentTheoryName)
             this.emit(`Función de instancia ${name}(${stmt.params.join(', ')}) declarada`);
-        }
-        else {
+        else
             this.emit(`Función ${name}(${stmt.params.join(', ')}) declarada`);
-        }
     }
     execReturnStmt(stmt) {
-        if (stmt.formula) {
+        if (stmt.formula)
             this.returnValue = this.resolveFormula(stmt.formula);
-        }
-        else {
+        else
             this.returnValue = undefined;
-        }
         this.returnSignal = true;
     }
     executeFnCall(stmt) {
-        // 0. Funciones Nativas (Built-ins) para Metaprogramación
-        if (['typeof', 'is_valid', 'is_satisfiable', 'get_atoms', 'input'].includes(stmt.name)) {
-            return this.executeBuiltin(stmt.name, stmt.args);
+        this.callDepth++;
+        if (this.callDepth > MAX_CALL_DEPTH) {
+            this.callDepth--;
+            throw new Error(`Límite de recursión excedido (${MAX_CALL_DEPTH}).`);
         }
-        // 0.5 Si es un método (obj.metodo), resolver el objeto primero
-        if (stmt.name.includes('.')) {
-            const [prefix, methodName] = stmt.name.split('.', 2);
-            let actualInstanceName = prefix;
-            // Intentar resolver prefijo si es una variable local
-            if (this.letBindings.has(prefix)) {
-                const resolved = this.letBindings.get(prefix);
-                if (resolved.kind === 'atom' && resolved.name) {
-                    actualInstanceName = resolved.name;
-                }
+        try {
+            if (['typeof', 'is_valid', 'is_satisfiable', 'get_atoms', 'input'].includes(stmt.name)) {
+                return this.executeBuiltin(stmt.name, stmt.args);
             }
-            const scope = this.theories.get(actualInstanceName);
-            if (scope) {
-                // En ST actual, las funciones no se guardan en TheoryScope sino que se ejecutan
-                // en el contexto del intérprete. Para soportar métodos de instancia,
-                // necesitamos que las funciones estén vinculadas al scope o prefijadas.
-                // Como solución rápida y potente: buscamos la función prefijada en el mapa global.
-                const internalFnName = `${actualInstanceName}.${methodName}`;
-                const fn = this.functions.get(internalFnName);
-                if (fn) {
-                    // Ejecutar función con el scope de la instancia inyectado
-                    return this.executeFunctionInScope(fn, stmt.args, scope);
+            if (stmt.name.includes('.')) {
+                const [prefix, methodName] = stmt.name.split('.', 2);
+                let actualInstanceName = prefix;
+                if (this.letBindings.has(prefix)) {
+                    const resolved = this.letBindings.get(prefix);
+                    if (resolved.kind === 'atom' && resolved.name)
+                        actualInstanceName = resolved.name;
+                }
+                const scope = this.theories.get(actualInstanceName);
+                if (scope) {
+                    const internalFnName = `${actualInstanceName}.${methodName}`;
+                    const fn = this.functions.get(internalFnName);
+                    if (fn)
+                        return this.executeFunctionInScope(fn, stmt.args, scope);
                 }
             }
-        }
-        // 1. Intentar instanciación de teoría (Clase)
-        const template = this.theoryTemplates.get(stmt.name);
-        if (template) {
-            // Nombre de instancia único si no estamos en un let (o usar un contador)
-            const instanceId = `inst_${stmt.name}_${this.theories.size}`;
-            this.instantiateTheory(template.node, instanceId, stmt.args);
-            return { kind: 'atom', name: instanceId };
-        }
-        // 2. Intentar llamada a función normal
-        const fn = this.functions.get(stmt.name);
-        if (!fn) {
-            throw new Error(`Función o Teoría '${stmt.name}' no declarada`);
-        }
-        if (stmt.args.length !== fn.params.length) {
-            throw new Error(`Función '${stmt.name}' espera ${fn.params.length} argumento(s), recibió ${stmt.args.length}`);
-        }
-        // Guardar bindings actuales de los parámetros
-        const savedBindings = new Map();
-        for (const param of fn.params) {
-            savedBindings.set(param, this.letBindings.get(param));
-        }
-        // Vincular argumentos a parámetros
-        for (let i = 0; i < fn.params.length; i++) {
-            const resolved = this.resolveFormula(stmt.args[i]);
-            this.letBindings.set(fn.params[i], resolved);
-        }
-        // Ejecutar cuerpo de la función
-        const savedReturnSignal = this.returnSignal;
-        const savedReturnValue = this.returnValue;
-        this.returnSignal = false;
-        this.returnValue = undefined;
-        for (const bodyStmt of fn.body) {
-            if (this.returnSignal)
-                break;
-            this.executeStatement(bodyStmt);
-        }
-        // Capturar valor de retorno
-        const result = this.returnValue;
-        this.returnSignal = savedReturnSignal;
-        this.returnValue = savedReturnValue;
-        // Restaurar bindings
-        for (const param of fn.params) {
-            const prev = savedBindings.get(param);
-            if (prev !== undefined) {
-                this.letBindings.set(param, prev);
+            const template = this.theoryTemplates.get(stmt.name);
+            if (template) {
+                const instanceId = `inst_${stmt.name}_${this.theories.size}`;
+                this.instantiateTheory(template.node, instanceId, stmt.args);
+                return { kind: 'atom', name: instanceId };
             }
-            else {
-                this.letBindings.delete(param);
+            const fn = this.functions.get(stmt.name);
+            if (!fn)
+                throw new Error(`Función o Teoría '${stmt.name}' no declarada`);
+            if (stmt.args.length !== fn.params.length)
+                throw new Error(`Argumentos incorrectos.`);
+            const savedBindings = new Map();
+            for (const param of fn.params)
+                savedBindings.set(param, this.letBindings.get(param));
+            for (let i = 0; i < fn.params.length; i++)
+                this.letBindings.set(fn.params[i], this.resolveFormula(stmt.args[i]));
+            const savedReturnSignal = this.returnSignal;
+            const savedReturnValue = this.returnValue;
+            this.returnSignal = false;
+            this.returnValue = undefined;
+            for (const bodyStmt of fn.body) {
+                if (this.returnSignal)
+                    break;
+                this.executeStatement(bodyStmt);
             }
+            const result = this.returnValue;
+            this.returnSignal = savedReturnSignal;
+            this.returnValue = savedReturnValue;
+            for (const param of fn.params) {
+                const prev = savedBindings.get(param);
+                if (prev !== undefined)
+                    this.letBindings.set(param, prev);
+                else
+                    this.letBindings.delete(param);
+            }
+            return result;
+        }
+        finally {
+            this.callDepth--;
         }
-        return result;
     }
-    /** Ejecuta una función inyectando bindings de un scope (para métodos de instancia) */
     executeFunctionInScope(fn, args, scope) {
-        if (args.length !== fn.params.length) {
-            throw new Error(`Método '${fn.name}' espera ${fn.params.length} argumento(s), recibió ${args.length}`);
-        }
-        // 1. Guardar estado global
-        const savedBindings = new Map(this.letBindings);
-        const savedAxioms = new Map(this.theory.axioms);
-        const savedTheorems = new Map(this.theory.theorems);
-        const savedTheoryName = this.currentTheoryName;
-        // 2. Inyectar scope de la instancia
-        for (const [k, v] of scope.letBindings)
-            this.letBindings.set(k, v);
-        for (const [k, v] of scope.axioms)
-            this.theory.axioms.set(k, v);
-        for (const [k, v] of scope.theorems)
-            this.theory.theorems.set(k, v);
-        this.currentTheoryName = scope.name;
-        // 3. Inyectar argumentos de la llamada
-        for (let i = 0; i < fn.params.length; i++) {
-            this.letBindings.set(fn.params[i], this.resolveFormula(args[i]));
+        this.callDepth++;
+        if (this.callDepth > MAX_CALL_DEPTH) {
+            this.callDepth--;
+            throw new Error(`Límite de recursión excedido.`);
         }
-        // 4. Ejecutar cuerpo
-        const savedReturnSignal = this.returnSignal;
-        const savedReturnValue = this.returnValue;
-        this.returnSignal = false;
-        this.returnValue = undefined;
-        for (const bodyStmt of fn.body) {
-            if (this.returnSignal)
-                break;
-            this.executeStatement(bodyStmt);
+        try {
+            const savedBindings = new Map(this.letBindings);
+            const savedAxioms = new Map(this.theory.axioms);
+            const savedTheorems = new Map(this.theory.theorems);
+            const savedTheoryName = this.currentTheoryName;
+            for (const [k, v] of scope.letBindings)
+                this.letBindings.set(k, v);
+            for (const [k, v] of scope.axioms)
+                this.theory.axioms.set(k, v);
+            for (const [k, v] of scope.theorems)
+                this.theory.theorems.set(k, v);
+            this.currentTheoryName = scope.name;
+            for (let i = 0; i < fn.params.length; i++)
+                this.letBindings.set(fn.params[i], this.resolveFormula(args[i]));
+            const savedReturnSignal = this.returnSignal;
+            const savedReturnValue = this.returnValue;
+            this.returnSignal = false;
+            this.returnValue = undefined;
+            for (const bodyStmt of fn.body) {
+                if (this.returnSignal)
+                    break;
+                this.executeStatement(bodyStmt);
+            }
+            const result = this.returnValue;
+            this.returnSignal = savedReturnSignal;
+            this.returnValue = savedReturnValue;
+            this.letBindings = savedBindings;
+            this.theory.axioms = savedAxioms;
+            this.theory.theorems = savedTheorems;
+            this.currentTheoryName = savedTheoryName;
+            return result;
+        }
+        finally {
+            this.callDepth--;
         }
-        const result = this.returnValue;
-        // 5. Restaurar estado global
-        this.returnSignal = savedReturnSignal;
-        this.returnValue = savedReturnValue;
-        this.letBindings = savedBindings;
-        this.theory.axioms = savedAxioms;
-        this.theory.theorems = savedTheorems;
-        this.currentTheoryName = savedTheoryName;
-        return result;
+    }
+    tryConstantFold(f) {
+        if (!f || !f.args)
+            return f;
+        const ARITH_OPS = {
+            add: (a, b) => a + b,
+            subtract: (a, b) => a - b,
+            multiply: (a, b) => a * b,
+            divide: (a, b) => (b === 0 ? NaN : a / b),
+            modulo: (a, b) => (b === 0 ? NaN : a % b),
+        };
+        const CMP_OPS = {
+            less: (a, b) => (a < b ? 1 : 0),
+            greater: (a, b) => (a > b ? 1 : 0),
+            less_eq: (a, b) => (a <= b ? 1 : 0),
+            greater_eq: (a, b) => (a >= b ? 1 : 0),
+        };
+        const newArgs = f.args.map((a) => this.tryConstantFold(a));
+        if (newArgs.length === 2 &&
+            newArgs[0].kind === 'number' &&
+            newArgs[1].kind === 'number' &&
+            (ARITH_OPS[f.kind] || CMP_OPS[f.kind])) {
+            const op = ARITH_OPS[f.kind] || CMP_OPS[f.kind];
+            const res = op(newArgs[0].value ?? 0, newArgs[1].value ?? 0);
+            return { kind: 'number', value: res, source: f.source };
+        }
+        return { ...f, args: newArgs };
     }
     executeBuiltin(name, args) {
-        if (args.length !== 1) {
-            throw new Error(`Built-in '${name}' espera exactamente 1 argumento, recibió ${args.length}`);
-        }
         const arg = this.resolveFormula(args[0]);
         if (name === 'typeof') {
             let typeStr = 'Formula';
@@ -1105,12 +1061,12 @@ class Interpreter {
             let inputStr;
             try {
                 process.stdout.write(prompt + ' ');
-                /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-argument */
+                // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
                 const fs = require('fs');
                 const buf = Buffer.alloc(256);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
                 const bytesRead = fs.readSync(process.stdin.fd, buf, 0, 256, null);
                 inputStr = buf.toString('utf8', 0, bytesRead).trim();
-                /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-argument */
             }
             catch {
                 inputStr = 'interactive_not_supported';
@@ -1121,68 +1077,45 @@ class Interpreter {
     }
     execImportDecl(stmt) {
         let filePath = stmt.path;
-        // Agregar extensión .st si no la tiene
         if (!filePath.endsWith('.st'))
             filePath += '.st';
-        // Evitar imports circulares
-        if (this.importedFiles.has(filePath)) {
-            this.emit(`Import: ${filePath} (ya importado, saltar)`);
+        if (this.importedFiles.has(filePath))
             return;
-        }
         this.importedFiles.add(filePath);
-        // Intentar leer el archivo (solo funciona en Node.js / CLI)
         let source;
         try {
-            /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
+            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
             const fs = require('fs');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
             const path = require('path');
-            // Resolver relativo al archivo actual si no es absoluto
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
             const resolved = path.isAbsolute(filePath)
                 ? filePath
-                : path.resolve(path.dirname(stmt.source.file || '.'), filePath);
+                : // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+                    path.resolve(path.dirname(stmt.source.file || '.'), filePath);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
             source = fs.readFileSync(resolved, 'utf-8');
-            /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
         }
         catch {
-            throw new Error(`No se pudo importar '${filePath}': archivo no encontrado`);
+            throw new Error(`No se pudo importar '${filePath}'`);
         }
         const parser = new parser_1.Parser(filePath);
         const program = parser.parse(source);
         this.diagnostics.push(...parser.diagnostics);
-        if (parser.diagnostics.some((d) => d.severity === 'error')) {
-            throw new Error(`Errores de parseo en '${filePath}'`);
-        }
-        // Guardar estado de exportación del importador
         const prevIsImporting = this.isImporting;
-        const prevExportedBindings = new Map(this.exportedBindings);
-        const prevExportedAxioms = new Map(this.exportedAxioms);
-        const prevExportedTheorems = new Map(this.exportedTheorems);
-        const prevExportedFunctions = new Map(this.exportedFunctions);
-        const prevExportedTheories = new Map(this.exportedTheories);
-        // Guardar scope local actual del importador para no contaminarlo durante la carga
         const prevLetBindings = new Map(this.letBindings);
         const prevAxioms = new Map(this.theory.axioms);
         const prevTheorems = new Map(this.theory.theorems);
         const prevFunctions = new Map(this.functions);
         const prevTheories = new Map(this.theories);
-        // Limpiar para capturar solo lo que exporta el archivo importado
         this.isImporting = true;
-        this.exportedBindings.clear();
-        this.exportedAxioms.clear();
-        this.exportedTheorems.clear();
-        this.exportedFunctions.clear();
-        this.exportedTheories.clear();
-        // No queremos que el archivo importado vea el scope del importador (encapsulamiento total)
         this.letBindings.clear();
         this.theory.axioms.clear();
         this.theory.theorems.clear();
         this.functions.clear();
         this.theories.clear();
-        // Ejecutar statements del archivo importado
-        for (const importedStmt of program.statements) {
+        for (const importedStmt of program.statements)
             this.executeStatement(importedStmt);
-        }
-        // Capturar lo exportado
         const newExports = {
             bindings: new Map(this.exportedBindings),
             axioms: new Map(this.exportedAxioms),
@@ -1190,19 +1123,12 @@ class Interpreter {
             functions: new Map(this.exportedFunctions),
             theories: new Map(this.exportedTheories),
         };
-        // Restaurar estado del importador (incluyendo su scope original)
         this.isImporting = prevIsImporting;
-        this.exportedBindings = prevExportedBindings;
-        this.exportedAxioms = prevExportedAxioms;
-        this.exportedTheorems = prevExportedTheorems;
-        this.exportedFunctions = prevExportedFunctions;
-        this.exportedTheories = prevExportedTheories;
         this.letBindings = prevLetBindings;
         this.theory.axioms = prevAxioms;
         this.theory.theorems = prevTheorems;
         this.functions = prevFunctions;
         this.theories = prevTheories;
-        // Fusionar solo lo exportado al scope actual
         for (const [k, v] of newExports.bindings)
             this.letBindings.set(k, v);
         for (const [k, v] of newExports.axioms)
@@ -1213,7 +1139,6 @@ class Interpreter {
             this.functions.set(k, v);
         for (const [k, v] of newExports.theories)
             this.theories.set(k, v);
-        this.emit(`Import: ${filePath} cargado (${newExports.bindings.size + newExports.axioms.size + newExports.theorems.size + newExports.functions.size + newExports.theories.size} elementos importados)`);
     }
     execExplainCmd(stmt) {
         const profile = this.requireProfile();
@@ -1223,160 +1148,39 @@ class Interpreter {
         if (result.output)
             this.emit(result.output);
     }
-    // --- Output helpers ---
     emit(msg) {
         this.stdoutLines.push(msg);
     }
     getVerbosity() {
         const v = this.letBindings.get('verbose');
-        if (v && v.kind === 'atom' && v.name) {
-            const n = v.name.toLowerCase();
-            // Remove quotes if present
-            return n.replace(/(^"|"$)/g, '');
-        }
+        if (v && v.kind === 'atom' && v.name)
+            return v.name.toLowerCase().replace(/(^"|"$)/g, '');
         return 'off';
     }
     emitResult(cmd, result) {
-        const statusIcon = this.statusIcon(result.status);
-        this.emit(`${statusIcon} [${cmd}] ${result.output || result.status}`);
+        this.emit(`${this.statusIcon(result.status)} [${cmd}] ${result.output || result.status}`);
         const verbosity = this.getVerbosity();
-        if (result.educationalNote && verbosity === 'on') {
-            this.emit(`  Nota pedagógica: ${result.educationalNote}`);
-        }
-        if (result.paradoxWarning) {
+        if (result.paradoxWarning)
             this.emit(`  ⚠ PARADOJA: ${result.paradoxWarning}`);
-        }
-        // Clasificación de la fórmula (si tenemos verbosidad on o si está precalculado)
         if (result.formula && (verbosity === 'on' || result.formulaClassification)) {
             const cls = (0, formula_classifier_1.classifyFormula)(result.formula);
             const name = result.formulaClassification || cls.formulaClassification;
-            if (name) {
+            if (name)
                 this.emit(`  Identificación: ${name}`);
-            }
-        }
-        if (result.reasoningType) {
-            this.emit(`  Patrón de razonamiento: ${result.reasoningType}`);
-        }
-        if (result.reasoningSchema) {
-            this.emit(`  Esquema: ${result.reasoningSchema}`);
-        }
-        if (result.normalForms && verbosity === 'on') {
-            this.emit(`  Formas Normales:`);
-            if (result.normalForms.nnf)
-                this.emit(`    NNF: ${result.normalForms.nnf}`);
-            if (result.normalForms.cnf)
-                this.emit(`    CNF: ${result.normalForms.cnf}`);
-            if (result.normalForms.dnf)
-                this.emit(`    DNF: ${result.normalForms.dnf}`);
-            if (result.normalForms.pnf)
-                this.emit(`    PNF: ${result.normalForms.pnf}`);
-            if (result.normalForms.skolem)
-                this.emit(`    Skolem: ${result.normalForms.skolem}`);
-        }
-        if (result.formula && (verbosity === 'on' || cmd === 'explain')) {
-            /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
-            const { compareAcrossSystems } = require('./cross-system-compare');
-            const { registry } = require('../profiles/interface');
-            const comp = result.crossSystemComparison || compareAcrossSystems(result.formula, registry);
-            /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
-            if (Object.keys(comp).length > 0) {
-                this.emit(`  Comparación entre sistemas:`);
-                for (const [sys, val] of Object.entries(comp)) {
-                    this.emit(`    ${sys.padEnd(30)} ${val}`);
-                }
-            }
         }
-        const outputFormatRaw = this.letBindings.get('output');
-        const isLatex = outputFormatRaw?.kind === 'atom' &&
-            outputFormatRaw.name?.replace(/['"]/g, '').toLowerCase() === 'latex';
-        const proof = result.proof;
-        if (proof &&
-            proof.steps.length > 0 &&
-            (verbosity === 'on' || verbosity === 'proof' || cmd === 'derive' || cmd === 'prove')) {
-            if (isLatex) {
-                /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
-                const { proofToLaTeX } = require('./format');
-                this.emit('  Prueba (LaTeX):');
-                this.emit(proofToLaTeX(proof));
-                /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
-            }
-            else {
-                this.emit('  Prueba:');
-                for (const step of proof.steps) {
-                    const premisesStr = step.premises.length > 0 ? ` [de ${step.premises.join(', ')}]` : '';
-                    this.emit(`    ${step.stepNumber}. ${(0, format_1.formulaToUnicode)(step.formula)}  — ${step.justification}${premisesStr}`);
-                }
+        if (result.model && (verbosity === 'on' || cmd === 'countermodel')) {
+            if (result.model.valuation) {
+                this.emit('  Modelo:');
+                for (const [k, v] of Object.entries(result.model.valuation))
+                    this.emit(`    ${k} = ${v}`);
             }
         }
-        const model = result.model;
-        if (model &&
-            (verbosity === 'on' ||
-                verbosity === 'model' ||
-                cmd === 'countermodel' ||
-                cmd === 'check_valid' ||
-                cmd === 'check_satisfiable')) {
-            // Display Kripke model with worlds if available
-            if (model.worlds && model.worlds.length > 0) {
-                this.emit('  Contramodelo Kripke:');
-                this.emit(`    Mundos: {${model.worlds.map((w) => w.name).join(', ')}}`);
-                this.emit('    Accesibilidad:');
-                for (const w of model.worlds) {
-                    if (w.accessible.length > 0) {
-                        this.emit(`      ${w.name} R ${w.accessible.join(', ')}`);
-                    }
-                }
-                this.emit('    Valuación:');
-                for (const w of model.worlds) {
-                    const trueAtoms = Object.entries(w.valuation)
-                        .filter(([, val]) => val)
-                        .map(([k]) => k);
-                    const falseAtoms = Object.entries(w.valuation)
-                        .filter(([, val]) => !val)
-                        .map(([k]) => k);
-                    const parts = [];
-                    if (trueAtoms.length > 0)
-                        parts.push(trueAtoms.join(', '));
-                    if (falseAtoms.length > 0)
-                        parts.push(`¬${falseAtoms.join(', ¬')}`);
-                    this.emit(`      V(${w.name}) = {${parts.join(', ')}}`);
-                }
-            }
-            else if (model.valuation) {
-                // Flat propositional model
-                this.emit('  Modelo / Valuación:');
-                for (const [k, v] of Object.entries(model.valuation)) {
-                    const desc = this.letDescriptions.get(k);
-                    const descStr = desc ? ` ("${desc}")` : '';
-                    this.emit(`    ${k}${descStr} = ${String(v)}`);
-                }
-            }
-        }
-        if (result.tableauTrace &&
-            result.tableauTrace.length > 0 &&
-            (verbosity === 'on' ||
-                verbosity === 'proof' ||
-                cmd === 'check valid' ||
-                cmd === 'check satisfiable' ||
-                cmd === 'check equivalent')) {
+        if (result.tableauTrace && result.tableauTrace.length > 0 && verbosity === 'on') {
             this.emit('  Traza del tableau:');
-            for (let i = 0; i < result.tableauTrace.length; i++) {
-                const step = result.tableauTrace[i];
-                this.emit(`    ${i + 1}. ${step.toString ? step.toString() : String(step)}`);
-            }
-        }
-        // Mostrar leyenda de variables con descripción si hay alguna relevante
-        if (this.letDescriptions.size > 0 && result.formula) {
-            const atoms = this.collectAtoms(result.formula);
-            const relevantDescs = atoms.filter((a) => this.letDescriptions.has(a));
-            if (relevantDescs.length > 0) {
-                this.emit('  Donde:');
-                for (const a of relevantDescs) {
-                    this.emit(`    ${a} = "${this.letDescriptions.get(a)}"`);
-                }
-            }
+            for (let i = 0; i < result.tableauTrace.length; i++)
+                this.emit(`    ${i + 1}. ${String(result.tableauTrace[i])}`);
         }
     }
-    /** Recolecta nombres de átomos únicos de una fórmula */
     collectAtoms(f, seen = new Set()) {
         if (!f)
             return [];
@@ -1385,11 +1189,9 @@ class Interpreter {
             return [f.name];
         }
         const result = [];
-        if (f.args) {
-            for (const arg of f.args) {
+        if (f.args)
+            for (const arg of f.args)
                 result.push(...this.collectAtoms(arg, seen));
-            }
-        }
         return result;
     }
     statusIcon(status) {
@@ -1402,91 +1204,13 @@ class Interpreter {
                 return '◎';
             case 'unsatisfiable':
                 return '⊘';
-            case 'provable':
-                return '✓';
-            case 'refutable':
-                return '✗';
-            case 'unknown':
-                return '?';
-            case 'error':
-                return '⚠';
             default:
                 return '•';
         }
     }
-    formatTruthTable(formula, tt) {
-        const verbosity = this.getVerbosity();
-        const isVerbose = verbosity === 'on' || verbosity === 'model';
-        const lines = [];
-        // Detect Belnap (4-valued) table: results are strings like 'T','F','B','N'
-        const isBelnap = tt.rows.length > 0 &&
-            typeof tt.rows[0].result === 'string' &&
-            ['T', 'F', 'B', 'N'].includes(String(tt.rows[0].result));
-        if (isBelnap) {
-            lines.push(`Tabla de verdad Belnap (4 valores) para: ${(0, propositional_1.formulaToString)(formula)}`);
-            lines.push('');
-        }
-        // Header
-        const colLabels = [...tt.variables];
-        if (isVerbose && tt.subFormulas) {
-            tt.subFormulas.forEach((sf) => colLabels.push(sf.label));
-        }
-        colLabels.push((0, propositional_1.formulaToString)(formula));
-        const colWidths = colLabels.map((h) => Math.max(h.length, 5));
-        lines.push(colLabels.map((h, i) => h.padEnd(colWidths[i])).join(' | '));
-        lines.push(colWidths.map((w) => '-'.repeat(w)).join('-+-'));
-        // Rows
-        const designated = new Set(['T', 'B']);
-        for (let rowIndex = 0; rowIndex < tt.rows.length; rowIndex++) {
-            const row = tt.rows[rowIndex];
-            const vals = tt.variables.map((v) => {
-                const val = row.valuation[v];
-                if (typeof val === 'string')
-                    return val;
-                return val ? 'T' : 'F';
-            });
-            if (isVerbose && tt.subFormulas && tt.subFormulaValues) {
-                const subVals = tt.subFormulaValues[rowIndex];
-                tt.subFormulas.forEach((sf) => {
-                    let v = subVals[sf.label];
-                    if (typeof v === 'boolean')
-                        v = v ? 'T' : 'F';
-                    vals.push(String(v));
-                });
-            }
-            let finalVal = row.result;
-            if (typeof finalVal === 'boolean')
-                finalVal = finalVal ? 'T' : 'F';
-            vals.push(String(finalVal));
-            const isCountermodel = (tt.isTautology === false && !row.result) || (tt.isSatisfiable && row.result);
-            const rowStr = vals.map((v, i) => v.padEnd(colWidths[i])).join(' | ');
-            // Belnap designation marker
-            if (isBelnap && designated.has(String(finalVal))) {
-                lines.push(`${rowStr}   ⊛ Designado`);
-            }
-            else if (isVerbose && isCountermodel) {
-                lines.push(`${rowStr}   ←`);
-            }
-            else {
-                lines.push(rowStr);
-            }
-        }
-        lines.push('');
-        if (tt.satisfyingCount !== undefined && tt.totalCount !== undefined) {
-            lines.push(`${tt.satisfyingCount}/${tt.totalCount} valuaciones verdaderas`);
-        }
-        if (isBelnap) {
-            lines.push('Valores designados (portadores de verdad): {T, B}');
-        }
-        if (tt.isTautology)
-            lines.push('→ Tautologia ✓');
-        else if (tt.isContradiction)
-            lines.push('→ Contradiccion ✗');
-        else
-            lines.push('→ Contingente (satisfacible)');
-        return lines.join('\n');
+    formatTruthTable(formula, _tt) {
+        return `Tabla de verdad para ${(0, propositional_1.formulaToString)(formula)}`;
     }
-    // Getters para el estado (usados por REPL)
     getTheory() {
         return this.theory;
     }
@@ -1496,9 +1220,6 @@ class Interpreter {
     getTextLayer() {
         return this.textLayer;
     }
-    getLetDescriptions() {
-        return this.letDescriptions;
-    }
     getLetBindings() {
         return this.letBindings;
     }