@stevenvo780/st-lang 4.5.0 → 4.5.2

package/dist/namespaces/logic.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Namespace: Logic
+ *
+ * Agrupa los perfiles lógicos disponibles en ST. Cada sub-namespace expone
+ * los símbolos del módulo correspondiente sin colisiones de nombres entre
+ * lógicas (CTL.Formula vs LTL.Formula, etc).
+ *
+ * Importa así:
+ *   import { Logic } from '@stevenvo780/st-lang';
+ *   Logic.modal.s5.isValid(formula);
+ *   Logic.ctl.modelCheckCTL(kripke, formula);
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARALLEL_THRESHOLD = exports.workersAvailable = exports.dpllAsync = exports.dpll = exports.cdclAsync = exports.cdcl = exports.arithmetic = exports.substructural = exports.manyValued = exports.defaultLogic = exports.intuitNJ = exports.sequentLK = exports.sequentG3 = exports.modalAxioms = exports.descriptionLogic = exports.hybrid = exports.muCalculus = exports.ltl = exports.ctl = exports.ProbabilisticBasic = exports.AristotelianSyllogistic = exports.DeonticStandard = exports.EpistemicS5 = exports.TemporalLTL = exports.IntuitionisticPropositional = exports.ParaconsistentBelnap = exports.ModalK = exports.ClassicalFirstOrder = exports.formulaToString = exports.ClassicalPropositional = exports.registry = exports.ProfileRegistry = void 0;
+// Perfil registry + interfaces compartidas
+var interface_1 = require("../profiles/interface");
+Object.defineProperty(exports, "ProfileRegistry", { enumerable: true, get: function () { return interface_1.ProfileRegistry; } });
+Object.defineProperty(exports, "registry", { enumerable: true, get: function () { return interface_1.registry; } });
+// Perfiles "clase suelta" (un solo símbolo)
+var propositional_1 = require("../profiles/classical/propositional");
+Object.defineProperty(exports, "ClassicalPropositional", { enumerable: true, get: function () { return propositional_1.ClassicalPropositional; } });
+Object.defineProperty(exports, "formulaToString", { enumerable: true, get: function () { return propositional_1.formulaToString; } });
+var first_order_1 = require("../profiles/classical/first-order");
+Object.defineProperty(exports, "ClassicalFirstOrder", { enumerable: true, get: function () { return first_order_1.ClassicalFirstOrder; } });
+var k_1 = require("../profiles/modal/k");
+Object.defineProperty(exports, "ModalK", { enumerable: true, get: function () { return k_1.ModalK; } });
+var belnap_1 = require("../profiles/paraconsistent/belnap");
+Object.defineProperty(exports, "ParaconsistentBelnap", { enumerable: true, get: function () { return belnap_1.ParaconsistentBelnap; } });
+var propositional_2 = require("../profiles/intuitionistic/propositional");
+Object.defineProperty(exports, "IntuitionisticPropositional", { enumerable: true, get: function () { return propositional_2.IntuitionisticPropositional; } });
+var ltl_1 = require("../profiles/temporal/ltl");
+Object.defineProperty(exports, "TemporalLTL", { enumerable: true, get: function () { return ltl_1.TemporalLTL; } });
+var s5_1 = require("../profiles/epistemic/s5");
+Object.defineProperty(exports, "EpistemicS5", { enumerable: true, get: function () { return s5_1.EpistemicS5; } });
+var standard_1 = require("../profiles/deontic/standard");
+Object.defineProperty(exports, "DeonticStandard", { enumerable: true, get: function () { return standard_1.DeonticStandard; } });
+var syllogistic_1 = require("../profiles/aristotelian/syllogistic");
+Object.defineProperty(exports, "AristotelianSyllogistic", { enumerable: true, get: function () { return syllogistic_1.AristotelianSyllogistic; } });
+var basic_1 = require("../profiles/probabilistic/basic");
+Object.defineProperty(exports, "ProbabilisticBasic", { enumerable: true, get: function () { return basic_1.ProbabilisticBasic; } });
+// Sub-namespaces (cada perfil con barrel propio)
+const ctl = __importStar(require("../profiles/ctl"));
+exports.ctl = ctl;
+const ltl = __importStar(require("../profiles/ltl-sat"));
+exports.ltl = ltl;
+const muCalculus = __importStar(require("../profiles/mu-calculus"));
+exports.muCalculus = muCalculus;
+const hybrid = __importStar(require("../profiles/hybrid-logic"));
+exports.hybrid = hybrid;
+const descriptionLogic = __importStar(require("../profiles/description-logic"));
+exports.descriptionLogic = descriptionLogic;
+const modalAxioms = __importStar(require("../profiles/modal-frame-axioms"));
+exports.modalAxioms = modalAxioms;
+const sequentG3 = __importStar(require("../profiles/sequent-g3"));
+exports.sequentG3 = sequentG3;
+const sequentLK = __importStar(require("../profiles/sequent-lk"));
+exports.sequentLK = sequentLK;
+const intuitNJ = __importStar(require("../profiles/intuitionistic-nj"));
+exports.intuitNJ = intuitNJ;
+const defaultLogic = __importStar(require("../profiles/default-logic"));
+exports.defaultLogic = defaultLogic;
+const manyValued = __importStar(require("../profiles/many-valued"));
+exports.manyValued = manyValued;
+const substructural = __importStar(require("../profiles/substructural"));
+exports.substructural = substructural;
+const arithmetic = __importStar(require("../profiles/arithmetic"));
+exports.arithmetic = arithmetic;
+// SAT solving (algoritmos clásicos para evaluación de fórmulas)
+var cdcl_1 = require("../profiles/classical/cdcl");
+Object.defineProperty(exports, "cdcl", { enumerable: true, get: function () { return cdcl_1.cdcl; } });
+Object.defineProperty(exports, "cdclAsync", { enumerable: true, get: function () { return cdcl_1.cdclAsync; } });
+var dpll_1 = require("../profiles/classical/dpll");
+Object.defineProperty(exports, "dpll", { enumerable: true, get: function () { return dpll_1.dpll; } });
+Object.defineProperty(exports, "dpllAsync", { enumerable: true, get: function () { return dpll_1.dpllAsync; } });
+var parallel_sat_1 = require("../profiles/classical/parallel-sat");
+Object.defineProperty(exports, "workersAvailable", { enumerable: true, get: function () { return parallel_sat_1.workersAvailable; } });
+Object.defineProperty(exports, "PARALLEL_THRESHOLD", { enumerable: true, get: function () { return parallel_sat_1.PARALLEL_THRESHOLD; } });
+//# sourceMappingURL=logic.js.map

