@stevenvo780/st-lang 4.2.0 → 4.4.0

package/dist/runtime/pi-calculus/congruence.js.map

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

package/dist/runtime/pi-calculus/index.d.ts

@@ -0,0 +1,6 @@
+export type { PiProcess } from './types';
+export { freeNames, boundNames, alphaRename, freshName } from './names';
+export { substitute } from './substitution';
+export { reduce, isDeadlocked, trace } from './reduction';
+export { structuralCongruence } from './congruence';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/pi-calculus/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/pi-calculus/index.ts"],"names":[],"mappings":"AAcA,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC"}

package/dist/runtime/pi-calculus/index.js

@@ -0,0 +1,30 @@
+"use strict";
+// ============================================================
+// ST π-calculus — barrel público.
+// ============================================================
+// API:
+//   freeNames(p)                  → Set<string> de nombres libres
+//   boundNames(p)                 → Set<string> de nombres ligados
+//   alphaRename(p, oldN, newN)    → AST con α-renaming
+//   substitute(p, x, v)           → p[x := v] capture-avoiding
+//   reduce(p)                     → PiProcess[] sucesores (un paso →)
+//   isDeadlocked(p)               → boolean
+//   trace(p, maxSteps?)           → traza determinista
+//   structuralCongruence(a, b)    → ≡
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.structuralCongruence = exports.trace = exports.isDeadlocked = exports.reduce = exports.substitute = exports.freshName = exports.alphaRename = exports.boundNames = exports.freeNames = void 0;
+var names_1 = require("./names");
+Object.defineProperty(exports, "freeNames", { enumerable: true, get: function () { return names_1.freeNames; } });
+Object.defineProperty(exports, "boundNames", { enumerable: true, get: function () { return names_1.boundNames; } });
+Object.defineProperty(exports, "alphaRename", { enumerable: true, get: function () { return names_1.alphaRename; } });
+Object.defineProperty(exports, "freshName", { enumerable: true, get: function () { return names_1.freshName; } });
+var substitution_1 = require("./substitution");
+Object.defineProperty(exports, "substitute", { enumerable: true, get: function () { return substitution_1.substitute; } });
+var reduction_1 = require("./reduction");
+Object.defineProperty(exports, "reduce", { enumerable: true, get: function () { return reduction_1.reduce; } });
+Object.defineProperty(exports, "isDeadlocked", { enumerable: true, get: function () { return reduction_1.isDeadlocked; } });
+Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return reduction_1.trace; } });
+var congruence_1 = require("./congruence");
+Object.defineProperty(exports, "structuralCongruence", { enumerable: true, get: function () { return congruence_1.structuralCongruence; } });
+//# sourceMappingURL=index.js.map

package/dist/runtime/pi-calculus/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/pi-calculus/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,kCAAkC;AAClC,+DAA+D;AAC/D,OAAO;AACP,kEAAkE;AAClE,mEAAmE;AACnE,uDAAuD;AACvD,+DAA+D;AAC/D,sEAAsE;AACtE,4CAA4C;AAC5C,uDAAuD;AACvD,sCAAsC;AACtC,+DAA+D;;;AAG/D,iCAAwE;AAA/D,kGAAA,SAAS,OAAA;AAAE,mGAAA,UAAU,OAAA;AAAE,oGAAA,WAAW,OAAA;AAAE,kGAAA,SAAS,OAAA;AACtD,+CAA4C;AAAnC,0GAAA,UAAU,OAAA;AACnB,yCAA0D;AAAjD,mGAAA,MAAM,OAAA;AAAE,yGAAA,YAAY,OAAA;AAAE,kGAAA,KAAK,OAAA;AACpC,2CAAoD;AAA3C,kHAAA,oBAAoB,OAAA"}

package/dist/runtime/pi-calculus/names.d.ts

