@stevenvo780/st-lang 4.5.1 → 4.5.2

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"}