@stevenvo780/st-lang 4.4.0 → 4.5.1

package/README.md

@@ -7,7 +7,8 @@
 **ST** es un lenguaje ejecutable para lógica, argumentación y formalización documental.
 Combina verificación formal, scripting declarativo, control de flujo, funciones, perfiles lógicos múltiples y una **Text Layer** para conectar fórmulas con texto humano real.
 
-[![Version](https://img.shields.io/badge/version-3.3.0-blue.svg)](package.json)
+[![Version](https://img.shields.io/badge/version-4.5.0-blue.svg)](package.json)
+[![Tests](https://img.shields.io/badge/tests-4041-brightgreen.svg)]()
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Build Status](https://img.shields.io/badge/build-passing-brightgreen.svg)]()
 
@@ -37,7 +38,7 @@ Combina verificación formal, scripting declarativo, control de flujo, funciones
 ### Con npm
 
 ```bash
-npm install -g @stevenvo780/st-lang
+npm install @stevenvo780/st-lang@4.5.0
 ```
 
 ### Desde el código fuente
@@ -52,41 +53,72 @@ npm link
 
 ---
 
-## Novedades en 3.3
-
-### AST visitors tipados
-
-Refactor del parser monolítico a un sistema de visitors con tipos exhaustivos.
-
-```typescript
-import { visit, BaseASTVisitor } from '@stevenvo780/st-lang/ast';
-
-class MyVisitor extends BaseASTVisitor<string> {
-  visitDerive(node) { return `derive: ${node.conclusion}`; }
-  // TypeScript exige manejar cada variante del AST
-}
-
-const result = visit(programAST, new MyVisitor());
-```
-
-### Type checker en runtime
-
-Valida programas antes de ejecutarlos. Detecta 7 categorías de error
-(TC001–TC008) con sugerencias automáticas vía distancia Levenshtein.
-
-```typescript
-import { typeCheck, evaluate } from '@stevenvo780/st-lang';
-
-const errors = typeCheck(programAST, 'classical', 'file.st');
-if (errors.length === 0) {
-  const result = evaluate(programAST, 'classical');
-}
-```
-
-### Cobertura y benchmarks
-
-- Tests: 1621 (cobertura 78.81%, subió desde 71%).
-- Suite de benchmarks formal con baselines y detección de regresión de rendimiento.
+## What's new in V4 (4.0 → 4.5.0)
+
+52+ módulos nuevos. 4041 tests (eran 1583 en v3.3).
+
+### Performance & SAT
+- CDCL v2 con VSIDS, clause learning y reinicios Luby.
+- SAT incremental — reutiliza estado entre consultas.
+- MUS (Minimal Unsatisfiable Subsets) para diagnóstico de inconsistencias.
+- Cache de derivaciones con memoización y theorem-cache persistente.
+
+### Type theory
+- Curry-Howard: pruebas como programas, términos como tipos.
+- System F con polimorfismo paramétrico.
+- MLTT (Martin-Löf Type Theory) con tipos dependientes.
+- NbE (Normalización por Evaluación) para reducción eficiente.
+- Refinement types sobre términos base.
+
+### Modal & temporal
+- Frame axioms K / T / B / 4 / 5 / D; sistemas S4, S5, KD45 completos.
+- CTL (Computation Tree Logic) con operadores EX/AX/EF/AF/EG/AG.
+- LTL (Linear Temporal Logic) con next/until/release.
+- μ-calculus modal con punto fijo mínimo y máximo.
+- Hybrid logic con operadores de nombrado y satisfacción (@).
+
+### Substructural & resource logic
+- Lógica lineal y afín (no-contraction, no-weakening).
+- π-calculus: razonamiento sobre procesos concurrentes.
+- Proof nets: representación canónica de pruebas lineales.
+
+### Non-classical
+- Intuicionista NJ (natural deduction intuicionista completa).
+- Lógica many-valued (Łukasiewicz, Gödel) y Belnap four-valued.
+- Paraconsistente — soporte para contradicciones sin explosión.
+
+### Decision procedures
+- FOL con igualdad — resolución para fragmentos decidibles.
+- ALC Description Logic (subsumption, instance checking).
+- AC-3 CSP — constraint propagation para problemas de satisfacción.
+- STRIPS — planificación clásica sobre estados y acciones.
+
+### Probabilistic & uncertainty
+- Bayesian reasoning con redes y propagación de evidencia.
+- Hyperreal extensions: probabilidad con infinitesimales.
+- Fuzzy logic — valores de verdad continuos en [0,1].
+
+### Term mechanics
+- TRS + KB (Term Rewriting Systems + Knuth-Bendix completion).
+- Anti-unification — lgg (least general generalization) de términos.
+- HO-unify (Higher-Order Unification).
+- SKI combinators y reducción.
+- λ-calculus con α/β/η reducción.
+
+### Integration
+- Text Layer v2 con invalidación propagada de claims.
+- MDX bridge bidireccional: prosa ↔ ST sincronizados.
+- Proof exchange Ed25519: pruebas firmadas y compartibles entre workspaces.
+- Time-travel: snapshots ST por commit de workspace.
+- Plugin system: perfiles lógicos custom registrables en runtime.
+
+### Knowledge & argumentation
+- FCA (Formal Concept Analysis) — retículos de conceptos formales.
+- Dung argumentation — grafos de ataque, extensiones admisibles/estables.
+- Default logic — inferencia por defecto con excepciones.
+- AGM belief revision — cambio de creencias con postulados AGM.
+- Abduction — inferencia a la mejor explicación.
+- Profile bridge — mapeo semántico entre perfiles lógicos.
 
 ---
 
@@ -403,6 +435,15 @@ st.exec('logic arithmetic');
 st.exec('explain 2 + 3 * 4');
 ```
 
+### Subpaths disponibles
+
+| Subpath | Uso |
+|---------|-----|
+| `@stevenvo780/st-lang` | Entrypoint principal: `evaluate`, `typeCheck`, `createInterpreter` |
+| `@stevenvo780/st-lang/api` | API pura sin CLI: `evaluate`, `createInterpreter` |
+| `@stevenvo780/st-lang/types` | Tipos TypeScript exportados (AST, perfiles, resultados) |
+| `@stevenvo780/st-lang/protocol` | `ProtocolHandler` para integraciones de editor |
+
 ---
 
 ## Carpeta `examples/`

package/dist/coinduction/index.d.ts

@@ -0,0 +1,136 @@
+export interface Stream<T> {
+    head: T;
+    tail: () => Stream<T>;
+}
+/**
+ * Cons explícito: crea un stream con cabeza `h` y cola perezosa
+ * `t` (una función que produce el resto cuando se evalúa).
+ */
+export declare function cons<T>(h: T, t: () => Stream<T>): Stream<T>;
+/**
+ * `repeat(x)` = x, x, x, ...  (stream constante)
+ *
+ * Definición corecursiva clásica: repeat(x) = cons(x, () => repeat(x)).
+ * El thunk evita la recursión infinita en tiempo de construcción.
+ */
+export declare function repeat<T>(x: T): Stream<T>;
+/**
+ * `iterate(f, x)` = x, f(x), f(f(x)), ...
+ *
+ * Definición corecursiva: iterate(f, x) = cons(x, () => iterate(f, f(x))).
+ */
+export declare function iterate<T>(f: (x: T) => T, x: T): Stream<T>;
+/**
+ * `unfold(seed, step)`: anamorfismo genérico. `step(s)` devuelve
+ * el siguiente par `[valor, próximaSemilla]` o `null` para terminar.
+ * Para streams infinitos, `step` nunca debe devolver `null`. Si
+ * devuelve `null` durante una iteración, devolvemos un stream que
+ * cicla la última cabeza producida (decisión: streams totales).
+ */
+export declare function unfold<S, T>(seed: S, step: (s: S) => readonly [T, S] | null): Stream<T>;
+/**
+ * `take(s, n)`: extrae los primeros n elementos de un stream.
+ * Observación finita; es la única forma de "ver" un stream.
+ */
+export declare function take<T>(s: Stream<T>, n: number): T[];
+/**
+ * `drop(s, n)`: descarta los primeros n elementos.
+ */
+export declare function drop<T>(s: Stream<T>, n: number): Stream<T>;
+/**
+ * `nth(s, i)`: i-ésimo elemento (0-indexed).
+ */
+export declare function nth<T>(s: Stream<T>, i: number): T;
+/**
+ * `map(f, s)`: aplica `f` a cada elemento.
+ *
+ * Definición corecursiva: map(f, s) = cons(f(head s), () => map(f, tail s)).
+ */
+export declare function map<T, U>(f: (x: T) => U, s: Stream<T>): Stream<U>;
+/**
+ * `zipWith(f, a, b)`: combina dos streams elemento a elemento.
+ *
+ * zipWith(f, a, b) = cons(f(head a, head b), () => zipWith(f, tail a, tail b))
+ */
+export declare function zipWith<A, B, C>(f: (a: A, b: B) => C, a: Stream<A>, b: Stream<B>): Stream<C>;
+/**
+ * `zip(a, b)`: par-zip estándar.
+ */
+export declare function zip<A, B>(a: Stream<A>, b: Stream<B>): Stream<[A, B]>;
+/**
+ * `filter(pred, s)`: PRECONDICIÓN — el predicado debe ser satisfecho
+ * infinitas veces, de lo contrario el stream resultante se "atasca".
+ * No protegemos contra eso porque coinductivamente no es decidible.
+ */
+export declare function filter<T>(pred: (x: T) => boolean, s: Stream<T>): Stream<T>;
+/**
+ * naturals = 0, 1, 2, 3, ...
+ */
+export declare const naturals: Stream<number>;
+export declare const fibonacci: Stream<number>;
+export interface BisimulationProof<T> {
+    /** Par inicial cuyo membership en la bisimulación queremos probar. */
+    initial: [Stream<T>, Stream<T>];
+    /**
+     * Relación candidata R. Por bisimulación, basta que R sea una
+     * "bisimulación up-to": cerrada bajo los destructores en el sentido
+     * de que R(s,t) ⇒ R(tail s, tail t).
+     */
+    relation: (a: Stream<T>, b: Stream<T>) => boolean;
+}
+/**
+ * `isBisimilar(a, b, depth)`: chequeo de bisimilaridad acotado.
+ * Compara cabezas hasta profundidad `depth`. Retorna `false` apenas
+ * encuentra una divergencia (refutación constructiva); retorna `true`
+ * si los primeros `depth` elementos coinciden (evidencia positiva
+ * acotada — para una prueba real de bisimilaridad, usar `prove`).
+ *
+ * Usa `Object.is` para comparar primitivos. Para tipos compuestos
+ * el caller debería envolver con un equality explícito (no hacemos
+ * deep-equals porque tendría costo no obvio y semántica ambigua).
+ */
+export declare function isBisimilar<T>(a: Stream<T>, b: Stream<T>, depth?: number): boolean;
+/**
+ * Igualdad observacional para elementos de un stream. Soportamos:
+ *   • primitivos (===, con Object.is para NaN/+0/-0)
+ *   • arrays y tuplas (recursión elemento a elemento)
+ *   • objetos planos por keys propias
+ * No hace circular-detection: si pasás un grafo cíclico, va a colgar.
+ */
+declare function equal(x: unknown, y: unknown): boolean;
+/**
+ * `prove(claim, depth)`: aplica la técnica de bisimulación up-to.
+ *
+ * Algoritmo: empieza con el par inicial, y para cada paso i ∈ [0, depth):
+ *   1. Verifica que la relación R sostenga el par actual (a_i, b_i).
+ *   2. Verifica que las cabezas sean iguales: head(a_i) = head(b_i).
+ *   3. Avanza: a_{i+1} = tail(a_i), b_{i+1} = tail(b_i).
+ *
+ * Si la relación R es genuinamente una bisimulación (clausurada bajo
+ * tail), todos los pasos pasarán para cualquier `depth`. El método
+ * es completo "en el límite": probar para `depth = ∞` ≡ probar bisim.
+ * En la práctica devolvemos true si depth pasos pasaron sin error.
+ *
+ * Si la relación falla en algún paso, retornamos false (evidencia de
+ * que R no es una bisimulación, o de que (a, b) no es bisimilar).
+ */
+export declare function prove<T>(claim: BisimulationProof<T>, depth?: number): boolean;
+/**
+ * `interleave(a, b)`: intercala a, b, a, b, ... toma 1 de a luego 1 de b.
+ *
+ * interleave(a, b) = cons(head a, () => interleave(b, tail a))
+ *
+ * Nota: el "switch" entre a y b se hace por el truco clásico:
+ * llamar recursivamente con los argumentos invertidos.
+ */
+export declare function interleave<T>(a: Stream<T>, b: Stream<T>): Stream<T>;
+/**
+ * `scan(f, init, s)`: prefijos acumulados; análogo a Array.prototype.reduce
+ * pero coinductivo. scan(+, 0, naturals) = 0, 0, 1, 3, 6, 10, ...
+ */
+export declare function scan<T, U>(f: (acc: U, x: T) => U, init: U, s: Stream<T>): Stream<U>;
+export declare const __internals: {
+    equal: typeof equal;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/coinduction/index.d.ts.map

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

package/dist/coinduction/index.js

@@ -0,0 +1,318 @@
+"use strict";
+// ============================================================
+// ST Coinduction — Streams + corecursion + bisimulación up-to
+// ============================================================
+// Streams coinductivos definidos por destructores (head, tail).
+// Construcción corecursiva via thunks perezosos (la cola es una
+// función `() => Stream<T>` para evitar evaluación infinita).
+//
+// Bisimulación: la noción natural de igualdad para streams. Dos
+// streams `s, t` son bisimilares si existe una relación R tal que
+//   • R(s, t) ⇒ head(s) = head(t)
+//   • R(s, t) ⇒ R(tail(s), tail(t))
+// La igualdad sintáctica falla (dos streams pueden generar la
+// misma secuencia con thunks distintos); la bisimulación es la
+// clausura coinductiva apropiada.
+//
+// Como las secuencias son infinitas no podemos verificar
+// bisimilaridad en general (semi-decidible). Por eso ofrecemos:
+//   • isBisimilar(a, b, depth): chequeo "hasta profundidad", suficiente
+//     para refutación (encontrar el primer prefijo divergente) y para
+//     evidencia computacional positiva acotada.
+//   • prove(claim, depth): técnica "bisimulación up-to". El usuario
+//     provee una relación R; chequeamos por `depth` pasos que
+//       R(a,b) ⇒ head(a)=head(b) ∧ R(tail a, tail b).
+//     Si la relación es realmente una bisimulación, ningún paso falla;
+//     si depth pasos pasaron sin fallar, tenemos alta confianza
+//     (en el caso límite, todos los pasos válidos = bisimulación).
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__internals = exports.fibonacci = exports.naturals = void 0;
+exports.cons = cons;
+exports.repeat = repeat;
+exports.iterate = iterate;
+exports.unfold = unfold;
+exports.take = take;
+exports.drop = drop;
+exports.nth = nth;
+exports.map = map;
+exports.zipWith = zipWith;
+exports.zip = zip;
+exports.filter = filter;
+exports.isBisimilar = isBisimilar;
+exports.prove = prove;
+exports.interleave = interleave;
+exports.scan = scan;
+// ── Constructores ───────────────────────────────────────────
+/**
+ * Cons explícito: crea un stream con cabeza `h` y cola perezosa
+ * `t` (una función que produce el resto cuando se evalúa).
+ */
+function cons(h, t) {
+    return { head: h, tail: t };
+}
+/**
+ * `repeat(x)` = x, x, x, ...  (stream constante)
+ *
+ * Definición corecursiva clásica: repeat(x) = cons(x, () => repeat(x)).
+ * El thunk evita la recursión infinita en tiempo de construcción.
+ */
+function repeat(x) {
+    // Truco para evitar reconstruir el objeto en cada `tail`: usamos
+    // un nodo que se referencia a sí mismo. Esto preserva la semántica
+    // (tail(repeat x) = repeat x) y además garantiza punto-fijo.
+    const node = { head: x, tail: () => node };
+    return node;
+}
+/**
+ * `iterate(f, x)` = x, f(x), f(f(x)), ...
+ *
+ * Definición corecursiva: iterate(f, x) = cons(x, () => iterate(f, f(x))).
+ */
+function iterate(f, x) {
+    return { head: x, tail: () => iterate(f, f(x)) };
+}
+/**
+ * `unfold(seed, step)`: anamorfismo genérico. `step(s)` devuelve
+ * el siguiente par `[valor, próximaSemilla]` o `null` para terminar.
+ * Para streams infinitos, `step` nunca debe devolver `null`. Si
+ * devuelve `null` durante una iteración, devolvemos un stream que
+ * cicla la última cabeza producida (decisión: streams totales).
+ */
+function unfold(seed, step) {
+    const next = step(seed);
+    if (next === null) {
+        // Streams en este módulo son totales; si el cliente decide terminar,
+        // estabilizamos en un punto fijo trivial usando undefined.
+        // En la práctica, los callers no deberían llamar unfold con un step
+        // que puede devolver null si esperan un stream infinito.
+        throw new Error('unfold: step returned null on infinite stream');
+    }
+    const [value, nextSeed] = next;
+    return { head: value, tail: () => unfold(nextSeed, step) };
+}
+// ── Destructores y observaciones ────────────────────────────
+/**
+ * `take(s, n)`: extrae los primeros n elementos de un stream.
+ * Observación finita; es la única forma de "ver" un stream.
+ */
+function take(s, n) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error(`take: n debe ser entero no-negativo, recibido ${n}`);
+    }
+    const out = [];
+    let cur = s;
+    for (let i = 0; i < n; i++) {
+        out.push(cur.head);
+        cur = cur.tail();
+    }
+    return out;
+}
+/**
+ * `drop(s, n)`: descarta los primeros n elementos.
+ */
+function drop(s, n) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error(`drop: n debe ser entero no-negativo, recibido ${n}`);
+    }
+    let cur = s;
+    for (let i = 0; i < n; i++)
+        cur = cur.tail();
+    return cur;
+}
+/**
+ * `nth(s, i)`: i-ésimo elemento (0-indexed).
+ */
+function nth(s, i) {
+    return drop(s, i).head;
+}
+// ── Functor / aplicativos ───────────────────────────────────
+/**
+ * `map(f, s)`: aplica `f` a cada elemento.
+ *
+ * Definición corecursiva: map(f, s) = cons(f(head s), () => map(f, tail s)).
+ */
+function map(f, s) {
+    return { head: f(s.head), tail: () => map(f, s.tail()) };
+}
+/**
+ * `zipWith(f, a, b)`: combina dos streams elemento a elemento.
+ *
+ * zipWith(f, a, b) = cons(f(head a, head b), () => zipWith(f, tail a, tail b))
+ */
+function zipWith(f, a, b) {
+    return {
+        head: f(a.head, b.head),
+        tail: () => zipWith(f, a.tail(), b.tail()),
+    };
+}
+/**
+ * `zip(a, b)`: par-zip estándar.
+ */
+function zip(a, b) {
+    return zipWith((x, y) => [x, y], a, b);
+}
+/**
+ * `filter(pred, s)`: PRECONDICIÓN — el predicado debe ser satisfecho
+ * infinitas veces, de lo contrario el stream resultante se "atasca".
+ * No protegemos contra eso porque coinductivamente no es decidible.
+ */
+function filter(pred, s) {
+    let cur = s;
+    while (!pred(cur.head)) {
+        cur = cur.tail();
+    }
+    const advanced = cur;
+    return {
+        head: advanced.head,
+        tail: () => filter(pred, advanced.tail()),
+    };
+}
+// ── Streams notables ────────────────────────────────────────
+/**
+ * naturals = 0, 1, 2, 3, ...
+ */
+exports.naturals = iterate((n) => n + 1, 0);
+/**
+ * fibonacci = 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
+ *
+ * Definición clásica corecursiva (Hinze):
+ *   fib = 0 :: 1 :: zipWith(+, fib, tail fib)
+ *
+ * En TypeScript necesitamos un thunk que se autorreferencie. Lo
+ * implementamos con una closure que devuelve siempre el mismo nodo.
+ */
+function makeFibonacci() {
+    // fib(n) clásico vía iterate sobre el par (a, b) = (fib n, fib (n+1)).
+    // Equivalente computacionalmente a la definición zipWith pero sin
+    // requerir auto-referencia en TS (que generaría thunks anidados
+    // exponencialmente sin memoización).
+    return map(([a, _b]) => a, iterate(([a, b]) => [b, a + b], [0, 1]));
+}
+exports.fibonacci = makeFibonacci();
+const DEFAULT_DEPTH = 64;
+/**
+ * `isBisimilar(a, b, depth)`: chequeo de bisimilaridad acotado.
+ * Compara cabezas hasta profundidad `depth`. Retorna `false` apenas
+ * encuentra una divergencia (refutación constructiva); retorna `true`
+ * si los primeros `depth` elementos coinciden (evidencia positiva
+ * acotada — para una prueba real de bisimilaridad, usar `prove`).
+ *
+ * Usa `Object.is` para comparar primitivos. Para tipos compuestos
+ * el caller debería envolver con un equality explícito (no hacemos
+ * deep-equals porque tendría costo no obvio y semántica ambigua).
+ */
+function isBisimilar(a, b, depth = DEFAULT_DEPTH) {
+    if (!Number.isInteger(depth) || depth < 0) {
+        throw new Error(`isBisimilar: depth debe ser entero no-negativo, recibido ${depth}`);
+    }
+    let curA = a;
+    let curB = b;
+    for (let i = 0; i < depth; i++) {
+        if (!equal(curA.head, curB.head))
+            return false;
+        curA = curA.tail();
+        curB = curB.tail();
+    }
+    return true;
+}
+/**
+ * Igualdad observacional para elementos de un stream. Soportamos:
+ *   • primitivos (===, con Object.is para NaN/+0/-0)
+ *   • arrays y tuplas (recursión elemento a elemento)
+ *   • objetos planos por keys propias
+ * No hace circular-detection: si pasás un grafo cíclico, va a colgar.
+ */
+function equal(x, y) {
+    if (Object.is(x, y))
+        return true;
+    if (typeof x !== typeof y)
+        return false;
+    if (x === null || y === null)
+        return false;
+    if (typeof x !== 'object')
+        return false;
+    if (Array.isArray(x) !== Array.isArray(y))
+        return false;
+    if (Array.isArray(x) && Array.isArray(y)) {
+        if (x.length !== y.length)
+            return false;
+        for (let i = 0; i < x.length; i++) {
+            if (!equal(x[i], y[i]))
+                return false;
+        }
+        return true;
+    }
+    const ox = x;
+    const oy = y;
+    const kx = Object.keys(ox);
+    const ky = Object.keys(oy);
+    if (kx.length !== ky.length)
+        return false;
+    for (const k of kx) {
+        if (!Object.prototype.hasOwnProperty.call(oy, k))
+            return false;
+        if (!equal(ox[k], oy[k]))
+            return false;
+    }
+    return true;
+}
+/**
+ * `prove(claim, depth)`: aplica la técnica de bisimulación up-to.
+ *
+ * Algoritmo: empieza con el par inicial, y para cada paso i ∈ [0, depth):
+ *   1. Verifica que la relación R sostenga el par actual (a_i, b_i).
+ *   2. Verifica que las cabezas sean iguales: head(a_i) = head(b_i).
+ *   3. Avanza: a_{i+1} = tail(a_i), b_{i+1} = tail(b_i).
+ *
+ * Si la relación R es genuinamente una bisimulación (clausurada bajo
+ * tail), todos los pasos pasarán para cualquier `depth`. El método
+ * es completo "en el límite": probar para `depth = ∞` ≡ probar bisim.
+ * En la práctica devolvemos true si depth pasos pasaron sin error.
+ *
+ * Si la relación falla en algún paso, retornamos false (evidencia de
+ * que R no es una bisimulación, o de que (a, b) no es bisimilar).
+ */
+function prove(claim, depth = DEFAULT_DEPTH) {
+    if (!Number.isInteger(depth) || depth < 0) {
+        throw new Error(`prove: depth debe ser entero no-negativo, recibido ${depth}`);
+    }
+    let [curA, curB] = claim.initial;
+    for (let i = 0; i < depth; i++) {
+        if (!claim.relation(curA, curB))
+            return false;
+        if (!equal(curA.head, curB.head))
+            return false;
+        curA = curA.tail();
+        curB = curB.tail();
+    }
+    return true;
+}
+// ── Utilidades para combinar streams (Hinze classics) ──────
+/**
+ * `interleave(a, b)`: intercala a, b, a, b, ... toma 1 de a luego 1 de b.
+ *
+ * interleave(a, b) = cons(head a, () => interleave(b, tail a))
+ *
+ * Nota: el "switch" entre a y b se hace por el truco clásico:
+ * llamar recursivamente con los argumentos invertidos.
+ */
+function interleave(a, b) {
+    return {
+        head: a.head,
+        tail: () => interleave(b, a.tail()),
+    };
+}
+/**
+ * `scan(f, init, s)`: prefijos acumulados; análogo a Array.prototype.reduce
+ * pero coinductivo. scan(+, 0, naturals) = 0, 0, 1, 3, 6, 10, ...
+ */
+function scan(f, init, s) {
+    return {
+        head: init,
+        tail: () => scan(f, f(init, s.head), s.tail()),
+    };
+}
+// ── Exports auxiliares para tests ───────────────────────────
+exports.__internals = { equal };
+//# sourceMappingURL=index.js.map

package/dist/coinduction/index.js.map

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

package/dist/combinators-ski/abstract.d.ts

@@ -0,0 +1,5 @@
+import type { Term as LambdaTerm } from '../lambda-calc/types';
+import type { CTerm } from './types';
+export declare function abstractFromLambda(t: LambdaTerm): CTerm;
+export declare function toLambda(c: CTerm): LambdaTerm;
+//# sourceMappingURL=abstract.d.ts.map

package/dist/combinators-ski/abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.d.ts","sourceRoot":"","sources":["../../src/combinators-ski/abstract.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIrC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,UAAU,GAAG,KAAK,CAYvD;AA+BD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG,UAAU,CAmB7C"}