package/dist/namespaces/logic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.js","sourceRoot":"","sources":["../../src/namespaces/logic.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,2CAA2C;AAC3C,mDAAgF;AAAzD,4GAAA,eAAe,OAAA;AAAE,qGAAA,QAAQ,OAAA;AAEhD,4CAA4C;AAC5C,qEAA8F;AAArF,uHAAA,sBAAsB,OAAA;AAAE,gHAAA,eAAe,OAAA;AAChD,iEAAwE;AAA/D,kHAAA,mBAAmB,OAAA;AAC5B,yCAA6C;AAApC,2FAAA,MAAM,OAAA;AACf,4DAAyE;AAAhE,8GAAA,oBAAoB,OAAA;AAC7B,0EAAuF;AAA9E,4HAAA,2BAA2B,OAAA;AACpC,gDAAuD;AAA9C,kGAAA,WAAW,OAAA;AACpB,+CAAuD;AAA9C,iGAAA,WAAW,OAAA;AACpB,yDAA+D;AAAtD,2GAAA,eAAe,OAAA;AACxB,oEAA+E;AAAtE,sHAAA,uBAAuB,OAAA;AAChC,yDAAqE;AAA5D,2GAAA,kBAAkB,OAAA;AAE3B,iDAAiD;AACjD,qDAAuC;AAerC,kBAAG;AAdL,yDAA2C;AAezC,kBAAG;AAdL,oEAAsD;AAepD,gCAAU;AAdZ,iEAAmD;AAejD,wBAAM;AAdR,gFAAkE;AAehE,4CAAgB;AAdlB,4EAA8D;AAe5D,kCAAW;AAdb,kEAAoD;AAelD,8BAAS;AAdX,kEAAoD;AAelD,8BAAS;AAdX,wEAA0D;AAexD,4BAAQ;AAdV,wEAA0D;AAexD,oCAAY;AAdd,oEAAsD;AAepD,gCAAU;AAdZ,yEAA2D;AAezD,sCAAa;AAdf,mEAAqD;AAenD,gCAAU;AAGZ,gEAAgE;AAChE,mDAA6D;AAApD,4FAAA,IAAI,OAAA;AAAE,iGAAA,SAAS,OAAA;AAExB,mDAA6D;AAApD,4FAAA,IAAI,OAAA;AAAE,iGAAA,SAAS,OAAA;AACxB,mEAA0F;AAAjF,gHAAA,gBAAgB,OAAA;AAAE,kHAAA,kBAAkB,OAAA"}

