libpetri 2.10.5 → 2.12.0

package/dist/{chunk-M3KT7BFO.js → chunk-V3WTQRHC.js}

@@ -588,6 +588,90 @@ function computePInvariants(matrix, flatNet, initialMarking) {
   }
   return invariants;
 }
+function computePSemiflows(matrix, flatNet, initialMarking) {
+  const np = matrix.numPlaces();
+  const nt = matrix.numTransitions();
+  if (np === 0) return [];
+  const incidence = matrix.incidence();
+  let rows = [];
+  for (let p = 0; p < np; p++) {
+    const sig = new Array(nt);
+    for (let t = 0; t < nt; t++) sig[t] = incidence[t][p];
+    const weight = new Array(np).fill(0);
+    weight[p] = 1;
+    rows.push({ sig, weight });
+  }
+  for (let t = 0; t < nt; t++) {
+    const next = rows.filter((r) => r.sig[t] === 0);
+    const pos = rows.filter((r) => r.sig[t] > 0);
+    const neg = rows.filter((r) => r.sig[t] < 0);
+    for (const rp of pos) {
+      for (const rn of neg) {
+        const cp = -rn.sig[t];
+        const cn = rp.sig[t];
+        const sig = combineRow(cp, rp.sig, cn, rn.sig);
+        const weight = combineRow(cp, rp.weight, cn, rn.weight);
+        if (sig === null || weight === null) continue;
+        reduceGcd(sig, weight);
+        next.push({ sig, weight });
+      }
+    }
+    rows = keepSupportMinimal(next);
+    if (rows.length > 8192) rows.length = 8192;
+  }
+  const semiflows = [];
+  for (const { weight } of rows) {
+    if (!weight.some((x) => x !== 0)) continue;
+    const support = /* @__PURE__ */ new Set();
+    let constant = 0;
+    for (let p = 0; p < np; p++) {
+      if (weight[p] !== 0) {
+        support.add(p);
+        constant += weight[p] * initialMarking.tokens(flatNet.places[p]);
+      }
+    }
+    if (!Number.isSafeInteger(constant)) continue;
+    semiflows.push(pInvariant(weight, constant, support));
+  }
+  return semiflows;
+}
+function combineRow(cp, a, cn, b) {
+  const out = new Array(a.length);
+  for (let i = 0; i < a.length; i++) {
+    const v = cp * a[i] + cn * b[i];
+    if (!Number.isSafeInteger(v)) return null;
+    out[i] = v;
+  }
+  return out;
+}
+function reduceGcd(sig, weight) {
+  let g = 0;
+  for (const v of sig) g = gcd(g, Math.abs(v));
+  for (const v of weight) g = gcd(g, Math.abs(v));
+  if (g > 1) {
+    for (let i = 0; i < sig.length; i++) sig[i] = sig[i] / g;
+    for (let i = 0; i < weight.length; i++) weight[i] = weight[i] / g;
+  }
+}
+function keepSupportMinimal(rows) {
+  const supports = rows.map((r) => {
+    const s = [];
+    for (let i = 0; i < r.weight.length; i++) if (r.weight[i] !== 0) s.push(i);
+    return s;
+  });
+  const keep = new Array(rows.length).fill(true);
+  for (let i = 0; i < rows.length; i++) {
+    if (!keep[i]) continue;
+    for (let j = 0; j < rows.length; j++) {
+      if (i === j || !keep[j]) continue;
+      if (supports[j].length < supports[i].length && supports[j].every((p) => supports[i].includes(p))) {
+        keep[i] = false;
+        break;
+      }
+    }
+  }
+  return rows.filter((_, i) => keep[i]);
+}
 function isCoveredByInvariants(invariants, numPlaces) {
   const covered = new Array(numPlaces).fill(false);
   for (const inv of invariants) {
@@ -1277,10 +1361,24 @@ var StateClass = class {
   marking;
   firingDomain;
   enabledTransitions;
-  constructor(marking, firingDomain, enabledTransitions) {
+  /**
+   * Class-relative earliest-ready time (seconds) of each enabled transition,
+   * parallel to `enabledTransitions`. Captured from the firing-domain DBM
+   * (`getLowerBound(k)`) *before* `letTimePass()` zeroes the lower bounds, i.e.
+   * the minimum time from class entry at which clock `k` may fire.
+   *
+   * Purely additive: base timed-reachability (marking + DBM zone, `equals`,
+   * `classKey`) ignores it. Read only by the ν conflict-priority prune (NU-052,
+   * `priorityDominated`), where comparing `readyEarliest[H] <= readyEarliest[L]`
+   * decides whether the strictly higher-priority `H` becomes ready no later than
+   * `L` and so pre-empts it.
+   */
+  readyEarliest;
+  constructor(marking, firingDomain, enabledTransitions, readyEarliest) {
     this.marking = marking;
     this.firingDomain = firingDomain;
     this.enabledTransitions = [...enabledTransitions];
+    this.readyEarliest = [...readyEarliest];
   }
   isEmpty() {
     return this.firingDomain.isEmpty();
@@ -1453,9 +1551,10 @@ function initialStateClass(net, initialMarking, envPlaces, envMode) {
   const clockNames = enabledTransitions.map((t) => t.name);
   const lowerBounds = enabledTransitions.map((t) => earliest(t.timing) / 1e3);
   const upperBounds = enabledTransitions.map((t) => latest(t.timing) / 1e3);
-  let initialDBM = DBM.create(clockNames, lowerBounds, upperBounds);
-  initialDBM = initialDBM.letTimePass();
-  return new StateClass(initialMarking, initialDBM, enabledTransitions);
+  const baseDBM = DBM.create(clockNames, lowerBounds, upperBounds);
+  const readyEarliest = enabledTransitions.map((_, k) => baseDBM.getLowerBound(k));
+  const initialDBM = baseDBM.letTimePass();
+  return new StateClass(initialMarking, initialDBM, enabledTransitions, readyEarliest);
 }
 function expandTransition(t) {
   let branches;
@@ -1493,16 +1592,17 @@ function computeSuccessor(net, current, fired, environmentPlaces, environmentMod
   const newClockNames = newlyEnabled.map((t) => t.name);
   const newLowerBounds = newlyEnabled.map((t) => earliest(t.timing) / 1e3);
   const newUpperBounds = newlyEnabled.map((t) => latest(t.timing) / 1e3);
-  let newDBM = current.firingDomain.fireTransition(
+  const firedDBM = current.firingDomain.fireTransition(
     firedIdx,
     newClockNames,
     newLowerBounds,
     newUpperBounds,
     persistentIndices
   );
-  newDBM = newDBM.letTimePass();
   const allEnabled = [...persistent, ...newlyEnabled];
-  return new StateClass(newMarking, newDBM, allEnabled);
+  const readyEarliest = allEnabled.map((_, k) => firedDBM.getLowerBound(k));
+  const newDBM = firedDBM.letTimePass();
+  return new StateClass(newMarking, newDBM, allEnabled, readyEarliest);
 }
 function findEnabledTransitions(net, marking, environmentPlaces, environmentMode) {
   const enabled = [];
@@ -1661,14 +1761,37 @@ function extractMarking(ctx, reachableApp, flatNet) {
 }
 
 // src/verification/z3/name-coloured-encoder.ts
-function buildColouredPlan(net, flat, initial, budgetNames) {
-  const P = flat.places.length;
-  if (flat.transitions.length !== [...net.transitions].length) {
-    return null;
+function colourSlotBound(coloured, semiflows) {
+  const w = (inv, pid) => inv.weights[pid] ?? 0;
+  const isSemiflow = (inv) => inv.weights.every((x) => x >= 0);
+  let single = null;
+  for (const inv of semiflows) {
+    if (isSemiflow(inv) && inv.constant >= 1 && coloured.every((pid) => w(inv, pid) >= 1)) {
+      if (single === null || inv.constant < single) single = inv.constant;
+    }
+  }
+  if (single !== null) return single;
+  let sumConst = 0;
+  const covered = new Array(coloured.length).fill(false);
+  for (const inv of semiflows) {
+    if (!isSemiflow(inv)) continue;
+    let touches = false;
+    for (let i = 0; i < coloured.length; i++) {
+      if (w(inv, coloured[i]) >= 1) {
+        covered[i] = true;
+        touches = true;
+      }
+    }
+    if (touches) sumConst += inv.constant;
   }
+  if (covered.every((c) => c) && sumConst >= 1) return sumConst;
+  return null;
+}
+function buildColouredPlan(net, flat, initial, budgetNames, fragmentMode, carrierPlaces, semiflows) {
+  const P = flat.places.length;
   const isColoured = new Array(P).fill(false);
-  for (const ft of flat.transitions) {
-    const ms = ft.source.matchSpec;
+  for (const t of net.transitions) {
+    const ms = t.matchSpec;
     if (ms) {
       for (const key of ms.keys) {
         const pid = flat.placeIndex.get(key.place.name);
@@ -1677,21 +1800,25 @@ function buildColouredPlan(net, flat, initial, budgetNames) {
       }
     }
   }
+  if (fragmentMode === "extended") {
+    for (const c of carrierPlaces) {
+      const pid = flat.placeIndex.get(c);
+      if (pid != null) isColoured[pid] = true;
+    }
+  }
   const coloured = [];
   for (let i = 0; i < P; i++) if (isColoured[i]) coloured.push(i);
   if (coloured.length === 0) return null;
   for (const pid of coloured) {
     if (initial.tokens(flat.places[pid]) !== 0) return null;
   }
+  const k = colourSlotBound(coloured, semiflows);
+  if (k === null) return null;
   const budgetIdx = /* @__PURE__ */ new Set();
   for (const n of budgetNames) {
     const i = flat.placeIndex.get(n);
     if (i != null) budgetIdx.add(i);
   }
-  if (budgetIdx.size === 0) return null;
-  let k = 0;
-  for (const b of budgetIdx) k += initial.tokens(flat.places[b]);
-  if (k === 0) return null;
   for (const ft of flat.transitions) {
     const touches = ft.inhibitorPlaces.some((i) => isColoured[i]) || ft.readPlaces.some((i) => isColoured[i]) || ft.resetPlaces.some((i) => isColoured[i]) || ft.consumeAll.some((ca, i) => ca && isColoured[i]);
     if (touches) return null;
@@ -1705,38 +1832,21 @@ function buildColouredPlan(net, flat, initial, budgetNames) {
       if (colouredOut.length !== 0 || colouredIn.length === 0) return null;
       if (colouredIn.some((pid) => ft.preVector[pid] !== 1)) return null;
       classes.push({ kind: "join", colouredIn });
+    } else if (colouredIn.length !== 0) {
+      if (fragmentMode !== "extended") return null;
+      if (colouredIn.length !== 1 || ft.preVector[colouredIn[0]] !== 1) return null;
+      if (colouredOut.some((o) => ft.postVector[o] !== 1)) return null;
+      classes.push({ kind: "consume", inputCol: colouredIn[0], colouredOut });
     } else if (colouredOut.length !== 0) {
-      if (colouredIn.length !== 0) return null;
       if (colouredOut.some((o) => ft.postVector[o] !== 1)) return null;
       let budgetConsumed = 0;
       for (const b of budgetIdx) budgetConsumed += ft.preVector[b];
       if (budgetConsumed < 1) return null;
       classes.push({ kind: "mint", colouredOut });
     } else {
-      if (colouredIn.length !== 0) return null;
       classes.push({ kind: "untouched" });
     }
   }
-  let minMintCost = null;
-  let maxJoinRefund = 0;
-  for (let ti = 0; ti < classes.length; ti++) {
-    const cls = classes[ti];
-    const ft = flat.transitions[ti];
-    for (const b of budgetIdx) {
-      if (ft.preVector[b] > 0 && cls.kind !== "mint") return null;
-      if (ft.postVector[b] > 0 && cls.kind !== "join") return null;
-    }
-    if (cls.kind === "mint") {
-      let cost = 0;
-      for (const b of budgetIdx) cost += ft.preVector[b];
-      minMintCost = minMintCost === null ? cost : Math.min(minMintCost, cost);
-    } else if (cls.kind === "join") {
-      let refund = 0;
-      for (const b of budgetIdx) refund += ft.postVector[b];
-      maxJoinRefund = Math.max(maxJoinRefund, refund);
-    }
-  }
-  if (minMintCost === null || maxJoinRefund > minMintCost) return null;
   return { coloured, isColoured, k, classes };
 }
 function buildLayout(ctx, plan, P) {
@@ -1760,7 +1870,7 @@ function buildLayout(ctx, plan, P) {
   }
   return { colUnc, colCol, nCols, cur, nxt };
 }
-function encodeColoured(ctx, fp, plan, flat, initial, property, invariants) {
+function encodeColoured(ctx, fp, plan, flat, initial, property, invariants, sinkPlaces = /* @__PURE__ */ new Set()) {
   const P = flat.places.length;
   const k = plan.k;
   const lay = buildLayout(ctx, plan, P);
@@ -1807,7 +1917,7 @@ function encodeColoured(ctx, fp, plan, flat, initial, property, invariants) {
           }
         });
       }
-    } else {
+    } else if (cls.kind === "join") {
       const colouredIn = cls.colouredIn;
       for (let c = 0; c < k; c++) {
         const cc = c;
@@ -1820,9 +1930,27 @@ function encodeColoured(ctx, fp, plan, flat, initial, property, invariants) {
           }
         });
       }
+    } else {
+      const inputCol = cls.inputCol;
+      const colouredOut = cls.colouredOut;
+      for (let c = 0; c < k; c++) {
+        const cc = c;
+        addRule(ctx, fp, reachable, lay, plan, invariants, `${ft.name}_consume_${cc}`, (enab, upd) => {
+          uncolouredIncidence(ctx, lay, plan, ft, enab, upd);
+          const icol = lay.colCol[inputCol][cc];
+          enab.push(lay.cur[icol].ge(1));
+          upd.set(icol, lay.cur[icol].add(-1));
+          for (const o of colouredOut) {
+            const ocol = lay.colCol[o][cc];
+            upd.set(ocol, lay.cur[ocol].add(1));
+          }
+        });
+      }
     }
   }
-  addErrorRule(ctx, fp, reachable, error, lay, plan, flat, property);
+  if (!addErrorRule(ctx, fp, reachable, error, lay, plan, flat, property, sinkPlaces)) {
+    return null;
+  }
   return {
     errorExpr: error.call(),
     reachableDecl: reachable
@@ -1886,20 +2014,22 @@ function liftedInvariant(ctx, inv, plan, lay, vars) {
   }
   return sum.eq(inv.constant);
 }
-function addErrorRule(ctx, fp, reachable, error, lay, plan, flat, property) {
+function addErrorRule(ctx, fp, reachable, error, lay, plan, flat, property, sinkPlaces) {
+  const violation = encodeViolation(ctx, plan, lay, flat, property, lay.cur, sinkPlaces);
+  if (violation === null) return false;
   const reachBody = reachable.call(...lay.cur);
-  const violation = encodeViolation(ctx, plan, lay, flat, property, lay.cur);
   const body = ctx.And(reachBody, violation);
   const head = error.call();
   const qRule = ctx.ForAll([...lay.cur], ctx.Implies(body, head));
   fp.addRule(qRule, "error");
+  return true;
 }
-function encodeViolation(ctx, plan, lay, flat, property, cur) {
+function encodeViolation(ctx, plan, lay, flat, property, cur, sinkPlaces) {
   switch (property.type) {
     case "place-bound":
     case "branch-place-bound": {
       const idx = flatNetIndexOf(flat, property.place);
-      if (idx < 0) return ctx.Bool.val(false);
+      if (idx < 0) return null;
       return aggregate(plan, lay, idx, cur).gt(property.bound);
     }
     case "mutual-exclusion": {
@@ -1917,15 +2047,130 @@ function encodeViolation(ctx, plan, lay, flat, property, cur) {
       if (conds.length === 0) return ctx.Bool.val(false);
       return conds.length === 1 ? conds[0] : ctx.And(...conds);
     }
-    // Quiescence properties are never routed here.
     case "deadlock-free":
-    case "joined-or-dead-lettered":
+      return encodeColouredDeadlock(ctx, plan, lay, flat, sinkPlaces);
+    case "joined-or-dead-lettered": {
+      const idx = flatNetIndexOf(flat, property.pending);
+      if (idx < 0) return null;
+      const deadlock = encodeColouredDeadlock(ctx, plan, lay, flat, sinkPlaces);
+      return ctx.And(deadlock, aggregate(plan, lay, idx, cur).ge(1));
+    }
+  }
+}
+function andAll(ctx, xs) {
+  if (xs.length === 0) return ctx.Bool.val(true);
+  let r = xs[0];
+  for (let i = 1; i < xs.length; i++) r = ctx.And(r, xs[i]);
+  return r;
+}
+function orAll(ctx, xs) {
+  if (xs.length === 0) return ctx.Bool.val(false);
+  let r = xs[0];
+  for (let i = 1; i < xs.length; i++) r = ctx.Or(r, xs[i]);
+  return r;
+}
+function injectedEnvIndices2(flat) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, bound] of flat.environmentInjection) {
+    const idx = flat.placeIndex.get(name);
+    if (idx != null) out.set(idx, bound);
+  }
+  return out;
+}
+function uncolouredDisable(ft, lay, plan, envInj) {
+  const reasons = [];
+  let permanentlyDisabled = false;
+  const P = ft.preVector.length;
+  for (let i = 0; i < P; i++) {
+    if (plan.isColoured[i] || ft.preVector[i] === 0) continue;
+    if (envInj.has(i)) {
+      const bound = envInj.get(i);
+      if (bound !== null && ft.preVector[i] > bound) permanentlyDisabled = true;
+      continue;
+    }
+    reasons.push(lay.cur[lay.colUnc[i]].lt(ft.preVector[i]));
+  }
+  for (const inh of ft.inhibitorPlaces) {
+    reasons.push(lay.cur[lay.colUnc[inh]].gt(0));
+  }
+  for (const rd of ft.readPlaces) {
+    if (envInj.has(rd)) {
+      const bound = envInj.get(rd);
+      if (bound !== null && bound < 1) permanentlyDisabled = true;
+      continue;
+    }
+    reasons.push(lay.cur[lay.colUnc[rd]].lt(1));
+  }
+  return { reasons, permanentlyDisabled };
+}
+function colouredDisabledTerm(ctx, cls, plan, lay) {
+  const k = plan.k;
+  switch (cls.kind) {
+    case "untouched":
+      return null;
+    case "mint": {
+      const perColour = [];
+      for (let c = 0; c < k; c++) {
+        const present = plan.coloured.map((q) => lay.cur[lay.colCol[q][c]].ge(1));
+        perColour.push(orAll(ctx, present));
+      }
+      return andAll(ctx, perColour);
+    }
+    case "join": {
+      const perColour = [];
+      for (let c = 0; c < k; c++) {
+        const missing = cls.colouredIn.map((i) => lay.cur[lay.colCol[i][c]].eq(0));
+        perColour.push(orAll(ctx, missing));
+      }
+      return andAll(ctx, perColour);
+    }
+    case "consume": {
+      const perColour = [];
+      for (let c = 0; c < k; c++) {
+        perColour.push(lay.cur[lay.colCol[cls.inputCol][c]].eq(0));
+      }
+      return andAll(ctx, perColour);
+    }
+  }
+}
+function encodeColouredDeadlock(ctx, plan, lay, flat, sinkPlaces) {
+  const envInj = injectedEnvIndices2(flat);
+  const disabledConditions = [];
+  for (let ti = 0; ti < plan.classes.length; ti++) {
+    const cls = plan.classes[ti];
+    const ft = flat.transitions[ti];
+    const { reasons, permanentlyDisabled } = uncolouredDisable(ft, lay, plan, envInj);
+    if (permanentlyDisabled) {
+      disabledConditions.push(ctx.Bool.val(true));
+      continue;
+    }
+    const term = colouredDisabledTerm(ctx, cls, plan, lay);
+    if (term !== null) reasons.push(term);
+    if (reasons.length === 0) {
       return ctx.Bool.val(false);
+    }
+    disabledConditions.push(reasons.length === 1 ? reasons[0] : orAll(ctx, reasons));
+  }
+  const sinkIndices = /* @__PURE__ */ new Set();
+  for (const sink of sinkPlaces) {
+    const idx = flatNetIndexOf(flat, sink);
+    if (idx >= 0) sinkIndices.add(idx);
+  }
+  if (sinkIndices.size > 0) {
+    const nonSink = [];
+    for (let pid = 0; pid < flat.places.length; pid++) {
+      if (sinkIndices.has(pid)) continue;
+      nonSink.push(aggregate(plan, lay, pid, lay.cur).ge(1));
+    }
+    if (nonSink.length > 0) {
+      disabledConditions.push(orAll(ctx, nonSink));
+    }
   }
+  return andAll(ctx, disabledConditions);
 }
 
 // src/verification/analysis/name-fragment.ts
-function classify(net) {
+function classify(net, mode, carrierPlaces) {
   const coloured = /* @__PURE__ */ new Set();
   let anyMatch = false;
   for (const t of net.transitions) {
@@ -1935,9 +2180,18 @@ function classify(net) {
     }
   }
   if (!anyMatch || coloured.size === 0) return null;
+  if (mode === "extended") {
+    for (const c of carrierPlaces) coloured.add(c);
+  }
+  for (const t of net.transitions) {
+    if (t.resets.some((r) => coloured.has(r.place.name)) || t.reads.some((r) => coloured.has(r.place.name)) || t.inhibitors.some((i) => coloured.has(i.place.name))) {
+      return null;
+    }
+  }
   const roles = /* @__PURE__ */ new Map();
   for (const t of net.transitions) {
-    const consumesColoured = t.inputSpecs.some((s) => coloured.has(s.place.name));
+    const colouredInputs = t.inputSpecs.filter((s) => coloured.has(s.place.name));
+    const consumesColoured = colouredInputs.length > 0;
     let producesColoured = false;
     if (t.outputSpec !== null) {
       for (const branch of enumerateBranches(t.outputSpec)) {
@@ -1958,11 +2212,16 @@ function classify(net) {
       }
       colouredIn.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
       role = { type: "join", colouredIn };
+    } else if (consumesColoured) {
+      if (mode === "base") return null;
+      if (colouredInputs.length !== 1) return null;
+      const spec = colouredInputs[0];
+      const countOne = spec.type === "one" || spec.type === "exactly" && spec.count === 1;
+      if (!countOne) return null;
+      role = { type: "consume", colouredInput: spec.place.name };
     } else if (producesColoured) {
-      if (consumesColoured) return null;
       role = { type: "mint" };
     } else {
-      if (consumesColoured) return null;
       role = { type: "ordinary" };
     }
     roles.set(t.name, role);
@@ -2113,7 +2372,7 @@ var NameStateClassGraph = class _NameStateClassGraph {
   markingOf(idx) {
     return this.classes[idx].base.marking;
   }
-  static build(net, initialMarking, fragment, maxClasses, environmentPlaces, environmentMode) {
+  static build(net, initialMarking, fragment, maxClasses, environmentPlaces, environmentMode, prioritySemantics = "none") {
     const envMode = environmentMode ?? ignore();
     const envPlaces = /* @__PURE__ */ new Set();
     if (environmentPlaces) {
@@ -2133,7 +2392,20 @@ var NameStateClassGraph = class _NameStateClassGraph {
       }
       const curIdx = queue.shift();
       const current = graph.classes[curIdx];
-      for (const transition of current.base.enabledTransitions) {
+      const enabled = current.base.enabledTransitions;
+      for (let idxL = 0; idxL < enabled.length; idxL++) {
+        const transition = enabled[idxL];
+        if (prioritySemantics === "conflict" && priorityDominated(
+          transition,
+          idxL,
+          enabled,
+          current.base.readyEarliest,
+          current.base.marking,
+          current.names,
+          fragment
+        )) {
+          continue;
+        }
         const role = fragment.role(transition.name);
         for (const vt of expandTransition(transition)) {
           const baseSucc = computeSuccessor(net, current.base, vt, envPlaces, envMode);
@@ -2165,12 +2437,66 @@ var NameStateClassGraph = class _NameStateClassGraph {
     this._successors[from].push(to);
   }
 };
+var READY_EPS = 1e-9;
+function priorityDominated(l, idxL, enabled, readyEarliest, marking, names, fragment) {
+  return enabled.some(
+    (h, idxH) => h !== l && h.priority > l.priority && readyEarliest[idxH] <= readyEarliest[idxL] + READY_EPS && willFire(h, names, fragment) && sharesConsumedInput(h, l, marking)
+  );
+}
+function willFire(h, names, fragment) {
+  const role = fragment.role(h.name);
+  switch (role.type) {
+    case "join":
+      return enablingSymbols(names, role.colouredIn).length > 0;
+    case "consume":
+      return names.symbolsIn(role.colouredInput).length > 0;
+    case "ordinary":
+    case "mint":
+      return true;
+    default: {
+      const _exhaustive = role;
+      return _exhaustive;
+    }
+  }
+}
+function sharesConsumedInput(h, l, marking) {
+  const lIns = /* @__PURE__ */ new Set();
+  for (const p of l.inputPlaces()) lIns.add(p.name);
+  for (const p of h.inputPlaces()) {
+    if (lIns.has(p.name) && marking.tokens(p) < consumedDemand(h, p.name) + consumedDemand(l, p.name)) {
+      return true;
+    }
+  }
+  return false;
+}
+function consumedDemand(t, placeName) {
+  let demand = 0;
+  for (const spec of t.inputSpecs) {
+    if (spec.place.name === placeName) demand += inputRequiredCount2(spec);
+  }
+  return demand;
+}
+function inputRequiredCount2(spec) {
+  switch (spec.type) {
+    case "one":
+      return 1;
+    case "exactly":
+      return spec.count;
+    case "all":
+      return 1;
+    case "at-least":
+      return spec.minimum;
+  }
+}
+function colouredOutputs(outputPlaces, fragment) {
+  return [...outputPlaces].filter((p) => fragment.isColoured(p.name)).map((p) => p.name);
+}
 function nameSuccessors(role, names, outputPlaces, fragment, sym) {
   switch (role.type) {
     case "ordinary":
       return [names.copy()];
     case "mint": {
-      const colouredOut = [...outputPlaces].filter((p) => fragment.isColoured(p.name)).map((p) => p.name);
+      const colouredOut = colouredOutputs(outputPlaces, fragment);
       const nm = names.copy();
       if (colouredOut.length > 0) {
         const fresh = sym.next++;
@@ -2187,6 +2513,17 @@ function nameSuccessors(role, names, outputPlaces, fragment, sym) {
       }
       return result;
     }
+    case "consume": {
+      const colouredOut = colouredOutputs(outputPlaces, fragment);
+      const result = [];
+      for (const s of names.symbolsIn(role.colouredInput)) {
+        const nm = names.copy();
+        nm.remove(role.colouredInput, s, 1);
+        for (const p of colouredOut) nm.add(p, s, 1);
+        result.push(nm);
+      }
+      return result;
+    }
   }
 }
 function enablingSymbols(names, colouredIn) {
@@ -2210,13 +2547,21 @@ function enablingSymbols(names, colouredIn) {
 
 // src/verification/nu-scg-verifier.ts
 var NOTE_EXACT = "\nNote: \u03BD-join correlation decided exactly via the state-class-graph name-partition quotient \u2014 the symbolic graph closed, so the verdict is sound AND complete (no spurious different-name counterexample; quiescence is name-aware), beyond the bounded-budget fragment (NU-050, Route B).\n";
-function verifyViaNameScg(net, initial, property, sinkPlaces, environmentPlaces, environmentMode, maxClasses) {
-  const fragment = classify(net);
+function verifyViaNameScg(net, initial, property, sinkPlaces, environmentPlaces, environmentMode, maxClasses, fragmentMode, carrierPlaces, prioritySemantics) {
+  const fragment = classify(net, fragmentMode, carrierPlaces);
   if (fragment === null) return null;
   for (const p of initial.placesWithTokens()) {
     if (fragment.isColoured(p.name)) return null;
   }
-  const scg = NameStateClassGraph.build(net, initial, fragment, maxClasses, environmentPlaces, environmentMode);
+  const scg = NameStateClassGraph.build(
+    net,
+    initial,
+    fragment,
+    maxClasses,
+    environmentPlaces,
+    environmentMode,
+    prioritySemantics
+  );
   if (!scg.isComplete()) {
     return {
       verdict: {
@@ -2322,6 +2667,9 @@ var SmtVerifier = class _SmtVerifier {
   _environmentMode = alwaysAvailable();
   _timeoutMs = 6e4;
   _nuMaxClasses = 1e5;
+  _fragmentMode = "base";
+  _carrierPlaces = /* @__PURE__ */ new Set();
+  _prioritySemantics = "none";
   static forNet(net) {
     return new _SmtVerifier(net);
   }
@@ -2381,6 +2729,50 @@ var SmtVerifier = class _SmtVerifier {
     this._nuMaxClasses = max;
     return this;
   }
+  /**
+   * Selects the ν-net coloured-place fragment for Route B (NU-051). `base`
+   * (default) admits the shipped mint → matched-join fragment only; `extended`
+   * additionally admits the opt-in coloured-consumer (drain/relay) role and the
+   * declared {@link carrierPlaces}. When `extended` is requested but the net
+   * falls outside the coloured-consumer fragment, Route B declines and a short
+   * note is appended to the report before falling back to the sound
+   * over-approximation.
+   */
+  fragmentMode(mode) {
+    this._fragmentMode = mode;
+    return this;
+  }
+  /**
+   * Declares ν-net *carrier* places (NU-051, EXTENDED only): intermediate places
+   * that carry a fresh name from the minting fork onward to a ν-join input. Under
+   * {@link fragmentMode} `extended` they are unioned into the coloured set so the
+   * existing mint co-mints one fresh name into all of them; under `base` they are
+   * ignored. Accumulating. Throws if a declared place is not in the net — a
+   * mistyped carrier name would let two fork branches mint independent names, so
+   * the join never becomes name-enabled and the verifier would otherwise report a
+   * confident false deadlock; it must surface, never silently proceed.
+   */
+  carrierPlaces(...places) {
+    for (const p of places) {
+      if (![...this.net.places].some((np) => np.name === p.name)) {
+        throw new Error(`declared carrier place '${p.name}' not in the net`);
+      }
+      this._carrierPlaces.add(p.name);
+    }
+    return this;
+  }
+  /**
+   * Selects how the Route-B name-aware analyzer treats transition priority
+   * (NU-052). Defaults to `'none'` (the priority-blind over-approximation).
+   * `'conflict'` models the executor's conflict-only priority resolution, so a
+   * lower-priority transition pre-empted by a conflicting, no-later-ready,
+   * strictly-higher-priority one is not explored — removing spurious
+   * dead-letter-drain stalls the eager, priority-ordered executor never produces.
+   */
+  prioritySemantics(semantics) {
+    this._prioritySemantics = semantics;
+    return this;
+  }
   /**
    * Runs the verification pipeline.
    */
@@ -2403,9 +2795,13 @@ var SmtVerifier = class _SmtVerifier {
         this._sinkPlaces,
         this._environmentPlaces,
         this._environmentMode,
-        this._nuMaxClasses
+        this._nuMaxClasses,
+        this._fragmentMode,
+        this._carrierPlaces,
+        this._prioritySemantics
       );
-      if (outcome !== null) {
+      const deferToRouteA = outcome !== null && outcome.verdict.type === "unknown" && !isReachabilitySafety(this._property) && nuBounded;
+      if (outcome !== null && !deferToRouteA) {
         report.push("=== \u03BD-net Route B: name-aware state-class graph (NU-050) ===");
         report.push(`  Name-partition state classes: ${outcome.classCount}`);
         report.push(outcome.note);
@@ -2427,6 +2823,15 @@ var SmtVerifier = class _SmtVerifier {
             structuralResult: "n/a (\u03BD name-partition SCG)"
           }
         );
+      } else if (deferToRouteA) {
+        report.push(
+          "\u03BD-net Route B inconclusive (name-partition truncated); deferring to Route A coloured IC3/PDR (NU-053)."
+        );
+      }
+      if (this._fragmentMode === "extended" && !deferToRouteA) {
+        report.push(
+          "\u03BD-net Route B (EXTENDED) declined: net outside coloured-consumer fragment (a coloured place consumed count != 1 or by multiple inputs, carries a reset/read/inhibitor arc, or a join re-mints a coloured place); verified via sound over-approximation instead."
+        );
       }
     }
     report.push("Phase 1: Flattening net...");
@@ -2471,6 +2876,7 @@ var SmtVerifier = class _SmtVerifier {
     report.push("Phase 3: Computing P-invariants...");
     const matrix = IncidenceMatrix.from(flatNet);
     const invariants = computePInvariants(matrix, flatNet, this._initialMarking);
+    const semiflows = computePSemiflows(matrix, flatNet, this._initialMarking);
     report.push(`  Found: ${invariants.length} P-invariant(s)`);
     const structurallyBounded = isCoveredByInvariants(invariants, flatNet.places.length);
     report.push(`  Structurally bounded: ${structurallyBounded ? "YES" : "NO"}`);
@@ -2479,7 +2885,15 @@ var SmtVerifier = class _SmtVerifier {
     }
     report.push("");
     report.push("Phase 4: IC3/PDR verification via Z3 Spacer...");
-    const colouredPlan = hasMatch && nuBounded && isReachabilitySafety(this._property) ? buildColouredPlan(this.net, flatNet, this._initialMarking, this._budgetPlaces) : null;
+    const colouredPlan = hasMatch && nuBounded ? buildColouredPlan(
+      this.net,
+      flatNet,
+      this._initialMarking,
+      this._budgetPlaces,
+      this._fragmentMode,
+      this._carrierPlaces,
+      semiflows
+    ) : null;
     let runner;
     try {
       runner = await createSpacerRunner(this._timeoutMs);
@@ -2505,7 +2919,23 @@ var SmtVerifier = class _SmtVerifier {
         report.push(
           `  \u03BD-encoding: name-coloured (exact within budget k=${colouredPlan.k}; ${colouredPlan.coloured.length} coloured place(s))`
         );
-        encoding = encodeColoured(runner.ctx, runner.fp, colouredPlan, flatNet, this._initialMarking, this._property, invariants);
+        encoding = encodeColoured(runner.ctx, runner.fp, colouredPlan, flatNet, this._initialMarking, this._property, invariants, this._sinkPlaces);
+        if (encoding == null) {
+          const reason = "property names a place that does not resolve in the net; refusing to certify (the encoding would be vacuously proven)";
+          report.push("  Status: UNKNOWN (unresolved property place)\n");
+          report.push("=== RESULT ===\n");
+          report.push(`UNKNOWN: ${reason}`);
+          return buildResult(
+            { type: "unknown", reason },
+            report.join("\n"),
+            invariants,
+            [],
+            [],
+            [],
+            performance.now() - start,
+            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+          );
+        }
       } else {
         encoding = encode(runner.ctx, runner.fp, flatNet, this._initialMarking, this._property, invariants, this._sinkPlaces);
       }
@@ -2655,6 +3085,10 @@ var SmtVerifier = class _SmtVerifier {
    */
   applyNuGuard(result, hasMatch, nuBounded, exact) {
     if (!hasMatch || result.verdict.type === "unknown") return result;
+    if (exact) {
+      const note2 = "\nNote: \u03BD-join name equality is encoded exactly via bounded name-colouring (k = budget); the verdict is sound and complete within the budget bound \u2014 no spurious different-name counterexample (NU-050 #1 / NU-053).\n";
+      return { ...result, report: result.report + note2 };
+    }
     if (!isReachabilitySafety(this._property)) {
       return downgradeToUnknown(
         result,
@@ -2667,7 +3101,7 @@ var SmtVerifier = class _SmtVerifier {
         "\u03BD-matching transitions present with unbounded fresh names (no budget place declared via budgetPlaces(...)); reachability over unbounded fresh names is undecidable (NU-040) \u2014 declare the budget place(s) that gate minting to verify within the bounded fragment"
       );
     }
-    const note = exact ? "\nNote: \u03BD-join name equality is encoded exactly via bounded name-colouring (k = budget); the verdict is sound and complete within the budget bound \u2014 no spurious different-name counterexample (NU-050 #1).\n" : "\nNote: matched (\u03BD-join) transitions are over-approximated (name equality assumed satisfiable). 'proven' is sound; a 'violated' counterexample may be spurious pending the exact \u03BD-analysis (NU-050).\n";
+    const note = "\nNote: matched (\u03BD-join) transitions are over-approximated (name equality assumed satisfiable). 'proven' is sound; a 'violated' counterexample may be spurious pending the exact \u03BD-analysis (NU-050).\n";
     return { ...result, report: result.report + note };
   }
 };
@@ -2753,6 +3187,7 @@ export {
   pInvariant,
   pInvariantToString,
   computePInvariants,
+  computePSemiflows,
   isCoveredByInvariants,
   structuralCheck,
   findMinimalSiphons,
@@ -2770,4 +3205,4 @@ export {
   isProven,
   isViolated
 };
-//# sourceMappingURL=chunk-M3KT7BFO.js.map
+//# sourceMappingURL=chunk-V3WTQRHC.js.map