@@ -0,0 +1,28 @@
+import type { PiProcess } from './types';
+/**
+ * Conjunto de nombres libres de un proceso π. Un nombre es "libre" si
+ * aparece referenciado pero no está bajo el alcance de un binder
+ * (input `c(x)` liga `x`; new `(νc)` liga `c`).
+ */
+export declare function freeNames(p: PiProcess): Set<string>;
+/**
+ * Conjunto de nombres ligados (introducidos por algún binder en el
+ * subárbol). Útil para detectar shadowing y evitar capturas.
+ */
+export declare function boundNames(p: PiProcess): Set<string>;
+/**
+ * α-renaming: renombrar un nombre en todo el AST. Útil para:
+ *   - Refrescar nombres ligados antes de sustituir (evitar capturas).
+ *   - Normalizar canales restringidos al testear congruencia estructural.
+ *
+ * No diferencia entre nombres libres y ligados: simplemente reemplaza
+ * cada ocurrencia de `oldN` por `newN`. La diferenciación libre/ligado
+ * se hace en `substitute`, que usa `alphaRename` como utility.
+ */
+export declare function alphaRename(p: PiProcess, oldN: string, newN: string): PiProcess;
+/**
+ * Genera un nombre fresco que no aparece en ninguno de los conjuntos
+ * `avoid`. Estrategia simple: base + sufijo numérico incremental.
+ */
+export declare function freshName(base: string, avoid: ReadonlySet<string>): string;
+//# sourceMappingURL=names.d.ts.map

package/dist/runtime/pi-calculus/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../../src/runtime/pi-calculus/names.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,CAiCnD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,CAwBpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CA2D/E;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAK1E"}

package/dist/runtime/pi-calculus/names.js

@@ -0,0 +1,182 @@
+"use strict";
+// ============================================================
+// π-calculus — nombres libres / ligados y α-renaming.
+// ============================================================
+// Definiciones estándar (Milner, "Communicating and Mobile Systems"):
+//
+//   fn(0)          = ∅
+//   fn(c(x).P)     = {c} ∪ (fn(P) \ {x})         x está ligado en P
+//   fn(c̄⟨v⟩.P)    = {c, v} ∪ fn(P)
+//   fn(P|Q)        = fn(P) ∪ fn(Q)
+//   fn((νc) P)     = fn(P) \ {c}                  c está ligado en P
+//   fn(!P)         = fn(P)
+//   fn(P+Q)        = fn(P) ∪ fn(Q)
+//   fn([x=y].P)    = {x, y} ∪ fn(P)
+//
+//   bn(0)          = ∅
+//   bn(c(x).P)     = {x} ∪ bn(P)
+//   bn((νc) P)     = {c} ∪ bn(P)
+//   (resto = unión de los hijos)
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freeNames = freeNames;
+exports.boundNames = boundNames;
+exports.alphaRename = alphaRename;
+exports.freshName = freshName;
+/**
+ * Conjunto de nombres libres de un proceso π. Un nombre es "libre" si
+ * aparece referenciado pero no está bajo el alcance de un binder
+ * (input `c(x)` liga `x`; new `(νc)` liga `c`).
+ */
+function freeNames(p) {
+    switch (p.kind) {
+        case 'nil':
+            return new Set();
+        case 'input': {
+            const fnCont = freeNames(p.cont);
+            fnCont.delete(p.bind);
+            fnCont.add(p.channel);
+            return fnCont;
+        }
+        case 'output': {
+            const fnCont = freeNames(p.cont);
+            fnCont.add(p.channel);
+            fnCont.add(p.value);
+            return fnCont;
+        }
+        case 'parallel':
+        case 'choice':
+            return union(freeNames(p.left), freeNames(p.right));
+        case 'new': {
+            const fnBody = freeNames(p.body);
+            fnBody.delete(p.channel);
+            return fnBody;
+        }
+        case 'replication':
+            return freeNames(p.body);
+        case 'match': {
+            const fnCont = freeNames(p.cont);
+            fnCont.add(p.left);
+            fnCont.add(p.right);
+            return fnCont;
+        }
+    }
+}
+/**
+ * Conjunto de nombres ligados (introducidos por algún binder en el
+ * subárbol). Útil para detectar shadowing y evitar capturas.
+ */
+function boundNames(p) {
+    switch (p.kind) {
+        case 'nil':
+            return new Set();
+        case 'input': {
+            const bn = boundNames(p.cont);
+            bn.add(p.bind);
+            return bn;
+        }
+        case 'output':
+            return boundNames(p.cont);
+        case 'parallel':
+        case 'choice':
+            return union(boundNames(p.left), boundNames(p.right));
+        case 'new': {
+            const bn = boundNames(p.body);
+            bn.add(p.channel);
+            return bn;
+        }
+        case 'replication':
+            return boundNames(p.body);
+        case 'match':
+            return boundNames(p.cont);
+    }
+}
+/**
+ * α-renaming: renombrar un nombre en todo el AST. Útil para:
+ *   - Refrescar nombres ligados antes de sustituir (evitar capturas).
+ *   - Normalizar canales restringidos al testear congruencia estructural.
+ *
+ * No diferencia entre nombres libres y ligados: simplemente reemplaza
+ * cada ocurrencia de `oldN` por `newN`. La diferenciación libre/ligado
+ * se hace en `substitute`, que usa `alphaRename` como utility.
+ */
+function alphaRename(p, oldN, newN) {
+    if (oldN === newN)
+        return p;
+    switch (p.kind) {
+        case 'nil':
+            return p;
+        case 'input': {
+            const newChannel = p.channel === oldN ? newN : p.channel;
+            // Si el binder mismo es `oldN`, la sustitución se detiene en él:
+            // el cuerpo `cont` ya no ve `oldN` como referencia al exterior.
+            if (p.bind === oldN) {
+                return { kind: 'input', channel: newChannel, bind: p.bind, cont: p.cont };
+            }
+            return {
+                kind: 'input',
+                channel: newChannel,
+                bind: p.bind,
+                cont: alphaRename(p.cont, oldN, newN),
+            };
+        }
+        case 'output':
+            return {
+                kind: 'output',
+                channel: p.channel === oldN ? newN : p.channel,
+                value: p.value === oldN ? newN : p.value,
+                cont: alphaRename(p.cont, oldN, newN),
+            };
+        case 'parallel':
+            return {
+                kind: 'parallel',
+                left: alphaRename(p.left, oldN, newN),
+                right: alphaRename(p.right, oldN, newN),
+            };
+        case 'choice':
+            return {
+                kind: 'choice',
+                left: alphaRename(p.left, oldN, newN),
+                right: alphaRename(p.right, oldN, newN),
+            };
+        case 'new': {
+            // Mismo principio que en input: el binder atrapa el nombre.
+            if (p.channel === oldN) {
+                return p;
+            }
+            return {
+                kind: 'new',
+                channel: p.channel,
+                body: alphaRename(p.body, oldN, newN),
+            };
+        }
+        case 'replication':
+            return { kind: 'replication', body: alphaRename(p.body, oldN, newN) };
+        case 'match':
+            return {
+                kind: 'match',
+                left: p.left === oldN ? newN : p.left,
+                right: p.right === oldN ? newN : p.right,
+                cont: alphaRename(p.cont, oldN, newN),
+            };
+    }
+}
+/**
+ * Genera un nombre fresco que no aparece en ninguno de los conjuntos
+ * `avoid`. Estrategia simple: base + sufijo numérico incremental.
+ */
+function freshName(base, avoid) {
+    if (!avoid.has(base))
+        return base;
+    let i = 0;
+    while (avoid.has(`${base}_${i}`))
+        i++;
+    return `${base}_${i}`;
+}
+function union(a, b) {
+    const out = new Set(a);
+    for (const x of b)
+        out.add(x);
+    return out;
+}
+//# sourceMappingURL=names.js.map