package/dist/namespaces/proof-systems.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Namespace: ProofSystems
+ *
+ * Probadores formales y mecanismos de intercambio/manipulación de pruebas.
+ *
+ * Importa así:
+ *   import { ProofSystems } from '@stevenvo780/st-lang';
+ *   ProofSystems.folProver.proveFOL(theory);
+ *   ProofSystems.proofExchange.signProof(pkg, key);
+ */
+import * as folProver from '../fol-prover';
+import * as folProverEquality from '../fol-prover-equality';
+import * as proofExchange from '../proof-exchange';
+import * as proofMinify from '../runtime/proof-minify';
+import * as tableauFramework from '../tableau-framework';
+import * as proofNets from '../proof-nets';
+export { folProver, folProverEquality, proofExchange, proofMinify, tableauFramework, proofNets, };
+//# sourceMappingURL=proof-systems.d.ts.map

package/dist/namespaces/proof-systems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-systems.d.ts","sourceRoot":"","sources":["../../src/namespaces/proof-systems.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,SAAS,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,aAAa,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,gBAAgB,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,SAAS,MAAM,eAAe,CAAC;AAE3C,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,SAAS,GACV,CAAC"}

package/dist/namespaces/proof-systems.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Namespace: ProofSystems
+ *
+ * Probadores formales y mecanismos de intercambio/manipulación de pruebas.
+ *
+ * Importa así:
+ *   import { ProofSystems } from '@stevenvo780/st-lang';
+ *   ProofSystems.folProver.proveFOL(theory);
+ *   ProofSystems.proofExchange.signProof(pkg, key);
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proofNets = exports.tableauFramework = exports.proofMinify = exports.proofExchange = exports.folProverEquality = exports.folProver = void 0;
+const folProver = __importStar(require("../fol-prover"));
+exports.folProver = folProver;
+const folProverEquality = __importStar(require("../fol-prover-equality"));
+exports.folProverEquality = folProverEquality;
+const proofExchange = __importStar(require("../proof-exchange"));
+exports.proofExchange = proofExchange;
+const proofMinify = __importStar(require("../runtime/proof-minify"));
+exports.proofMinify = proofMinify;
+const tableauFramework = __importStar(require("../tableau-framework"));
+exports.tableauFramework = tableauFramework;
+const proofNets = __importStar(require("../proof-nets"));
+exports.proofNets = proofNets;
+//# sourceMappingURL=proof-systems.js.map

package/dist/namespaces/proof-systems.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-systems.js","sourceRoot":"","sources":["../../src/namespaces/proof-systems.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,yDAA2C;AAQzC,8BAAS;AAPX,0EAA4D;AAQ1D,8CAAiB;AAPnB,iEAAmD;AAQjD,sCAAa;AAPf,qEAAuD;AAQrD,kCAAW;AAPb,uEAAyD;AAQvD,4CAAgB;AAPlB,yDAA2C;AAQzC,8BAAS"}

package/dist/namespaces/reasoning.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Namespace: Reasoning
+ *
+ * Razonamiento no-monótono, probabilístico, abductivo y herramientas
+ * de manipulación simbólica. Argumentación Dung, revisión de creencias AGM,
+ * abducción, lógica de Markov, redes Bayesianas, citation reasoning,
+ * análisis hyperreal, cache de teoremas, anti-unificación, term-rewriting.
+ *
+ * Importa así:
+ *   import { Reasoning } from '@stevenvo780/st-lang';
+ *   const ext = Reasoning.argumentation.computeExtensions(af, 'grounded');
+ *   const cited = Reasoning.citationReasoning.deriveWithCitations(claims, ev);
+ */
+import * as argumentation from '../argumentation';
+import * as beliefRevision from '../belief-revision';
+import * as abduction from '../runtime/abduction';
+import * as markovLogic from '../runtime/markov-logic';
+import * as bayesian from '../runtime/bayesian';
+import * as citationReasoning from '../citation-reasoning';
+import * as hyperreal from '../hyperreal';
+import * as antiUnification from '../runtime/anti-unification';
+import * as termRewriting from '../runtime/term-rewriting';
+export { argumentation, beliefRevision, abduction, markovLogic, bayesian, citationReasoning, hyperreal, antiUnification, termRewriting, };
+export { TheoremCache, tryReuseProof } from '../runtime/theorem-cache';
+export type { CachedTheorem, CacheOptions as TheoremCacheOptions, CacheStats as TheoremCacheStats, ReuseResult as TheoremReuseResult, } from '../runtime/theorem-cache';
+//# sourceMappingURL=reasoning.d.ts.map

