@stevenvo780/st-lang 3.2.3 → 4.0.0

package/dist/parser/parser.js

@@ -1,57 +1,47 @@
 "use strict";
 /**
  * ST Parser — Parser recursivo descendente
+ *
+ * Refactor α2 (V4): el parser monolitico se descompone en modulos.
+ * - ./state.ts        — ParserState: token cursor + diagnostico
+ * - ./formulas.ts     — precedencia de formulas + MODAL_ALIASES + formulaToString
+ *
+ * La clase `Parser` es el facade publico: misma firma de constructor,
+ * mismo `parse(source): Program`, mismo `diagnostics`. Los consumidores
+ * (interpreter, cli, api, protocol/handler) NO cambian.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
 const tokens_1 = require("../lexer/tokens");
 const lexer_1 = require("../lexer/lexer");
 const compat_1 = require("../runtime/compat");
-// Modal aliases per profile: maps identifier names to modal formula types
-const MODAL_ALIASES = {
-    'deontic.standard': { O: 'box', P: 'diamond', F: 'box_not' },
-    'epistemic.s5': { K: 'box', B: 'diamond' },
-    'temporal.ltl': { G: 'box', F: 'diamond' },
-    'modal.k': { Box: 'box', Dia: 'diamond' },
-    'modal.s4': { Box: 'box', Dia: 'diamond' },
-    'modal.s5': { Box: 'box', Dia: 'diamond' },
-    'modal.t': { Box: 'box', Dia: 'diamond' },
-};
+const state_1 = require("./state");
+const formulas_1 = require("./formulas");
 class Parser {
-    tokens = [];
-    pos = 0;
-    file;
-    diagnostics = [];
-    contextStack = [];
-    knownFunctionNames = new Set([
-        'typeof',
-        'is_valid',
-        'is_satisfiable',
-        'get_atoms',
-        'atoms_of',
-        'len',
-        'at',
-        'formula_eq',
-        'input',
-    ]);
-    knownTheoryNames = new Set();
-    currentProfile = '';
+    state;
     initialProfile;
     constructor(file = '<stdin>', profile) {
-        this.file = file;
+        this.state = new state_1.ParserState(file);
         this.initialProfile = profile;
     }
+    // --- Acceso compatible al estado (diagnostics expuesto como antes) ---
+    get diagnostics() {
+        return this.state.diagnostics;
+    }
+    set diagnostics(value) {
+        this.state.diagnostics = value;
+    }
     parse(source) {
         const normalizedSource = (0, compat_1.normalizeSTSource)(source);
-        const lexer = new lexer_1.Lexer(normalizedSource, this.file, this.initialProfile);
-        this.tokens = lexer.tokenize();
-        this.diagnostics.push(...lexer.diagnostics);
-        this.pos = 0;
-        this.contextStack = [];
+        const lexer = new lexer_1.Lexer(normalizedSource, this.state.file, this.initialProfile);
+        this.state.tokens = lexer.tokenize();
+        this.state.diagnostics.push(...lexer.diagnostics);
+        this.state.pos = 0;
+        this.state.contextStack = [];
         const statements = [];
-        while (!this.isAtEnd()) {
-            this.skipNewlines();
-            if (this.isAtEnd())
+        while (!this.state.isAtEnd()) {
+            this.state.skipNewlines();
+            if (this.state.isAtEnd())
                 break;
             try {
                 const stmt = this.parseStatement();
@@ -61,34 +51,29 @@ class Parser {
             }
             catch (e) {
                 const message = e instanceof Error ? e.message : 'Error de parseo inesperado';
-                this.diagnostics.push({
-                    severity: 'error',
-                    message,
-                    file: this.file,
-                    line: this.current().line,
-                    column: this.current().column,
-                });
+                this.state.pushDiagnostic('error', message);
                 this.advanceToNextStatement();
             }
         }
-        return { statements, file: this.file };
+        return { statements, file: this.state.file };
     }
     // --- Parsing de statements ---
     parseStatement() {
-        const tok = this.current();
+        const s = this.state;
+        const tok = s.current();
         // Detección de llamada a función: nombre(...)
-        if (this.peek(1) === tokens_1.TokenType.LPAREN &&
-            (tok.type === tokens_1.TokenType.IDENTIFIER || this.knownFunctionNames.has(tok.value))) {
-            return this.withContext(`llamada a funcion '${tok.value}'`, () => this.parseFnCall());
+        if (s.peek(1) === tokens_1.TokenType.LPAREN &&
+            (tok.type === tokens_1.TokenType.IDENTIFIER || s.knownFunctionNames.has(tok.value))) {
+            return s.withContext(`llamada a funcion '${tok.value}'`, () => this.parseFnCall());
         }
         // Detección de llamada a método: objeto.metodo(...)
         if (tok.type === tokens_1.TokenType.IDENTIFIER &&
-            this.peek(1) === tokens_1.TokenType.DOT &&
-            this.peek(2) === tokens_1.TokenType.IDENTIFIER &&
-            this.peek(3) === tokens_1.TokenType.LPAREN) {
-            return this.withContext(`llamada a metodo '${tok.value}'`, () => this.parseMemberFnCall());
+            s.peek(1) === tokens_1.TokenType.DOT &&
+            s.peek(2) === tokens_1.TokenType.IDENTIFIER &&
+            s.peek(3) === tokens_1.TokenType.LPAREN) {
+            return s.withContext(`llamada a metodo '${tok.value}'`, () => this.parseMemberFnCall());
         }
-        return this.withContext(this.describeStatementContext(tok), () => {
+        return s.withContext(this.describeStatementContext(tok), () => {
             switch (tok.type) {
                 case tokens_1.TokenType.LOGIC:
                     return this.parseLogicDecl();
@@ -158,72 +143,76 @@ class Parser {
                 case tokens_1.TokenType.GLOSSARY:
                     return this.parseGlossaryCmd();
                 case tokens_1.TokenType.IDENTIFIER:
-                    throw new Error(this.contextualize(`Statement inesperado: '${tok.value}' (${tok.type})`));
+                    throw new Error(s.contextualize(`Statement inesperado: '${tok.value}' (${tok.type})`));
                 case tokens_1.TokenType.NEWLINE:
-                    this.advance();
+                    s.advance();
                     return null;
                 case tokens_1.TokenType.EOF:
                     return null;
                 default:
-                    throw new Error(this.contextualize(`Statement inesperado: '${tok.value}' (${tok.type})`));
+                    throw new Error(s.contextualize(`Statement inesperado: '${tok.value}' (${tok.type})`));
             }
         });
     }
     // logic classical.propositional
     parseLogicDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.LOGIC);
-        // Leer perfil como secuencia de ID.ID
-        let profile = this.expectIdent();
-        while (this.match(tokens_1.TokenType.DOT)) {
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.LOGIC);
+        let profile = s.expectIdent();
+        while (s.match(tokens_1.TokenType.DOT)) {
             profile += '.';
-            profile += this.expectIdent();
+            profile += s.expectIdent();
         }
-        this.currentProfile = profile;
+        s.currentProfile = profile;
         return { kind: 'logic_decl', profile, source: src };
     }
     // axiom name = FORMULA  o  axiom name : FORMULA
     parseAxiomDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.AXIOM);
-        const name = this.expectIdent();
-        this.expectOneOf(tokens_1.TokenType.EQUALS, tokens_1.TokenType.COLON);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.AXIOM);
+        const name = s.expectIdent();
+        s.expectOneOf(tokens_1.TokenType.EQUALS, tokens_1.TokenType.COLON);
         const formula = this.parseFormula();
         return { kind: 'axiom_decl', name, formula, source: src };
     }
     // theorem name = FORMULA  o  theorem name : FORMULA
     parseTheoremDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.THEOREM);
-        const name = this.expectIdent();
-        this.expectOneOf(tokens_1.TokenType.EQUALS, tokens_1.TokenType.COLON);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.THEOREM);
+        const name = s.expectIdent();
+        s.expectOneOf(tokens_1.TokenType.EQUALS, tokens_1.TokenType.COLON);
         const formula = this.parseFormula();
         return { kind: 'theorem_decl', name, formula, source: src };
     }
     // derive FORMULA from {a1, a2, ...}
     parseDeriveCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.DERIVE);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.DERIVE);
         const goal = this.parseFormula();
-        this.expect(tokens_1.TokenType.FROM);
-        const premises = this.parseIdList();
+        s.expect(tokens_1.TokenType.FROM);
+        const premises = (0, formulas_1.parseIdList)(s);
         return { kind: 'derive_cmd', goal, premises, source: src };
     }
     // check valid FORMULA | check satisfiable FORMULA | check equivalent F, F
     parseCheckCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.CHECK);
-        if (this.match(tokens_1.TokenType.VALID)) {
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.CHECK);
+        if (s.match(tokens_1.TokenType.VALID)) {
             const formula = this.parseFormula();
             return { kind: 'check_valid_cmd', formula, source: src };
         }
-        if (this.match(tokens_1.TokenType.SATISFIABLE)) {
+        if (s.match(tokens_1.TokenType.SATISFIABLE)) {
             const formula = this.parseFormula();
             return { kind: 'check_satisfiable_cmd', formula, source: src };
         }
-        if (this.match(tokens_1.TokenType.EQUIVALENT)) {
+        if (s.match(tokens_1.TokenType.EQUIVALENT)) {
             const left = this.parseFormula();
-            this.expect(tokens_1.TokenType.COMMA);
+            s.expect(tokens_1.TokenType.COMMA);
             const right = this.parseFormula();
             return { kind: 'check_equivalent_cmd', left, right, source: src };
         }
@@ -231,98 +220,96 @@ class Parser {
     }
     // prove FORMULA [from {a1, a2}]
     parseProveCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.PROVE);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.PROVE);
         const goal = this.parseFormula();
-        // 'from' is optional — if omitted, prove from entire theory
         let premises = [];
-        if (this.match(tokens_1.TokenType.FROM)) {
-            premises = this.parseIdList();
+        if (s.match(tokens_1.TokenType.FROM)) {
+            premises = (0, formulas_1.parseIdList)(s);
         }
         return { kind: 'prove_cmd', goal, premises, source: src };
     }
     // countermodel FORMULA | refute FORMULA
     parseCountermodelCmd() {
-        const src = this.loc();
-        // Acepta tanto 'countermodel' como 'refute'
-        if (this.checkType(tokens_1.TokenType.COUNTERMODEL)) {
-            this.advance();
+        const s = this.state;
+        const src = s.loc();
+        if (s.checkType(tokens_1.TokenType.COUNTERMODEL)) {
+            s.advance();
         }
         else {
-            this.expect(tokens_1.TokenType.REFUTE);
+            s.expect(tokens_1.TokenType.REFUTE);
         }
         const formula = this.parseFormula();
         return { kind: 'countermodel_cmd', formula, source: src };
     }
     // truth_table FORMULA
     parseTruthTableCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.TRUTH_TABLE);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.TRUTH_TABLE);
         const formula = this.parseFormula();
         return { kind: 'truth_table_cmd', formula, source: src };
     }
     // let name = passage([[path#anchor]])
     // let name = formalize passageName as FORMULA
     parseLetDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.LET);
-        const name = this.expectIdent();
-        this.expect(tokens_1.TokenType.EQUALS);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.LET);
+        const name = s.expectIdent();
+        s.expect(tokens_1.TokenType.EQUALS);
         if (this.canStartActionExpr()) {
             const action = this.parseActionExpr();
             return { kind: 'let_decl', name, letType: 'action', action, source: src };
         }
-        if (this.match(tokens_1.TokenType.PASSAGE)) {
+        if (s.match(tokens_1.TokenType.PASSAGE)) {
             // passage @Source "text" (standalone passage with source and raw text)
-            if (this.checkType(tokens_1.TokenType.AT)) {
-                this.advance(); // skip @
-                const sourceRef = this.expectName();
-                // Optional section: §section or just a string
+            if (s.checkType(tokens_1.TokenType.AT)) {
+                s.advance(); // skip @
+                const sourceRef = s.expectName();
                 let section = '';
-                if (this.checkType(tokens_1.TokenType.STRING)) {
+                if (s.checkType(tokens_1.TokenType.STRING)) {
                     // No section, just text
                 }
-                else if (this.checkType(tokens_1.TokenType.IDENTIFIER) || this.checkType(tokens_1.TokenType.NUMBER)) {
-                    section = this.current().value;
-                    this.advance();
+                else if (s.checkType(tokens_1.TokenType.IDENTIFIER) || s.checkType(tokens_1.TokenType.NUMBER)) {
+                    section = s.current().value;
+                    s.advance();
                 }
-                if (this.checkType(tokens_1.TokenType.STRING)) {
-                    this.advance(); // consume the raw text string
+                if (s.checkType(tokens_1.TokenType.STRING)) {
+                    s.advance();
                     const anchorPath = `@${sourceRef}${section ? '#' + section : ''}`;
                     return { kind: 'let_decl', name, letType: 'passage', anchorPath, source: src };
                 }
             }
-            this.expect(tokens_1.TokenType.LPAREN);
-            this.expect(tokens_1.TokenType.LBRACKET_DOUBLE);
-            // El lexer ya leyó el contenido como STRING entre [[ y ]]
+            s.expect(tokens_1.TokenType.LPAREN);
+            s.expect(tokens_1.TokenType.LBRACKET_DOUBLE);
             let anchorPath = '';
-            if (this.checkType(tokens_1.TokenType.STRING)) {
-                anchorPath = this.current().value;
-                this.advance();
+            if (s.checkType(tokens_1.TokenType.STRING)) {
+                anchorPath = s.current().value;
+                s.advance();
             }
             else {
-                // Fallback: leer tokens hasta ]]
-                while (!this.checkType(tokens_1.TokenType.RBRACKET_DOUBLE) && !this.isAtEnd()) {
-                    anchorPath += this.current().value;
-                    this.advance();
+                while (!s.checkType(tokens_1.TokenType.RBRACKET_DOUBLE) && !s.isAtEnd()) {
+                    anchorPath += s.current().value;
+                    s.advance();
                 }
             }
-            this.expect(tokens_1.TokenType.RBRACKET_DOUBLE);
-            this.expect(tokens_1.TokenType.RPAREN);
+            s.expect(tokens_1.TokenType.RBRACKET_DOUBLE);
+            s.expect(tokens_1.TokenType.RPAREN);
             return { kind: 'let_decl', name, letType: 'passage', anchorPath, source: src };
         }
-        if (this.match(tokens_1.TokenType.FORMALIZE)) {
-            const passageName = this.expectIdent();
-            this.expect(tokens_1.TokenType.AS);
+        if (s.match(tokens_1.TokenType.FORMALIZE)) {
+            const passageName = s.expectIdent();
+            s.expect(tokens_1.TokenType.AS);
             const formula = this.parseFormula();
             return { kind: 'let_decl', name, letType: 'formalize', passageName, formula, source: src };
         }
         // let name = "texto descriptivo" [: FORMULA]
-        if (this.checkType(tokens_1.TokenType.STRING)) {
-            const description = this.current().value;
-            this.advance();
-            // Opcionalmente: let name = "desc" : FORMULA
-            if (this.match(tokens_1.TokenType.COLON)) {
+        if (s.checkType(tokens_1.TokenType.STRING)) {
+            const description = s.current().value;
+            s.advance();
+            if (s.match(tokens_1.TokenType.COLON)) {
                 const formula = this.parseFormula();
                 return { kind: 'let_decl', name, letType: 'formula', formula, description, source: src };
             }
@@ -334,192 +321,194 @@ class Parser {
     }
     // claim name = ID_OR_FORMULA
     parseClaimDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.CLAIM);
-        const name = this.expectIdent();
-        this.expect(tokens_1.TokenType.EQUALS);
-        // Si es un identificador simple y no tiene paréntesis (no es predicado)
-        // podría ser una referencia a una formalización o pasaje.
-        if (this.checkType(tokens_1.TokenType.IDENTIFIER) && this.peek(1) !== tokens_1.TokenType.LPAREN) {
-            const val = this.current().value;
-            const saved = this.pos;
-            this.advance();
-            // Si después del IDENTIFIER hay un NEWLINE o EOF, es una referencia.
-            if (this.isAtEnd() || this.checkType(tokens_1.TokenType.NEWLINE)) {
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.CLAIM);
+        const name = s.expectIdent();
+        s.expect(tokens_1.TokenType.EQUALS);
+        if (s.checkType(tokens_1.TokenType.IDENTIFIER) && s.peek(1) !== tokens_1.TokenType.LPAREN) {
+            const val = s.current().value;
+            const saved = s.pos;
+            s.advance();
+            if (s.isAtEnd() || s.checkType(tokens_1.TokenType.NEWLINE)) {
                 return { kind: 'claim_decl', name, value: val, formalization: val, source: src };
             }
-            // Si no, backtrack y parsear como formula completa
-            this.pos = saved;
+            s.pos = saved;
         }
         const formula = this.parseFormula();
         return {
             kind: 'claim_decl',
             name,
-            value: this.formulaToString(formula),
+            value: (0, formulas_1.formulaToString)(formula),
             formula,
             source: src,
         };
     }
     // support claimName <- sourceName
     parseSupportDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.SUPPORT);
-        const claimName = this.expectIdent();
-        this.expect(tokens_1.TokenType.BACK_ARROW);
-        const sourceName = this.expectIdent();
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.SUPPORT);
+        const claimName = s.expectIdent();
+        s.expect(tokens_1.TokenType.BACK_ARROW);
+        const sourceName = s.expectIdent();
         return { kind: 'support_decl', claimName, sourceName, source: src };
     }
     // confidence claimName = NUMBER
     parseConfidenceDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.CONFIDENCE);
-        const claimName = this.expectIdent();
-        this.expect(tokens_1.TokenType.EQUALS);
-        const tok = this.expect(tokens_1.TokenType.NUMBER);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.CONFIDENCE);
+        const claimName = s.expectIdent();
+        s.expect(tokens_1.TokenType.EQUALS);
+        const tok = s.expect(tokens_1.TokenType.NUMBER);
         return { kind: 'confidence_decl', claimName, value: parseFloat(tok.value), source: src };
     }
     // context claimName = "text"
     parseContextDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.CONTEXT);
-        const claimName = this.expectIdent();
-        this.expect(tokens_1.TokenType.EQUALS);
-        const tok = this.expect(tokens_1.TokenType.STRING);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.CONTEXT);
+        const claimName = s.expectIdent();
+        s.expect(tokens_1.TokenType.EQUALS);
+        const tok = s.expect(tokens_1.TokenType.STRING);
         return { kind: 'context_decl', claimName, text: tok.value, source: src };
     }
     // render target [as FORMAT] | render glossary [as FORMAT] | render analysis [as FORMAT]
     parseRenderCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.RENDER);
-        // El target puede ser un identificador, keyword 'theory', 'glossary', o 'analysis'
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.RENDER);
         let target;
-        if (this.checkType(tokens_1.TokenType.THEORY)) {
-            target = this.current().value;
-            this.advance();
+        if (s.checkType(tokens_1.TokenType.THEORY)) {
+            target = s.current().value;
+            s.advance();
         }
-        else if (this.checkType(tokens_1.TokenType.GLOSSARY)) {
+        else if (s.checkType(tokens_1.TokenType.GLOSSARY)) {
             target = 'glossary';
-            this.advance();
+            s.advance();
         }
         else {
-            target = this.expectIdent();
+            target = s.expectIdent();
         }
         let format = 'markdown';
-        // render X as FORMAT
-        if (this.match(tokens_1.TokenType.AS)) {
-            if (this.checkType(tokens_1.TokenType.IDENTIFIER)) {
-                format = this.current().value;
-                this.advance();
+        if (s.match(tokens_1.TokenType.AS)) {
+            if (s.checkType(tokens_1.TokenType.IDENTIFIER)) {
+                format = s.current().value;
+                s.advance();
             }
         }
-        else if (this.checkType(tokens_1.TokenType.IDENTIFIER)) {
-            // Backward compatible: render X markdown
-            format = this.current().value;
-            this.advance();
+        else if (s.checkType(tokens_1.TokenType.IDENTIFIER)) {
+            format = s.current().value;
+            s.advance();
         }
         return { kind: 'render_cmd', target, format, source: src };
     }
     // analyze {P1, P2, ...} -> CONCLUSION
     parseAnalyzeCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.ANALYZE);
-        this.expect(tokens_1.TokenType.LBRACE);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.ANALYZE);
+        s.expect(tokens_1.TokenType.LBRACE);
         const premises = [];
-        if (!this.checkType(tokens_1.TokenType.RBRACE)) {
+        if (!s.checkType(tokens_1.TokenType.RBRACE)) {
             premises.push(this.parseFormula());
-            while (this.match(tokens_1.TokenType.COMMA)) {
+            while (s.match(tokens_1.TokenType.COMMA)) {
                 premises.push(this.parseFormula());
             }
         }
-        this.expect(tokens_1.TokenType.RBRACE);
-        this.expect(tokens_1.TokenType.ARROW);
+        s.expect(tokens_1.TokenType.RBRACE);
+        s.expect(tokens_1.TokenType.ARROW);
         const conclusion = this.parseFormula();
         return { kind: 'analyze_cmd', premises, conclusion, source: src };
     }
     // explain FORMULA
     parseExplainCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.EXPLAIN);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.EXPLAIN);
         const formula = this.parseFormula();
         return { kind: 'explain_cmd', formula, source: src };
     }
     canStartActionExpr() {
-        return (this.checkType(tokens_1.TokenType.CHECK) ||
-            this.checkType(tokens_1.TokenType.DERIVE) ||
-            this.checkType(tokens_1.TokenType.PROVE) ||
-            this.checkType(tokens_1.TokenType.COUNTERMODEL) ||
-            this.checkType(tokens_1.TokenType.REFUTE) ||
-            this.checkType(tokens_1.TokenType.TRUTH_TABLE) ||
-            this.checkType(tokens_1.TokenType.EXPLAIN));
+        const s = this.state;
+        return (s.checkType(tokens_1.TokenType.CHECK) ||
+            s.checkType(tokens_1.TokenType.DERIVE) ||
+            s.checkType(tokens_1.TokenType.PROVE) ||
+            s.checkType(tokens_1.TokenType.COUNTERMODEL) ||
+            s.checkType(tokens_1.TokenType.REFUTE) ||
+            s.checkType(tokens_1.TokenType.TRUTH_TABLE) ||
+            s.checkType(tokens_1.TokenType.EXPLAIN));
     }
     parseActionExpr() {
-        const src = this.loc();
-        if (this.match(tokens_1.TokenType.CHECK)) {
-            if (this.match(tokens_1.TokenType.VALID)) {
+        const s = this.state;
+        const src = s.loc();
+        if (s.match(tokens_1.TokenType.CHECK)) {
+            if (s.match(tokens_1.TokenType.VALID)) {
                 const formula = this.parseFormula();
                 return { kind: 'action_expr', action: 'check_valid', formula, source: src };
             }
-            if (this.match(tokens_1.TokenType.SATISFIABLE)) {
+            if (s.match(tokens_1.TokenType.SATISFIABLE)) {
                 const formula = this.parseFormula();
                 return { kind: 'action_expr', action: 'check_satisfiable', formula, source: src };
             }
-            if (this.match(tokens_1.TokenType.EQUIVALENT)) {
+            if (s.match(tokens_1.TokenType.EQUIVALENT)) {
                 const left = this.parseFormula();
-                this.expect(tokens_1.TokenType.COMMA);
+                s.expect(tokens_1.TokenType.COMMA);
                 const right = this.parseFormula();
                 return { kind: 'action_expr', action: 'check_equivalent', left, right, source: src };
             }
             throw new Error(`Se esperaba 'valid', 'satisfiable' o 'equivalent' despues de 'check'`);
         }
-        if (this.match(tokens_1.TokenType.DERIVE)) {
+        if (s.match(tokens_1.TokenType.DERIVE)) {
             const goal = this.parseFormula();
-            this.expect(tokens_1.TokenType.FROM);
-            const premises = this.parseIdList();
+            s.expect(tokens_1.TokenType.FROM);
+            const premises = (0, formulas_1.parseIdList)(s);
             return { kind: 'action_expr', action: 'derive', goal, premises, source: src };
         }
-        if (this.match(tokens_1.TokenType.PROVE)) {
+        if (s.match(tokens_1.TokenType.PROVE)) {
             const goal = this.parseFormula();
-            this.expect(tokens_1.TokenType.FROM);
-            const premises = this.parseIdList();
+            s.expect(tokens_1.TokenType.FROM);
+            const premises = (0, formulas_1.parseIdList)(s);
             return { kind: 'action_expr', action: 'prove', goal, premises, source: src };
         }
-        if (this.checkType(tokens_1.TokenType.COUNTERMODEL)) {
-            this.advance();
+        if (s.checkType(tokens_1.TokenType.COUNTERMODEL)) {
+            s.advance();
             const formula = this.parseFormula();
             return { kind: 'action_expr', action: 'countermodel', formula, source: src };
         }
-        if (this.match(tokens_1.TokenType.REFUTE)) {
+        if (s.match(tokens_1.TokenType.REFUTE)) {
             const formula = this.parseFormula();
             return { kind: 'action_expr', action: 'countermodel', formula, source: src };
         }
-        if (this.match(tokens_1.TokenType.TRUTH_TABLE)) {
+        if (s.match(tokens_1.TokenType.TRUTH_TABLE)) {
             const formula = this.parseFormula();
             return { kind: 'action_expr', action: 'truth_table', formula, source: src };
         }
-        if (this.match(tokens_1.TokenType.EXPLAIN)) {
+        if (s.match(tokens_1.TokenType.EXPLAIN)) {
             const formula = this.parseFormula();
             return { kind: 'action_expr', action: 'explain', formula, source: src };
         }
-        throw new Error(`Se esperaba una acción capturable, encontrado '${this.current().value}'`);
+        throw new Error(`Se esperaba una acción capturable, encontrado '${s.current().value}'`);
     }
     // import "path/to/file.st" | import path/to/file
     parseImportDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.IMPORT);
-        // Acepta string entrecomillado o secuencia de ident.ident/ident
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.IMPORT);
         let path;
-        if (this.checkType(tokens_1.TokenType.STRING)) {
-            path = this.current().value;
-            this.advance();
+        if (s.checkType(tokens_1.TokenType.STRING)) {
+            path = s.current().value;
+            s.advance();
         }
         else {
-            path = this.expectIdent();
-            while (this.checkType(tokens_1.TokenType.DOT) || this.checkType(tokens_1.TokenType.IDENTIFIER)) {
-                if (this.match(tokens_1.TokenType.DOT)) {
+            path = s.expectIdent();
+            while (s.checkType(tokens_1.TokenType.DOT) || s.checkType(tokens_1.TokenType.IDENTIFIER)) {
+                if (s.match(tokens_1.TokenType.DOT)) {
                     path += '.';
-                    if (this.checkType(tokens_1.TokenType.IDENTIFIER)) {
-                        path += this.current().value;
-                        this.advance();
+                    if (s.checkType(tokens_1.TokenType.IDENTIFIER)) {
+                        path += s.current().value;
+                        s.advance();
                     }
                 }
                 else {
@@ -531,85 +520,73 @@ class Parser {
     }
     // assume name : FORMULA\n ... \n show FORMULA\n ... \n qed
     parseProofBlock() {
-        const src = this.loc();
+        const s = this.state;
+        const src = s.loc();
         const assumptions = [];
-        // Parsear una o más assumptions
-        while (this.checkType(tokens_1.TokenType.ASSUME)) {
-            this.advance();
-            const name = this.expectIdent();
-            this.expectOneOf(tokens_1.TokenType.COLON, tokens_1.TokenType.EQUALS);
+        while (s.checkType(tokens_1.TokenType.ASSUME)) {
+            s.advance();
+            const name = s.expectIdent();
+            s.expectOneOf(tokens_1.TokenType.COLON, tokens_1.TokenType.EQUALS);
             const formula = this.parseFormula();
             assumptions.push({ name, formula });
-            this.skipNewlines();
+            s.skipNewlines();
         }
-        // Esperar 'show FORMULA'
-        this.expect(tokens_1.TokenType.SHOW);
+        s.expect(tokens_1.TokenType.SHOW);
         const goal = this.parseFormula();
-        this.skipNewlines();
-        // Parsear body statements hasta 'qed'
+        s.skipNewlines();
         const body = [];
-        while (!this.checkType(tokens_1.TokenType.QED) && !this.isAtEnd()) {
-            this.skipNewlines();
-            if (this.checkType(tokens_1.TokenType.QED))
+        while (!s.checkType(tokens_1.TokenType.QED) && !s.isAtEnd()) {
+            s.skipNewlines();
+            if (s.checkType(tokens_1.TokenType.QED))
                 break;
             try {
-                const stmt = this.checkType(tokens_1.TokenType.ASSUME)
-                    ? this.parseProofBlock()
-                    : this.parseStatement();
+                const stmt = s.checkType(tokens_1.TokenType.ASSUME) ? this.parseProofBlock() : this.parseStatement();
                 if (stmt)
                     body.push(stmt);
             }
             catch (e) {
                 const message = e instanceof Error ? e.message : 'Error de parseo en bloque de prueba';
-                this.diagnostics.push({
-                    severity: 'error',
-                    message,
-                    file: this.file,
-                    line: this.current().line,
-                    column: this.current().column,
-                });
+                s.pushDiagnostic('error', message);
                 this.advanceToNextStatement();
             }
         }
-        if (this.isAtEnd()) {
+        if (s.isAtEnd()) {
             throw new Error(`Se esperaba 'qed' para cerrar el bloque de prueba abierto en linea ${src.line}, columna ${src.column}`);
         }
-        this.expect(tokens_1.TokenType.QED);
+        s.expect(tokens_1.TokenType.QED);
         return { kind: 'proof_block', assumptions, goal, body, source: src };
     }
     // theory Name(params) { ... } | theory Name extends Parent { ... }
     parseTheoryDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.THEORY);
-        const name = this.expectName();
-        this.knownTheoryNames.add(name);
-        // Parámetros opcionales (constructor): theory Math(n)
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.THEORY);
+        const name = s.expectName();
+        s.knownTheoryNames.add(name);
         let params;
-        if (this.match(tokens_1.TokenType.LPAREN)) {
+        if (s.match(tokens_1.TokenType.LPAREN)) {
             params = [];
-            if (!this.checkType(tokens_1.TokenType.RPAREN)) {
-                params.push(this.expectName());
-                while (this.match(tokens_1.TokenType.COMMA)) {
-                    params.push(this.expectName());
+            if (!s.checkType(tokens_1.TokenType.RPAREN)) {
+                params.push(s.expectName());
+                while (s.match(tokens_1.TokenType.COMMA)) {
+                    params.push(s.expectName());
                 }
             }
-            this.expect(tokens_1.TokenType.RPAREN);
+            s.expect(tokens_1.TokenType.RPAREN);
         }
-        // Herencia opcional: extends Parent
         let parent;
-        if (this.match(tokens_1.TokenType.EXTENDS)) {
-            parent = this.expectName();
+        if (s.match(tokens_1.TokenType.EXTENDS)) {
+            parent = s.expectName();
         }
-        this.expect(tokens_1.TokenType.LBRACE);
-        this.skipNewlines();
+        s.expect(tokens_1.TokenType.LBRACE);
+        s.skipNewlines();
         const members = [];
-        while (!this.checkType(tokens_1.TokenType.RBRACE) && !this.isAtEnd()) {
-            this.skipNewlines();
-            if (this.checkType(tokens_1.TokenType.RBRACE))
+        while (!s.checkType(tokens_1.TokenType.RBRACE) && !s.isAtEnd()) {
+            s.skipNewlines();
+            if (s.checkType(tokens_1.TokenType.RBRACE))
                 break;
-            // Visibilidad: private/privado o public (default)
             let visibility = 'public';
-            if (this.match(tokens_1.TokenType.PRIVATE)) {
+            if (s.match(tokens_1.TokenType.PRIVATE)) {
                 visibility = 'private';
             }
             try {
@@ -620,70 +597,62 @@ class Parser {
             }
             catch (e) {
                 const message = e instanceof Error ? e.message : 'Error de parseo en theory';
-                this.diagnostics.push({
-                    severity: 'error',
-                    message,
-                    file: this.file,
-                    line: this.current().line,
-                    column: this.current().column,
-                });
+                s.pushDiagnostic('error', message);
                 this.advanceToNextStatement();
             }
         }
-        this.expect(tokens_1.TokenType.RBRACE);
+        s.expect(tokens_1.TokenType.RBRACE);
         return { kind: 'theory_decl', name, params, parent, members, source: src };
     }
     // --- print "texto" | print formula ---
     parsePrintCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.PRINT);
-        if (this.checkType(tokens_1.TokenType.STRING)) {
-            const value = this.current().value;
-            this.advance();
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.PRINT);
+        if (s.checkType(tokens_1.TokenType.STRING)) {
+            const value = s.current().value;
+            s.advance();
             return { kind: 'print_cmd', value, source: src };
         }
-        // Imprimir resultado de fórmula
         const formula = this.parseFormula();
         return { kind: 'print_cmd', value: null, formula, source: src };
     }
     // --- set x = formula ---
     parseSetCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.SET);
-        const name = this.expectName();
-        this.expectOneOf(tokens_1.TokenType.EQUALS, tokens_1.TokenType.COLON);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.SET);
+        const name = s.expectName();
+        s.expectOneOf(tokens_1.TokenType.EQUALS, tokens_1.TokenType.COLON);
         const formula = this.parseFormula();
         return { kind: 'set_cmd', name, formula, source: src };
     }
     // --- if valid FORMULA { } else if satisfiable FORMULA { } else { } ---
     parseIfStmt() {
-        const src = this.loc();
+        const s = this.state;
+        const src = s.loc();
         const branches = [];
         let elseBranch;
-        // Primera rama: if
-        this.expect(tokens_1.TokenType.IF);
+        s.expect(tokens_1.TokenType.IF);
         branches.push(this.parseConditionBranch());
-        // Ramas else if
         while (this.checkElseIf()) {
-            this.expect(tokens_1.TokenType.ELSE);
-            this.expect(tokens_1.TokenType.IF);
+            s.expect(tokens_1.TokenType.ELSE);
+            s.expect(tokens_1.TokenType.IF);
             branches.push(this.parseConditionBranch());
         }
-        // Rama else
-        if (this.match(tokens_1.TokenType.ELSE)) {
+        if (s.match(tokens_1.TokenType.ELSE)) {
             elseBranch = this.parseBlock();
         }
         return { kind: 'if_stmt', branches, elseBranch, source: src };
     }
     checkElseIf() {
-        // Mira si hay else seguido de if (con posibles newlines entre medio)
-        if (!this.checkType(tokens_1.TokenType.ELSE))
+        const s = this.state;
+        if (!s.checkType(tokens_1.TokenType.ELSE))
             return false;
-        // Buscar if después de else (puede haber newlines)
         let lookahead = 1;
-        while (this.peek(lookahead) === tokens_1.TokenType.NEWLINE)
+        while (s.peek(lookahead) === tokens_1.TokenType.NEWLINE)
             lookahead++;
-        return this.peek(lookahead) === tokens_1.TokenType.IF;
+        return s.peek(lookahead) === tokens_1.TokenType.IF;
     }
     parseConditionBranch() {
         const condition = this.parseConditionKeyword();
@@ -692,46 +661,48 @@ class Parser {
         return { condition, formula, body };
     }
     parseConditionKeyword() {
-        if (this.match(tokens_1.TokenType.VALID))
+        const s = this.state;
+        if (s.match(tokens_1.TokenType.VALID))
             return 'valid';
-        if (this.match(tokens_1.TokenType.SATISFIABLE))
+        if (s.match(tokens_1.TokenType.SATISFIABLE))
             return 'satisfiable';
-        // Aceptar "invalid" / "unsatisfiable" como identifiers
-        if (this.checkType(tokens_1.TokenType.IDENTIFIER)) {
-            const v = this.current().value.toLowerCase();
+        if (s.checkType(tokens_1.TokenType.IDENTIFIER)) {
+            const v = s.current().value.toLowerCase();
             if (v === 'invalid' || v === 'invalido') {
-                this.advance();
+                s.advance();
                 return 'invalid';
             }
             if (v === 'unsatisfiable' || v === 'insatisfacible') {
-                this.advance();
+                s.advance();
                 return 'unsatisfiable';
             }
         }
-        throw new Error(this.contextualize(`Se esperaba una condición lógica ('valid', 'satisfiable', 'invalid' o 'unsatisfiable'), encontrado '${this.current().value}'`));
+        throw new Error(s.contextualize(`Se esperaba una condición lógica ('valid', 'satisfiable', 'invalid' o 'unsatisfiable'), encontrado '${s.current().value}'`));
     }
     // --- for x in {A, B, C} { body } ---
     parseForStmt() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.FOR);
-        const variable = this.expectName();
-        this.expect(tokens_1.TokenType.IN);
-        this.expect(tokens_1.TokenType.LBRACE);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.FOR);
+        const variable = s.expectName();
+        s.expect(tokens_1.TokenType.IN);
+        s.expect(tokens_1.TokenType.LBRACE);
         const items = [];
-        if (!this.checkType(tokens_1.TokenType.RBRACE)) {
+        if (!s.checkType(tokens_1.TokenType.RBRACE)) {
             items.push(this.parseFormula());
-            while (this.match(tokens_1.TokenType.COMMA)) {
+            while (s.match(tokens_1.TokenType.COMMA)) {
                 items.push(this.parseFormula());
             }
         }
-        this.expect(tokens_1.TokenType.RBRACE);
+        s.expect(tokens_1.TokenType.RBRACE);
         const body = this.parseBlock();
         return { kind: 'for_stmt', variable, items, body, source: src };
     }
     // --- while valid FORMULA { body } ---
     parseWhileStmt() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.WHILE);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.WHILE);
         const condition = this.parseConditionKeyword();
         const formula = this.parseFormula();
         const body = this.parseBlock();
@@ -739,44 +710,45 @@ class Parser {
     }
     // --- fn nombre(param1, param2) { body } ---
     parseFnDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.FN);
-        const name = this.expectName();
-        this.knownFunctionNames.add(name);
-        this.expect(tokens_1.TokenType.LPAREN);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.FN);
+        const name = s.expectName();
+        s.knownFunctionNames.add(name);
+        s.expect(tokens_1.TokenType.LPAREN);
         const params = [];
-        if (!this.checkType(tokens_1.TokenType.RPAREN)) {
-            params.push(this.expectName());
-            while (this.match(tokens_1.TokenType.COMMA)) {
-                params.push(this.expectName());
+        if (!s.checkType(tokens_1.TokenType.RPAREN)) {
+            params.push(s.expectName());
+            while (s.match(tokens_1.TokenType.COMMA)) {
+                params.push(s.expectName());
             }
         }
-        this.expect(tokens_1.TokenType.RPAREN);
+        s.expect(tokens_1.TokenType.RPAREN);
         const body = this.parseBlock();
         return { kind: 'fn_decl', name, params, body, source: src };
     }
     // --- return formula ---
     parseReturnStmt() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.RETURN);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.RETURN);
         let formula;
-        // Si hay algo después del return que no sea newline/EOF/}
-        if (!this.checkType(tokens_1.TokenType.NEWLINE) &&
-            !this.checkType(tokens_1.TokenType.EOF) &&
-            !this.checkType(tokens_1.TokenType.RBRACE)) {
+        if (!s.checkType(tokens_1.TokenType.NEWLINE) &&
+            !s.checkType(tokens_1.TokenType.EOF) &&
+            !s.checkType(tokens_1.TokenType.RBRACE)) {
             formula = this.parseFormula();
         }
         return { kind: 'return_stmt', formula, source: src };
     }
     // --- export STATEMENT ---
     parseExportDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.EXPORT);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.EXPORT);
         const stmt = this.parseStatement();
         if (!stmt) {
             throw new Error('Se esperaba un statement después de "export"');
         }
-        // Solo permitimos exportar declaraciones
         const exportable = [
             'let_decl',
             'axiom_decl',
@@ -792,157 +764,160 @@ class Parser {
     }
     // --- define NAME(params?) := FORMULA (description "text")? ---
     parseDefineDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.DEFINE);
-        const name = this.expectName();
-        // Parámetros opcionales: define F(x, y) := ...
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.DEFINE);
+        const name = s.expectName();
         let params;
-        if (this.match(tokens_1.TokenType.LPAREN)) {
+        if (s.match(tokens_1.TokenType.LPAREN)) {
             params = [];
-            if (!this.checkType(tokens_1.TokenType.RPAREN)) {
-                params.push(this.expectName());
-                while (this.match(tokens_1.TokenType.COMMA)) {
-                    params.push(this.expectName());
+            if (!s.checkType(tokens_1.TokenType.RPAREN)) {
+                params.push(s.expectName());
+                while (s.match(tokens_1.TokenType.COMMA)) {
+                    params.push(s.expectName());
                 }
             }
-            this.expect(tokens_1.TokenType.RPAREN);
+            s.expect(tokens_1.TokenType.RPAREN);
         }
-        // := (colon + equals) or just =
-        if (this.match(tokens_1.TokenType.COLON)) {
-            this.expect(tokens_1.TokenType.EQUALS);
+        if (s.match(tokens_1.TokenType.COLON)) {
+            s.expect(tokens_1.TokenType.EQUALS);
         }
         else {
-            this.expect(tokens_1.TokenType.EQUALS);
+            s.expect(tokens_1.TokenType.EQUALS);
         }
         const body = this.parseFormula();
-        // Optional description: description "text" (on next line or same line)
         let description;
-        this.skipNewlines();
-        if (this.checkType(tokens_1.TokenType.DESCRIPTION)) {
-            this.advance();
-            if (this.checkType(tokens_1.TokenType.STRING)) {
-                description = this.current().value;
-                this.advance();
+        s.skipNewlines();
+        if (s.checkType(tokens_1.TokenType.DESCRIPTION)) {
+            s.advance();
+            if (s.checkType(tokens_1.TokenType.STRING)) {
+                description = s.current().value;
+                s.advance();
             }
         }
         return { kind: 'define_decl', name, params, body, description, source: src };
     }
     // --- unfold FORMULA ---
     parseUnfoldCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.UNFOLD);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.UNFOLD);
         const formula = this.parseFormula();
         return { kind: 'unfold_cmd', formula, source: src };
     }
     // --- fold FORMULA ---
     parseFoldCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.FOLD);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.FOLD);
         const formula = this.parseFormula();
         return { kind: 'fold_cmd', formula, source: src };
     }
     // --- source NAME { key "value", ... } ---
     parseSourceDecl() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.SOURCE_KW);
-        const name = this.expectName();
-        this.expect(tokens_1.TokenType.LBRACE);
-        this.skipNewlines();
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.SOURCE_KW);
+        const name = s.expectName();
+        s.expect(tokens_1.TokenType.LBRACE);
+        s.skipNewlines();
         const fields = [];
-        while (!this.checkType(tokens_1.TokenType.RBRACE) && !this.isAtEnd()) {
-            this.skipNewlines();
-            if (this.checkType(tokens_1.TokenType.RBRACE))
+        while (!s.checkType(tokens_1.TokenType.RBRACE) && !s.isAtEnd()) {
+            s.skipNewlines();
+            if (s.checkType(tokens_1.TokenType.RBRACE))
                 break;
-            const key = this.expectName();
-            // Value: string or number
-            if (this.checkType(tokens_1.TokenType.STRING)) {
-                fields.push({ key, value: this.current().value });
-                this.advance();
+            const key = s.expectName();
+            if (s.checkType(tokens_1.TokenType.STRING)) {
+                fields.push({ key, value: s.current().value });
+                s.advance();
             }
-            else if (this.checkType(tokens_1.TokenType.NUMBER)) {
-                fields.push({ key, value: parseFloat(this.current().value) });
-                this.advance();
+            else if (s.checkType(tokens_1.TokenType.NUMBER)) {
+                fields.push({ key, value: parseFloat(s.current().value) });
+                s.advance();
             }
-            else if (this.checkType(tokens_1.TokenType.MINUS)) {
-                // Negative number (e.g., year -350)
-                this.advance();
-                if (this.checkType(tokens_1.TokenType.NUMBER)) {
-                    fields.push({ key, value: -parseFloat(this.current().value) });
-                    this.advance();
+            else if (s.checkType(tokens_1.TokenType.MINUS)) {
+                s.advance();
+                if (s.checkType(tokens_1.TokenType.NUMBER)) {
+                    fields.push({ key, value: -parseFloat(s.current().value) });
+                    s.advance();
                 }
             }
-            this.skipNewlines();
+            s.skipNewlines();
         }
-        this.expect(tokens_1.TokenType.RBRACE);
+        s.expect(tokens_1.TokenType.RBRACE);
         return { kind: 'source_decl', name, fields, source: src };
     }
     // --- interpret "text" as FORMULA  |  interpret IDENT as FORMULA ---
     parseInterpretCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.INTERPRET);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.INTERPRET);
         let text;
         let passageRef;
-        if (this.checkType(tokens_1.TokenType.STRING)) {
-            text = this.current().value;
-            this.advance();
+        if (s.checkType(tokens_1.TokenType.STRING)) {
+            text = s.current().value;
+            s.advance();
         }
         else {
-            // interpret passageRef as FORMULA
-            passageRef = this.expectName();
+            passageRef = s.expectName();
             text = passageRef;
         }
-        this.expect(tokens_1.TokenType.AS);
+        s.expect(tokens_1.TokenType.AS);
         const formula = this.parseFormula();
         return { kind: 'interpret_cmd', text, passageRef, formula, source: src };
     }
     // --- glossary ---
     parseGlossaryCmd() {
-        const src = this.loc();
-        this.expect(tokens_1.TokenType.GLOSSARY);
+        const s = this.state;
+        const src = s.loc();
+        s.expect(tokens_1.TokenType.GLOSSARY);
         return { kind: 'glossary_cmd', source: src };
     }
     // --- nombre(arg1, arg2) — llamada a función ---
     parseFnCall() {
-        const src = this.loc();
-        const name = this.expectName();
-        this.expect(tokens_1.TokenType.LPAREN);
+        const s = this.state;
+        const src = s.loc();
+        const name = s.expectName();
+        s.expect(tokens_1.TokenType.LPAREN);
         const args = [];
-        if (!this.checkType(tokens_1.TokenType.RPAREN)) {
+        if (!s.checkType(tokens_1.TokenType.RPAREN)) {
             args.push(this.parseFormula());
-            while (this.match(tokens_1.TokenType.COMMA)) {
+            while (s.match(tokens_1.TokenType.COMMA)) {
                 args.push(this.parseFormula());
             }
         }
-        this.expect(tokens_1.TokenType.RPAREN);
+        s.expect(tokens_1.TokenType.RPAREN);
         return { kind: 'fn_call', name, args, source: src };
     }
     // --- obj.method(arg1, arg2) ---
     parseMemberFnCall() {
-        const src = this.loc();
-        const obj = this.expectIdent();
-        this.expect(tokens_1.TokenType.DOT);
-        const method = this.expectIdent();
+        const s = this.state;
+        const src = s.loc();
+        const obj = s.expectIdent();
+        s.expect(tokens_1.TokenType.DOT);
+        const method = s.expectIdent();
         const fullName = `${obj}.${method}`;
-        this.expect(tokens_1.TokenType.LPAREN);
+        s.expect(tokens_1.TokenType.LPAREN);
         const args = [];
-        if (!this.checkType(tokens_1.TokenType.RPAREN)) {
+        if (!s.checkType(tokens_1.TokenType.RPAREN)) {
             args.push(this.parseFormula());
-            while (this.match(tokens_1.TokenType.COMMA)) {
+            while (s.match(tokens_1.TokenType.COMMA)) {
                 args.push(this.parseFormula());
             }
         }
-        this.expect(tokens_1.TokenType.RPAREN);
+        s.expect(tokens_1.TokenType.RPAREN);
         return { kind: 'fn_call', name: fullName, args, source: src };
     }
     // --- Helper: parsear un bloque { statements } ---
     parseBlock() {
-        this.skipNewlines();
-        this.expect(tokens_1.TokenType.LBRACE);
-        this.skipNewlines();
+        const s = this.state;
+        s.skipNewlines();
+        s.expect(tokens_1.TokenType.LBRACE);
+        s.skipNewlines();
         const body = [];
-        while (!this.checkType(tokens_1.TokenType.RBRACE) && !this.isAtEnd()) {
-            this.skipNewlines();
-            if (this.checkType(tokens_1.TokenType.RBRACE))
+        while (!s.checkType(tokens_1.TokenType.RBRACE) && !s.isAtEnd()) {
+            s.skipNewlines();
+            if (s.checkType(tokens_1.TokenType.RBRACE))
                 break;
             try {
                 const stmt = this.parseStatement();
@@ -951,611 +926,18 @@ class Parser {
             }
             catch (e) {
                 const message = e instanceof Error ? e.message : 'Error de parseo en bloque';
-                this.diagnostics.push({
-                    severity: 'error',
-                    message,
-                    file: this.file,
-                    line: this.current().line,
-                    column: this.current().column,
-                });
+                s.pushDiagnostic('error', message);
                 this.advanceToNextStatement();
             }
         }
-        this.expect(tokens_1.TokenType.RBRACE);
+        s.expect(tokens_1.TokenType.RBRACE);
         return body;
     }
-    // --- Parsing de fórmulas (precedencia) ---
-    // Precedencia (de menor a mayor):
-    // 1. <-> (bicondicional)
-    // 2. -> (implicación, asocia a la derecha)
-    // 3. | (disyunción)
-    // 4. & (conjunción)
-    // 5. ! (negación) y átomos
+    // --- Delegacion a modulo de formulas ---
     parseFormula() {
-        return this.parseBiconditional();
-    }
-    parseBiconditional() {
-        let left = this.parseImplication();
-        while (this.match(tokens_1.TokenType.BICONDITIONAL)) {
-            const right = this.parseImplication();
-            left = { kind: 'biconditional', args: [left, right], source: this.loc() };
-        }
-        return left;
-    }
-    parseImplication() {
-        const left = this.parseDisjunction();
-        if (this.match(tokens_1.TokenType.ARROW)) {
-            // Asociatividad a la derecha
-            const right = this.parseImplication();
-            return { kind: 'implies', args: [left, right], source: this.loc() };
-        }
-        return left;
-    }
-    parseDisjunction() {
-        let left = this.parseUntil();
-        let firstKind = null;
-        while (this.match(tokens_1.TokenType.OR) || this.match(tokens_1.TokenType.XOR) || this.match(tokens_1.TokenType.NOR)) {
-            const type = this.previous().type;
-            const currentKind = type === tokens_1.TokenType.OR ? 'or' : type === tokens_1.TokenType.XOR ? 'xor' : 'nor';
-            if (firstKind !== null && firstKind !== currentKind) {
-                const tok = this.previous();
-                this.diagnostics.push({
-                    severity: 'warning',
-                    message: `Mezcla de conectivos ${firstKind}/${currentKind} al mismo nivel de precedencia; asociación izquierda aplicada — usar paréntesis para desambiguar`,
-                    file: this.file,
-                    line: tok.line,
-                    column: tok.column,
-                });
-            }
-            firstKind = firstKind ?? currentKind;
-            const right = this.parseUntil();
-            left = { kind: currentKind, args: [left, right], source: this.loc() };
-        }
-        return left;
-    }
-    parseUntil() {
-        let left = this.parseConjunction();
-        while (this.match(tokens_1.TokenType.UNTIL)) {
-            const right = this.parseConjunction();
-            left = { kind: 'temporal_until', args: [left, right], source: this.loc() };
-        }
-        return left;
-    }
-    parseConjunction() {
-        let left = this.parseComparison();
-        let firstKind = null;
-        while (this.match(tokens_1.TokenType.AND) || this.match(tokens_1.TokenType.NAND)) {
-            const type = this.previous().type;
-            const currentKind = type === tokens_1.TokenType.AND ? 'and' : 'nand';
-            if (firstKind !== null && firstKind !== currentKind) {
-                const tok = this.previous();
-                this.diagnostics.push({
-                    severity: 'warning',
-                    message: `Mezcla de conectivos ${firstKind}/${currentKind} al mismo nivel de precedencia; asociación izquierda aplicada — usar paréntesis para desambiguar`,
-                    file: this.file,
-                    line: tok.line,
-                    column: tok.column,
-                });
-            }
-            firstKind = firstKind ?? currentKind;
-            const right = this.parseComparison();
-            left = { kind: currentKind, args: [left, right], source: this.loc() };
-        }
-        return left;
-    }
-    // --- Arithmetic precedence ---
-    parseComparison() {
-        let left = this.parseAdditive();
-        while (this.checkType(tokens_1.TokenType.LT) ||
-            this.checkType(tokens_1.TokenType.GT) ||
-            this.checkType(tokens_1.TokenType.LTE) ||
-            this.checkType(tokens_1.TokenType.GTE)) {
-            if (this.match(tokens_1.TokenType.LT)) {
-                const right = this.parseAdditive();
-                left = { kind: 'less', args: [left, right], source: this.loc() };
-            }
-            else if (this.match(tokens_1.TokenType.GT)) {
-                const right = this.parseAdditive();
-                left = { kind: 'greater', args: [left, right], source: this.loc() };
-            }
-            else if (this.match(tokens_1.TokenType.LTE)) {
-                const right = this.parseAdditive();
-                left = { kind: 'less_eq', args: [left, right], source: this.loc() };
-            }
-            else if (this.match(tokens_1.TokenType.GTE)) {
-                const right = this.parseAdditive();
-                left = { kind: 'greater_eq', args: [left, right], source: this.loc() };
-            }
-        }
-        return left;
-    }
-    parseAdditive() {
-        let left = this.parseMultiplicative();
-        while (this.checkType(tokens_1.TokenType.PLUS) || this.checkType(tokens_1.TokenType.MINUS)) {
-            if (this.match(tokens_1.TokenType.PLUS)) {
-                const right = this.parseMultiplicative();
-                left = { kind: 'add', args: [left, right], source: this.loc() };
-            }
-            else if (this.match(tokens_1.TokenType.MINUS)) {
-                const right = this.parseMultiplicative();
-                left = { kind: 'subtract', args: [left, right], source: this.loc() };
-            }
-        }
-        return left;
-    }
-    parseMultiplicative() {
-        let left = this.parseUnary();
-        while (this.checkType(tokens_1.TokenType.STAR) ||
-            this.checkType(tokens_1.TokenType.SLASH) ||
-            this.checkType(tokens_1.TokenType.PERCENT)) {
-            if (this.match(tokens_1.TokenType.STAR)) {
-                const right = this.parseUnary();
-                left = { kind: 'multiply', args: [left, right], source: this.loc() };
-            }
-            else if (this.match(tokens_1.TokenType.SLASH)) {
-                const right = this.parseUnary();
-                left = { kind: 'divide', args: [left, right], source: this.loc() };
-            }
-            else if (this.match(tokens_1.TokenType.PERCENT)) {
-                const right = this.parseUnary();
-                left = { kind: 'modulo', args: [left, right], source: this.loc() };
-            }
-        }
-        return left;
-    }
-    parseUnary() {
-        // Unary minus: -expr → subtract(0, expr)
-        if (this.match(tokens_1.TokenType.MINUS)) {
-            const operand = this.parseUnary();
-            return {
-                kind: 'subtract',
-                args: [{ kind: 'number', value: 0, source: this.loc() }, operand],
-                source: this.loc(),
-            };
-        }
-        if (this.match(tokens_1.TokenType.NOT)) {
-            const operand = this.parseUnary();
-            return { kind: 'not', args: [operand], source: this.loc() };
-        }
-        if (this.match(tokens_1.TokenType.BOX)) {
-            const operand = this.parseUnary();
-            return { kind: 'modal_necessity', args: [operand], source: this.loc() };
-        }
-        if (this.match(tokens_1.TokenType.DIAMOND)) {
-            const operand = this.parseUnary();
-            return { kind: 'modal_possibility', args: [operand], source: this.loc() };
-        }
-        if (this.match(tokens_1.TokenType.FORALL)) {
-            const variable = this.expectIdent();
-            const operand = this.parseUnary();
-            return { kind: 'forall', variable, args: [operand], source: this.loc() };
-        }
-        if (this.match(tokens_1.TokenType.EXISTS)) {
-            const variable = this.expectIdent();
-            const operand = this.parseUnary();
-            return { kind: 'exists', variable, args: [operand], source: this.loc() };
-        }
-        if (this.match(tokens_1.TokenType.NEXT)) {
-            const operand = this.parseUnary();
-            return { kind: 'temporal_next', args: [operand], source: this.loc() };
-        }
-        return this.parsePostfix();
-    }
-    parsePostfix() {
-        let expr = this.parsePrimary();
-        while (this.match(tokens_1.TokenType.LBRACKET)) {
-            const index = this.parseFormula();
-            this.expect(tokens_1.TokenType.RBRACKET);
-            expr = {
-                kind: 'fn_call',
-                name: 'at',
-                args: [expr, index],
-                source: expr.source ?? index.source ?? this.loc(),
-            };
-        }
-        return expr;
-    }
-    parsePrimary() {
-        // Constantes lógicas ⊤/⊥ (true/false/verdadero/falso)
-        if (this.checkType(tokens_1.TokenType.TRUE_CONST)) {
-            const tok = this.current();
-            this.advance();
-            return { kind: 'true', source: { line: tok.line, column: tok.column } };
-        }
-        if (this.checkType(tokens_1.TokenType.FALSE_CONST)) {
-            const tok = this.current();
-            this.advance();
-            return { kind: 'false', source: { line: tok.line, column: tok.column } };
-        }
-        // Literal numérico
-        if (this.checkType(tokens_1.TokenType.NUMBER)) {
-            const tok = this.current();
-            this.advance();
-            return {
-                kind: 'number',
-                value: parseFloat(tok.value),
-                source: { line: tok.line, column: tok.column },
-            };
-        }
-        if (this.match(tokens_1.TokenType.LBRACKET)) {
-            const items = [];
-            if (!this.checkType(tokens_1.TokenType.RBRACKET)) {
-                items.push(this.parseFormula());
-                while (this.match(tokens_1.TokenType.COMMA)) {
-                    items.push(this.parseFormula());
-                }
-            }
-            this.expect(tokens_1.TokenType.RBRACKET);
-            return {
-                kind: 'list',
-                args: items,
-                source: this.loc(),
-            };
-        }
-        // Literal de texto (String)
-        if (this.checkType(tokens_1.TokenType.STRING)) {
-            const tok = this.current();
-            this.advance();
-            // Lo representamos como un átomo especial o un nuevo kind.
-            // Por simplicidad para el motor lógico, lo tratamos como un átomo cuyo nombre es el valor del string entre comillas.
-            return {
-                kind: 'atom',
-                name: `"${tok.value}"`,
-                source: { line: tok.line, column: tok.column },
-            };
-        }
-        // Paréntesis
-        if (this.match(tokens_1.TokenType.LPAREN)) {
-            const inner = this.parseFormula();
-            this.expect(tokens_1.TokenType.RPAREN);
-            return inner;
-        }
-        // Dot notation con keyword como prefijo: Logic.mp, Theory.axiom, etc.
-        // Si el token actual es una keyword seguida de DOT + IDENTIFIER, tratarlo como nombre calificado
-        if (this.checkType(tokens_1.TokenType.DOT) === false &&
-            this.current().type !== tokens_1.TokenType.IDENTIFIER &&
-            this.current().type !== tokens_1.TokenType.NEWLINE &&
-            this.current().type !== tokens_1.TokenType.EOF &&
-            this.peek(1) === tokens_1.TokenType.DOT &&
-            this.peek(2) === tokens_1.TokenType.IDENTIFIER) {
-            const tok = this.current();
-            this.advance(); // consumir keyword
-            this.advance(); // consumir DOT
-            const memberTok = this.current();
-            this.advance(); // consumir IDENTIFIER
-            return {
-                kind: 'atom',
-                name: `${tok.value}.${memberTok.value}`,
-                source: { line: tok.line, column: tok.column },
-            };
-        }
-        // Predicado o Atomo proposicional
-        if (this.checkType(tokens_1.TokenType.IDENTIFIER)) {
-            const tok = this.current();
-            this.advance();
-            // Notación con punto: Theory.member (acceso calificado)
-            if (this.checkType(tokens_1.TokenType.DOT) && this.peek(1) === tokens_1.TokenType.IDENTIFIER) {
-                this.advance(); // consumir DOT
-                const memberTok = this.current();
-                this.advance(); // consumir IDENTIFIER
-                // Nombre calificado: "Theory.member"
-                return {
-                    kind: 'atom',
-                    name: `${tok.value}.${memberTok.value}`,
-                    source: { line: tok.line, column: tok.column },
-                };
-            }
-            if (this.match(tokens_1.TokenType.LPAREN)) {
-                // Modal alias check: e.g. K(P) in epistemic, O(P) in deontic
-                const profileAliases = MODAL_ALIASES[this.currentProfile];
-                const aliasType = profileAliases?.[tok.value];
-                if (aliasType) {
-                    const inner = this.parseFormula();
-                    this.expect(tokens_1.TokenType.RPAREN);
-                    if (aliasType === 'box') {
-                        return {
-                            kind: 'modal_necessity',
-                            args: [inner],
-                            source: { line: tok.line, column: tok.column },
-                        };
-                    }
-                    else if (aliasType === 'diamond') {
-                        return {
-                            kind: 'modal_possibility',
-                            args: [inner],
-                            source: { line: tok.line, column: tok.column },
-                        };
-                    }
-                    else {
-                        // box_not: e.g. deontic F(φ) = □(¬φ)
-                        return {
-                            kind: 'modal_necessity',
-                            args: [
-                                { kind: 'not', args: [inner], source: { line: tok.line, column: tok.column } },
-                            ],
-                            source: { line: tok.line, column: tok.column },
-                        };
-                    }
-                }
-                // Podría ser un predicado P(x, y) o una llamada a función fn(arg1, arg2)
-                if (this.knownFunctionNames.has(tok.value) || this.knownTheoryNames.has(tok.value)) {
-                    const args = [];
-                    if (!this.checkType(tokens_1.TokenType.RPAREN)) {
-                        args.push(this.parseFormula());
-                        while (this.match(tokens_1.TokenType.COMMA)) {
-                            args.push(this.parseFormula());
-                        }
-                    }
-                    this.expect(tokens_1.TokenType.RPAREN);
-                    return {
-                        kind: 'fn_call',
-                        name: tok.value,
-                        args,
-                        source: { line: tok.line, column: tok.column },
-                    };
-                }
-                // Predicado: P(x, y, ...)
-                const args = [];
-                if (!this.checkType(tokens_1.TokenType.RPAREN)) {
-                    args.push(this.parseFormula());
-                    while (this.match(tokens_1.TokenType.COMMA)) {
-                        args.push(this.parseFormula());
-                    }
-                }
-                this.expect(tokens_1.TokenType.RPAREN);
-                const paramStrings = args.map((a) => this.formulaToString(a));
-                const predFormula = {
-                    kind: 'predicate',
-                    name: tok.value,
-                    params: paramStrings,
-                    source: { line: tok.line, column: tok.column },
-                };
-                // FOL igualdad: P(x) = Q(y) (raro pero posible)
-                if (this.checkType(tokens_1.TokenType.EQUALS)) {
-                    this.advance();
-                    const right = this.parsePrimary();
-                    return {
-                        kind: 'equals',
-                        args: [predFormula, right],
-                        source: { line: tok.line, column: tok.column },
-                    };
-                }
-                return predFormula;
-            }
-            // FOL igualdad: x = y (identidad entre términos)
-            if (this.checkType(tokens_1.TokenType.EQUALS)) {
-                this.advance();
-                const rightTok = this.current();
-                if (this.checkType(tokens_1.TokenType.IDENTIFIER)) {
-                    this.advance();
-                    const left = {
-                        kind: 'atom',
-                        name: tok.value,
-                        source: { line: tok.line, column: tok.column },
-                    };
-                    const right = {
-                        kind: 'atom',
-                        name: rightTok.value,
-                        source: { line: rightTok.line, column: rightTok.column },
-                    };
-                    return {
-                        kind: 'equals',
-                        args: [left, right],
-                        source: { line: tok.line, column: tok.column },
-                    };
-                }
-                // Si no es un identificador, backtrack — el = pertenece al statement
-                this.pos--;
-            }
-            return { kind: 'atom', name: tok.value, source: { line: tok.line, column: tok.column } };
-        }
-        throw new Error(`Se esperaba formula en linea ${this.current().line}, columna ${this.current().column}, ` +
-            `encontrado: '${this.current().value}' (${this.current().type})`);
-    }
-    // --- Helpers ---
-    parseIdList() {
-        this.expect(tokens_1.TokenType.LBRACE);
-        const ids = [];
-        if (!this.checkType(tokens_1.TokenType.RBRACE)) {
-            ids.push(this.expectIdent());
-            while (this.match(tokens_1.TokenType.COMMA)) {
-                ids.push(this.expectIdent());
-            }
-        }
-        this.expect(tokens_1.TokenType.RBRACE);
-        return ids;
-    }
-    collectAssociativeArgs(f, kind) {
-        if (f.kind !== kind || !f.args?.length)
-            return [f];
-        const items = [];
-        for (const arg of f.args) {
-            if (!arg)
-                continue;
-            items.push(...this.collectAssociativeArgs(arg, kind));
-        }
-        return items;
-    }
-    formulaToString(f) {
-        const arg0 = f.args?.[0];
-        const arg1 = f.args?.[1];
-        switch (f.kind) {
-            case 'atom':
-                return f.name || '?';
-            case 'list':
-                return `[${(f.args ?? []).map((a) => this.formulaToString(a)).join(', ')}]`;
-            case 'number':
-                return f.value !== undefined ? String(f.value) : '?';
-            case 'not':
-                return arg0 ? `!${this.formulaToString(arg0)}` : '!?';
-            case 'modal_necessity':
-                return arg0 ? `[]${this.formulaToString(arg0)}` : '[]?';
-            case 'modal_possibility':
-                return arg0 ? `<>${this.formulaToString(arg0)}` : '<>?';
-            case 'forall':
-                return arg0
-                    ? `forall ${f.variable} ${this.formulaToString(arg0)}`
-                    : `forall ${f.variable} ?`;
-            case 'exists':
-                return arg0
-                    ? `exists ${f.variable} ${this.formulaToString(arg0)}`
-                    : `exists ${f.variable} ?`;
-            case 'predicate': {
-                const params = f.params || [];
-                return `${f.name || '?'}(${params.join(', ')})`;
-            }
-            case 'and':
-                return arg0 && arg1
-                    ? `(${this.collectAssociativeArgs(f, 'and')
-                        .map((a) => this.formulaToString(a))
-                        .join(' & ')})`
-                    : '(? & ?)';
-            case 'or':
-                return arg0 && arg1
-                    ? `(${this.collectAssociativeArgs(f, 'or')
-                        .map((a) => this.formulaToString(a))
-                        .join(' | ')})`
-                    : '(? | ?)';
-            case 'nand':
-                return arg0 && arg1
-                    ? `(${this.formulaToString(arg0)} ↑ ${this.formulaToString(arg1)})`
-                    : '(? ↑ ?)';
-            case 'nor':
-                return arg0 && arg1
-                    ? `(${this.formulaToString(arg0)} ↓ ${this.formulaToString(arg1)})`
-                    : '(? ↓ ?)';
-            case 'xor':
-                return arg0 && arg1
-                    ? `(${this.collectAssociativeArgs(f, 'xor')
-                        .map((a) => this.formulaToString(a))
-                        .join(' ⊕ ')})`
-                    : '(? ⊕ ?)';
-            case 'implies':
-                return arg0 && arg1
-                    ? `(${this.formulaToString(arg0)} -> ${this.formulaToString(arg1)})`
-                    : '(? -> ?)';
-            case 'biconditional':
-                return arg0 && arg1
-                    ? `(${this.formulaToString(arg0)} <-> ${this.formulaToString(arg1)})`
-                    : '(? <-> ?)';
-            case 'equals':
-                return arg0 && arg1
-                    ? `(${this.formulaToString(arg0)} = ${this.formulaToString(arg1)})`
-                    : '(? = ?)';
-            case 'temporal_next':
-                return arg0 ? `X(${this.formulaToString(arg0)})` : 'X(?)';
-            case 'temporal_until':
-                return arg0 && arg1
-                    ? `(${this.formulaToString(arg0)} U ${this.formulaToString(arg1)})`
-                    : '(? U ?)';
-            case 'fn_call':
-                return `${f.name || '?'}(${(f.args ?? []).map((a) => this.formulaToString(a)).join(', ')})`;
-            default:
-                return '?';
-        }
-    }
-    current() {
-        if (this.pos >= this.tokens.length) {
-            return { type: tokens_1.TokenType.EOF, value: '', line: 0, column: 0 };
-        }
-        return this.tokens[this.pos];
-    }
-    previous() {
-        if (this.pos === 0)
-            return this.tokens[0];
-        return this.tokens[this.pos - 1];
-    }
-    peek(offset) {
-        const idx = this.pos + offset;
-        if (idx >= this.tokens.length)
-            return tokens_1.TokenType.EOF;
-        return this.tokens[idx].type;
-    }
-    advance() {
-        const tok = this.current();
-        this.pos++;
-        return tok;
-    }
-    isAtEnd() {
-        return this.current().type === tokens_1.TokenType.EOF;
-    }
-    checkType(type) {
-        return this.current().type === type;
-    }
-    match(type) {
-        if (this.checkType(type)) {
-            this.advance();
-            return true;
-        }
-        return false;
-    }
-    expect(type) {
-        if (this.checkType(type)) {
-            return this.advance();
-        }
-        throw new Error(this.contextualize(`Se esperaba ${type}, encontrado '${this.current().value}' (${this.current().type}) ` +
-            `en linea ${this.current().line}, columna ${this.current().column}`));
-    }
-    expectOneOf(...types) {
-        for (const type of types) {
-            if (this.checkType(type)) {
-                return this.advance();
-            }
-        }
-        throw new Error(this.contextualize(`Se esperaba ${types.join(' o ')}, encontrado '${this.current().value}' (${this.current().type}) ` +
-            `en linea ${this.current().line}, columna ${this.current().column}`));
-    }
-    expectIdent() {
-        const tok = this.expect(tokens_1.TokenType.IDENTIFIER);
-        return tok.value;
-    }
-    /**
-     * Acepta un IDENTIFIER o cualquier keyword como nombre
-     * (para soportar nombres como "Logic", "Theory", etc. que colisionan con keywords)
-     */
-    expectName() {
-        const tok = this.current();
-        if (tok.type === tokens_1.TokenType.IDENTIFIER) {
-            this.advance();
-            return tok.value;
-        }
-        // Aceptar cualquier keyword como nombre en contextos de nombre
-        if (tok.type !== tokens_1.TokenType.NEWLINE &&
-            tok.type !== tokens_1.TokenType.EOF &&
-            tok.type !== tokens_1.TokenType.LPAREN &&
-            tok.type !== tokens_1.TokenType.RPAREN &&
-            tok.type !== tokens_1.TokenType.LBRACE &&
-            tok.type !== tokens_1.TokenType.RBRACE &&
-            tok.type !== tokens_1.TokenType.COLON &&
-            tok.type !== tokens_1.TokenType.EQUALS &&
-            tok.type !== tokens_1.TokenType.ARROW &&
-            tok.type !== tokens_1.TokenType.AND &&
-            tok.type !== tokens_1.TokenType.OR &&
-            tok.type !== tokens_1.TokenType.NOT &&
-            tok.type !== tokens_1.TokenType.DOT &&
-            tok.type !== tokens_1.TokenType.COMMA &&
-            tok.type !== tokens_1.TokenType.STRING &&
-            tok.type !== tokens_1.TokenType.NUMBER) {
-            this.advance();
-            return tok.value;
-        }
-        throw new Error(this.contextualize(`Se esperaba nombre/identificador, encontrado '${tok.value}' (${tok.type}) ` +
-            `en linea ${tok.line}, columna ${tok.column}`));
-    }
-    contextualize(message) {
-        if (this.contextStack.length === 0)
-            return message;
-        return `${message} mientras se parseaba ${this.contextStack.join(' > ')}`;
-    }
-    withContext(context, fn) {
-        this.contextStack.push(context);
-        try {
-            return fn();
-        }
-        finally {
-            this.contextStack.pop();
-        }
+        return (0, formulas_1.parseFormula)(this.state);
     }