package/dist/runtime/pi-calculus/names.js.map

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

package/dist/runtime/pi-calculus/reduction.d.ts

@@ -0,0 +1,25 @@
+import type { PiProcess } from './types';
+/**
+ * Devuelve todos los procesos sucesores tras un paso de reducción.
+ *
+ * Implementa la regla COMM atravesando new (canales restringidos pueden
+ * comunicar internamente: scope extrusion básica intra-scope) y desplegando
+ * replicaciones lazy. Match se evalúa al pasar.
+ *
+ * Si el resultado es vacío, no hay comunicación posible (deadlock o
+ * proceso terminal).
+ */
+export declare function reduce(p: PiProcess): PiProcess[];
+/**
+ * `isDeadlocked(p)`: `true` si no hay ninguna reducción posible.
+ * Incluye procesos terminales (`0`, `0 | 0`, etc.) y procesos con
+ * prefijos que no pueden sincronizar por incompatibilidad de canales.
+ */
+export declare function isDeadlocked(p: PiProcess): boolean;
+/**
+ * `trace(p, maxSteps)`: explora una traza determinista (elige el
+ * primer sucesor en cada paso). Útil para inspección, no pretende ser
+ * una semántica completa. Se detiene en deadlock o tras `maxSteps`.
+ */
+export declare function trace(p: PiProcess, maxSteps?: number): PiProcess[];
+//# sourceMappingURL=reduction.d.ts.map

package/dist/runtime/pi-calculus/reduction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduction.d.ts","sourceRoot":"","sources":["../../../src/runtime/pi-calculus/reduction.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AA4HzC;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAMhD;AAuND;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,QAAQ,GAAE,MAAY,GAAG,SAAS,EAAE,CAWvE"}