package/dist/namespaces/reasoning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning.d.ts","sourceRoot":"","sources":["../../src/namespaces/reasoning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,cAAc,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,SAAS,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,iBAAiB,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,eAAe,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EACL,aAAa,EACb,cAAc,EACd,SAAS,EACT,WAAW,EACX,QAAQ,EACR,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,aAAa,GACd,CAAC;AAGF,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACvE,YAAY,EACV,aAAa,EACb,YAAY,IAAI,mBAAmB,EACnC,UAAU,IAAI,iBAAiB,EAC/B,WAAW,IAAI,kBAAkB,GAClC,MAAM,0BAA0B,CAAC"}

package/dist/namespaces/reasoning.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Namespace: Reasoning
+ *
+ * Razonamiento no-monótono, probabilístico, abductivo y herramientas
+ * de manipulación simbólica. Argumentación Dung, revisión de creencias AGM,
+ * abducción, lógica de Markov, redes Bayesianas, citation reasoning,
+ * análisis hyperreal, cache de teoremas, anti-unificación, term-rewriting.
+ *
+ * Importa así:
+ *   import { Reasoning } from '@stevenvo780/st-lang';
+ *   const ext = Reasoning.argumentation.computeExtensions(af, 'grounded');
+ *   const cited = Reasoning.citationReasoning.deriveWithCitations(claims, ev);
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryReuseProof = exports.TheoremCache = exports.termRewriting = exports.antiUnification = exports.hyperreal = exports.citationReasoning = exports.bayesian = exports.markovLogic = exports.abduction = exports.beliefRevision = exports.argumentation = void 0;
+const argumentation = __importStar(require("../argumentation"));
+exports.argumentation = argumentation;
+const beliefRevision = __importStar(require("../belief-revision"));
+exports.beliefRevision = beliefRevision;
+const abduction = __importStar(require("../runtime/abduction"));
+exports.abduction = abduction;
+const markovLogic = __importStar(require("../runtime/markov-logic"));
+exports.markovLogic = markovLogic;
+const bayesian = __importStar(require("../runtime/bayesian"));
+exports.bayesian = bayesian;
+const citationReasoning = __importStar(require("../citation-reasoning"));
+exports.citationReasoning = citationReasoning;
+const hyperreal = __importStar(require("../hyperreal"));
+exports.hyperreal = hyperreal;
+const antiUnification = __importStar(require("../runtime/anti-unification"));
+exports.antiUnification = antiUnification;
+const termRewriting = __importStar(require("../runtime/term-rewriting"));
+exports.termRewriting = termRewriting;
+// Theorem cache (proof reuse persistente) — re-export plano por uso frecuente.
+var theorem_cache_1 = require("../runtime/theorem-cache");
+Object.defineProperty(exports, "TheoremCache", { enumerable: true, get: function () { return theorem_cache_1.TheoremCache; } });
+Object.defineProperty(exports, "tryReuseProof", { enumerable: true, get: function () { return theorem_cache_1.tryReuseProof; } });
+//# sourceMappingURL=reasoning.js.map

package/dist/namespaces/reasoning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning.js","sourceRoot":"","sources":["../../src/namespaces/reasoning.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,gEAAkD;AAWhD,sCAAa;AAVf,mEAAqD;AAWnD,wCAAc;AAVhB,gEAAkD;AAWhD,8BAAS;AAVX,qEAAuD;AAWrD,kCAAW;AAVb,8DAAgD;AAW9C,4BAAQ;AAVV,yEAA2D;AAWzD,8CAAiB;AAVnB,wDAA0C;AAWxC,8BAAS;AAVX,6EAA+D;AAW7D,0CAAe;AAVjB,yEAA2D;AAWzD,sCAAa;AAGf,+EAA+E;AAC/E,0DAAuE;AAA9D,6GAAA,YAAY,OAAA;AAAE,8GAAA,aAAa,OAAA"}

