@stevenvo780/st-lang 4.2.0 → 4.4.0

package/dist/runtime/planning/ground.js

@@ -0,0 +1,154 @@
+"use strict";
+// ============================================================
+// ST Planning — Grounding y aplicación de acciones
+// ============================================================
+//
+// "Grounding" = instanciar un action schema lifted (con ?vars) a
+// una acción concreta sobre objetos del dominio.
+//
+// Ejemplo:
+//   schema:   move(?from, ?to) pre: at(?from)  add: at(?to)  del: at(?from)
+//   binding:  { '?from': 'a', '?to': 'b' }
+//   ground:   pre: at(a)  add: at(b)  del: at(a)
+//
+// La sustitución es textual: reemplazamos ?from → a en cada string
+// del schema. Usamos boundary `(?[A-Za-z_][A-Za-z0-9_]*)` para no
+// pisar variables que comparten prefijo (`?x` vs `?xy`).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substituteVars = substituteVars;
+exports.ground = ground;
+exports.applyAction = applyAction;
+exports.preconditionsSatisfied = preconditionsSatisfied;
+exports.goalSatisfied = goalSatisfied;
+exports.groundAll = groundAll;
+/**
+ * Sustituye variables `?var` por sus valores ligados en una cadena.
+ * Si la variable no está en bindings, se deja como está (permite
+ * grounding parcial / debugging).
+ */
+function substituteVars(text, bindings) {
+    // Match ?<ident> donde ident es [A-Za-z_][A-Za-z0-9_-]*.
+    return text.replace(/\?([A-Za-z_][A-Za-z0-9_-]*)/g, (match, name) => {
+        const key = `?${name}`;
+        if (Object.prototype.hasOwnProperty.call(bindings, key)) {
+            return bindings[key];
+        }
+        return match;
+    });
+}
+/**
+ * Aplica un binding a un schema y devuelve una acción ground.
+ *
+ * No valida que el binding cubra todos los parámetros: lo que falte
+ * queda con `?var` en el string (caller's responsibility validar).
+ */
+function ground(action, bindings) {
+    const pre = new Set();
+    const add = new Set();
+    const del = new Set();
+    for (const p of action.preconditions)
+        pre.add(substituteVars(p, bindings));
+    for (const a of action.addList)
+        add.add(substituteVars(a, bindings));
+    for (const d of action.delList)
+        del.add(substituteVars(d, bindings));
+    return { preconditions: pre, addList: add, delList: del };
+}
+/**
+ * Aplica una acción ground a un estado, devolviendo un nuevo estado.
+ *
+ * Convención STRIPS estándar: primero se borran los hechos en delList,
+ * luego se añaden los de addList. Si un hecho está en ambos, el
+ * resultado neto es "añadido" (delete antes que add).
+ *
+ * NO valida preconditions — esa verificación se hace en el planner
+ * antes de invocar applyAction. (Permite usarlo para forward search
+ * sin redundancia.)
+ */
+function applyAction(state, grounded) {
+    const next = new Set(state);
+    for (const d of grounded.delList)
+        next.delete(d);
+    for (const a of grounded.addList)
+        next.add(a);
+    return next;
+}
+/**
+ * Chequea si un estado satisface las preconditions de una acción
+ * ground (todas presentes).
+ */
+function preconditionsSatisfied(state, preconditions) {
+    for (const p of preconditions) {
+        if (!state.has(p))
+            return false;
+    }
+    return true;
+}
+/**
+ * Chequea si un estado satisface el goal (goal ⊆ state).
+ */
+function goalSatisfied(state, goal) {
+    for (const g of goal) {
+        if (!state.has(g))
+            return false;
+    }
+    return true;
+}
+/**
+ * Enumera el producto cartesiano de objetos para los parámetros de
+ * una acción y devuelve TODAS las acciones ground posibles.
+ *
+ * Si el dominio tiene tipos en `objects`, por simplicidad enumeramos
+ * sobre `flatObjects = union(values of objects)`. Quien necesite
+ * tipos más finos puede pre-filtrar las acciones ground devueltas.
+ *
+ * Para |params|=2 con |objs|=10 → 100 acciones ground por schema. Es
+ * fácil que esto explote, así que el planner aplica `preconditionsSatisfied`
+ * como filtro early y typically la mayoría se podan.
+ */
+function groundAll(action, objects) {
+    // Universo plano de objetos disponibles.
+    const allObjects = [];
+    const seen = new Set();
+    for (const vals of Object.values(objects)) {
+        for (const v of vals) {
+            if (!seen.has(v)) {
+                seen.add(v);
+                allObjects.push(v);
+            }
+        }
+    }
+    if (action.parameters.length === 0) {
+        return [{ bindings: {}, grounded: ground(action, {}) }];
+    }
+    // Producto cartesiano iterativo.
+    const results = [];
+    const indices = Array.from({ length: action.parameters.length }, () => 0);
+    const total = allObjects.length;
+    if (total === 0)
+        return [];
+    while (true) {
+        const bindings = {};
+        for (let i = 0; i < action.parameters.length; i++) {
+            const param = action.parameters[i];
+            const idx = indices[i];
+            bindings[param] = allObjects[idx];
+        }
+        results.push({ bindings, grounded: ground(action, bindings) });
+        // Avanzar al siguiente combo (ripple).
+        let k = action.parameters.length - 1;
+        while (k >= 0) {
+            const cur = indices[k] + 1;
+            if (cur < total) {
+                indices[k] = cur;
+                break;
+            }
+            indices[k] = 0;
+            k--;
+        }
+        if (k < 0)
+            break;
+    }
+    return results;
+}
+//# sourceMappingURL=ground.js.map