package/dist/runtime/pi-calculus/reduction.js

@@ -0,0 +1,338 @@
+"use strict";
+// ============================================================
+// π-calculus — semántica de reducción (operacional).
+// ============================================================
+// Reglas básicas (relación →):
+//
+//   COMM     c̄⟨v⟩.P | c(x).Q   →   P | Q[x := v]
+//   PAR      P → P'   ⇒   P|Q → P'|Q
+//   RES      P → P'   ⇒   (νc) P → (νc) P'
+//   STRUCT   P ≡ P' → Q' ≡ Q   ⇒   P → Q     (congruencia estructural)
+//   SUM      P → P'   ⇒   P + Q → P'         (elige rama y descarta otra)
+//   REPL     !P → P | !P                      (unfold de replicación)
+//   MATCH    [x = x].P  →  P                  (match exitoso)
+//
+// La función `reduce(p)` devuelve el conjunto de todos los procesos
+// inmediatamente sucesores; un proceso sin sucesores está deadlocked.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = reduce;
+exports.isDeadlocked = isDeadlocked;
+exports.trace = trace;
+const substitution_1 = require("./substitution");
+const names_1 = require("./names");
+/**
+ * Recolecta todos los prefijos input expuestos al "top level" del
+ * proceso (es decir, no anidados bajo otro prefijo o binder cerrado).
+ * Atraviesa parallel, choice, replication (haciendo unfold virtual) y
+ * new (transparentemente, registrando el contexto).
+ *
+ * Cada prefijo recolectado lleva una función `rebuild` que dado un
+ * proceso reemplazo (lo que queda tras consumir el prefijo) reconstruye
+ * el proceso global con esa parte cambiada.
+ */
+function collectInputs(p, rebuild, out) {
+    switch (p.kind) {
+        case 'input':
+            out.push({
+                channel: p.channel,
+                bind: p.bind,
+                cont: p.cont,
+                rebuild,
+            });
+            break;
+        case 'parallel':
+            collectInputs(p.left, (q) => rebuild({ kind: 'parallel', left: q, right: p.right }), out);
+            collectInputs(p.right, (q) => rebuild({ kind: 'parallel', left: p.left, right: q }), out);
+            break;
+        case 'choice':
+            // En un choice, consumir un prefijo descarta la otra rama.
+            collectInputs(p.left, (q) => rebuild(q), out);
+            collectInputs(p.right, (q) => rebuild(q), out);
+            break;
+        case 'replication':
+            // Unfold: !P ≡ P | !P. Tomamos una copia y dejamos la replicación intacta.
+            collectInputs(p.body, (q) => rebuild({ kind: 'parallel', left: q, right: { kind: 'replication', body: p.body } }), out);
+            break;
+        case 'match':
+            if (p.left === p.right) {
+                // [x=x].P se evalúa a P; entonces los prefijos visibles son los de P.
+                collectInputs(p.cont, rebuild, out);
+            }
+            break;
+        case 'new':
+        case 'nil':
+        case 'output':
+            // new se trata fuera de este recolector (afecta el contexto de scope).
+            // output y nil no exponen inputs en el top level.
+            break;
+    }
+}
+function collectOutputs(p, rebuild, out) {
+    switch (p.kind) {
+        case 'output':
+            out.push({
+                channel: p.channel,
+                value: p.value,
+                cont: p.cont,
+                rebuild,
+            });
+            break;
+        case 'parallel':
+            collectOutputs(p.left, (q) => rebuild({ kind: 'parallel', left: q, right: p.right }), out);
+            collectOutputs(p.right, (q) => rebuild({ kind: 'parallel', left: p.left, right: q }), out);
+            break;
+        case 'choice':
+            collectOutputs(p.left, (q) => rebuild(q), out);
+            collectOutputs(p.right, (q) => rebuild(q), out);
+            break;
+        case 'replication':
+            collectOutputs(p.body, (q) => rebuild({ kind: 'parallel', left: q, right: { kind: 'replication', body: p.body } }), out);
+            break;
+        case 'match':
+            if (p.left === p.right) {
+                collectOutputs(p.cont, rebuild, out);
+            }
+            break;
+        case 'new':
+        case 'nil':
+        case 'input':
+            break;
+    }
+}
+// ------------------------------------------------------------
+// reduce — devuelve los procesos sucesores posibles (un paso →).
+// ------------------------------------------------------------
+/**
+ * Devuelve todos los procesos sucesores tras un paso de reducción.
+ *
+ * Implementa la regla COMM atravesando new (canales restringidos pueden
+ * comunicar internamente: scope extrusion básica intra-scope) y desplegando
+ * replicaciones lazy. Match se evalúa al pasar.
+ *
+ * Si el resultado es vacío, no hay comunicación posible (deadlock o
+ * proceso terminal).
+ */
+function reduce(p) {
+    // Caso especial: [x=x].P → P es una "reducción" silenciosa
+    // (no es COMM, pero forma parte de la relación →). Lo exponemos también.
+    const successors = [];
+    collectCommReductions(p, (q) => q, successors);
+    return successors;
+}
+/**
+ * Recorre el AST descendiendo por (ν) (que no bloquea reducciones
+ * internas) y emite todos los sucesores de COMM.
+ */
+function collectCommReductions(p, rebuild, out) {
+    // 1. Match top-level
+    if (p.kind === 'match' && p.left === p.right) {
+        out.push(rebuild(p.cont));
+    }
+    // 2. Descenso por (νc) — las reducciones dentro suben envueltas.
+    if (p.kind === 'new') {
+        collectCommReductions(p.body, (q) => rebuild({ kind: 'new', channel: p.channel, body: q }), out);
+    }
+    // 3. COMM: buscamos pares input/output con el mismo canal en este "nivel".
+    const inputs = [];
+    const outputs = [];
+    collectInputs(p, (q) => q, inputs);
+    collectOutputs(p, (q) => q, outputs);
+    for (const i of inputs) {
+        for (const o of outputs) {
+            if (i.channel !== o.channel)
+                continue;
+            // Para sincronizar dentro del mismo proceso necesitamos que i y o
+            // vivan en ramas paralelas: el rebuild de uno aplicado al resultado
+            // del otro debe componer paralelamente. Reconstruimos manualmente:
+            const reduced = applyComm(p, i, o);
+            if (reduced !== null)
+                out.push(rebuild(reduced));
+        }
+    }
+}
+/**
+ * Aplica una reducción COMM concreta sobre `p`: localiza los prefijos
+ * `i` y `o` (que viven en ramas paralelas) y los reemplaza por sus
+ * continuaciones (con sustitución en el input).
+ *
+ * Estrategia: como `rebuild` de cada prefijo asume que reemplaza
+ * solo su propio sub-proceso, no podemos componerlos directamente.
+ * En su lugar reconstruimos el AST haciendo un "structural walk" que
+ * marca y reemplaza los dos prefijos en una sola pasada.
+ */
+function applyComm(p, i, o) {
+    const marker = { found: false };
+    const result = replaceTwoPrefixes(p, i, o, marker);
+    return marker.found ? result : null;
+}
+/**
+ * Reemplaza simultáneamente el prefijo input `i` y el prefijo output `o`
+ * en el AST. Los identifica por referencia estructural (mismo kind y
+ * mismas continuaciones — funciona porque collectInputs/Outputs
+ * preserva las referencias originales).
+ */
+function replaceTwoPrefixes(p, i, o, marker) {
+    // ¿Es el input que buscamos?
+    if (p.kind === 'input' && p.channel === i.channel && p.bind === i.bind && p.cont === i.cont) {
+        const substituted = (0, substitution_1.substitute)(p.cont, p.bind, o.value);
+        return substituted;
+    }
+    // ¿Es el output que buscamos?
+    if (p.kind === 'output' && p.channel === o.channel && p.value === o.value && p.cont === o.cont) {
+        return p.cont;
+    }
+    switch (p.kind) {
+        case 'nil':
+        case 'input':
+        case 'output':
+            return p;
+        case 'parallel': {
+            const leftHadIO = containsPrefixes(p.left, i, o);
+            const rightHadIO = containsPrefixes(p.right, i, o);
+            if (leftHadIO.hasInput && rightHadIO.hasOutput) {
+                marker.found = true;
+                return {
+                    kind: 'parallel',
+                    left: replaceTwoPrefixes(p.left, i, o, { found: false }),
+                    right: replaceTwoPrefixes(p.right, i, o, { found: false }),
+                };
+            }
+            if (rightHadIO.hasInput && leftHadIO.hasOutput) {
+                marker.found = true;
+                return {
+                    kind: 'parallel',
+                    left: replaceTwoPrefixes(p.left, i, o, { found: false }),
+                    right: replaceTwoPrefixes(p.right, i, o, { found: false }),
+                };
+            }
+            // Ambos en el mismo lado: descender.
+            if (leftHadIO.hasInput && leftHadIO.hasOutput) {
+                return {
+                    kind: 'parallel',
+                    left: replaceTwoPrefixes(p.left, i, o, marker),
+                    right: p.right,
+                };
+            }
+            if (rightHadIO.hasInput && rightHadIO.hasOutput) {
+                return {
+                    kind: 'parallel',
+                    left: p.left,
+                    right: replaceTwoPrefixes(p.right, i, o, marker),
+                };
+            }
+            return p;
+        }
+        case 'choice': {
+            // En un choice, elegir un prefijo descarta la otra rama.
+            const leftHas = containsPrefixes(p.left, i, o);
+            const rightHas = containsPrefixes(p.right, i, o);
+            if (leftHas.hasInput || leftHas.hasOutput) {
+                return replaceTwoPrefixes(p.left, i, o, marker);
+            }
+            if (rightHas.hasInput || rightHas.hasOutput) {
+                return replaceTwoPrefixes(p.right, i, o, marker);
+            }
+            return p;
+        }
+        case 'new': {
+            // α-renombramos el binder si el valor a enviar coincide (evita captura).
+            let body = p.body;
+            let channel = p.channel;
+            if (p.channel === o.value) {
+                const avoid = new Set();
+                for (const n of (0, names_1.freeNames)(body))
+                    avoid.add(n);
+                avoid.add(o.value);
+                avoid.add(i.bind);
+                const fresh = (0, names_1.freshName)(p.channel, avoid);
+                body = (0, names_1.alphaRename)(body, p.channel, fresh);
+                channel = fresh;
+            }
+            return { kind: 'new', channel, body: replaceTwoPrefixes(body, i, o, marker) };
+        }
+        case 'replication': {
+            // Desplegamos: !P ≡ P | !P; el prefijo consumido viene de la copia.
+            const has = containsPrefixes(p.body, i, o);
+            if ((has.hasInput || has.hasOutput) && (has.hasInput || has.hasOutput)) {
+                const unfolded = {
+                    kind: 'parallel',
+                    left: p.body,
+                    right: { kind: 'replication', body: p.body },
+                };
+                return replaceTwoPrefixes(unfolded, i, o, marker);
+            }
+            return p;
+        }
+        case 'match':
+            if (p.left === p.right) {
+                return replaceTwoPrefixes(p.cont, i, o, marker);
+            }
+            return p;
+    }
+}
+/**
+ * Tests si un subárbol contiene los prefijos buscados (por referencia).
+ * Conservador: si `p` está bajo replicación, se reporta como "contiene"
+ * porque podría producir una copia.
+ */
+function containsPrefixes(p, i, o) {
+    let hasInput = false;
+    let hasOutput = false;
+    walk(p);
+    return { hasInput, hasOutput };
+    function walk(q) {
+        if (q.kind === 'input' && q.channel === i.channel && q.bind === i.bind && q.cont === i.cont) {
+            hasInput = true;
+        }
+        if (q.kind === 'output' &&
+            q.channel === o.channel &&
+            q.value === o.value &&
+            q.cont === o.cont) {
+            hasOutput = true;
+        }
+        switch (q.kind) {
+            case 'parallel':
+            case 'choice':
+                walk(q.left);
+                walk(q.right);
+                return;
+            case 'new':
+            case 'replication':
+                walk(q.body);
+                return;
+            case 'match':
+                walk(q.cont);
+                return;
+            default:
+                return;
+        }
+    }
+}
+/**
+ * `isDeadlocked(p)`: `true` si no hay ninguna reducción posible.
+ * Incluye procesos terminales (`0`, `0 | 0`, etc.) y procesos con
+ * prefijos que no pueden sincronizar por incompatibilidad de canales.
+ */
+function isDeadlocked(p) {
+    return reduce(p).length === 0;
+}
+/**
+ * `trace(p, maxSteps)`: explora una traza determinista (elige el
+ * primer sucesor en cada paso). Útil para inspección, no pretende ser
+ * una semántica completa. Se detiene en deadlock o tras `maxSteps`.
+ */
+function trace(p, maxSteps = 100) {
+    const result = [p];
+    let current = p;
+    for (let step = 0; step < maxSteps; step++) {
+        const next = reduce(current);
+        if (next.length === 0)
+            break;
+        const head = next[0];
+        result.push(head);
+        current = head;
+    }
+    return result;
+}
+//# sourceMappingURL=reduction.js.map