package/dist/namespaces/semantics.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Namespace: Semantics
+ *
+ * Capas semánticas y puentes de interpretación: text-layer (claims/passages
+ * con grafo de dependencias), MDX bridge, game semantics dialógico (IPC
+ * Lorenzen-Felscher), profile-bridge (traducciones entre lógicas), y
+ * coinducción (streams, bisimulación).
+ *
+ * Importa así:
+ *   import { Semantics } from '@stevenvo780/st-lang';
+ *   const state = Semantics.textLayer.createTextLayerState();
+ *   const win = Semantics.gameSemantics.winningStrategy(formula);
+ */
+import * as textLayerCompiler from '../text-layer/compiler';
+import * as textLayerV2 from '../text-layer/v2';
+import * as gameSemantics from '../game-semantics';
+import * as profileBridge from '../profile-bridge';
+import * as coinduction from '../coinduction';
+export { textLayerCompiler, textLayerV2, gameSemantics, profileBridge, coinduction, };
+export declare const textLayer: typeof textLayerCompiler;
+//# sourceMappingURL=semantics.d.ts.map

package/dist/namespaces/semantics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantics.d.ts","sourceRoot":"","sources":["../../src/namespaces/semantics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAC;AAE5D,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAEhD,OAAO,KAAK,aAAa,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,aAAa,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EACL,iBAAiB,EACjB,WAAW,EACX,aAAa,EACb,aAAa,EACb,WAAW,GACZ,CAAC;AAGF,eAAO,MAAM,SAAS,0BAAoB,CAAC"}

package/dist/namespaces/semantics.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Namespace: Semantics
+ *
+ * Capas semánticas y puentes de interpretación: text-layer (claims/passages
+ * con grafo de dependencias), MDX bridge, game semantics dialógico (IPC
+ * Lorenzen-Felscher), profile-bridge (traducciones entre lógicas), y
+ * coinducción (streams, bisimulación).
+ *
+ * Importa así:
+ *   import { Semantics } from '@stevenvo780/st-lang';
+ *   const state = Semantics.textLayer.createTextLayerState();
+ *   const win = Semantics.gameSemantics.winningStrategy(formula);
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textLayer = exports.coinduction = exports.profileBridge = exports.gameSemantics = exports.textLayerV2 = exports.textLayerCompiler = void 0;
+// Text layer v1 — compilador legacy
+const textLayerCompiler = __importStar(require("../text-layer/compiler"));
+exports.textLayerCompiler = textLayerCompiler;
+// Text layer v2 — grafo de claims con dependencias
+const textLayerV2 = __importStar(require("../text-layer/v2"));
+exports.textLayerV2 = textLayerV2;
+const gameSemantics = __importStar(require("../game-semantics"));
+exports.gameSemantics = gameSemantics;
+const profileBridge = __importStar(require("../profile-bridge"));
+exports.profileBridge = profileBridge;
+const coinduction = __importStar(require("../coinduction"));
+exports.coinduction = coinduction;
+// Aliases convenientes — text-layer flat para coincidir con flat exports.
+exports.textLayer = textLayerCompiler;
+//# sourceMappingURL=semantics.js.map

package/dist/namespaces/semantics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantics.js","sourceRoot":"","sources":["../../src/namespaces/semantics.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,oCAAoC;AACpC,0EAA4D;AAS1D,8CAAiB;AARnB,mDAAmD;AACnD,8DAAgD;AAQ9C,kCAAW;AANb,iEAAmD;AAOjD,sCAAa;AANf,iEAAmD;AAOjD,sCAAa;AANf,4DAA8C;AAO5C,kCAAW;AAGb,0EAA0E;AAC7D,QAAA,SAAS,GAAG,iBAAiB,CAAC"}