+    // --- Helpers de diagnostico/descripcion ---
     describeStatementContext(tok) {
         switch (tok.type) {
             case tokens_1.TokenType.LOGIC:
@@ -1629,17 +1011,8 @@ class Parser {
                 return `statement '${tok.value}'`;
         }
     }
-    loc() {
-        const tok = this.current();
-        return { line: tok.line, column: tok.column, file: this.file };
-    }
-    skipNewlines() {
-        while (this.checkType(tokens_1.TokenType.NEWLINE)) {
-            this.advance();
-        }
-    }
     advanceToNextStatement() {
-        // Avanza hasta encontrar un newline o un token que inicie un statement
+        const s = this.state;
         const statementStarters = new Set([
             tokens_1.TokenType.LOGIC,
             tokens_1.TokenType.AXIOM,
@@ -1682,35 +1055,35 @@ class Parser {
         let parenDepth = 0;
         let braceDepth = 0;
         let bracketDepth = 0;
-        while (!this.isAtEnd()) {
-            if (this.checkType(tokens_1.TokenType.NEWLINE) &&
+        while (!s.isAtEnd()) {
+            if (s.checkType(tokens_1.TokenType.NEWLINE) &&
                 parenDepth === 0 &&
                 braceDepth === 0 &&
                 bracketDepth === 0) {
-                this.skipNewlines();
+                s.skipNewlines();
                 return;
             }
             if (parenDepth === 0 &&
                 braceDepth === 0 &&
                 bracketDepth === 0 &&
-                statementStarters.has(this.current().type)) {
-                return; // Encontramos el inicio del siguiente statement
+                statementStarters.has(s.current().type)) {
+                return;
             }
-            if (this.checkType(tokens_1.TokenType.LPAREN))
+            if (s.checkType(tokens_1.TokenType.LPAREN))
                 parenDepth += 1;
-            else if (this.checkType(tokens_1.TokenType.RPAREN))
+            else if (s.checkType(tokens_1.TokenType.RPAREN))
                 parenDepth = Math.max(0, parenDepth - 1);
-            else if (this.checkType(tokens_1.TokenType.LBRACE))
+            else if (s.checkType(tokens_1.TokenType.LBRACE))
                 braceDepth += 1;
-            else if (this.checkType(tokens_1.TokenType.RBRACE))
+            else if (s.checkType(tokens_1.TokenType.RBRACE))
                 braceDepth = Math.max(0, braceDepth - 1);
-            else if (this.checkType(tokens_1.TokenType.LBRACKET) || this.checkType(tokens_1.TokenType.LBRACKET_DOUBLE)) {
+            else if (s.checkType(tokens_1.TokenType.LBRACKET) || s.checkType(tokens_1.TokenType.LBRACKET_DOUBLE)) {
                 bracketDepth += 1;
             }
-            else if (this.checkType(tokens_1.TokenType.RBRACKET) || this.checkType(tokens_1.TokenType.RBRACKET_DOUBLE)) {
+            else if (s.checkType(tokens_1.TokenType.RBRACKET) || s.checkType(tokens_1.TokenType.RBRACKET_DOUBLE)) {
                 bracketDepth = Math.max(0, bracketDepth - 1);
             }
-            this.advance();
+            s.advance();
         }
     }
 }