package/dist/runtime/planning/ground.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground.js","sourceRoot":"","sources":["../../../src/runtime/planning/ground.ts"],"names":[],"mappings":"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"}

package/dist/runtime/planning/heuristic.d.ts

@@ -0,0 +1,29 @@
+import type { Fact, Heuristic, STRIPSAction, STRIPSProblem } from './types';
+/**
+ * Distancia básica: `|goal \ state|` (número de hechos del goal aún
+ * no presentes en state). Es admisible pero muy débil.
+ */
+export declare const goalCountHeuristic: Heuristic;
+/**
+ * Heurística Fast-Forward (versión por niveles, ignora delete-list).
+ *
+ * Construcción:
+ *   F₀ = state
+ *   F_{i+1} = F_i ∪ {add-effects de toda acción ground con pre ⊆ F_i}
+ *   Termina cuando goal ⊆ F_k → devuelve k.
+ *   Si F se estabiliza sin alcanzar el goal → devuelve Infinity
+ *   (estado dead-end del problema relajado, por lo tanto del original).
+ *
+ * Sin delete-list, F crece monotónicamente, así que la iteración
+ * termina en ≤ |universo de hechos accesibles| pasos.
+ *
+ * `actions` debe ser una lista de schemas (lifted). Internamente
+ * grounded en cada nivel con los objetos del dominio.
+ */
+export declare function fastForwardHeuristic(state: Set<Fact>, goal: Set<Fact>, actions: STRIPSAction[], objects?: Record<string, string[]>): number;
+/**
+ * Helper para crear una heurística FF cerrada sobre el problema.
+ * Devuelve una función `Heuristic` que `aStarPlan` puede consumir.
+ */
+export declare function makeFFHeuristic(problem: STRIPSProblem): Heuristic;
+//# sourceMappingURL=heuristic.d.ts.map

package/dist/runtime/planning/heuristic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heuristic.d.ts","sourceRoot":"","sources":["../../../src/runtime/planning/heuristic.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAIhC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAChB,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,EACf,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACjC,MAAM,CA8GR;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,CAEjE"}

package/dist/runtime/planning/heuristic.js