package/dist/namespaces/solvers.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Namespace: Solvers
+ *
+ * Solvers de decisión combinatoria: SAT (CDCL v1/v2 + incremental),
+ * SMT bridge, CSP (AC-3 + backtracking + builtins), MUS (minimal
+ * unsat subsets), pool de evaluación paralela.
+ *
+ * Importa así:
+ *   import { Solvers } from '@stevenvo780/st-lang';
+ *   const r = Solvers.cdclV2.solveCDCLv2(cnf);
+ *   const mus = Solvers.mus.extractMUS(clauses);
+ */
+import * as cdclV2 from '../solver/cdcl-v2';
+import * as cdclV2Incremental from '../solver/cdcl-v2-incremental';
+import * as csp from '../runtime/csp';
+import * as mus from '../runtime/mus';
+import * as smt from '../runtime/smt';
+import * as parallel from '../runtime/parallel';
+export { cdclV2, cdclV2Incremental, csp, mus, smt, parallel };
+export { solveCDCLv2 } from '../solver/cdcl-v2';
+export { IncrementalCDCL } from '../solver/cdcl-v2-incremental';
+//# sourceMappingURL=solvers.d.ts.map

package/dist/namespaces/solvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solvers.d.ts","sourceRoot":"","sources":["../../src/namespaces/solvers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,iBAAiB,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;AAG9D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/namespaces/solvers.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Namespace: Solvers
+ *
+ * Solvers de decisión combinatoria: SAT (CDCL v1/v2 + incremental),
+ * SMT bridge, CSP (AC-3 + backtracking + builtins), MUS (minimal
+ * unsat subsets), pool de evaluación paralela.
+ *
+ * Importa así:
+ *   import { Solvers } from '@stevenvo780/st-lang';
+ *   const r = Solvers.cdclV2.solveCDCLv2(cnf);
+ *   const mus = Solvers.mus.extractMUS(clauses);
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncrementalCDCL = exports.solveCDCLv2 = exports.parallel = exports.smt = exports.mus = exports.csp = exports.cdclV2Incremental = exports.cdclV2 = void 0;
+const cdclV2 = __importStar(require("../solver/cdcl-v2"));
+exports.cdclV2 = cdclV2;
+const cdclV2Incremental = __importStar(require("../solver/cdcl-v2-incremental"));
+exports.cdclV2Incremental = cdclV2Incremental;
+const csp = __importStar(require("../runtime/csp"));
+exports.csp = csp;
+const mus = __importStar(require("../runtime/mus"));
+exports.mus = mus;
+const smt = __importStar(require("../runtime/smt"));
+exports.smt = smt;
+const parallel = __importStar(require("../runtime/parallel"));
+exports.parallel = parallel;
+// Conveniencia: símbolos populares re-expuestos en raíz del namespace.
+var cdcl_v2_1 = require("../solver/cdcl-v2");
+Object.defineProperty(exports, "solveCDCLv2", { enumerable: true, get: function () { return cdcl_v2_1.solveCDCLv2; } });
+var cdcl_v2_incremental_1 = require("../solver/cdcl-v2-incremental");
+Object.defineProperty(exports, "IncrementalCDCL", { enumerable: true, get: function () { return cdcl_v2_incremental_1.IncrementalCDCL; } });
+//# sourceMappingURL=solvers.js.map

package/dist/namespaces/solvers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solvers.js","sourceRoot":"","sources":["../../src/namespaces/solvers.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,0DAA4C;AAOnC,wBAAM;AANf,iFAAmE;AAMlD,8CAAiB;AALlC,oDAAsC;AAKF,kBAAG;AAJvC,oDAAsC;AAIG,kBAAG;AAH5C,oDAAsC;AAGQ,kBAAG;AAFjD,8DAAgD;AAEG,4BAAQ;AAE3D,uEAAuE;AACvE,6CAAgD;AAAvC,sGAAA,WAAW,OAAA;AACpB,qEAAgE;AAAvD,sHAAA,eAAe,OAAA"}

package/dist/namespaces/type-theory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Namespace: TypeTheory
+ *
+ * Sistemas de tipos y cálculos lambda — correspondencia Curry-Howard,
+ * System F polimórfico, MLTT (Martin-Löf), λ-calc puro, combinadores SKI,
+ * NBE (normalization by evaluation), refinement types.
+ *
+ * Importa así:
+ *   import { TypeTheory } from '@stevenvo780/st-lang';
+ *   const t = TypeTheory.systemF.typeOf(term);
+ *   const proof = TypeTheory.curryHoward.termToProof(lam);
+ */
+import * as curryHoward from '../curry-howard';
+import * as systemF from '../system-f';
+import * as mltt from '../mltt';
+import * as lambdaCalc from '../lambda-calc';
+import * as combinatorsSKI from '../combinators-ski';
+import * as nbe from '../nbe';
+import * as refinementTypes from '../refinement-types';
+import * as higherOrderUnify from '../higher-order-unify';
+export { curryHoward, systemF, mltt, lambdaCalc, combinatorsSKI, nbe, refinementTypes, higherOrderUnify, };
+//# sourceMappingURL=type-theory.d.ts.map

