libpetri 4.1.0 → 5.0.0

package/dist/{chunk-GJAHGHGT.js → chunk-4HMFNYTH.js}

@@ -762,7 +762,7 @@ function stripClusterEdgeAttrs(line) {
 }
 
 // src/viewer/version.ts
-var VERSION = true ? "4.1.0" : "0.0.0-dev";
+var VERSION = true ? "5.0.0" : "0.0.0-dev";
 
 // src/viewer/index.ts
 async function mount(dotSource, container, opts = {}) {
@@ -1013,4 +1013,4 @@ export {
   VERSION,
   mount
 };
-//# sourceMappingURL=chunk-GJAHGHGT.js.map
+//# sourceMappingURL=chunk-4HMFNYTH.js.map

package/dist/{chunk-FD3S4TZM.js → chunk-75KEJQGC.js}

@@ -331,6 +331,9 @@ var MarkingStateBuilder = class {
 function deadlockFree() {
   return { type: "deadlock-free" };
 }
+function terminatesAtSink() {
+  return { type: "terminates-at-sink" };
+}
 function mutualExclusion(p1, p2) {
   return { type: "mutual-exclusion", p1, p2 };
 }
@@ -350,6 +353,8 @@ function propertyDescription(prop) {
   switch (prop.type) {
     case "deadlock-free":
       return "Deadlock-freedom";
+    case "terminates-at-sink":
+      return "Terminates at a declared sink";
     case "mutual-exclusion":
       return `Mutual exclusion of ${prop.p1.name} and ${prop.p2.name}`;
     case "place-bound":
@@ -1545,8 +1550,31 @@ function indexOrdered(flatNet, places) {
 }
 function encodePropertyViolation(flatNet, property, mVars, sinkPlaces, envInject) {
   switch (property.type) {
-    case "deadlock-free":
-      return encodeDeadlock(flatNet, mVars, sinkPlaces, envInject);
+    // DeadlockFree (VER-002): a quiescent marking that STRANDS a token — holds one
+    // in a place that is not a declared sink. The empty marking strands nothing and
+    // is therefore not a violation (AC4).
+    case "deadlock-free": {
+      const conditions = encodeQuiescent(flatNet, mVars, envInject);
+      if (conditions == null) return "false";
+      const sinks = new Set(indexOrdered(flatNet, sinkPlaces));
+      const stranded = [];
+      for (let pid = 0; pid < flatNet.places.length; pid++) {
+        if (!sinks.has(pid)) stranded.push(`(>= ${mVars[pid]} 1)`);
+      }
+      if (stranded.length === 0) return "false";
+      conditions.push(`(or ${stranded.join(" ")})`);
+      return joinConditions(conditions);
+    }
+    // TerminatesAtSink (VER-002): a quiescent marking that reached NO declared sink.
+    // This is the predicate DeadlockFree carried before the VER-002 split, unchanged.
+    case "terminates-at-sink": {
+      const conditions = encodeQuiescent(flatNet, mVars, envInject);
+      if (conditions == null) return "false";
+      for (const pid of indexOrdered(flatNet, sinkPlaces)) {
+        conditions.push(`(= ${mVars[pid]} 0)`);
+      }
+      return joinConditions(conditions);
+    }
     case "mutual-exclusion": {
       const conditions = indexOrdered(flatNet, [property.p1, property.p2]).map((i) => `(>= ${mVars[i]} 1)`);
       return conditions.length === 0 ? "false" : `(and ${conditions.join(" ")})`;
@@ -1560,14 +1588,23 @@ function encodePropertyViolation(flatNet, property, mVars, sinkPlaces, envInject
       const conditions = indexOrdered(flatNet, property.places).map((i) => `(>= ${mVars[i]} 1)`);
       return conditions.length === 0 ? "false" : `(and ${conditions.join(" ")})`;
     }
+    // JoinedOrDeadLettered (NU-040 AC4): a quiescent state that still holds a
+    // `pending` token is a stranded correlation group. Carries NO sink clause — a
+    // declared sink must not excuse a stranded group.
     case "joined-or-dead-lettered": {
-      const deadlock = encodeDeadlock(flatNet, mVars, sinkPlaces, envInject);
       const pid = flatNet.placeIndex.get(property.pending.name);
-      return pid == null ? "false" : `(and ${deadlock} (>= ${mVars[pid]} 1))`;
+      if (pid == null) return "false";
+      const conditions = encodeQuiescent(flatNet, mVars, envInject);
+      if (conditions == null) return "false";
+      conditions.push(`(>= ${mVars[pid]} 1)`);
+      return joinConditions(conditions);
     }
   }
 }
-function encodeDeadlock(flatNet, mVars, sinkPlaces, envInject) {
+function joinConditions(conditions) {
+  return conditions.length === 0 ? "true" : `(and ${conditions.join("\n         ")})`;
+}
+function encodeQuiescent(flatNet, mVars, envInject) {
   const envBound = /* @__PURE__ */ new Map();
   for (const inj of envInject) envBound.set(inj.pid, inj.bound);
   const disabledConditions = [];
@@ -1597,13 +1634,10 @@ function encodeDeadlock(flatNet, mVars, sinkPlaces, envInject) {
       disabledConditions.push("true");
       continue;
     }
-    if (disableReasons.length === 0) return "false";
+    if (disableReasons.length === 0) return null;
     disabledConditions.push(`(or ${disableReasons.join(" ")})`);
   }
-  for (const pid of indexOrdered(flatNet, sinkPlaces)) {
-    disabledConditions.push(`(= ${mVars[pid]} 0)`);
-  }
-  return disabledConditions.length === 0 ? "true" : `(and ${disabledConditions.join("\n         ")})`;
+  return disabledConditions;
 }
 function injectionMap(flatNet) {
   const out = /* @__PURE__ */ new Map();
@@ -2511,20 +2545,38 @@ function enabledRelaxEnv(state, ft, envInj) {
   }
   return true;
 }
-function isDeadlockA(index, state) {
+function isQuiescent(index, state) {
   for (const ft of index.flatNet.transitions) {
     if (enabledRelaxEnv(state, ft, index.envInj)) return false;
   }
   return true;
 }
+function sinkIndices(flatNet, sinkPlaces) {
+  const idx = /* @__PURE__ */ new Set();
+  for (const sink of sinkPlaces) {
+    const i = flatNetIndexOf(flatNet, sink);
+    if (i >= 0) idx.add(i);
+  }
+  return idx;
+}
 function satisfiesBadIndexed(index, state, property, sinkPlaces) {
   const flatNet = index.flatNet;
   switch (property.type) {
+    // DeadlockFree (VER-002): quiescent AND some marked place is not a declared
+    // sink. Mirrors the encoder's `stranded` disjunction.
     case "deadlock-free": {
-      if (!isDeadlockA(index, state)) return false;
-      for (const sink of sinkPlaces) {
-        const idx = flatNetIndexOf(flatNet, sink);
-        if (idx >= 0 && state[idx] > 0) return false;
+      if (!isQuiescent(index, state)) return false;
+      const sinks = sinkIndices(flatNet, sinkPlaces);
+      for (let pid = 0; pid < flatNet.places.length; pid++) {
+        if (!sinks.has(pid) && state[pid] >= 1) return true;
+      }
+      return false;
+    }
+    // TerminatesAtSink (VER-002): quiescent AND no declared sink marked.
+    case "terminates-at-sink": {
+      if (!isQuiescent(index, state)) return false;
+      for (const pid of sinkIndices(flatNet, sinkPlaces)) {
+        if (state[pid] !== 0) return false;
       }
       return true;
     }
@@ -2540,10 +2592,12 @@ function satisfiesBadIndexed(index, state, property, sinkPlaces) {
       if (idx < 0) return false;
       return state[idx] > property.bound;
     }
+    // JoinedOrDeadLettered (NU-040 AC4): quiescent AND `pending` marked. No sink
+    // clause — a marked sink must not excuse a stranded group.
     case "joined-or-dead-lettered": {
       const idx = flatNetIndexOf(flatNet, property.pending);
       if (idx < 0) return false;
-      return isDeadlockA(index, state) && state[idx] >= 1;
+      return isQuiescent(index, state) && state[idx] >= 1;
     }
     case "unreachable": {
       let resolved = 0;
@@ -2914,13 +2968,38 @@ function encodeViolation(plan, lay, flat, property, sinkPlaces, envInj) {
       return anyPlacePresent([property.p1, property.p2]);
     case "unreachable":
       return anyPlacePresent(property.places);
-    case "deadlock-free":
-      return encodeColouredDeadlock(plan, lay, flat, sinkPlaces, envInj);
+    // DeadlockFree (VER-002): quiescent AND some marked place is not a declared
+    // sink. Mirrors the flat encoder's `stranded` disjunction.
+    case "deadlock-free": {
+      const conds = encodeColouredQuiescent(plan, lay, flat, envInj);
+      if (conds == null) return "false";
+      const sinks = new Set(indexOrdered(flat, sinkPlaces));
+      const stranded = [];
+      for (let pid = 0; pid < flat.places.length; pid++) {
+        if (!sinks.has(pid)) stranded.push(`(>= ${aggregate(plan, lay, pid, lay.cur)} 1)`);
+      }
+      if (stranded.length === 0) return "false";
+      conds.push(`(or ${stranded.join(" ")})`);
+      return joinColoured(conds);
+    }
+    // TerminatesAtSink (VER-002): quiescent AND no declared sink marked.
+    case "terminates-at-sink": {
+      const conds = encodeColouredQuiescent(plan, lay, flat, envInj);
+      if (conds == null) return "false";
+      for (const pid of indexOrdered(flat, sinkPlaces)) {
+        conds.push(`(= ${aggregate(plan, lay, pid, lay.cur)} 0)`);
+      }
+      return joinColoured(conds);
+    }
+    // JoinedOrDeadLettered (NU-040 AC4): quiescent AND `pending` marked, with NO
+    // sink clause.
     case "joined-or-dead-lettered": {
       const pid = flat.placeIndex.get(property.pending.name);
       if (pid == null) return null;
-      const deadlock = encodeColouredDeadlock(plan, lay, flat, sinkPlaces, envInj);
-      return `(and ${deadlock} (>= ${aggregate(plan, lay, pid, lay.cur)} 1))`;
+      const conds = encodeColouredQuiescent(plan, lay, flat, envInj);
+      if (conds == null) return "false";
+      conds.push(`(>= ${aggregate(plan, lay, pid, lay.cur)} 1)`);
+      return joinColoured(conds);
     }
   }
 }
@@ -2978,7 +3057,10 @@ function colouredDisabledTerm(cls, plan, lay) {
     }
   }
 }
-function encodeColouredDeadlock(plan, lay, flat, sinkPlaces, envInj) {
+function joinColoured(conds) {
+  return conds.length === 0 ? "true" : `(and ${conds.join(" ")})`;
+}
+function encodeColouredQuiescent(plan, lay, flat, envInj) {
   const disabledConditions = [];
   for (let ti = 0; ti < plan.classes.length; ti++) {
     const cls = plan.classes[ti];
@@ -2991,13 +3073,10 @@ function encodeColouredDeadlock(plan, lay, flat, sinkPlaces, envInj) {
     }
     const term = colouredDisabledTerm(cls, plan, lay);
     if (term != null) reasons.push(term);
-    if (reasons.length === 0) return "false";
+    if (reasons.length === 0) return null;
     disabledConditions.push(reasons.length === 1 ? reasons[0] : `(or ${reasons.join(" ")})`);
   }
-  for (const pid of indexOrdered(flat, sinkPlaces)) {
-    disabledConditions.push(`(= ${aggregate(plan, lay, pid, lay.cur)} 0)`);
-  }
-  return disabledConditions.length === 0 ? "true" : `(and ${disabledConditions.join(" ")})`;
+  return disabledConditions;
 }
 
 // src/verification/analysis/name-fragment.ts
@@ -3484,8 +3563,16 @@ function decide(scg, property, sinkPlaces) {
         const m = scg.markingOf(i);
         return m.hasTokens(property.p1) && m.hasTokens(property.p2);
       });
+    // DeadlockFree (VER-002): a quiescent class that strands a token — some marked
+    // place is not a declared sink. The empty marking strands nothing (AC4).
     case "deadlock-free":
       return firstWhere((i) => scg.successorsOf(i).length === 0 && !allTokensInSinks(scg.markingOf(i), sinkPlaces));
+    // TerminatesAtSink (VER-002): a quiescent class that marks NO declared sink.
+    // Inverts with DeadlockFree on the empty marking, by design.
+    case "terminates-at-sink":
+      return firstWhere((i) => scg.successorsOf(i).length === 0 && !anySinkMarked(scg.markingOf(i), sinkPlaces));
+    // JoinedOrDeadLettered (NU-040 AC4): a quiescent class still holding a pending
+    // token. No sink clause.
     case "joined-or-dead-lettered":
       return firstWhere((i) => scg.successorsOf(i).length === 0 && scg.markingOf(i).hasTokens(property.pending));
   }
@@ -3498,6 +3585,14 @@ function allTokensInSinks(m, sinks) {
   }
   return true;
 }
+function anySinkMarked(m, sinks) {
+  const sinkNames = /* @__PURE__ */ new Set();
+  for (const s of sinks) sinkNames.add(s.name);
+  for (const p of m.placesWithTokens()) {
+    if (sinkNames.has(p.name)) return true;
+  }
+  return false;
+}
 function counterexamplePath(scg, target) {
   const n = scg.classCount();
   const parent = new Array(n).fill(-1);
@@ -4206,6 +4301,7 @@ function isReachabilitySafety(property) {
     case "unreachable":
       return true;
     case "deadlock-free":
+    case "terminates-at-sink":
     case "joined-or-dead-lettered":
       return false;
   }
@@ -4282,6 +4378,8 @@ function unresolvedPropertyPlace(flatNet, property) {
     switch (property.type) {
       case "deadlock-free":
         return [];
+      case "terminates-at-sink":
+        return [];
       case "mutual-exclusion":
         return [property.p1, property.p2];
       case "place-bound":
@@ -4350,6 +4448,7 @@ export {
   MarkingState,
   MarkingStateBuilder,
   deadlockFree,
+  terminatesAtSink,
   mutualExclusion,
   placeBound,
   unreachable,
@@ -4403,4 +4502,4 @@ export {
   isProven,
   isViolated
 };
-//# sourceMappingURL=chunk-FD3S4TZM.js.map
+//# sourceMappingURL=chunk-75KEJQGC.js.map