@stevenvo780/st-lang 2.8.0 → 3.0.1

package/dist/tests/v3-stress.test.js

@@ -0,0 +1,755 @@
+"use strict";
+// ============================================================
+// Tests v3 Stress — Cross-profile, combinatorial, edge cases
+// Validates v3 features (define, unfold, fold, source,
+// interpret, glossary, render) across ALL 11 logic profiles
+// and under syntactic stress.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const interpreter_1 = require("../runtime/interpreter");
+// ── Helpers ──────────────────────────────────────────────────
+function run(source) {
+    const interp = new interpreter_1.Interpreter();
+    return interp.execute(source);
+}
+function runOk(source) {
+    const out = run(source);
+    if (out.exitCode !== 0) {
+        const errs = out.diagnostics
+            .filter((d) => d.severity === 'error')
+            .map((d) => `L${d.line}: ${d.message}`)
+            .join('\n');
+        throw new Error(`exitCode=${out.exitCode}\n${errs}\nstdout:\n${out.stdout}`);
+    }
+    return out;
+}
+// ── All profiles ─────────────────────────────────────────────
+const ALL_PROFILES = [
+    'classical.propositional',
+    'classical.first_order',
+    'modal.k',
+    'paraconsistent.belnap',
+    'deontic.standard',
+    'epistemic.s5',
+    'aristotelian.syllogistic',
+    'intuitionistic.propositional',
+    'temporal.ltl',
+    'probabilistic.basic',
+    'arithmetic',
+];
+// Profiles that support standard propositional operators (P -> Q)
+const PROPOSITIONAL_PROFILES = [
+    'classical.propositional',
+    'classical.first_order',
+    'modal.k',
+    'paraconsistent.belnap',
+    'deontic.standard',
+    'epistemic.s5',
+    'intuitionistic.propositional',
+    'temporal.ltl',
+    'probabilistic.basic',
+];
+// ============================================================
+// 1. define — across ALL profiles
+// ============================================================
+(0, vitest_1.describe)('v3 cross-profile: define + glossary', () => {
+    for (const profile of ALL_PROFILES) {
+        (0, vitest_1.it)(`define + glossary works in ${profile}`, () => {
+            const formula = profile === 'arithmetic' ? '2 + 3' : 'P -> Q';
+            const out = runOk(`logic ${profile}\ndefine D := ${formula}\nglossary`);
+            (0, vitest_1.expect)(out.stdout).toContain('Define');
+            (0, vitest_1.expect)(out.stdout).toContain('GLOSARIO');
+            (0, vitest_1.expect)(out.stdout).toContain('D');
+        });
+    }
+    for (const profile of ALL_PROFILES) {
+        (0, vitest_1.it)(`define with description works in ${profile}`, () => {
+            const formula = profile === 'arithmetic' ? '2 + 3' : 'P -> Q';
+            const out = runOk(`logic ${profile}\ndefine D := ${formula}\ndescription "test desc"\nglossary`);
+            (0, vitest_1.expect)(out.stdout).toContain('test desc');
+        });
+    }
+});
+// ============================================================
+// 2. define with params — propositional profiles
+// ============================================================
+(0, vitest_1.describe)('v3 cross-profile: parametric define', () => {
+    for (const profile of PROPOSITIONAL_PROFILES) {
+        (0, vitest_1.it)(`parametric define Impl(x,y) := x -> y in ${profile}`, () => {
+            const out = runOk(`logic ${profile}\ndefine Impl(x, y) := x -> y\nunfold Impl(P, Q)`);
+            (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+        });
+    }
+});
+// ============================================================
+// 3. define expansion in check valid — all profiles that
+//    recognize P -> P as valid
+// ============================================================
+(0, vitest_1.describe)('v3 cross-profile: define expansion in check valid', () => {
+    // P -> P is valid in classical, modal, deontic, epistemic, intuitionistic, temporal, probabilistic
+    const validProfiles = [
+        'classical.propositional',
+        'classical.first_order',
+        'modal.k',
+        'deontic.standard',
+        'epistemic.s5',
+        'intuitionistic.propositional',
+        'temporal.ltl',
+        'probabilistic.basic',
+    ];
+    for (const profile of validProfiles) {
+        (0, vitest_1.it)(`define T := P -> P; check valid T → valid in ${profile}`, () => {
+            const out = runOk(`logic ${profile}\ndefine T := P -> P\ncheck valid T`);
+            (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+        });
+    }
+    // Belnap: P -> P is NOT valid (4-valued logic)
+    (0, vitest_1.it)('define T := P -> P; check valid T → invalid in paraconsistent.belnap', () => {
+        const out = runOk('logic paraconsistent.belnap\ndefine T := P -> P\ncheck valid T');
+        (0, vitest_1.expect)(out.results[0].status).toBe('invalid');
+    });
+    // Arithmetic uses different expressions
+    (0, vitest_1.it)('define Sum := 2 + 3; check valid (Sum > 0) in arithmetic', () => {
+        const out = runOk('logic arithmetic\ndefine Sum := 2 + 3\ncheck valid (Sum > 0)');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+});
+// ============================================================
+// 4. define expansion in derive — across profiles
+// ============================================================
+(0, vitest_1.describe)('v3 cross-profile: define expansion in derive', () => {
+    const deriveProfiles = [
+        'classical.propositional',
+        'classical.first_order',
+        'modal.k',
+        'deontic.standard',
+        'epistemic.s5',
+        'intuitionistic.propositional',
+        'temporal.ltl',
+        'probabilistic.basic',
+    ];
+    for (const profile of deriveProfiles) {
+        (0, vitest_1.it)(`derive with defined axiom in ${profile}`, () => {
+            const out = runOk(`logic ${profile}\n` +
+                'define IMP := P -> Q\n' +
+                'axiom A1 : IMP\n' +
+                'axiom A2 : P\n' +
+                'derive Q from {A1, A2}');
+            // Some profiles return 'provable', others 'valid'
+            (0, vitest_1.expect)(['provable', 'valid']).toContain(out.results[0].status);
+        });
+    }
+});
+// ============================================================
+// 5. unfold / fold — cross-profile
+// ============================================================
+(0, vitest_1.describe)('v3 cross-profile: unfold + fold', () => {
+    for (const profile of PROPOSITIONAL_PROFILES) {
+        (0, vitest_1.it)(`unfold D then fold back in ${profile}`, () => {
+            const out = runOk(`logic ${profile}\ndefine D := P & Q\nunfold D\nfold (P & Q)`);
+            (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+            (0, vitest_1.expect)(out.stdout).toContain('Fold');
+            // fold should find definition name D
+            (0, vitest_1.expect)(out.stdout).toMatch(/Fold:.*D/);
+        });
+    }
+    (0, vitest_1.it)('unfold works in arithmetic', () => {
+        const out = runOk('logic arithmetic\ndefine S := 2 + 3\nunfold S');
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+    });
+});
+// ============================================================
+// 6. source — cross-profile
+// ============================================================
+(0, vitest_1.describe)('v3 cross-profile: source', () => {
+    for (const profile of ALL_PROFILES) {
+        (0, vitest_1.it)(`source declaration works in ${profile}`, () => {
+            const out = runOk(`logic ${profile}\n` +
+                'source Frege {\n' +
+                '  author "Gottlob Frege"\n' +
+                '  work "Begriffsschrift"\n' +
+                '  year 1879\n' +
+                '}\n' +
+                'glossary');
+            (0, vitest_1.expect)(out.stdout).toContain('Frege');
+            (0, vitest_1.expect)(out.stdout).toContain('Fuentes');
+        });
+    }
+});
+// ============================================================
+// 7. interpret — cross-profile
+// ============================================================
+(0, vitest_1.describe)('v3 cross-profile: interpret', () => {
+    for (const profile of PROPOSITIONAL_PROFILES) {
+        (0, vitest_1.it)(`interpret creates binding in ${profile}`, () => {
+            const out = runOk(`logic ${profile}\n` + 'interpret "premise" as P -> Q\n' + 'glossary');
+            (0, vitest_1.expect)(out.stdout).toContain('Interpret');
+            (0, vitest_1.expect)(out.stdout).toContain('Interpretaciones');
+        });
+    }
+});
+// ============================================================
+// 8. render glossary + analysis — cross-profile
+// ============================================================
+(0, vitest_1.describe)('v3 cross-profile: render glossary', () => {
+    const formats = ['markdown', 'json', 'latex'];
+    for (const format of formats) {
+        (0, vitest_1.it)(`render glossary as ${format} works with propositional`, () => {
+            const out = runOk('logic classical.propositional\n' + 'define D := P -> Q\n' + `render glossary as ${format}`);
+            (0, vitest_1.expect)(out.exitCode).toBe(0);
+            if (format === 'markdown')
+                (0, vitest_1.expect)(out.stdout).toContain('**D**');
+            if (format === 'json')
+                (0, vitest_1.expect)(out.stdout).toContain('"D"');
+            if (format === 'latex')
+                (0, vitest_1.expect)(out.stdout).toContain('\\newcommand');
+        });
+    }
+});
+(0, vitest_1.describe)('v3 cross-profile: render analysis', () => {
+    for (const profile of PROPOSITIONAL_PROFILES) {
+        (0, vitest_1.it)(`render analysis in ${profile}`, () => {
+            const out = runOk(`logic ${profile}\n` +
+                'define D := P -> Q\n' +
+                'axiom A1 : P -> Q\n' +
+                'render analysis as markdown');
+            (0, vitest_1.expect)(out.stdout).toContain('Análisis');
+            (0, vitest_1.expect)(out.stdout).toContain('Definiciones');
+            (0, vitest_1.expect)(out.stdout).toContain('Axiomas');
+        });
+    }
+});
+// ============================================================
+// 9. Profile-specific operators inside define
+// ============================================================
+(0, vitest_1.describe)('v3 profile-specific operators in define', () => {
+    // Modal: box/diamond
+    (0, vitest_1.it)('modal.k: define with []P (necessity)', () => {
+        const out = runOk('logic modal.k\ndefine NecP := []P\nunfold NecP');
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+    });
+    (0, vitest_1.it)('modal.k: define with <>P (possibility)', () => {
+        const out = runOk('logic modal.k\ndefine PosP := <>P\nunfold PosP');
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+    });
+    // Deontic: O(...), P(...)
+    (0, vitest_1.it)('deontic.standard: define with O(P) (obligation)', () => {
+        const out = runOk('logic deontic.standard\ndefine Obligatorio := O(P)\nunfold Obligatorio');
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+    });
+    // Epistemic: K(...)
+    (0, vitest_1.it)('epistemic.s5: define with K(P) (knowledge)', () => {
+        const out = runOk('logic epistemic.s5\ndefine Sabe := K(P)\nunfold Sabe');
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+    });
+    // Epistemic: K(P) -> P is valid in S5
+    (0, vitest_1.it)('epistemic.s5: define K(P) -> P is valid (veridicality)', () => {
+        const out = runOk('logic epistemic.s5\ndefine Veridical := K(P) -> P\ncheck valid Veridical');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+    // Temporal: X(...), U(...)
+    (0, vitest_1.it)('temporal.ltl: define with X(P) (next)', () => {
+        const out = runOk('logic temporal.ltl\ndefine NextP := X(P)\nunfold NextP');
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+    });
+    // FOL: predicates and quantifiers
+    (0, vitest_1.it)('classical.first_order: define with predicate', () => {
+        const out = runOk('logic classical.first_order\ndefine Human := P(x) -> Q(x)\nunfold Human');
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+    });
+    (0, vitest_1.it)('classical.first_order: define + check valid (forall tautology)', () => {
+        const out = runOk('logic classical.first_order\n' + 'define T := forall x (P(x) -> P(x))\n' + 'check valid T');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+    // Arithmetic: numeric operations
+    (0, vitest_1.it)('arithmetic: define numeric expression + check valid', () => {
+        const out = runOk('logic arithmetic\ndefine Expr := (2 + 3) * 2\ncheck valid (Expr > 5)');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+    // Paraconsistent: both values
+    (0, vitest_1.it)('paraconsistent.belnap: define + check satisfiable', () => {
+        const out = runOk('logic paraconsistent.belnap\ndefine Conj := P & Q\ncheck satisfiable Conj');
+        (0, vitest_1.expect)(out.results[0].status).toBe('satisfiable');
+    });
+    // Intuitionistic: specific behaviors
+    (0, vitest_1.it)('intuitionistic: define DNE (double negation elimination) is NOT valid', () => {
+        const out = runOk('logic intuitionistic.propositional\ndefine DNE := !!P -> P\ncheck valid DNE');
+        // DNE is NOT valid in intuitionistic logic
+        (0, vitest_1.expect)(out.results[0].status).toBe('invalid');
+    });
+    (0, vitest_1.it)('intuitionistic: define (P -> P) IS valid', () => {
+        const out = runOk('logic intuitionistic.propositional\ndefine Id := P -> P\ncheck valid Id');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+    // Aristotelian: syllogistic only supports its own formula types
+    (0, vitest_1.it)('aristotelian.syllogistic: define + glossary', () => {
+        const out = runOk('logic aristotelian.syllogistic\n' +
+            'define Regla := P -> Q\n' +
+            'description "Una regla"\n' +
+            'glossary');
+        (0, vitest_1.expect)(out.stdout).toContain('GLOSARIO');
+        (0, vitest_1.expect)(out.stdout).toContain('Regla');
+    });
+    // Probabilistic
+    (0, vitest_1.it)('probabilistic.basic: define + check valid', () => {
+        const out = runOk('logic probabilistic.basic\ndefine Id := P -> P\ncheck valid Id');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+});
+// ============================================================
+// 10. Combination stress: define + source + interpret + all
+// ============================================================
+(0, vitest_1.describe)('v3 full workflow stress — per profile', () => {
+    for (const profile of PROPOSITIONAL_PROFILES) {
+        (0, vitest_1.it)(`full workflow (define+source+interpret+unfold+fold+glossary+render) in ${profile}`, () => {
+            const out = runOk(`logic ${profile}\n` +
+                'source Author {\n' +
+                '  author "Test Author"\n' +
+                '  work "Test Work"\n' +
+                '  year 2025\n' +
+                '}\n' +
+                'define D := P -> Q\n' +
+                'description "Test definition"\n' +
+                'interpret "premise" as P -> Q\n' +
+                'unfold D\n' +
+                'fold (P -> Q)\n' +
+                'glossary\n' +
+                'render glossary as markdown\n' +
+                'render analysis as markdown');
+            (0, vitest_1.expect)(out.stdout).toContain('Source');
+            (0, vitest_1.expect)(out.stdout).toContain('Define');
+            (0, vitest_1.expect)(out.stdout).toContain('Interpret');
+            (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+            (0, vitest_1.expect)(out.stdout).toContain('Fold');
+            (0, vitest_1.expect)(out.stdout).toContain('GLOSARIO');
+            (0, vitest_1.expect)(out.stdout).toContain('**D**');
+            (0, vitest_1.expect)(out.stdout).toContain('Análisis');
+        });
+    }
+});
+// ============================================================
+// 11. Syntactic stress — edge cases, malformed input, limits
+// ============================================================
+(0, vitest_1.describe)('v3 syntactic stress', () => {
+    // Many definitions at once
+    (0, vitest_1.it)('50 chained definitions without error', () => {
+        const defs = Array.from({ length: 50 }, (_, i) => `define D${i} := ${i > 0 ? `D${i - 1} -> P${i}` : 'P0'}`).join('\n');
+        const out = runOk(`logic classical.propositional\n${defs}\nglossary`);
+        (0, vitest_1.expect)(out.stdout).toContain('D49');
+        (0, vitest_1.expect)(out.stdout).toContain('GLOSARIO');
+    });
+    // Many sources
+    (0, vitest_1.it)('20 source declarations without error', () => {
+        const sources = Array.from({ length: 20 }, (_, i) => `source S${i} {\n  author "Author${i}"\n  work "Work${i}"\n  year ${1900 + i}\n}`).join('\n');
+        const out = runOk(`logic classical.propositional\n${sources}\nglossary`);
+        (0, vitest_1.expect)(out.stdout).toContain('S19');
+        (0, vitest_1.expect)(out.stdout).toContain('Fuentes');
+    });
+    // Many interpretations
+    (0, vitest_1.it)('20 interpret commands without error', () => {
+        const interps = Array.from({ length: 20 }, (_, i) => `interpret "text${i}" as P${i}`).join('\n');
+        const out = runOk(`logic classical.propositional\n${interps}\nglossary`);
+        (0, vitest_1.expect)(out.stdout).toContain('Interpretaciones');
+        (0, vitest_1.expect)(out.stdout).toContain('text19');
+    });
+    // Deeply nested definition body
+    (0, vitest_1.it)('define with deeply nested formula (10 levels of implication)', () => {
+        // P -> (P -> (P -> ... ))
+        let formula = 'P';
+        for (let i = 0; i < 10; i++)
+            formula = `(${formula} -> P)`;
+        const out = runOk(`logic classical.propositional\ndefine Deep := ${formula}`);
+        (0, vitest_1.expect)(out.stdout).toContain('Define');
+        (0, vitest_1.expect)(out.stdout).toContain('Deep');
+    });
+    // Parametric define with many params
+    (0, vitest_1.it)('define with 5 params', () => {
+        const out = runOk('logic classical.propositional\ndefine F(a, b, c, d, e) := a -> b -> c -> d -> e');
+        (0, vitest_1.expect)(out.stdout).toContain('F(a, b, c, d, e)');
+    });
+    // Empty source block
+    (0, vitest_1.it)('source with no fields parses OK', () => {
+        const out = runOk('logic classical.propositional\nsource Empty {\n}\nglossary');
+        (0, vitest_1.expect)(out.stdout).toContain('Fuentes');
+    });
+    // Source redefinition warning
+    (0, vitest_1.it)('source redefinition produces warning', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'source S1 {\n  author "A"\n}\n' +
+            'source S1 {\n  author "B"\n}\n' +
+            'glossary');
+        // Should succeed but with a warning diagnostic
+        const warnings = out.diagnostics.filter((d) => d.severity === 'warning');
+        (0, vitest_1.expect)(warnings.length).toBeGreaterThan(0);
+    });
+    // Define overwrite
+    (0, vitest_1.it)('redefining same name replaces the definition', () => {
+        const out = runOk('logic classical.propositional\ndefine D := P\ndefine D := Q\nglossary');
+        // Glossary should show Q, not P
+        (0, vitest_1.expect)(out.stdout).toContain('Q');
+    });
+    // Circular: direct
+    (0, vitest_1.it)('circular define (direct) is rejected', () => {
+        const out = run('logic classical.propositional\ndefine Loop := Loop');
+        (0, vitest_1.expect)(out.exitCode).not.toBe(0);
+    });
+    // Circular: indirect depth 2
+    (0, vitest_1.it)('circular define (indirect depth 2) is rejected', () => {
+        const out = run('logic classical.propositional\ndefine A := B\ndefine B := A');
+        (0, vitest_1.expect)(out.exitCode).not.toBe(0);
+    });
+    // Circular: indirect depth 3
+    (0, vitest_1.it)('circular define (indirect depth 3) is rejected', () => {
+        const out = run('logic classical.propositional\ndefine A := B\ndefine B := C\ndefine C := A');
+        (0, vitest_1.expect)(out.exitCode).not.toBe(0);
+    });
+    // Unfold on undefined name
+    (0, vitest_1.it)('unfold on undefined name does not crash', () => {
+        const out = runOk('logic classical.propositional\nunfold Unknown');
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+    });
+    // Fold on formula matching no definition
+    (0, vitest_1.it)('fold on non-matching formula returns as-is', () => {
+        const out = runOk('logic classical.propositional\nfold (P -> Q)');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+    // Define inside theory block
+    (0, vitest_1.it)('define inside theory block works', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'theory T {\n' +
+            '  define D := P -> Q\n' +
+            '  axiom A1 : D\n' +
+            '}');
+        (0, vitest_1.expect)(out.exitCode).toBe(0);
+    });
+    // Multiple theory blocks with their own defines
+    (0, vitest_1.it)('separate theory blocks each have own defines', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'theory T1 {\n' +
+            '  define D := P\n' +
+            '  axiom A1 : D\n' +
+            '}\n' +
+            'theory T2 {\n' +
+            '  define D := Q\n' +
+            '  axiom A1 : D\n' +
+            '}');
+        (0, vitest_1.expect)(out.exitCode).toBe(0);
+    });
+    // Spanish aliases mixed with English
+    (0, vitest_1.it)('mix of Spanish and English keywords', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'definir D := P -> Q\n' +
+            'description "desc"\n' +
+            'fuente S {\n' +
+            '  author "Autor"\n' +
+            '  work "Obra"\n' +
+            '}\n' +
+            'interpretar "texto" as P\n' +
+            'desplegar D\n' +
+            'plegar (P -> Q)\n' +
+            'glosario');
+        (0, vitest_1.expect)(out.stdout).toContain('Define');
+        (0, vitest_1.expect)(out.stdout).toContain('Source');
+        (0, vitest_1.expect)(out.stdout).toContain('Interpret');
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+        (0, vitest_1.expect)(out.stdout).toContain('Fold');
+        (0, vitest_1.expect)(out.stdout).toContain('GLOSARIO');
+    });
+    // Long definition name
+    (0, vitest_1.it)('define with very long name (50 chars)', () => {
+        const name = 'A'.repeat(50);
+        const out = runOk(`logic classical.propositional\ndefine ${name} := P -> Q`);
+        (0, vitest_1.expect)(out.stdout).toContain(name);
+    });
+    // Source with all fields
+    (0, vitest_1.it)('source with all 6 fields', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'source Full {\n' +
+            '  author "Author"\n' +
+            '  work "Work"\n' +
+            '  year 2025\n' +
+            '  section "Ch.1"\n' +
+            '  edition "2nd"\n' +
+            '  url "https://example.com"\n' +
+            '}\n' +
+            'glossary');
+        (0, vitest_1.expect)(out.stdout).toContain('Author');
+        (0, vitest_1.expect)(out.stdout).toContain('Fuentes');
+    });
+    // Negative year in source
+    (0, vitest_1.it)('source with negative year', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'source Ancient {\n' +
+            '  author "Parmenides"\n' +
+            '  year -500\n' +
+            '}');
+        (0, vitest_1.expect)(out.stdout).toContain('Parmenides');
+    });
+    // interpret with passageRef identifier
+    (0, vitest_1.it)('interpret with identifier ref', () => {
+        const out = runOk('logic classical.propositional\ninterpret MyRef as P -> Q');
+        (0, vitest_1.expect)(out.stdout).toContain('Interpret');
+        (0, vitest_1.expect)(out.stdout).toContain('MyRef');
+    });
+    // Glossary with no entries
+    (0, vitest_1.it)('empty glossary is safe', () => {
+        const out = runOk('logic classical.propositional\nglossary');
+        (0, vitest_1.expect)(out.stdout).toContain('sin definiciones registradas');
+    });
+    // render glossary with no definitions
+    (0, vitest_1.it)('render glossary with no definitions emits placeholder', () => {
+        const out = runOk('logic classical.propositional\nrender glossary as markdown');
+        (0, vitest_1.expect)(out.stdout).toContain('sin definiciones');
+    });
+    // render analysis with empty theory
+    (0, vitest_1.it)('render analysis with no content is minimal', () => {
+        const out = runOk('logic classical.propositional\nrender analysis as markdown');
+        (0, vitest_1.expect)(out.stdout).toContain('Análisis');
+    });
+    // Export define
+    (0, vitest_1.it)('export define works', () => {
+        const out = runOk('logic classical.propositional\nexport define D := P -> Q');
+        (0, vitest_1.expect)(out.stdout).toContain('Define');
+    });
+});
+// ============================================================
+// 12. Define interaction with other v2 features
+// ============================================================
+(0, vitest_1.describe)('v3 + v2 feature interactions', () => {
+    // define + let binding
+    (0, vitest_1.it)('define + let coexist', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'define D := P -> Q\n' +
+            'let x = P & Q\n' +
+            'check valid (D | x | !(D | x))');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+    // define + truth_table
+    (0, vitest_1.it)('define expansion in truth_table', () => {
+        const out = runOk('logic classical.propositional\ndefine D := P | !P\ntruth_table D');
+        (0, vitest_1.expect)(out.stdout).toContain('T');
+    });
+    // define + countermodel
+    (0, vitest_1.it)('define expansion in countermodel', () => {
+        const out = runOk('logic classical.propositional\ndefine D := P\ncountermodel D');
+        (0, vitest_1.expect)(out.results[0].status).toBe('invalid');
+    });
+    // define + check equivalent
+    (0, vitest_1.it)('define + check equivalent', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'define A := P -> Q\n' +
+            'define B := !P | Q\n' +
+            'check equivalent A, B');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+    // define + prove
+    (0, vitest_1.it)('define + prove', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'define IMP := P -> Q\n' +
+            'axiom A1 : IMP\n' +
+            'axiom A2 : P\n' +
+            'prove Q from {A1, A2}');
+        (0, vitest_1.expect)(out.results[0].status).toBe('provable');
+    });
+    // define + analyze (analyze works with raw formulas)
+    (0, vitest_1.it)('define + analyze', () => {
+        const out = runOk('logic classical.propositional\n' + 'define IMP := P -> Q\n' + 'analyze {(P -> Q), P} -> Q');
+        (0, vitest_1.expect)(out.exitCode).toBe(0);
+    });
+    // define + explain
+    (0, vitest_1.it)('define + explain', () => {
+        const out = runOk('logic classical.propositional\ndefine T := P -> P\nexplain (P -> P)');
+        (0, vitest_1.expect)(out.exitCode).toBe(0);
+    });
+    // define + truth_table (v2 feature)
+    (0, vitest_1.it)('define + check satisfiable', () => {
+        const out = runOk('logic classical.propositional\ndefine D := P & Q\ncheck satisfiable D');
+        (0, vitest_1.expect)(out.results[0].status).toBe('satisfiable');
+    });
+    // define in if/else block
+    (0, vitest_1.it)('define before if/else block works', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'define T := P -> P\n' +
+            'if valid (P | !P) {\n' +
+            '  check valid T\n' +
+            '}');
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+    // define with check inside if
+    (0, vitest_1.it)('define + if valid with defined tautology', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'define LEM := P | !P\n' +
+            'if valid (P | !P) {\n' +
+            '  print "LEM holds"\n' +
+            '}');
+        (0, vitest_1.expect)(out.stdout).toContain('LEM holds');
+    });
+    // source + claim
+    (0, vitest_1.it)('source + claim integration', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'source S {\n' +
+            '  author "Author"\n' +
+            '  work "Work"\n' +
+            '}\n' +
+            'let p = passage([[ref#1]])\n' +
+            'let phi = formalize p as (P -> Q)\n' +
+            'claim C = phi\n' +
+            'render analysis as markdown');
+        (0, vitest_1.expect)(out.stdout).toContain('Fuentes');
+        (0, vitest_1.expect)(out.stdout).toContain('Análisis');
+    });
+    // define + passage + formalize
+    (0, vitest_1.it)('define + passage coexistence', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'define D := P -> Q\n' +
+            'let p1 = passage([[ref#1]])\n' +
+            'let phi = formalize p1 as (P -> Q)\n' +
+            'glossary');
+        (0, vitest_1.expect)(out.stdout).toContain('GLOSARIO');
+    });
+});
+// ============================================================
+// 13. Heavy stress: many ops, large scripts
+// ============================================================
+(0, vitest_1.describe)('v3 heavy stress', () => {
+    (0, vitest_1.it)('100 defines + check valid on the last one', () => {
+        const defs = Array.from({ length: 100 }, (_, i) => `define D${i} := P${i} -> P${i}`).join('\n');
+        const out = runOk(`logic classical.propositional\n${defs}\ncheck valid D99`);
+        (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+    });
+    (0, vitest_1.it)('50 defines + 50 unfolds', () => {
+        const lines = [];
+        for (let i = 0; i < 50; i++) {
+            lines.push(`define D${i} := P${i} -> Q${i}`);
+        }
+        for (let i = 0; i < 50; i++) {
+            lines.push(`unfold D${i}`);
+        }
+        const out = runOk(`logic classical.propositional\n${lines.join('\n')}`);
+        (0, vitest_1.expect)(out.results).toHaveLength(50);
+    });
+    (0, vitest_1.it)('define chain depth 30 + unfold last', () => {
+        const defs = ['define D0 := P'];
+        for (let i = 1; i < 30; i++) {
+            defs.push(`define D${i} := D${i - 1} -> Q${i}`);
+        }
+        defs.push('unfold D29');
+        const out = runOk(`logic classical.propositional\n${defs.join('\n')}`);
+        (0, vitest_1.expect)(out.stdout).toContain('Unfold');
+    });
+    (0, vitest_1.it)('10 sources + 10 defines + 10 interprets + glossary', () => {
+        const lines = [];
+        for (let i = 0; i < 10; i++) {
+            lines.push(`source S${i} {\n  author "A${i}"\n  work "W${i}"\n  year ${2000 + i}\n}`);
+        }
+        for (let i = 0; i < 10; i++) {
+            lines.push(`define D${i} := P${i} -> Q${i}\ndescription "Desc ${i}"`);
+        }
+        for (let i = 0; i < 10; i++) {
+            lines.push(`interpret "text ${i}" as P${i}`);
+        }
+        lines.push('glossary');
+        const out = runOk(`logic classical.propositional\n${lines.join('\n')}`);
+        (0, vitest_1.expect)(out.stdout).toContain('GLOSARIO');
+        (0, vitest_1.expect)(out.stdout).toContain('Fuentes');
+        (0, vitest_1.expect)(out.stdout).toContain('Interpretaciones');
+        (0, vitest_1.expect)(out.stdout).toContain('D9');
+        (0, vitest_1.expect)(out.stdout).toContain('S9');
+        (0, vitest_1.expect)(out.stdout).toContain('text 9');
+    });
+    (0, vitest_1.it)('render analysis with all v3 features combined', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'source Frege {\n  author "Frege"\n  work "Begriffsschrift"\n  year 1879\n}\n' +
+            'define Impl(x, y) := x -> y\n' +
+            'description "Implicación material"\n' +
+            'define LEM := P | !P\n' +
+            'description "Ley del tercero excluido"\n' +
+            'axiom A1 : P -> Q\n' +
+            'axiom A2 : P\n' +
+            'theorem T1 = Q\n' +
+            'interpret "si P entonces Q" as P -> Q\n' +
+            'check valid LEM\n' +
+            'check valid Impl(P, P)\n' +
+            'derive Q from {A1, A2}\n' +
+            'glossary\n' +
+            'render glossary as json\n' +
+            'render analysis as markdown');
+        (0, vitest_1.expect)(out.stdout).toContain('Análisis');
+        (0, vitest_1.expect)(out.stdout).toContain('Definiciones');
+        (0, vitest_1.expect)(out.stdout).toContain('Axiomas');
+        (0, vitest_1.expect)(out.stdout).toContain('Fuentes');
+        (0, vitest_1.expect)(out.stdout).toContain('Verificaciones');
+        (0, vitest_1.expect)(out.results.length).toBeGreaterThanOrEqual(3);
+    });
+    // Parametric define with all propositional profiles
+    (0, vitest_1.it)('parametric define Impl(x,y) := x -> y + check valid Impl(A,A) across all propositional profiles', () => {
+        const validProfiles = [
+            'classical.propositional',
+            'classical.first_order',
+            'modal.k',
+            'deontic.standard',
+            'epistemic.s5',
+            'intuitionistic.propositional',
+            'temporal.ltl',
+            'probabilistic.basic',
+        ];
+        for (const profile of validProfiles) {
+            const out = runOk(`logic ${profile}\n` + 'define Impl(x, y) := x -> y\n' + 'check valid Impl(A, A)');
+            (0, vitest_1.expect)(out.results[0].status).toBe('valid');
+        }
+    });
+});
+// ============================================================
+// 14. Regression guards
+// ============================================================
+(0, vitest_1.describe)('v3 regression guards', () => {
+    // Ensure define doesn't break normal axiom/theorem workflow
+    (0, vitest_1.it)('normal axiom+theorem workflow unaffected by define presence', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'define D := P -> Q\n' +
+            'axiom A1 : P -> Q\n' +
+            'axiom A2 : Q -> R\n' +
+            'theorem T1 = P -> R\n' +
+            'derive R from {A1, A2, T1}');
+        // Should be provable as before
+        (0, vitest_1.expect)(out.results.length).toBeGreaterThan(0);
+    });
+    // Ensure source doesn't interfere with text layer
+    (0, vitest_1.it)('source + passage + claim coexist without errors', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'source S {\n  author "A"\n  work "W"\n}\n' +
+            'let p1 = passage([[ref#1]])\n' +
+            'let phi = formalize p1 as P\n' +
+            'claim C = phi\n' +
+            'render analysis as markdown');
+        (0, vitest_1.expect)(out.exitCode).toBe(0);
+    });
+    // Ensure glossary after complex theory
+    (0, vitest_1.it)('glossary after theory with extends', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'theory Base {\n' +
+            '  axiom A1 : P -> Q\n' +
+            '}\n' +
+            'theory Ext extends Base {\n' +
+            '  axiom A2 : Q -> R\n' +
+            '}\n' +
+            'define D := P -> R\n' +
+            'glossary');
+        (0, vitest_1.expect)(out.stdout).toContain('GLOSARIO');
+        (0, vitest_1.expect)(out.stdout).toContain('D');
+    });
+    // for loop with define
+    (0, vitest_1.it)('define before for loop', () => {
+        const out = runOk('logic classical.propositional\n' +
+            'define T := P -> P\n' +
+            'for F in {P, Q, R} {\n' +
+            '  check valid (F -> F)\n' +
+            '}\n' +
+            'check valid T');
+        // 3 checks from loop + 1 final check = 4 results
+        (0, vitest_1.expect)(out.results.length).toBe(4);
+        (0, vitest_1.expect)(out.results[3].status).toBe('valid');
+    });
+});
+//# sourceMappingURL=v3-stress.test.js.map