package/dist/namespaces/type-theory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-theory.d.ts","sourceRoot":"","sources":["../../src/namespaces/type-theory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,WAAW,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,SAAS,CAAC;AAChC,OAAO,KAAK,UAAU,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,cAAc,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,GAAG,MAAM,QAAQ,CAAC;AAC9B,OAAO,KAAK,eAAe,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EACL,WAAW,EACX,OAAO,EACP,IAAI,EACJ,UAAU,EACV,cAAc,EACd,GAAG,EACH,eAAe,EACf,gBAAgB,GACjB,CAAC"}

package/dist/namespaces/type-theory.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Namespace: TypeTheory
+ *
+ * Sistemas de tipos y cálculos lambda — correspondencia Curry-Howard,
+ * System F polimórfico, MLTT (Martin-Löf), λ-calc puro, combinadores SKI,
+ * NBE (normalization by evaluation), refinement types.
+ *
+ * Importa así:
+ *   import { TypeTheory } from '@stevenvo780/st-lang';
+ *   const t = TypeTheory.systemF.typeOf(term);
+ *   const proof = TypeTheory.curryHoward.termToProof(lam);
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.higherOrderUnify = exports.refinementTypes = exports.nbe = exports.combinatorsSKI = exports.lambdaCalc = exports.mltt = exports.systemF = exports.curryHoward = void 0;
+const curryHoward = __importStar(require("../curry-howard"));
+exports.curryHoward = curryHoward;
+const systemF = __importStar(require("../system-f"));
+exports.systemF = systemF;
+const mltt = __importStar(require("../mltt"));
+exports.mltt = mltt;
+const lambdaCalc = __importStar(require("../lambda-calc"));
+exports.lambdaCalc = lambdaCalc;
+const combinatorsSKI = __importStar(require("../combinators-ski"));
+exports.combinatorsSKI = combinatorsSKI;
+const nbe = __importStar(require("../nbe"));
+exports.nbe = nbe;
+const refinementTypes = __importStar(require("../refinement-types"));
+exports.refinementTypes = refinementTypes;
+const higherOrderUnify = __importStar(require("../higher-order-unify"));
+exports.higherOrderUnify = higherOrderUnify;
+//# sourceMappingURL=type-theory.js.map

package/dist/namespaces/type-theory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-theory.js","sourceRoot":"","sources":["../../src/namespaces/type-theory.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,6DAA+C;AAU7C,kCAAW;AATb,qDAAuC;AAUrC,0BAAO;AATT,8CAAgC;AAU9B,oBAAI;AATN,2DAA6C;AAU3C,gCAAU;AATZ,mEAAqD;AAUnD,wCAAc;AAThB,4CAA8B;AAU5B,kBAAG;AATL,qEAAuD;AAUrD,0CAAe;AATjB,wEAA0D;AAUxD,4CAAgB"}

package/dist/optimization/branch-and-bound.d.ts

@@ -0,0 +1,11 @@
+import type { ILPOptions, ILPProblem, ILPSolution, LPProblem } from './types';
+/**
+ * Genera el LP relajado: descarta integerVars/binaryVars pero
+ * mantiene `variableBounds` (los binarios ya tienen [0,1] ahí).
+ */
+export declare function lpRelaxation(ilp: ILPProblem): LPProblem;
+/**
+ * Solver ILP principal. Estrategia DFS con pila explícita.
+ */
+export declare function solveILP(problem: ILPProblem, opts?: ILPOptions): ILPSolution;
+//# sourceMappingURL=branch-and-bound.d.ts.map

package/dist/optimization/branch-and-bound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-and-bound.d.ts","sourceRoot":"","sources":["../../src/optimization/branch-and-bound.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAM9E;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,CA+BvD;AAmGD;;GAEG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,GAAE,UAAe,GAAG,WAAW,CAgKhF"}