@@ -0,0 +1,172 @@
+"use strict";
+// ============================================================
+// ST Planning — Heurísticas
+// ============================================================
+//
+// Heurística "Fast-Forward" simplificada (Hoffmann & Nebel 2001):
+// ignora la delete-list (delete-relaxation), construye un grafo de
+// planificación relajado por "niveles" hasta que todos los hechos
+// del goal aparezcan, y devuelve el número de niveles como estima.
+//
+// Es admisible (en el sentido relajado) y barata; en práctica guía
+// muy bien a A* clásico para STRIPS.
+//
+// La versión completa de FF haría además extracción de plan relajado
+// con contadores de "support" para mejorar el factor de rama. Acá nos
+// quedamos con la estima por niveles, que ya es estricta mejor que
+// `|goal \ state|` para problemas no triviales.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goalCountHeuristic = void 0;
+exports.fastForwardHeuristic = fastForwardHeuristic;
+exports.makeFFHeuristic = makeFFHeuristic;
+const ground_1 = require("./ground");
+/**
+ * Distancia básica: `|goal \ state|` (número de hechos del goal aún
+ * no presentes en state). Es admisible pero muy débil.
+ */
+const goalCountHeuristic = (state, goal) => {
+    let missing = 0;
+    for (const g of goal)
+        if (!state.has(g))
+            missing++;
+    return missing;
+};
+exports.goalCountHeuristic = goalCountHeuristic;
+/**
+ * Heurística Fast-Forward (versión por niveles, ignora delete-list).
+ *
+ * Construcción:
+ *   F₀ = state
+ *   F_{i+1} = F_i ∪ {add-effects de toda acción ground con pre ⊆ F_i}
+ *   Termina cuando goal ⊆ F_k → devuelve k.
+ *   Si F se estabiliza sin alcanzar el goal → devuelve Infinity
+ *   (estado dead-end del problema relajado, por lo tanto del original).
+ *
+ * Sin delete-list, F crece monotónicamente, así que la iteración
+ * termina en ≤ |universo de hechos accesibles| pasos.
+ *
+ * `actions` debe ser una lista de schemas (lifted). Internamente
+ * grounded en cada nivel con los objetos del dominio.
+ */
+function fastForwardHeuristic(state, goal, actions, objects) {
+    // Early exit.
+    let missing = 0;
+    for (const g of goal)
+        if (!state.has(g))
+            missing++;
+    if (missing === 0)
+        return 0;
+    // Universo plano de objetos para grounding.
+    const allObjects = [];
+    if (objects) {
+        const seen = new Set();
+        for (const vals of Object.values(objects)) {
+            for (const v of vals) {
+                if (!seen.has(v)) {
+                    seen.add(v);
+                    allObjects.push(v);
+                }
+            }
+        }
+    }
+    // Si no hay objetos, solo aplican acciones sin parámetros.
+    const facts = new Set(state);
+    let level = 0;
+    const maxLevel = 1000; // Safety.
+    while (level < maxLevel) {
+        // Goal satisfied en este nivel.
+        let allPresent = true;
+        for (const g of goal) {
+            if (!facts.has(g)) {
+                allPresent = false;
+                break;
+            }
+        }
+        if (allPresent)
+            return level;
+        // Expandir un nivel: snapshot del nivel actual y aplicar toda
+        // acción ground cuyas pre ⊆ snapshot. Los efectos se aplican
+        // sobre `facts` pero las preconditions se chequean contra
+        // `snapshot` — así un mismo nivel no encadena varios pasos.
+        const snapshot = new Set(facts);
+        let added = false;
+        for (const a of actions) {
+            if (a.parameters.length === 0) {
+                // Acción ground directa.
+                let ok = true;
+                for (const p of a.preconditions) {
+                    if (!snapshot.has(p)) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (ok) {
+                    for (const eff of a.addList) {
+                        if (!facts.has(eff)) {
+                            facts.add(eff);
+                            added = true;
+                        }
+                    }
+                }
+            }
+            else {
+                // Enumerar bindings (producto cartesiano).
+                const indices = Array.from({ length: a.parameters.length }, () => 0);
+                const n = allObjects.length;
+                if (n === 0)
+                    continue;
+                while (true) {
+                    const bindings = {};
+                    for (let i = 0; i < a.parameters.length; i++) {
+                        bindings[a.parameters[i]] = allObjects[indices[i]];
+                    }
+                    // Chequear pre contra snapshot.
+                    let ok = true;
+                    for (const p of a.preconditions) {
+                        const inst = (0, ground_1.substituteVars)(p, bindings);
+                        if (!snapshot.has(inst)) {
+                            ok = false;
+                            break;
+                        }
+                    }
+                    if (ok) {
+                        for (const eff of a.addList) {
+                            const inst = (0, ground_1.substituteVars)(eff, bindings);
+                            if (!facts.has(inst)) {
+                                facts.add(inst);
+                                added = true;
+                            }
+                        }
+                    }
+                    // Ripple.
+                    let k = a.parameters.length - 1;
+                    while (k >= 0) {
+                        const cur = indices[k] + 1;
+                        if (cur < n) {
+                            indices[k] = cur;
+                            break;
+                        }
+                        indices[k] = 0;
+                        k--;
+                    }
+                    if (k < 0)
+                        break;
+                }
+            }
+        }
+        if (!added) {
+            // Fixed point: relajación se estabilizó sin alcanzar goal → dead end.
+            return Infinity;
+        }
+        level++;
+    }
+    return Infinity;
+}
+/**
+ * Helper para crear una heurística FF cerrada sobre el problema.
+ * Devuelve una función `Heuristic` que `aStarPlan` puede consumir.
+ */
+function makeFFHeuristic(problem) {
+    return (state, goal) => fastForwardHeuristic(state, goal, problem.actions, problem.objects);
+}
+//# sourceMappingURL=heuristic.js.map

package/dist/runtime/planning/heuristic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heuristic.js","sourceRoot":"","sources":["../../../src/runtime/planning/heuristic.ts"],"names":[],"mappings":"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"}

package/dist/runtime/planning/index.d.ts

@@ -0,0 +1,6 @@
+export { bfsPlan, hashState } from './bfs';
+export { aStarPlan } from './astar';
+export { applyAction, goalSatisfied, ground, groundAll, preconditionsSatisfied, substituteVars, } from './ground';
+export { fastForwardHeuristic, goalCountHeuristic, makeFFHeuristic } from './heuristic';
+export type { AStarOptions, CostFunction, Fact, GroundedAction, Heuristic, Plan, PlanStep, PlannerOptions, STRIPSAction, STRIPSProblem, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/planning/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/planning/index.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EACL,WAAW,EACX,aAAa,EACb,MAAM,EACN,SAAS,EACT,sBAAsB,EACtB,cAAc,GACf,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACxF,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,IAAI,EACJ,cAAc,EACd,SAAS,EACT,IAAI,EACJ,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,aAAa,GACd,MAAM,SAAS,CAAC"}

package/dist/runtime/planning/index.js

@@ -0,0 +1,38 @@
+"use strict";
+// ============================================================
+// ST Planning — Barrel
+// ============================================================
+//
+// Planificación clásica STRIPS / PDDL light.
+//
+// API pública:
+//   - `bfsPlan(problem, opts?)`       → BFS, plan de menor longitud
+//   - `aStarPlan(problem, opts?)`     → A*, plan de menor costo
+//   - `ground(action, bindings)`      → instanciar schema
+//   - `applyAction(state, ground)`    → estado sucesor
+//   - `goalSatisfied(state, goal)`    → goal ⊆ state
+//   - `fastForwardHeuristic(...)`     → heurística FF por niveles
+//   - `makeFFHeuristic(problem)`      → curry FF al problema
+//   - `goalCountHeuristic`            → |goal\state| trivial
+//
+// Tipos: `STRIPSAction`, `STRIPSProblem`, `Plan`, `PlanStep`,
+// `GroundedAction`, `Heuristic`, `PlannerOptions`, `AStarOptions`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFFHeuristic = exports.goalCountHeuristic = exports.fastForwardHeuristic = exports.substituteVars = exports.preconditionsSatisfied = exports.groundAll = exports.ground = exports.goalSatisfied = exports.applyAction = exports.aStarPlan = exports.hashState = exports.bfsPlan = void 0;
+var bfs_1 = require("./bfs");
+Object.defineProperty(exports, "bfsPlan", { enumerable: true, get: function () { return bfs_1.bfsPlan; } });
+Object.defineProperty(exports, "hashState", { enumerable: true, get: function () { return bfs_1.hashState; } });
+var astar_1 = require("./astar");
+Object.defineProperty(exports, "aStarPlan", { enumerable: true, get: function () { return astar_1.aStarPlan; } });
+var ground_1 = require("./ground");
+Object.defineProperty(exports, "applyAction", { enumerable: true, get: function () { return ground_1.applyAction; } });
+Object.defineProperty(exports, "goalSatisfied", { enumerable: true, get: function () { return ground_1.goalSatisfied; } });
+Object.defineProperty(exports, "ground", { enumerable: true, get: function () { return ground_1.ground; } });
+Object.defineProperty(exports, "groundAll", { enumerable: true, get: function () { return ground_1.groundAll; } });
+Object.defineProperty(exports, "preconditionsSatisfied", { enumerable: true, get: function () { return ground_1.preconditionsSatisfied; } });
+Object.defineProperty(exports, "substituteVars", { enumerable: true, get: function () { return ground_1.substituteVars; } });
+var heuristic_1 = require("./heuristic");
+Object.defineProperty(exports, "fastForwardHeuristic", { enumerable: true, get: function () { return heuristic_1.fastForwardHeuristic; } });
+Object.defineProperty(exports, "goalCountHeuristic", { enumerable: true, get: function () { return heuristic_1.goalCountHeuristic; } });
+Object.defineProperty(exports, "makeFFHeuristic", { enumerable: true, get: function () { return heuristic_1.makeFFHeuristic; } });
+//# sourceMappingURL=index.js.map

package/dist/runtime/planning/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/planning/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,uBAAuB;AACvB,+DAA+D;AAC/D,EAAE;AACF,6CAA6C;AAC7C,EAAE;AACF,eAAe;AACf,oEAAoE;AACpE,gEAAgE;AAChE,0DAA0D;AAC1D,uDAAuD;AACvD,qDAAqD;AACrD,kEAAkE;AAClE,6DAA6D;AAC7D,6DAA6D;AAC7D,EAAE;AACF,8DAA8D;AAC9D,mEAAmE;;;AAEnE,6BAA2C;AAAlC,8FAAA,OAAO,OAAA;AAAE,gGAAA,SAAS,OAAA;AAC3B,iCAAoC;AAA3B,kGAAA,SAAS,OAAA;AAClB,mCAOkB;AANhB,qGAAA,WAAW,OAAA;AACX,uGAAA,aAAa,OAAA;AACb,gGAAA,MAAM,OAAA;AACN,mGAAA,SAAS,OAAA;AACT,gHAAA,sBAAsB,OAAA;AACtB,wGAAA,cAAc,OAAA;AAEhB,yCAAwF;AAA/E,iHAAA,oBAAoB,OAAA;AAAE,+GAAA,kBAAkB,OAAA;AAAE,4GAAA,eAAe,OAAA"}

package/dist/runtime/planning/types.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Un hecho atómico ground. Lo representamos como string opaque al
+ * motor — el formato típico es `predicate(arg1, arg2, …)` o simplemente
+ * `predicate-arg1-arg2`. El motor solo compara igualdad de strings.
+ */
+export type Fact = string;
+/**
+ * Una acción STRIPS (puede ser lifted con `?` en los parámetros).
+ *
+ * Convención: los parámetros se nombran con prefijo `?` dentro de
+ * los strings de preconditions/addList/delList. Ejemplo:
+ *
+ *   {
+ *     name: 'move',
+ *     parameters: ['?from', '?to'],
+ *     preconditions: ['at(?from)', 'connected(?from, ?to)'],
+ *     addList: ['at(?to)'],
+ *     delList: ['at(?from)'],
+ *   }
+ *
+ * Para acciones ya ground, `parameters` puede ser `[]` y los strings
+ * no contienen `?`.
+ */
+export interface STRIPSAction {
+    name: string;
+    parameters: string[];
+    preconditions: string[];
+    addList: string[];
+    delList: string[];
+}
+/**
+ * Problema de planificación STRIPS.
+ *
+ * - `predicates`: lista declarativa (puramente documental — no se
+ *   valida internamente, pero sirve para introspección).
+ * - `objects`: mapa de `tipo → valores`. Si no usás tipos, podés
+ *   usar `{ object: [...] }` y referir `object` como el "tipo" en los
+ *   parámetros si quisieras, pero el grounding por defecto enumera
+ *   todos los objetos para cada parámetro (sin filtrar por tipo).
+ * - `actions`: schemas de acciones (lifted o ground).
+ * - `initialState`: hechos verdaderos en S₀ (closed-world assumption).
+ * - `goal`: hechos que deben estar en el estado final. Si goal ⊆ S
+ *   entonces S satisface el goal.
+ */
+export interface STRIPSProblem {
+    predicates: string[];
+    objects: Record<string, string[]>;
+    actions: STRIPSAction[];
+    initialState: Set<Fact>;
+    goal: Set<Fact>;
+}
+/**
+ * Una acción ya instanciada (ground) — el resultado de aplicar un
+ * binding concreto a un schema lifted.
+ */
+export interface GroundedAction {
+    preconditions: Set<Fact>;
+    addList: Set<Fact>;
+    delList: Set<Fact>;
+}
+/** Un paso del plan: el schema + el binding que lo grounded. */
+export interface PlanStep {
+    action: STRIPSAction;
+    bindings: Record<string, string>;
+}
+/**
+ * Plan completo.
+ *
+ * - `actions`: secuencia ordenada de pasos.
+ * - `length`: número de pasos (= actions.length).
+ * - `cost`: costo total. Por default = length (cada acción cuesta 1).
+ */
+export interface Plan {
+    actions: PlanStep[];
+    length: number;
+    cost: number;
+}
+/**
+ * Heurística admisible: estima el costo restante desde `state` hasta
+ * algún estado que satisfaga `goal`. Para A* admisible, debe ser
+ * ≤ costo real (no sobreestimar).
+ */
+export type Heuristic = (state: Set<Fact>, goal: Set<Fact>) => number;
+/** Costo por acción (default: 1). Permite acciones de costo variable. */
+export type CostFunction = (step: PlanStep) => number;
+export interface PlannerOptions {
+    /** Profundidad máxima del plan. Default: 50 para BFS, 200 para A*. */
+    maxDepth?: number;
+    /**
+     * Límite de nodos expandidos (corta búsqueda explosiva). Default:
+     * 100_000.
+     */
+    maxNodes?: number;
+    /** Costo por acción. Default: () => 1. */
+    costFunction?: CostFunction;
+}
+export interface AStarOptions extends PlannerOptions {
+    heuristic?: Heuristic;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/planning/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/planning/types.ts"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAClC,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,YAAY,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IACxB,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IACzB,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IACnB,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;CACpB;AAED,gEAAgE;AAChE,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,IAAI;IACnB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,MAAM,CAAC;AAEtE,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,CAAC;AAEtD,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB"}

package/dist/runtime/planning/types.js

@@ -0,0 +1,22 @@
+"use strict";
+// ============================================================
+// ST Planning — Tipos públicos (STRIPS / PDDL light)
+// ============================================================
+//
+// STRIPS (Fikes & Nilsson 1971): planificación clásica donde el
+// estado es un conjunto finito de hechos atómicos y las acciones
+// modifican ese conjunto mediante:
+//
+//   - preconditions: hechos que deben estar presentes para aplicar
+//   - addList:       hechos que se vuelven verdaderos tras aplicar
+//   - delList:       hechos que se eliminan tras aplicar
+//
+// El planificador busca una secuencia ⟨a₁, …, aₙ⟩ tal que aplicarla
+// al estado inicial S₀ produzca un estado Sₙ ⊇ goal.
+//
+// "PDDL light": soportamos parámetros tipados via `objects` y
+// `parameters` (los strings con `?x` se sustituyen). No soportamos
+// fluents numéricos, cuantificadores universales, ni tipos
+// jerárquicos — el grueso del PDDL nivel 1 (STRIPS + typing).
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/runtime/planning/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/planning/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,qDAAqD;AACrD,+DAA+D;AAC/D,EAAE;AACF,gEAAgE;AAChE,iEAAiE;AACjE,mCAAmC;AACnC,EAAE;AACF,mEAAmE;AACnE,mEAAmE;AACnE,yDAAyD;AACzD,EAAE;AACF,oEAAoE;AACpE,qDAAqD;AACrD,EAAE;AACF,8DAA8D;AAC9D,mEAAmE;AACnE,2DAA2D;AAC3D,8DAA8D"}

package/dist/runtime/proof-minify/index.d.ts

@@ -0,0 +1,3 @@
+export { minifyProof, compactModusPonensChain, removeUnusedSubproofs, countNodes, depthOf, } from './minify';
+export type { GenericProofNode, MinifyOptions, MinifyResult, MinifyRule } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/proof-minify/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/proof-minify/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,WAAW,EACX,uBAAuB,EACvB,qBAAqB,EACrB,UAAU,EACV,OAAO,GACR,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}

package/dist/runtime/proof-minify/index.js

@@ -0,0 +1,13 @@
+"use strict";
+// ============================================================
+// ST Proof Minification — Barrel
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depthOf = exports.countNodes = exports.removeUnusedSubproofs = exports.compactModusPonensChain = exports.minifyProof = void 0;
+var minify_1 = require("./minify");
+Object.defineProperty(exports, "minifyProof", { enumerable: true, get: function () { return minify_1.minifyProof; } });
+Object.defineProperty(exports, "compactModusPonensChain", { enumerable: true, get: function () { return minify_1.compactModusPonensChain; } });
+Object.defineProperty(exports, "removeUnusedSubproofs", { enumerable: true, get: function () { return minify_1.removeUnusedSubproofs; } });
+Object.defineProperty(exports, "countNodes", { enumerable: true, get: function () { return minify_1.countNodes; } });
+Object.defineProperty(exports, "depthOf", { enumerable: true, get: function () { return minify_1.depthOf; } });
+//# sourceMappingURL=index.js.map

package/dist/runtime/proof-minify/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/proof-minify/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,iCAAiC;AACjC,+DAA+D;;;AAE/D,mCAMkB;AALhB,qGAAA,WAAW,OAAA;AACX,iHAAA,uBAAuB,OAAA;AACvB,+GAAA,qBAAqB,OAAA;AACrB,oGAAA,UAAU,OAAA;AACV,iGAAA,OAAO,OAAA"}

package/dist/runtime/proof-minify/minify.d.ts

@@ -0,0 +1,13 @@
+import type { GenericProofNode, MinifyOptions, MinifyResult } from './types';
+/** Cuenta los nodos de un árbol (raíz incluida). */
+export declare function countNodes(n: GenericProofNode): number;
+/** Profundidad máxima (raíz = 0). */
+export declare function depthOf(n: GenericProofNode): number;
+export declare function compactModusPonensChain(proof: GenericProofNode): GenericProofNode;
+export declare function removeUnusedSubproofs(proof: GenericProofNode): GenericProofNode;
+/**
+ * Minifica un árbol de pruebas iterando las reglas hasta punto fijo
+ * o agotar `maxIterations`.
+ */
+export declare function minifyProof(proof: GenericProofNode, opts?: MinifyOptions): MinifyResult;
+//# sourceMappingURL=minify.d.ts.map

package/dist/runtime/proof-minify/minify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minify.d.ts","sourceRoot":"","sources":["../../../src/runtime/proof-minify/minify.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,YAAY,EAAc,MAAM,SAAS,CAAC;AA2GzF,oDAAoD;AACpD,wBAAgB,UAAU,CAAC,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAItD;AAED,qCAAqC;AACrC,wBAAgB,OAAO,CAAC,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAQnD;AAqGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,CAwBjF;AAgJD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,CAG/E;AA8GD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,GAAE,aAAkB,GAAG,YAAY,CAuC3F"}