@stevenvo780/st-lang 1.5.8 → 2.0.0

package/dist/runtime/interpreter.js

@@ -22,6 +22,8 @@ class Interpreter {
     letBindings = new Map();
     letDescriptions = new Map();
     theories = new Map();
+    /** Plantillas de teorías (clases) */
+    theoryTemplates = new Map();
     /** Nombre de la teoría actual (si estamos dentro de una) */
     currentTheoryName = null;
     /** Funciones declaradas */
@@ -29,9 +31,31 @@ class Interpreter {
     /** Señal de return activa (para salir de funciones) */
     returnSignal = false;
     returnValue = undefined;
+    /** Modo importación: solo registrar exports */
+    isImporting = false;
+    /** Elementos exportados por el archivo actual */
+    exportedBindings = new Map();
+    exportedAxioms = new Map();
+    exportedTheorems = new Map();
+    exportedFunctions = new Map();
+    exportedTheories = new Map();
     constructor() {
         this.theory = this.createEmptyTheory();
         this.textLayer = (0, compiler_1.createTextLayerState)();
+        this.registerBuiltins();
+    }
+    /** Registra funciones nativas (Built-ins) para metaprogramación e interactividad */
+    registerBuiltins() {
+        const builtins = ['typeof', 'is_valid', 'is_satisfiable', 'get_atoms', 'input'];
+        for (const name of builtins) {
+            this.functions.set(name, {
+                kind: 'fn_decl',
+                name,
+                params: ['arg'],
+                body: [],
+                source: { line: 0, column: 0 }
+            });
+        }
     }
     createEmptyTheory() {
         return {
@@ -56,8 +80,15 @@ class Interpreter {
         this.theories.clear();
         this.currentTheoryName = null;
         this.functions.clear();
+        this.registerBuiltins();
         this.returnSignal = false;
         this.returnValue = undefined;
+        this.isImporting = false;
+        this.exportedBindings.clear();
+        this.exportedAxioms.clear();
+        this.exportedTheorems.clear();
+        this.exportedFunctions.clear();
+        this.exportedTheories.clear();
     }
     execute(source, file = '<stdin>') {
         this.diagnostics = [];
@@ -148,6 +179,23 @@ class Interpreter {
     executeStatement(stmt) {
         if (this.returnSignal)
             return;
+        // Si estamos importando, ignoramos comandos que no sean declaraciones
+        const sideEffects = [
+            'derive_cmd',
+            'check_valid_cmd',
+            'check_satisfiable_cmd',
+            'check_equivalent_cmd',
+            'prove_cmd',
+            'countermodel_cmd',
+            'truth_table_cmd',
+            'print_cmd',
+            'analyze_cmd',
+            'explain_cmd',
+            'render_cmd',
+        ];
+        if (this.isImporting && (sideEffects.includes(stmt.kind) || stmt.kind === 'logic_decl')) {
+            return;
+        }
         switch (stmt.kind) {
             case 'logic_decl':
                 return this.execLogicDecl(stmt);
@@ -206,7 +254,36 @@ class Interpreter {
             case 'return_stmt':
                 return this.execReturnStmt(stmt);
             case 'fn_call':
-                return this.execFnCall(stmt);
+                this.executeFnCall(stmt);
+                return;
+            case 'export_decl':
+                return this.execExportDecl(stmt);
+        }
+    }
+    execExportDecl(stmt) {
+        // Ejecutar la declaración interna
+        this.executeStatement(stmt.statement);
+        // Registrarla como exportada
+        const s = stmt.statement;
+        switch (s.kind) {
+            case 'let_decl':
+                if (s.letType === 'formula') {
+                    this.exportedBindings.set(s.name, this.letBindings.get(s.name));
+                    this.exportedAxioms.set(s.name, this.theory.axioms.get(s.name));
+                }
+                break;
+            case 'axiom_decl':
+                this.exportedAxioms.set(s.name, this.theory.axioms.get(s.name));
+                break;
+            case 'theorem_decl':
+                this.exportedTheorems.set(s.name, this.theory.theorems.get(s.name));
+                break;
+            case 'fn_decl':
+                this.exportedFunctions.set(s.name, this.functions.get(s.name));
+                break;
+            case 'theory_decl':
+                this.exportedTheories.set(s.name, this.theories.get(s.name));
+                break;
         }
     }
     requireProfile() {
@@ -226,39 +303,41 @@ class Interpreter {
             return f;
         // Si es un átomo, intentar resolver
         if (f.kind === 'atom' && f.name) {
-            // Dot notation: Theory.member
+            // Dot notation: Theory.member o instance.member
             if (f.name.includes('.')) {
-                const [theoryName, memberName] = f.name.split('.', 2);
-                const scope = this.theories.get(theoryName);
+                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) {
+                            if (scope.privateMembers.has(memberName) && this.currentTheoryName !== actualInstanceName)
+                                return f;
+                            if (scope.letBindings.has(memberName))
+                                return this.resolveFormula(scope.letBindings.get(memberName), new Set(visited));
+                            if (scope.axioms.has(memberName))
+                                return this.resolveFormula(scope.axioms.get(memberName), new Set(visited));
+                            if (scope.theorems.has(memberName))
+                                return this.resolveFormula(scope.theorems.get(memberName), new Set(visited));
+                        }
+                    }
+                }
+                // 2. Intentar resolver como nombre de teoría global (Singleton)
+                const scope = this.theories.get(prefix);
                 if (scope) {
-                    // Verificar encapsulamiento: miembros privados no accesibles desde fuera
-                    if (scope.privateMembers.has(memberName) && this.currentTheoryName !== theoryName) {
-                        // Miembro privado — no resolver, dejar como átomo
+                    if (scope.privateMembers.has(memberName) && this.currentTheoryName !== prefix)
                         return f;
-                    }
-                    // Buscar en letBindings de la teoría
-                    if (scope.letBindings.has(memberName)) {
-                        if (visited.has(f.name))
-                            return f;
-                        visited.add(f.name);
+                    if (scope.letBindings.has(memberName))
                         return this.resolveFormula(scope.letBindings.get(memberName), new Set(visited));
-                    }
-                    // Buscar en axiomas de la teoría
-                    if (scope.axioms.has(memberName)) {
-                        if (visited.has(f.name))
-                            return f;
-                        visited.add(f.name);
+                    if (scope.axioms.has(memberName))
                         return this.resolveFormula(scope.axioms.get(memberName), new Set(visited));
-                    }
-                    // Buscar en teoremas de la teoría
-                    if (scope.theorems.has(memberName)) {
-                        if (visited.has(f.name))
-                            return f;
-                        visited.add(f.name);
+                    if (scope.theorems.has(memberName))
                         return this.resolveFormula(scope.theorems.get(memberName), new Set(visited));
-                    }
                 }
-                // No se encontró — dejar como átomo con punto
                 return f;
             }
             // Binding local normal
@@ -283,6 +362,11 @@ class Interpreter {
                 return this.resolveFormula(this.theory.theorems.get(f.name), new Set(visited));
             }
         }
+        // Llamada a función como expresión
+        if (f.kind === 'fn_call' && f.name) {
+            const result = this.executeFnCall({ name: f.name, args: f.args || [] });
+            return result || { kind: 'atom', name: 'undefined', source: f.source };
+        }
         // Recorrer hijos recursivamente
         if (f.args && f.args.length > 0) {
             const newArgs = f.args.map(a => a ? this.resolveFormula(a, new Set(visited)) : a);
@@ -609,11 +693,23 @@ class Interpreter {
     }
     execTheoryDecl(stmt) {
         const theoryName = stmt.name;
-        // Si ya existe una teoría con este nombre, sobreescribirla
+        // 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`);
+            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;
+        const templateName = node.name;
         // Crear scope vacío
         const scope = {
             name: theoryName,
-            parent: stmt.parent,
+            parent: node.parent,
             letBindings: new Map(),
             letDescriptions: new Map(),
             axioms: new Map(),
@@ -621,32 +717,25 @@ class Interpreter {
             privateMembers: new Set(),
         };
         // HERENCIA: Si extends Parent, copiar bindings/axiomas/teoremas del padre
-        if (stmt.parent) {
-            const parentScope = this.theories.get(stmt.parent);
+        // 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 '${stmt.parent}' no encontrada. Declárela antes de '${theoryName}'.`);
+                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)
-            for (const [k, v] of parentScope.letBindings) {
-                if (!parentScope.privateMembers.has(k)) {
+            for (const [k, v] of parentScope.letBindings)
+                if (!parentScope.privateMembers.has(k))
                     scope.letBindings.set(k, v);
-                }
-            }
-            for (const [k, v] of parentScope.letDescriptions) {
-                if (!parentScope.privateMembers.has(k)) {
+            for (const [k, v] of parentScope.letDescriptions)
+                if (!parentScope.privateMembers.has(k))
                     scope.letDescriptions.set(k, v);
-                }
-            }
-            for (const [k, v] of parentScope.axioms) {
-                if (!parentScope.privateMembers.has(k)) {
+            for (const [k, v] of parentScope.axioms)
+                if (!parentScope.privateMembers.has(k))
                     scope.axioms.set(k, v);
-                }
-            }
-            for (const [k, v] of parentScope.theorems) {
-                if (!parentScope.privateMembers.has(k)) {
+            for (const [k, v] of parentScope.theorems)
+                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);
@@ -654,30 +743,33 @@ class Interpreter {
         const savedAxioms = new Map(this.theory.axioms);
         const savedTheorems = new Map(this.theory.theorems);
         const savedTheoryName = this.currentTheoryName;
-        // Establecer el scope de la teoría como contexto actual
+        // 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) {
+                    const resolvedArg = this.resolveFormula(args[i]);
+                    this.letBindings.set(node.params[i], resolvedArg);
+                    scope.letBindings.set(node.params[i], resolvedArg);
+                }
+            }
+        }
         // Inyectar bindings heredados al scope local para que los statements internos los vean
-        for (const [k, v] of scope.letBindings) {
+        for (const [k, v] of scope.letBindings)
             this.letBindings.set(k, v);
-        }
-        for (const [k, v] of scope.letDescriptions) {
+        for (const [k, v] of scope.letDescriptions)
             this.letDescriptions.set(k, v);
-        }
-        for (const [k, v] of scope.axioms) {
+        for (const [k, v] of scope.axioms)
             this.theory.axioms.set(k, v);
-        }
-        for (const [k, v] of scope.theorems) {
+        for (const [k, v] of scope.theorems)
             this.theory.theorems.set(k, v);
-        }
         this.currentTheoryName = theoryName;
-        this.emit(`── Theory ${theoryName}${stmt.parent ? ` extends ${stmt.parent}` : ''} ──`);
+        this.emit(`── Instanciando Theory ${theoryName} ──`);
         // Ejecutar los miembros del body
-        for (const member of stmt.members) {
-            // Registrar visibilidad
+        for (const member of node.members) {
             const memberStmt = member.statement;
             const memberName = 'name' in memberStmt ? memberStmt.name : null;
-            if (member.visibility === 'private' && memberName) {
+            if (member.visibility === 'private' && memberName)
                 scope.privateMembers.add(memberName);
-            }
             try {
                 this.executeStatement(memberStmt);
             }
@@ -686,43 +778,35 @@ class Interpreter {
                 this.diagnostics.push({
                     severity: 'error',
                     message: `[theory ${theoryName}] ${message}`,
-                    file: stmt.source.file,
+                    file: node.source.file,
                     line: memberStmt.source.line,
                     column: memberStmt.source.column,
                 });
             }
         }
-        // Capturar lo que los statements internos produjeron en el scope
-        // (nuevos letBindings, axiomas, teoremas, descriptions)
-        for (const [k, v] of this.letBindings) {
-            if (!savedLetBindings.has(k)) {
+        // Capturar lo producido
+        for (const [k, v] of this.letBindings)
+            if (!savedLetBindings.has(k))
                 scope.letBindings.set(k, v);
-            }
-        }
-        for (const [k, v] of this.letDescriptions) {
-            if (!savedLetDescriptions.has(k)) {
+        for (const [k, v] of this.letDescriptions)
+            if (!savedLetDescriptions.has(k))
                 scope.letDescriptions.set(k, v);
-            }
-        }
-        for (const [k, v] of this.theory.axioms) {
-            if (!savedAxioms.has(k)) {
+        for (const [k, v] of this.theory.axioms)
+            if (!savedAxioms.has(k))
                 scope.axioms.set(k, v);
-            }
-        }
-        for (const [k, v] of this.theory.theorems) {
-            if (!savedTheorems.has(k)) {
+        for (const [k, v] of this.theory.theorems)
+            if (!savedTheorems.has(k))
                 scope.theorems.set(k, v);
-            }
-        }
-        // Restaurar estado global (encapsulamiento — los internos no escapan)
+        // Restaurar estado global
         this.letBindings = savedLetBindings;
         this.letDescriptions = savedLetDescriptions;
         this.theory.axioms = savedAxioms;
         this.theory.theorems = savedTheorems;
         this.currentTheoryName = savedTheoryName;
-        // Registrar la teoría
+        // Registrar la instancia
         this.theories.set(theoryName, scope);
-        this.emit(`── End Theory ${theoryName} ──`);
+        this.emit(`── End Theory Instance ${theoryName} ──`);
+        return theoryName;
     }
     // =============================================
     // Control flow & funciones (v1.5.8)
@@ -842,8 +926,14 @@ class Interpreter {
         }
     }
     execFnDecl(stmt) {
-        this.functions.set(stmt.name, stmt);
-        this.emit(`Función ${stmt.name}(${stmt.params.join(', ')}) declarada`);
+        const name = this.currentTheoryName ? `${this.currentTheoryName}.${stmt.name}` : stmt.name;
+        this.functions.set(name, stmt);
+        if (this.currentTheoryName) {
+            this.emit(`Función de instancia ${name}(${stmt.params.join(', ')}) declarada`);
+        }
+        else {
+            this.emit(`Función ${name}(${stmt.params.join(', ')}) declarada`);
+        }
     }
     execReturnStmt(stmt) {
         if (stmt.formula) {
@@ -854,10 +944,48 @@ class Interpreter {
         }
         this.returnSignal = true;
     }
-    execFnCall(stmt) {
+    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);
+        }
+        // 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;
+                }
+            }
+            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);
+                }
+            }
+        }
+        // 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 '${stmt.name}' no declarada`);
+            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}`);
@@ -882,8 +1010,8 @@ class Interpreter {
                 break;
             this.executeStatement(bodyStmt);
         }
-        // Capturar valor de retorno (si lo hay) — queda en this.returnValue
-        // Por ahora no hacemos nada con él, pero está disponible para extensión futura
+        // Capturar valor de retorno
+        const result = this.returnValue;
         this.returnSignal = savedReturnSignal;
         this.returnValue = savedReturnValue;
         // Restaurar bindings
@@ -896,6 +1024,94 @@ class Interpreter {
                 this.letBindings.delete(param);
             }
         }
+        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]));
+        }
+        // 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);
+        }
+        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;
+    }
+    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';
+            if (arg.kind === 'number')
+                typeStr = 'Number';
+            if (arg.kind === 'atom' && arg.name?.startsWith('"'))
+                typeStr = 'String';
+            return { kind: 'atom', name: `"${typeStr}"`, source: arg.source };
+        }
+        if (name === 'is_valid' || name === 'is_satisfiable') {
+            const profile = this.requireProfile();
+            try {
+                const result = name === 'is_valid' ? profile.checkValid(arg) : profile.checkSatisfiable(arg);
+                const isTrue = result.status === 'valid' || result.status === 'satisfiable';
+                return { kind: 'atom', name: `"${isTrue ? 'True' : 'False'}"`, source: arg.source };
+            }
+            catch (e) {
+                return { kind: 'atom', name: '"Error"', source: arg.source };
+            }
+        }
+        if (name === 'get_atoms') {
+            const atoms = this.collectAtoms(arg);
+            return { kind: 'atom', name: `"{ ${atoms.join(', ')} }"`, source: arg.source };
+        }
+        if (name === 'input') {
+            const prompt = arg.kind === 'atom' && arg.name?.startsWith('"') ? arg.name.replace(/(^"|"$)/g, '') : (0, propositional_1.formulaToString)(arg);
+            let inputStr = '';
+            try {
+                process.stdout.write(prompt + ' ');
+                const fs = require('fs');
+                const buf = Buffer.alloc(256);
+                const bytesRead = fs.readSync(process.stdin.fd, buf, 0, 256, null);
+                inputStr = buf.toString('utf8', 0, bytesRead).trim();
+            }
+            catch (e) {
+                inputStr = "interactive_not_supported";
+            }
+            return { kind: 'atom', name: `"${inputStr}"`, source: arg.source };
+        }
+        return undefined;
     }
     execImportDecl(stmt) {
         let filePath = stmt.path;
@@ -929,11 +1145,68 @@ class Interpreter {
         if (parser.diagnostics.some((d) => d.severity === 'error')) {
             throw new Error(`Errores de parseo en '${filePath}'`);
         }
-        // Ejecutar statements del archivo importado en el contexto actual
+        // 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) {
             this.executeStatement(importedStmt);
         }
-        this.emit(`Import: ${filePath} cargado`);
+        // Capturar lo exportado
+        const newExports = {
+            bindings: new Map(this.exportedBindings),
+            axioms: new Map(this.exportedAxioms),
+            theorems: new Map(this.exportedTheorems),
+            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)
+            this.theory.axioms.set(k, v);
+        for (const [k, v] of newExports.theorems)
+            this.theory.theorems.set(k, v);
+        for (const [k, v] of newExports.functions)
+            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();