@stevenvo780/st-lang 4.5.1 → 4.6.0

package/dist/csp-hoare/analysis.js

@@ -0,0 +1,317 @@
+"use strict";
+// ============================================================
+// CSP Hoare — Trazas, failures, deadlock, livelock, refinement
+// ============================================================
+// Sobre la LTS definida en `semantics.ts` calculamos las semánticas
+// observacionales clásicas de CSP:
+//
+//   • traces(P)   — conjunto de prefijos de eventos visibles posibles.
+//   • failures(P) — pares (traza, refusal). El conjunto de refusal es el
+//                   conjunto de eventos que el proceso PUEDE rehusar tras
+//                   esa traza, bajo ALGUNA resolución del no-determinismo.
+//
+// Refinement (notación CSP estándar):
+//
+//   P ⊑_T Q   ⇔   traces(Q) ⊆ traces(P)
+//   P ⊑_F Q   ⇔   traces(Q) ⊆ traces(P) ∧ failures(Q) ⊆ failures(P)
+//
+// Intuición: Q refina a P sii Q es "más predecible" / "más determinista".
+// STOP es el refinement máximo: refina todo lo que tenga traza vacía.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traces = traces;
+exports.failures = failures;
+exports.isDeadlocked = isDeadlocked;
+exports.isLiveLocked = isLiveLocked;
+exports.refinesTraces = refinesTraces;
+exports.refinesFailures = refinesFailures;
+const semantics_1 = require("./semantics");
+// ── Trazas ──────────────────────────────────────────────────
+/**
+ * Enumera todas las trazas de `p` hasta longitud `maxLength` (inclusive).
+ * Incluye la traza vacía (siempre presente) y los prefijos intermedios.
+ *
+ * Las trazas se devuelven sin duplicados, ordenadas por longitud
+ * ascendente, y como copias de arrays inmutables (las modificaciones no
+ * afectan el motor).
+ */
+function traces(p, maxLength = 6) {
+    const seen = new Set();
+    const out = [];
+    const visit = (q, prefix) => {
+        const key = prefix.join('
');
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push([...prefix]);
+        if (prefix.length >= maxLength)
+            return;
+        // Para enumerar trazas hay que considerar TODAS las resoluciones
+        // internas: cada rama puede ofrecer eventos distintos.
+        const resolutions = (0, semantics_1.internalResolutions)(q);
+        for (const r of resolutions) {
+            const initials = (0, semantics_1.nextEvents)(r);
+            for (const e of initials) {
+                const next = (0, semantics_1.step)(r, e);
+                if (next !== null) {
+                    visit(next, [...prefix, e]);
+                }
+            }
+        }
+    };
+    visit(p, []);
+    // Orden estable: por longitud, luego lex.
+    out.sort((a, b) => {
+        if (a.length !== b.length)
+            return a.length - b.length;
+        for (let i = 0; i < a.length; i++) {
+            const av = a[i] ?? '';
+            const bv = b[i] ?? '';
+            if (av !== bv)
+                return av < bv ? -1 : 1;
+        }
+        return 0;
+    });
+    return out;
+}
+// ── Failures ────────────────────────────────────────────────
+/**
+ * Para una RESOLUCIÓN interna estable `q`, el conjunto de refusal máximo
+ * sobre un alfabeto candidato `Σ` es: todo evento de `Σ` que `q` no
+ * ofrezca como inicial. (Definición estándar: R es refusal sii q no
+ * tiene transición para ningún a ∈ R.)
+ *
+ * `candidates` debe ser el conjunto de eventos relevantes (alfabeto de
+ * comparación) — típicamente la unión sintáctica de los alfabetos de los
+ * procesos involucrados en un test de refinement.
+ */
+function refusalsOf(q, candidates) {
+    const offered = (0, semantics_1.nextEvents)(q);
+    const r = new Set();
+    for (const e of candidates) {
+        if (!offered.has(e))
+            r.add(e);
+    }
+    return r;
+}
+/**
+ * Calcula failures hasta `maxLength`. Para cada traza alcanzable, registra
+ * los refusal sets posibles iterando todas las resoluciones internas del
+ * estado tras la traza.
+ *
+ * Devuelve una lista (no un set) porque los refusal sets son objetos —
+ * agrupamos por igualdad estructural y deduplicamos manualmente.
+ */
+function failures(p, maxLength = 4) {
+    const alphaPrime = collectVisibleEvents(p);
+    const reachable = [];
+    const seenStates = new Set();
+    const enqueue = (state, trace) => {
+        const key = trace.join('
');
+        if (seenStates.has(key))
+            return;
+        seenStates.add(key);
+        reachable.push({ state, trace });
+        if (trace.length >= maxLength)
+            return;
+        const resolutions = (0, semantics_1.internalResolutions)(state);
+        for (const r of resolutions) {
+            const initials = (0, semantics_1.nextEvents)(r);
+            for (const e of initials) {
+                const next = (0, semantics_1.step)(r, e);
+                if (next !== null)
+                    enqueue(next, [...trace, e]);
+            }
+        }
+    };
+    enqueue(p, []);
+    const out = [];
+    const seenPairs = new Set();
+    for (const { state, trace } of reachable) {
+        const resolutions = (0, semantics_1.internalResolutions)(state);
+        for (const r of resolutions) {
+            const ref = refusalsOf(r, alphaPrime);
+            const k = trace.join('
') + '|' + [...ref].sort().join(',');
+            if (seenPairs.has(k))
+                continue;
+            seenPairs.add(k);
+            out.push({ trace: [...trace], refusal: ref });
+        }
+    }
+    return out;
+}
+/** Alfabeto visible relevante (incluye tick si aparece). */
+function collectVisibleEvents(p) {
+    // Reaprovechamos `traces` superficialmente: alcanzamos hasta profundidad
+    // moderada para acumular eventos efectivamente observables.
+    const out = new Set();
+    const visit = (q, depth) => {
+        if (depth > 8)
+            return;
+        for (const r of (0, semantics_1.internalResolutions)(q)) {
+            const initials = (0, semantics_1.nextEvents)(r);
+            for (const e of initials) {
+                out.add(e);
+                const next = (0, semantics_1.step)(r, e);
+                if (next !== null)
+                    visit(next, depth + 1);
+            }
+        }
+    };
+    visit(p, 0);
+    return out;
+}
+// ── Deadlock / livelock ─────────────────────────────────────
+/**
+ * Hay deadlock si el proceso no ofrece NINGÚN evento (ni siquiera ✓) en
+ * ALGUNA resolución interna alcanzable desde el estado inicial.
+ *
+ * En `STOP` el chequeo es trivial: `nextEvents(STOP) = ∅`.
+ */
+function isDeadlocked(p) {
+    for (const r of (0, semantics_1.internalResolutions)(p)) {
+        if ((0, semantics_1.nextEvents)(r).size === 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Detección heurística de livelock: el proceso recorre eventos ocultos
+ * (τ) indefinidamente sin avanzar visiblemente. Implementación: chequea
+ * si la profundidad de despliegues internos excede `depth` sin ofrecer
+ * eventos visibles.
+ *
+ * No es decisión: usamos límite acotado. Útil para advertir sobre `μX.X`
+ * o `(a → STOP) \ {a}` con loop.
+ */
+function isLiveLocked(p, depth = 32) {
+    // Estrategia: si tras `depth` resoluciones internas seguidas no hay
+    // eventos visibles (cardinality 0) pero la recursión sigue siendo
+    // "productiva" internamente, lo consideramos livelock probable.
+    const initials = (0, semantics_1.nextEvents)(p);
+    if (initials.size > 0)
+        return false;
+    // Sin eventos: distinguir deadlock estructural (STOP) vs livelock real
+    // requiere examinar el cuerpo de la recursión.
+    return isLiveLockedRec(p, depth);
+}
+function isLiveLockedRec(p, depth) {
+    if (depth <= 0)
+        return true;
+    // Si hay recursión que se autoincorpora sin guarda visible, divergir.
+    if (p.kind === 'recursion') {
+        // Cuerpo sin prefix ni skip → diverge.
+        if (!hasVisibleGuard(p.body, p.name))
+            return true;
+        return false;
+    }
+    if (p.kind === 'hide') {
+        // Si todos los eventos iniciales son ocultos, podemos estar en un loop τ.
+        const hidden = new Set(p.events);
+        const inner = (0, semantics_1.nextEvents)(p.process);
+        if (inner.size === 0)
+            return false;
+        let allHidden = true;
+        for (const e of inner) {
+            if (!hidden.has(e)) {
+                allHidden = false;
+                break;
+            }
+        }
+        return allHidden;
+    }
+    return false;
+}
+function hasVisibleGuard(body, recName) {
+    switch (body.kind) {
+        case 'prefix':
+            return true; // hay un evento visible antes de recurrir.
+        case 'skip':
+            return true; // SKIP da ✓ (visible).
+        case 'choice':
+        case 'internal':
+        case 'parallel':
+        case 'interleave':
+        case 'sequence':
+            return hasVisibleGuard(body.left, recName) || hasVisibleGuard(body.right, recName);
+        case 'hide':
+        case 'rename':
+            return hasVisibleGuard(body.process, recName);
+        case 'recursion':
+            return hasVisibleGuard(body.body, recName);
+        case 'var':
+            return body.name !== recName; // si referencia otra var, asumimos guardada.
+        case 'stop':
+            return true; // STOP no es guarda pero tampoco divergente.
+    }
+}
+// ── Refinement ──────────────────────────────────────────────
+/**
+ * P ⊑_T Q : Q refina a P en trazas sii cada traza de Q es traza de P.
+ * Equivalentemente: Q no puede hacer nada que P no pudiera observar.
+ */
+function refinesTraces(spec, impl, maxLength = 6) {
+    const specTraces = encodeSet(traces(spec, maxLength));
+    const implTraces = traces(impl, maxLength);
+    for (const t of implTraces) {
+        if (!specTraces.has(encodeTrace(t)))
+            return false;
+    }
+    return true;
+}
+/**
+ * P ⊑_F Q : refinamiento en failures. Q refina a P sii:
+ *   (a) traces(Q) ⊆ traces(P)
+ *   (b) failures(Q) ⊆ failures(P)
+ *
+ * Una falla `(t, R)` de Q debe poder ser exhibida también por P. Esto
+ * capta el principio de que Q es "menos no-determinista" que P.
+ */
+function refinesFailures(spec, impl, maxLength = 4) {
+    if (!refinesTraces(spec, impl, maxLength))
+        return false;
+    const specF = failures(spec, maxLength);
+    const implF = failures(impl, maxLength);
+    // Para cada failure de impl, debe existir un failure de spec con la
+    // misma traza y un refusal ⊇ del de impl. (Refusal sets son cerrados
+    // por subconjunto en CSP: si P rehúsa R, también rehúsa todo R' ⊆ R.)
+    const specByTrace = new Map();
+    for (const f of specF) {
+        const k = encodeTrace(f.trace);
+        const arr = specByTrace.get(k) ?? [];
+        arr.push(f.refusal);
+        specByTrace.set(k, arr);
+    }
+    for (const f of implF) {
+        const k = encodeTrace(f.trace);
+        const candidates = specByTrace.get(k);
+        if (!candidates)
+            return false;
+        let matched = false;
+        for (const r of candidates) {
+            if (subsetEq(f.refusal, r)) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            return false;
+    }
+    return true;
+}
+function encodeTrace(t) {
+    return t.join('
');
+}
+function encodeSet(ts) {
+    const out = new Set();
+    for (const t of ts)
+        out.add(encodeTrace(t));
+    return out;
+}
+function subsetEq(a, b) {
+    for (const e of a)
+        if (!b.has(e))
+            return false;
+    return true;
+}
+//# sourceMappingURL=analysis.js.map

package/dist/csp-hoare/analysis.js.map

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

package/dist/csp-hoare/examples.d.ts

@@ -0,0 +1,33 @@
+import type { Process } from './types';
+/**
+ * Máquina expendedora simple: acepta una moneda y luego ofrece al
+ * entorno elegir entre té y café.
+ *
+ *   VM = coin → ((tea → STOP) □ (coffee → STOP))
+ *
+ * Para uso en bucle infinito, ver `vendingMachineLoop`.
+ */
+export declare function vendingMachine(): Process;
+/** Versión recursiva: tras servir, vuelve al estado inicial. */
+export declare function vendingMachineLoop(): Process;
+/**
+ * Filósofo `i` (dining philosophers a la Hoare): toma su tenedor
+ * izquierdo (`L`), luego el derecho (`R`), come, los suelta y repite.
+ *
+ *   PHIL_i = picks_up.L → picks_up.R → eats → puts_down.R → puts_down.L → STOP
+ *
+ * El bloqueo clásico aparece cuando todos los filósofos toman primero
+ * el izquierdo y luego intentan tomar el derecho: ya nadie lo tendrá
+ * libre. Lo detectamos con `isDeadlocked` sobre la composición paralela.
+ */
+export declare function philosopher(name: string): Process;
+/**
+ * Composición paralela de `n` filósofos circulares con sus tenedores
+ * compartidos. El alfabeto de sincronización es exactamente el conjunto
+ * de eventos `pick.*` y `put.*` que comparten filósofo y fork.
+ *
+ * Con `n ≥ 2` y la estrategia ingenua (todos toman primero el izquierdo)
+ * llegamos a deadlock estructural una vez todos hicieron `pick.L`.
+ */
+export declare function diningPhilosophers(n: number): Process;
+//# sourceMappingURL=examples.d.ts.map

package/dist/csp-hoare/examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples.d.ts","sourceRoot":"","sources":["../../src/csp-hoare/examples.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAS,MAAM,SAAS,CAAC;AAG9C;;;;;;;GAOG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAED,gEAAgE;AAChE,wBAAgB,kBAAkB,IAAI,OAAO,CAK5C;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOjD;AA0BD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CA+BrD"}

package/dist/csp-hoare/examples.js

@@ -0,0 +1,108 @@
+"use strict";
+// ============================================================
+// CSP Hoare — Ejemplos estándar del libro de Hoare (1985)
+// ============================================================
+// Construcciones canónicas que también sirven como tests integradores
+// de la semántica.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vendingMachine = vendingMachine;
+exports.vendingMachineLoop = vendingMachineLoop;
+exports.philosopher = philosopher;
+exports.diningPhilosophers = diningPhilosophers;
+const semantics_1 = require("./semantics");
+/**
+ * Máquina expendedora simple: acepta una moneda y luego ofrece al
+ * entorno elegir entre té y café.
+ *
+ *   VM = coin → ((tea → STOP) □ (coffee → STOP))
+ *
+ * Para uso en bucle infinito, ver `vendingMachineLoop`.
+ */
+function vendingMachine() {
+    return (0, semantics_1.prefix)('coin', (0, semantics_1.choice)((0, semantics_1.prefix)('tea', semantics_1.STOP), (0, semantics_1.prefix)('coffee', semantics_1.STOP)));
+}
+/** Versión recursiva: tras servir, vuelve al estado inicial. */
+function vendingMachineLoop() {
+    return (0, semantics_1.recursion)('VM', (0, semantics_1.prefix)('coin', (0, semantics_1.choice)((0, semantics_1.prefix)('tea', (0, semantics_1.processVar)('VM')), (0, semantics_1.prefix)('coffee', (0, semantics_1.processVar)('VM')))));
+}
+/**
+ * Filósofo `i` (dining philosophers a la Hoare): toma su tenedor
+ * izquierdo (`L`), luego el derecho (`R`), come, los suelta y repite.
+ *
+ *   PHIL_i = picks_up.L → picks_up.R → eats → puts_down.R → puts_down.L → STOP
+ *
+ * El bloqueo clásico aparece cuando todos los filósofos toman primero
+ * el izquierdo y luego intentan tomar el derecho: ya nadie lo tendrá
+ * libre. Lo detectamos con `isDeadlocked` sobre la composición paralela.
+ */
+function philosopher(name) {
+    const pickL = `pick.${name}.L`;
+    const pickR = `pick.${name}.R`;
+    const eats = `eat.${name}`;
+    const putR = `put.${name}.R`;
+    const putL = `put.${name}.L`;
+    return (0, semantics_1.prefix)(pickL, (0, semantics_1.prefix)(pickR, (0, semantics_1.prefix)(eats, (0, semantics_1.prefix)(putR, (0, semantics_1.prefix)(putL, semantics_1.STOP)))));
+}
+/**
+ * Tenedor `i`: oscila entre "libre" y "tomado". Solo puede ser tomado o
+ * soltado, alternativamente.
+ *
+ *   FORK_i = pick → put → FORK_i
+ *
+ * En el modelo de Hoare, los nombres de evento son compartidos entre
+ * filósofo y tenedor: `pick.phi.X` debe coincidir con el evento
+ * correspondiente del fork.
+ *
+ * Aquí codificamos el deadlock estructuralmente: la composición paralela
+ * de N filósofos sin recursión queda en STOP global cuando todos se
+ * bloquean.
+ */
+function fork(_forkId, philLeft, philRight) {
+    // El tenedor es L para `philLeft` y R para `philRight`.
+    const pickL = `pick.${philLeft}.L`;
+    const putL = `put.${philLeft}.L`;
+    const pickR = `pick.${philRight}.R`;
+    const putR = `put.${philRight}.R`;
+    // Solo aceptamos cada movimiento UNA vez (modelado finito → deadlock visible).
+    return (0, semantics_1.choice)((0, semantics_1.prefix)(pickL, (0, semantics_1.prefix)(putL, semantics_1.STOP)), (0, semantics_1.prefix)(pickR, (0, semantics_1.prefix)(putR, semantics_1.STOP)));
+}
+/**
+ * Composición paralela de `n` filósofos circulares con sus tenedores
+ * compartidos. El alfabeto de sincronización es exactamente el conjunto
+ * de eventos `pick.*` y `put.*` que comparten filósofo y fork.
+ *
+ * Con `n ≥ 2` y la estrategia ingenua (todos toman primero el izquierdo)
+ * llegamos a deadlock estructural una vez todos hicieron `pick.L`.
+ */
+function diningPhilosophers(n) {
+    if (n < 2)
+        throw new Error('diningPhilosophers requiere n ≥ 2');
+    // Construimos `n` filósofos y `n` tenedores en una mesa circular.
+    // Fork `i` está entre Phil `i` y Phil `(i+1) mod n`.
+    const phils = [];
+    const forks = [];
+    for (let i = 0; i < n; i++) {
+        phils.push(philosopher(`P${i}`));
+    }
+    for (let i = 0; i < n; i++) {
+        const left = `P${i}`;
+        const right = `P${(i + 1) % n}`;
+        forks.push(fork(i, left, right));
+    }
+    // Alfabeto: todos los `pick.*` y `put.*`.
+    const sync = [];
+    for (let i = 0; i < n; i++) {
+        sync.push(`pick.P${i}.L`, `pick.P${i}.R`, `put.P${i}.L`, `put.P${i}.R`);
+    }
+    // Componemos en cascada: ((Phil0 |[A]| Fork0) |[A]| Phil1) |[A]| ...
+    let acc = phils[0];
+    for (let i = 0; i < n; i++) {
+        acc = (0, semantics_1.parallel)(acc, forks[i], sync);
+        if (i + 1 < n) {
+            acc = (0, semantics_1.parallel)(acc, phils[i + 1], sync);
+        }
+    }
+    return acc;
+}
+//# sourceMappingURL=examples.js.map

package/dist/csp-hoare/examples.js.map

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

package/dist/csp-hoare/index.d.ts

@@ -0,0 +1,6 @@
+export type { Event, Process, Trace, FailurePair } from './types';
+export { TICK } from './types';
+export { STOP, SKIP, prefix, choice, internal, parallel, interleave, sequence, hide, rename, recursion, processVar, alphabet, nextEvents, step, internalResolutions, } from './semantics';
+export { traces, failures, isDeadlocked, isLiveLocked, refinesTraces, refinesFailures, } from './analysis';
+export { vendingMachine, vendingMachineLoop, philosopher, diningPhilosophers } from './examples';
+//# sourceMappingURL=index.d.ts.map

package/dist/csp-hoare/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/csp-hoare/index.ts"],"names":[],"mappings":"AAgBA,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,SAAS,EACT,UAAU,EACV,QAAQ,EACR,UAAU,EACV,IAAI,EACJ,mBAAmB,GACpB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,MAAM,EACN,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/csp-hoare/index.js

@@ -0,0 +1,50 @@
+"use strict";
+// ============================================================
+// CSP Hoare — Comunicating Sequential Processes (Hoare 1978/1985)
+// ============================================================
+// Cálculo de procesos basado en eventos atómicos sincronizados.
+// A diferencia del π-cálculo (centrado en pasar nombres), CSP modela
+// concurrencia mediante la ocurrencia coordinada de nombres de evento
+// compartidos en el alfabeto del paralelo.
+//
+// Semánticas implementadas:
+//   • Traces — qué secuencias de eventos visibles pueden ocurrir.
+//   • Failures — pares (traza, refusal) que capturan no-determinismo.
+//   • Refinement — P ⊑_T Q y P ⊑_F Q según las semánticas anteriores.
+//
+// Ejemplos canónicos: máquina expendedora, filósofos cenando.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diningPhilosophers = exports.philosopher = exports.vendingMachineLoop = exports.vendingMachine = exports.refinesFailures = exports.refinesTraces = exports.isLiveLocked = exports.isDeadlocked = exports.failures = exports.traces = exports.internalResolutions = exports.step = exports.nextEvents = exports.alphabet = exports.processVar = exports.recursion = exports.rename = exports.hide = exports.sequence = exports.interleave = exports.parallel = exports.internal = exports.choice = exports.prefix = exports.SKIP = exports.STOP = exports.TICK = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "TICK", { enumerable: true, get: function () { return types_1.TICK; } });
+var semantics_1 = require("./semantics");
+Object.defineProperty(exports, "STOP", { enumerable: true, get: function () { return semantics_1.STOP; } });
+Object.defineProperty(exports, "SKIP", { enumerable: true, get: function () { return semantics_1.SKIP; } });
+Object.defineProperty(exports, "prefix", { enumerable: true, get: function () { return semantics_1.prefix; } });
+Object.defineProperty(exports, "choice", { enumerable: true, get: function () { return semantics_1.choice; } });
+Object.defineProperty(exports, "internal", { enumerable: true, get: function () { return semantics_1.internal; } });
+Object.defineProperty(exports, "parallel", { enumerable: true, get: function () { return semantics_1.parallel; } });
+Object.defineProperty(exports, "interleave", { enumerable: true, get: function () { return semantics_1.interleave; } });
+Object.defineProperty(exports, "sequence", { enumerable: true, get: function () { return semantics_1.sequence; } });
+Object.defineProperty(exports, "hide", { enumerable: true, get: function () { return semantics_1.hide; } });
+Object.defineProperty(exports, "rename", { enumerable: true, get: function () { return semantics_1.rename; } });
+Object.defineProperty(exports, "recursion", { enumerable: true, get: function () { return semantics_1.recursion; } });
+Object.defineProperty(exports, "processVar", { enumerable: true, get: function () { return semantics_1.processVar; } });
+Object.defineProperty(exports, "alphabet", { enumerable: true, get: function () { return semantics_1.alphabet; } });
+Object.defineProperty(exports, "nextEvents", { enumerable: true, get: function () { return semantics_1.nextEvents; } });
+Object.defineProperty(exports, "step", { enumerable: true, get: function () { return semantics_1.step; } });
+Object.defineProperty(exports, "internalResolutions", { enumerable: true, get: function () { return semantics_1.internalResolutions; } });
+var analysis_1 = require("./analysis");
+Object.defineProperty(exports, "traces", { enumerable: true, get: function () { return analysis_1.traces; } });
+Object.defineProperty(exports, "failures", { enumerable: true, get: function () { return analysis_1.failures; } });
+Object.defineProperty(exports, "isDeadlocked", { enumerable: true, get: function () { return analysis_1.isDeadlocked; } });
+Object.defineProperty(exports, "isLiveLocked", { enumerable: true, get: function () { return analysis_1.isLiveLocked; } });
+Object.defineProperty(exports, "refinesTraces", { enumerable: true, get: function () { return analysis_1.refinesTraces; } });
+Object.defineProperty(exports, "refinesFailures", { enumerable: true, get: function () { return analysis_1.refinesFailures; } });
+var examples_1 = require("./examples");
+Object.defineProperty(exports, "vendingMachine", { enumerable: true, get: function () { return examples_1.vendingMachine; } });
+Object.defineProperty(exports, "vendingMachineLoop", { enumerable: true, get: function () { return examples_1.vendingMachineLoop; } });
+Object.defineProperty(exports, "philosopher", { enumerable: true, get: function () { return examples_1.philosopher; } });
+Object.defineProperty(exports, "diningPhilosophers", { enumerable: true, get: function () { return examples_1.diningPhilosophers; } });
+//# sourceMappingURL=index.js.map

package/dist/csp-hoare/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/csp-hoare/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,kEAAkE;AAClE,+DAA+D;AAC/D,gEAAgE;AAChE,qEAAqE;AACrE,sEAAsE;AACtE,2CAA2C;AAC3C,EAAE;AACF,4BAA4B;AAC5B,kEAAkE;AAClE,sEAAsE;AACtE,sEAAsE;AACtE,EAAE;AACF,8DAA8D;AAC9D,+DAA+D;;;AAG/D,iCAA+B;AAAtB,6FAAA,IAAI,OAAA;AAEb,yCAiBqB;AAhBnB,iGAAA,IAAI,OAAA;AACJ,iGAAA,IAAI,OAAA;AACJ,mGAAA,MAAM,OAAA;AACN,mGAAA,MAAM,OAAA;AACN,qGAAA,QAAQ,OAAA;AACR,qGAAA,QAAQ,OAAA;AACR,uGAAA,UAAU,OAAA;AACV,qGAAA,QAAQ,OAAA;AACR,iGAAA,IAAI,OAAA;AACJ,mGAAA,MAAM,OAAA;AACN,sGAAA,SAAS,OAAA;AACT,uGAAA,UAAU,OAAA;AACV,qGAAA,QAAQ,OAAA;AACR,uGAAA,UAAU,OAAA;AACV,iGAAA,IAAI,OAAA;AACJ,gHAAA,mBAAmB,OAAA;AAGrB,uCAOoB;AANlB,kGAAA,MAAM,OAAA;AACN,oGAAA,QAAQ,OAAA;AACR,wGAAA,YAAY,OAAA;AACZ,wGAAA,YAAY,OAAA;AACZ,yGAAA,aAAa,OAAA;AACb,2GAAA,eAAe,OAAA;AAGjB,uCAAiG;AAAxF,0GAAA,cAAc,OAAA;AAAE,8GAAA,kBAAkB,OAAA;AAAE,uGAAA,WAAW,OAAA;AAAE,8GAAA,kBAAkB,OAAA"}

package/dist/csp-hoare/semantics.d.ts

@@ -0,0 +1,49 @@
+import type { Event, Process } from './types';
+export declare const STOP: Process;
+export declare const SKIP: Process;
+export declare function prefix(event: Event, cont: Process): Process;
+export declare function choice(left: Process, right: Process): Process;
+export declare function internal(left: Process, right: Process): Process;
+export declare function parallel(left: Process, right: Process, alphabet: Event[]): Process;
+export declare function interleave(left: Process, right: Process): Process;
+export declare function sequence(left: Process, right: Process): Process;
+export declare function hide(process: Process, events: Event[]): Process;
+export declare function rename(process: Process, mapping: Map<Event, Event>): Process;
+export declare function recursion(name: string, body: Process): Process;
+export declare function processVar(name: string): Process;
+/**
+ * Conjunto de eventos visibles mencionados sintácticamente en `p`.
+ * Los eventos renombrados aportan tanto la fuente como el destino
+ * (la fuente puede aparecer en una rama no recorrida, y el destino
+ * es lo que el entorno observa).
+ */
+export declare function alphabet(p: Process): Set<Event>;
+/**
+ * Eventos visibles que `p` puede ofrecer inmediatamente como su primer
+ * evento (tomando todas las resoluciones internas). No incluye τ (los
+ * eventos ocultos son silenciosos por construcción).
+ *
+ * Para `SKIP` reportamos el tick `✓` — termina exitosamente.
+ */
+export declare function nextEvents(p: Process): Set<Event>;
+/**
+ * `step(P, a)` aplica una transición visible etiquetada con `a` y devuelve
+ * el continuante, o `null` si `a` no está habilitado. Para procesos no-
+ * deterministas elegimos arbitrariamente cualquier rama que habilite `a`
+ * (eso es válido para análisis de trazas; para failures inspeccionamos
+ * todas las resoluciones aparte).
+ */
+export declare function step(p: Process, event: Event): Process | null;
+/**
+ * Enumera todos los estados "estables" alcanzables desde `p` resolviendo
+ * elecciones internas (`⊓`) y desplegando recursiones inmediatas, sin
+ * consumir eventos visibles. Útil para la semántica de failures, donde
+ * el conjunto de refusal depende de QUÉ rama interna se eligió.
+ *
+ * Devuelve procesos sin un `internal` en la raíz (después de empujarlo
+ * hacia adentro de operadores asociativos cuando aplica). El número de
+ * resoluciones es 2^(# de internals encadenados), así que limitamos a un
+ * número razonable para no explotar.
+ */
+export declare function internalResolutions(p: Process, limit?: number): Process[];
+//# sourceMappingURL=semantics.d.ts.map

package/dist/csp-hoare/semantics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantics.d.ts","sourceRoot":"","sources":["../../src/csp-hoare/semantics.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAK9C,eAAO,MAAM,IAAI,EAAE,OAA0B,CAAC;AAC9C,eAAO,MAAM,IAAI,EAAE,OAA0B,CAAC;AAE9C,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAE3D;AACD,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAE7D;AACD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAE/D;AACD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,OAAO,CAElF;AACD,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAEjE;AACD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAE/D;AACD,wBAAgB,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAE/D;AACD,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,OAAO,CAE5E;AACD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAE9D;AACD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAID;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,CAI/C;AAiHD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,CAIjD;AA8GD;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,IAAI,CAE7D;AA0HD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,SAAK,GAAG,OAAO,EAAE,CAIrE"}