libpetri 0.5.3 → 0.6.0

package/dist/verification/index.js

@@ -2,6 +2,10 @@ import {
   allPlaces,
   enumerateBranches
 } from "../chunk-VQ4XMJTD.js";
+import {
+  earliest,
+  latest
+} from "../chunk-FN773SSE.js";
 
 // src/verification/marking-state.ts
 var MARKING_STATE_KEY = /* @__PURE__ */ Symbol("MarkingState.internal");
@@ -80,6 +84,31 @@ var MarkingStateBuilder = class {
     }
     return this;
   }
+  /** Removes tokens from a place. Throws if insufficient. */
+  removeTokens(place, count) {
+    const current = this.tokenCounts.get(place.name) ?? 0;
+    const newCount = current - count;
+    if (newCount < 0) {
+      throw new Error(
+        `Cannot remove ${count} tokens from ${place.name} (has ${current})`
+      );
+    }
+    if (newCount === 0) {
+      this.tokenCounts.delete(place.name);
+      this.placesByName.delete(place.name);
+    } else {
+      this.tokenCounts.set(place.name, newCount);
+    }
+    return this;
+  }
+  /** Copies all token counts from another marking state. */
+  copyFrom(other) {
+    for (const p of other.placesWithTokens()) {
+      this.tokenCounts.set(p.name, other.tokens(p));
+      this.placesByName.set(p.name, p);
+    }
+    return this;
+  }
   build() {
     return new MarkingState(MARKING_STATE_KEY, new Map(this.tokenCounts), new Map(this.placesByName));
   }
@@ -1190,19 +1219,892 @@ function formatInvariant(inv, flatNet) {
 function buildResult(verdict, report, invariants, discoveredInvariants, trace, transitions, elapsedMs, statistics) {
   return { verdict, report, invariants, discoveredInvariants, counterexampleTrace: trace, counterexampleTransitions: transitions, elapsedMs, statistics };
 }
+
+// src/verification/analysis/dbm.ts
+var EPSILON = 1e-9;
+var DBM = class _DBM {
+  bounds;
+  dim;
+  clockNames;
+  _empty;
+  constructor(bounds, dim, clockNames, empty) {
+    this.bounds = bounds;
+    this.dim = dim;
+    this.clockNames = clockNames;
+    this._empty = empty;
+  }
+  /** Creates an initial firing domain for enabled transitions. */
+  static create(clockNames, lowerBounds, upperBounds) {
+    const n = clockNames.length;
+    const dim = n + 1;
+    const bounds = makeMatrix(dim, Infinity);
+    for (let i = 0; i < n; i++) {
+      bounds[0 * dim + (i + 1)] = -lowerBounds[i];
+      bounds[(i + 1) * dim + 0] = upperBounds[i];
+    }
+    return new _DBM(bounds, dim, clockNames, false).canonicalize();
+  }
+  /** Creates an empty (unsatisfiable) zone. */
+  static empty(clockNames) {
+    const b = new Float64Array(1);
+    b[0] = 0;
+    return new _DBM(b, 1, clockNames, true);
+  }
+  isEmpty() {
+    return this._empty;
+  }
+  clockCount() {
+    return this.clockNames.length;
+  }
+  get(i, j) {
+    return this.bounds[i * this.dim + j];
+  }
+  /** Gets the lower bound (earliest firing time) for clock i. */
+  getLowerBound(clockIndex) {
+    if (this._empty || clockIndex < 0 || clockIndex >= this.clockNames.length) return 0;
+    const val = -this.get(0, clockIndex + 1);
+    return val === 0 ? 0 : val;
+  }
+  /** Gets the upper bound (latest firing time / deadline) for clock i. */
+  getUpperBound(clockIndex) {
+    if (this._empty || clockIndex < 0 || clockIndex >= this.clockNames.length) return Infinity;
+    return this.get(clockIndex + 1, 0);
+  }
+  /** Checks if transition can fire (lower bound <= 0 after time passage). */
+  canFire(clockIndex) {
+    return !this._empty && this.getLowerBound(clockIndex) <= EPSILON;
+  }
+  /**
+   * Computes the successor firing domain after firing transition t_f.
+   * Implements the 5-step Berthomieu-Diaz successor formula.
+   */
+  fireTransition(firedClock, newClockNames, newLowerBounds, newUpperBounds, persistentClocks) {
+    if (this._empty) return this;
+    const n = this.clockNames.length;
+    if (firedClock < 0 || firedClock >= n) {
+      throw new Error(`Invalid fired clock index: ${firedClock}`);
+    }
+    const constrained = new Float64Array(this.bounds);
+    const dim = this.dim;
+    const f = firedClock + 1;
+    for (let i = 0; i < n; i++) {
+      if (i !== firedClock) {
+        const idx = i + 1;
+        const pos = f * dim + idx;
+        constrained[pos] = Math.min(constrained[pos], 0);
+      }
+    }
+    if (!canonicalizeInPlace(constrained, dim)) {
+      return _DBM.empty([]);
+    }
+    const newN = persistentClocks.length + newClockNames.length;
+    const newDim = newN + 1;
+    const newBounds = makeMatrix(newDim, Infinity);
+    for (let pi = 0; pi < persistentClocks.length; pi++) {
+      const oldIdx = persistentClocks[pi] + 1;
+      const newIdx = pi + 1;
+      const upper = constrained[oldIdx * dim + f];
+      const lower = Math.max(0, -constrained[f * dim + oldIdx]);
+      newBounds[0 * newDim + newIdx] = -lower;
+      newBounds[newIdx * newDim + 0] = upper;
+      for (let pj = 0; pj < persistentClocks.length; pj++) {
+        const oldJ = persistentClocks[pj] + 1;
+        const newJ = pj + 1;
+        newBounds[newIdx * newDim + newJ] = constrained[oldIdx * dim + oldJ];
+      }
+    }
+    const offset = persistentClocks.length;
+    for (let k = 0; k < newClockNames.length; k++) {
+      const idx = offset + k + 1;
+      newBounds[0 * newDim + idx] = -newLowerBounds[k];
+      newBounds[idx * newDim + 0] = newUpperBounds[k];
+    }
+    const allNames = [];
+    for (const idx of persistentClocks) {
+      allNames.push(this.clockNames[idx]);
+    }
+    allNames.push(...newClockNames);
+    return new _DBM(newBounds, newDim, allNames, false).canonicalize();
+  }
+  /** Lets time pass: set all lower bounds to 0. */
+  letTimePass() {
+    if (this._empty) return this;
+    const newBounds = new Float64Array(this.bounds);
+    for (let i = 1; i < this.dim; i++) {
+      newBounds[0 * this.dim + i] = 0;
+    }
+    return new _DBM(newBounds, this.dim, this.clockNames, false).canonicalize();
+  }
+  canonicalize() {
+    if (this._empty) return this;
+    const canon = new Float64Array(this.bounds);
+    if (!canonicalizeInPlace(canon, this.dim)) {
+      return _DBM.empty(this.clockNames);
+    }
+    return new _DBM(canon, this.dim, this.clockNames, false);
+  }
+  equals(other) {
+    if (this === other) return true;
+    if (this._empty && other._empty) return true;
+    if (this._empty || other._empty) return false;
+    if (this.clockNames.length !== other.clockNames.length) return false;
+    for (let i = 0; i < this.clockNames.length; i++) {
+      if (this.clockNames[i] !== other.clockNames[i]) return false;
+    }
+    if (this.bounds.length !== other.bounds.length) return false;
+    for (let i = 0; i < this.bounds.length; i++) {
+      if (Math.abs(this.bounds[i] - other.bounds[i]) > EPSILON) return false;
+    }
+    return true;
+  }
+  toString() {
+    if (this._empty) return "DBM[empty]";
+    const parts = [];
+    for (let i = 0; i < this.clockNames.length; i++) {
+      const lo = formatBound(this.getLowerBound(i));
+      const hi = formatBound(this.getUpperBound(i));
+      parts.push(`${this.clockNames[i]}:[${lo},${hi}]`);
+    }
+    return `DBM{${parts.join(", ")}}`;
+  }
+};
+function makeMatrix(dim, fill) {
+  const m = new Float64Array(dim * dim).fill(fill);
+  for (let i = 0; i < dim; i++) {
+    m[i * dim + i] = 0;
+  }
+  return m;
+}
+function canonicalizeInPlace(dbm, dim) {
+  for (let k = 0; k < dim; k++) {
+    for (let i = 0; i < dim; i++) {
+      for (let j = 0; j < dim; j++) {
+        const ik = dbm[i * dim + k];
+        const kj = dbm[k * dim + j];
+        if (ik < Infinity && kj < Infinity) {
+          const via = ik + kj;
+          if (via < dbm[i * dim + j]) {
+            dbm[i * dim + j] = via;
+          }
+        }
+      }
+    }
+  }
+  for (let i = 0; i < dim; i++) {
+    if (dbm[i * dim + i] < -EPSILON) return false;
+  }
+  return true;
+}
+function formatBound(b) {
+  if (b >= Infinity / 2) return "\u221E";
+  if (b === Math.trunc(b)) return String(b);
+  return b.toFixed(3);
+}
+
+// src/verification/analysis/state-class.ts
+var StateClass = class {
+  marking;
+  firingDomain;
+  enabledTransitions;
+  constructor(marking, firingDomain, enabledTransitions) {
+    this.marking = marking;
+    this.firingDomain = firingDomain;
+    this.enabledTransitions = [...enabledTransitions];
+  }
+  isEmpty() {
+    return this.firingDomain.isEmpty();
+  }
+  canFire(transition) {
+    const idx = this.enabledTransitions.indexOf(transition);
+    if (idx < 0) return false;
+    return this.firingDomain.getUpperBound(idx) >= 0;
+  }
+  transitionIndex(transition) {
+    return this.enabledTransitions.indexOf(transition);
+  }
+  equals(other) {
+    if (this === other) return true;
+    return this.marking.toString() === other.marking.toString() && this.firingDomain.equals(other.firingDomain);
+  }
+  toString() {
+    return `StateClass{${this.marking}, ${this.firingDomain}}`;
+  }
+};
+
+// src/verification/analysis/scc-analyzer.ts
+function computeSCCs(nodes, successors) {
+  const nodeArray = [...nodes];
+  const indexMap = /* @__PURE__ */ new Map();
+  const lowlink = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const sccs = [];
+  let index = 0;
+  function strongConnect(v) {
+    indexMap.set(v, index);
+    lowlink.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+    for (const w of successors(v)) {
+      if (!indexMap.has(w)) {
+        strongConnect(w);
+        lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
+      } else if (onStack.has(w)) {
+        lowlink.set(v, Math.min(lowlink.get(v), indexMap.get(w)));
+      }
+    }
+    if (lowlink.get(v) === indexMap.get(v)) {
+      const scc = /* @__PURE__ */ new Set();
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.add(w);
+      } while (w !== v);
+      sccs.push(scc);
+    }
+  }
+  for (const node of nodeArray) {
+    if (!indexMap.has(node)) {
+      strongConnect(node);
+    }
+  }
+  return sccs;
+}
+function findTerminalSCCs(nodes, successors) {
+  const allSCCs = computeSCCs(nodes, successors);
+  const terminal = [];
+  for (const scc of allSCCs) {
+    let isTerminal = true;
+    for (const node of scc) {
+      for (const succ of successors(node)) {
+        if (!scc.has(succ)) {
+          isTerminal = false;
+          break;
+        }
+      }
+      if (!isTerminal) break;
+    }
+    if (isTerminal) {
+      terminal.push(scc);
+    }
+  }
+  return terminal;
+}
+
+// src/verification/analysis/environment-analysis-mode.ts
+function alwaysAvailable() {
+  return { type: "always-available" };
+}
+function bounded2(maxTokens) {
+  if (maxTokens < 0) throw new Error("maxTokens must be non-negative");
+  return { type: "bounded", maxTokens };
+}
+function ignore() {
+  return { type: "ignore" };
+}
+
+// src/verification/analysis/state-class-graph.ts
+var StateClassGraph = class _StateClassGraph {
+  net;
+  initialClass;
+  _stateClasses;
+  _transitions;
+  _successors;
+  _predecessors;
+  _complete;
+  constructor(net, initialClass, stateClasses, transitions, complete) {
+    this.net = net;
+    this.initialClass = initialClass;
+    this._stateClasses = stateClasses;
+    this._transitions = transitions;
+    this._complete = complete;
+    this._successors = /* @__PURE__ */ new Map();
+    this._predecessors = /* @__PURE__ */ new Map();
+    for (const sc of stateClasses) {
+      this._successors.set(sc, /* @__PURE__ */ new Set());
+      this._predecessors.set(sc, /* @__PURE__ */ new Set());
+    }
+    for (const [from, tMap] of transitions) {
+      for (const edges of tMap.values()) {
+        for (const edge of edges) {
+          this._successors.get(from).add(edge.target);
+          this._predecessors.get(edge.target).add(from);
+        }
+      }
+    }
+  }
+  /** Builds the state class graph for a Time Petri Net. */
+  static build(net, initialMarking, maxClasses, environmentPlaces, environmentMode) {
+    const envMode = environmentMode ?? ignore();
+    const envPlaces = /* @__PURE__ */ new Set();
+    if (environmentPlaces) {
+      for (const ep of environmentPlaces) {
+        envPlaces.add(ep.place);
+      }
+    }
+    const enabledTransitions = findEnabledTransitions(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();
+    const initialClass = new StateClass(initialMarking, initialDBM, enabledTransitions);
+    const stateClasses = [initialClass];
+    const stateClassSet = /* @__PURE__ */ new Set([classKey(initialClass)]);
+    const classMap = /* @__PURE__ */ new Map([[classKey(initialClass), initialClass]]);
+    const transitionMap = /* @__PURE__ */ new Map();
+    transitionMap.set(initialClass, /* @__PURE__ */ new Map());
+    const queue = [initialClass];
+    let complete = true;
+    while (queue.length > 0) {
+      if (stateClasses.length >= maxClasses) {
+        complete = false;
+        break;
+      }
+      const current = queue.shift();
+      for (const transition of current.enabledTransitions) {
+        const virtualTransitions = expandTransition(transition);
+        for (const vt of virtualTransitions) {
+          const successor = computeSuccessor(net, current, vt, envPlaces, envMode);
+          if (successor === null || successor.isEmpty()) continue;
+          const tEdges = transitionMap.get(current);
+          if (!tEdges.has(transition)) tEdges.set(transition, []);
+          tEdges.get(transition).push({ branchIndex: vt.branchIndex, target: successor });
+          const key = classKey(successor);
+          if (!stateClassSet.has(key)) {
+            stateClassSet.add(key);
+            classMap.set(key, successor);
+            stateClasses.push(successor);
+            transitionMap.set(successor, /* @__PURE__ */ new Map());
+            queue.push(successor);
+          } else {
+            const canonical = classMap.get(key);
+            if (canonical !== successor) {
+              const edges = tEdges.get(transition);
+              edges[edges.length - 1] = { branchIndex: vt.branchIndex, target: canonical };
+            }
+          }
+        }
+      }
+    }
+    return new _StateClassGraph(net, initialClass, stateClasses, transitionMap, complete);
+  }
+  stateClasses() {
+    return this._stateClasses;
+  }
+  size() {
+    return this._stateClasses.length;
+  }
+  isComplete() {
+    return this._complete;
+  }
+  successors(sc) {
+    return this._successors.get(sc) ?? /* @__PURE__ */ new Set();
+  }
+  predecessors(sc) {
+    return this._predecessors.get(sc) ?? /* @__PURE__ */ new Set();
+  }
+  /** Returns all outgoing transitions with their branch edges. */
+  outgoingBranchEdges(sc) {
+    return this._transitions.get(sc) ?? /* @__PURE__ */ new Map();
+  }
+  /** Returns the branch edges for a specific transition from a state class. */
+  branchEdges(sc, transition) {
+    const map = this._transitions.get(sc);
+    if (!map) return [];
+    return map.get(transition) ?? [];
+  }
+  /** Returns all transitions that are enabled from a state class. */
+  enabledTransitions(sc) {
+    const map = this._transitions.get(sc);
+    if (!map) return /* @__PURE__ */ new Set();
+    return new Set(map.keys());
+  }
+  /** Finds all state classes with a given marking. */
+  classesWithMarking(marking) {
+    const key = marking.toString();
+    return this._stateClasses.filter((sc) => sc.marking.toString() === key);
+  }
+  /** Checks if a marking is reachable. */
+  isReachable(marking) {
+    const key = marking.toString();
+    return this._stateClasses.some((sc) => sc.marking.toString() === key);
+  }
+  /** Gets all reachable markings. */
+  reachableMarkings() {
+    const markings = /* @__PURE__ */ new Set();
+    for (const sc of this._stateClasses) {
+      markings.add(sc.marking.toString());
+    }
+    return markings;
+  }
+  /** Counts edges in the graph (each branch edge counts separately). */
+  edgeCount() {
+    let count = 0;
+    for (const map of this._transitions.values()) {
+      for (const edges of map.values()) {
+        count += edges.length;
+      }
+    }
+    return count;
+  }
+  toString() {
+    return `StateClassGraph[classes=${this.size()}, edges=${this.edgeCount()}, complete=${this._complete}]`;
+  }
+};
+function classKey(sc) {
+  return `${sc.marking.toString()}|${sc.firingDomain.toString()}`;
+}
+function expandTransition(t) {
+  let branches;
+  if (t.outputSpec !== null) {
+    branches = enumerateBranches(t.outputSpec);
+  } else {
+    branches = [/* @__PURE__ */ new Set()];
+  }
+  return branches.map((outputPlaces, i) => ({
+    transition: t,
+    branchIndex: i,
+    outputPlaces
+  }));
+}
+function computeSuccessor(net, current, fired, environmentPlaces, environmentMode) {
+  const transition = fired.transition;
+  const newMarking = fireTransition(current.marking, transition, fired.outputPlaces, environmentPlaces, environmentMode);
+  const newEnabledAll = findEnabledTransitions(net, newMarking, environmentPlaces, environmentMode);
+  const persistent = [];
+  const persistentIndices = [];
+  for (let i = 0; i < current.enabledTransitions.length; i++) {
+    const t = current.enabledTransitions[i];
+    if (t !== transition && newEnabledAll.includes(t)) {
+      persistent.push(t);
+      persistentIndices.push(i);
+    }
+  }
+  const newlyEnabled = [];
+  for (const t of newEnabledAll) {
+    if (!persistent.includes(t)) {
+      newlyEnabled.push(t);
+    }
+  }
+  const firedIdx = current.transitionIndex(transition);
+  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(
+    firedIdx,
+    newClockNames,
+    newLowerBounds,
+    newUpperBounds,
+    persistentIndices
+  );
+  newDBM = newDBM.letTimePass();
+  const allEnabled = [...persistent, ...newlyEnabled];
+  return new StateClass(newMarking, newDBM, allEnabled);
+}
+function findEnabledTransitions(net, marking, environmentPlaces, environmentMode) {
+  const enabled = [];
+  for (const transition of net.transitions) {
+    if (isEnabled(transition, marking, environmentPlaces, environmentMode)) {
+      enabled.push(transition);
+    }
+  }
+  return enabled;
+}
+function isEnabled(transition, marking, environmentPlaces, environmentMode) {
+  for (const spec of transition.inputSpecs) {
+    const required = inputRequiredCount(spec);
+    if (!checkPlaceEnabled(spec.place, required, marking, environmentPlaces, environmentMode)) {
+      return false;
+    }
+  }
+  for (const arc of transition.reads) {
+    if (!checkPlaceEnabled(arc.place, 1, marking, environmentPlaces, environmentMode)) {
+      return false;
+    }
+  }
+  for (const arc of transition.inhibitors) {
+    if (marking.hasTokens(arc.place)) {
+      return false;
+    }
+  }
+  return true;
+}
+function inputRequiredCount(spec) {
+  switch (spec.type) {
+    case "one":
+      return 1;
+    case "exactly":
+      return spec.count;
+    case "all":
+      return 1;
+    case "at-least":
+      return spec.minimum;
+  }
+}
+function inputConsumeCount(spec) {
+  switch (spec.type) {
+    case "one":
+      return 1;
+    case "exactly":
+      return spec.count;
+    case "all":
+      return 1;
+    // Analysis: consume minimum (1 token)
+    case "at-least":
+      return spec.minimum;
+  }
+}
+function checkPlaceEnabled(place, required, marking, environmentPlaces, environmentMode) {
+  if (!environmentPlaces.has(place)) {
+    return marking.tokens(place) >= required;
+  }
+  switch (environmentMode.type) {
+    case "always-available":
+      return true;
+    case "bounded":
+      return required <= environmentMode.maxTokens;
+    case "ignore":
+      return marking.tokens(place) >= required;
+  }
+}
+function fireTransition(marking, transition, outputPlaces, environmentPlaces, environmentMode) {
+  const builder = MarkingState.builder().copyFrom(marking);
+  for (const spec of transition.inputSpecs) {
+    const toConsume = inputConsumeCount(spec);
+    consumeFromPlace(builder, spec.place, toConsume, environmentPlaces, environmentMode);
+  }
+  for (const arc of transition.resets) {
+    const current = marking.tokens(arc.place);
+    if (current > 0) {
+      builder.removeTokens(arc.place, current);
+    }
+  }
+  for (const place of outputPlaces) {
+    builder.addTokens(place, 1);
+  }
+  return builder.build();
+}
+function consumeFromPlace(builder, place, count, environmentPlaces, environmentMode) {
+  if (!environmentPlaces.has(place)) {
+    builder.removeTokens(place, count);
+    return;
+  }
+  if (environmentMode.type === "ignore") {
+    builder.removeTokens(place, count);
+  }
+}
+
+// src/verification/analysis/time-petri-net-analyzer.ts
+var TimePetriNetAnalyzer = class _TimePetriNetAnalyzer {
+  net;
+  initialMarking;
+  goalPlaces;
+  maxClasses;
+  environmentPlaces;
+  environmentMode;
+  /** @internal Called by builder — use `TimePetriNetAnalyzer.forNet()` instead. */
+  static create(net, initialMarking, goalPlaces, maxClasses, environmentPlaces, environmentMode) {
+    return new _TimePetriNetAnalyzer(net, initialMarking, goalPlaces, maxClasses, environmentPlaces, environmentMode);
+  }
+  constructor(net, initialMarking, goalPlaces, maxClasses, environmentPlaces, environmentMode) {
+    this.net = net;
+    this.initialMarking = initialMarking;
+    this.goalPlaces = goalPlaces;
+    this.maxClasses = maxClasses;
+    this.environmentPlaces = environmentPlaces;
+    this.environmentMode = environmentMode;
+  }
+  static forNet(net) {
+    return new TimePetriNetAnalyzerBuilder(net);
+  }
+  /** Performs formal liveness analysis. */
+  analyze() {
+    const report = [];
+    report.push("=== TIME PETRI NET FORMAL ANALYSIS ===\n");
+    report.push(`Method: State Class Graph (Berthomieu-Diaz 1991)`);
+    report.push(`Net: ${this.net.name}`);
+    report.push(`Places: ${this.net.places.size}`);
+    report.push(`Transitions: ${this.net.transitions.size}`);
+    report.push(`Goal places: [${[...this.goalPlaces].map((p) => p.name).join(", ")}]
+`);
+    report.push("Phase 1: Building State Class Graph...");
+    if (this.environmentPlaces.size > 0) {
+      report.push(`  Environment places: ${this.environmentPlaces.size}`);
+      report.push(`  Environment mode: ${this.environmentMode.type}`);
+    }
+    const scg = StateClassGraph.build(this.net, this.initialMarking, this.maxClasses, this.environmentPlaces, this.environmentMode);
+    report.push(`  State classes: ${scg.size()}`);
+    report.push(`  Edges: ${scg.edgeCount()}`);
+    report.push(`  Complete: ${scg.isComplete() ? "YES" : "NO (truncated)"}`);
+    if (!scg.isComplete()) {
+      report.push(`  WARNING: State class graph truncated at ${this.maxClasses} classes. Analysis may be incomplete.`);
+    }
+    report.push("");
+    report.push("Phase 2: Identifying goal state classes...");
+    const goalClasses = /* @__PURE__ */ new Set();
+    for (const sc of scg.stateClasses()) {
+      if (sc.marking.hasTokensInAny(this.goalPlaces)) {
+        goalClasses.add(sc);
+      }
+    }
+    report.push(`  Goal state classes: ${goalClasses.size}
+`);
+    report.push("Phase 3: Computing Strongly Connected Components...");
+    const successorFn = (sc) => scg.successors(sc);
+    const allSCCs = computeSCCs(scg.stateClasses(), successorFn);
+    const terminalSCCs = findTerminalSCCs(scg.stateClasses(), successorFn);
+    report.push(`  Total SCCs: ${allSCCs.length}`);
+    report.push(`  Terminal SCCs: ${terminalSCCs.length}
+`);
+    report.push("Phase 4: Verifying Goal Liveness...");
+    report.push("  Property: From every reachable state, a goal state is reachable");
+    const terminalSCCsWithGoal = [];
+    const terminalSCCsWithoutGoal = [];
+    for (const scc of terminalSCCs) {
+      let hasGoal = false;
+      for (const sc of scc) {
+        if (goalClasses.has(sc)) {
+          hasGoal = true;
+          break;
+        }
+      }
+      (hasGoal ? terminalSCCsWithGoal : terminalSCCsWithoutGoal).push(scc);
+    }
+    report.push(`  Terminal SCCs with goal: ${terminalSCCsWithGoal.length}`);
+    report.push(`  Terminal SCCs without goal: ${terminalSCCsWithoutGoal.length}`);
+    const canReachGoal = computeBackwardReachability(scg, goalClasses);
+    const statesNotReachingGoal = scg.size() - canReachGoal.size;
+    report.push(`  States that can reach goal: ${canReachGoal.size}/${scg.size()}
+`);
+    const isGoalLive = terminalSCCsWithoutGoal.length === 0 && statesNotReachingGoal === 0;
+    report.push("Phase 5: Verifying Classical Liveness (L4)...");
+    report.push("  Property: Every transition can fire from every reachable marking");
+    const allTransitions = new Set(this.net.transitions);
+    const terminalSCCsMissingTransitions = [];
+    for (const scc of terminalSCCs) {
+      const transitionsInSCC = /* @__PURE__ */ new Set();
+      for (const sc of scc) {
+        for (const t of scg.enabledTransitions(sc)) {
+          const edges = scg.branchEdges(sc, t);
+          for (const edge of edges) {
+            if (scc.has(edge.target)) {
+              transitionsInSCC.add(t);
+            }
+          }
+        }
+      }
+      let missingAny = false;
+      for (const t of allTransitions) {
+        if (!transitionsInSCC.has(t)) {
+          missingAny = true;
+          break;
+        }
+      }
+      if (missingAny) {
+        terminalSCCsMissingTransitions.push(scc);
+        const missing = [...allTransitions].filter((t) => !transitionsInSCC.has(t));
+        report.push(`  Terminal SCC missing transitions: [${missing.map((t) => t.name).join(", ")}]`);
+      }
+    }
+    const isL4Live = terminalSCCsMissingTransitions.length === 0 && scg.isComplete();
+    report.push("\n=== ANALYSIS RESULT ===\n");
+    if (isGoalLive && scg.isComplete()) {
+      report.push("GOAL LIVENESS VERIFIED");
+      report.push("  From every reachable state class, a goal marking is reachable.");
+    } else if (isGoalLive && !scg.isComplete()) {
+      report.push("GOAL LIVENESS LIKELY (incomplete proof)");
+    } else {
+      report.push("GOAL LIVENESS VIOLATION");
+      if (terminalSCCsWithoutGoal.length > 0) {
+        report.push(`  ${terminalSCCsWithoutGoal.length} terminal SCC(s) have no goal state.`);
+      }
+      if (statesNotReachingGoal > 0) {
+        report.push(`  ${statesNotReachingGoal} state class(es) cannot reach goal.`);
+      }
+    }
+    report.push("");
+    if (isL4Live) {
+      report.push("CLASSICAL LIVENESS (L4) VERIFIED");
+    } else {
+      report.push("CLASSICAL LIVENESS (L4) NOT VERIFIED");
+      if (terminalSCCsMissingTransitions.length > 0) {
+        report.push("  Some terminal SCCs don't contain all transitions.");
+      }
+      if (!scg.isComplete()) {
+        report.push("  (State class graph incomplete - cannot prove L4)");
+      }
+    }
+    return {
+      stateClassGraph: scg,
+      allSCCs,
+      terminalSCCs,
+      goalClasses,
+      canReachGoal,
+      isGoalLive,
+      isL4Live,
+      isComplete: scg.isComplete(),
+      report: report.join("\n")
+    };
+  }
+  /** Analyzes XOR branch coverage for a built state class graph. */
+  static analyzeXorBranches(scg) {
+    const result = /* @__PURE__ */ new Map();
+    for (const transition of scg.net.transitions) {
+      if (transition.outputSpec === null) continue;
+      const allBranches = enumerateBranches(transition.outputSpec);
+      if (allBranches.length <= 1) continue;
+      const takenBranches = /* @__PURE__ */ new Set();
+      for (const sc of scg.stateClasses()) {
+        const edges = scg.branchEdges(sc, transition);
+        for (const edge of edges) {
+          takenBranches.add(edge.branchIndex);
+        }
+      }
+      const untakenBranches = /* @__PURE__ */ new Set();
+      for (let i = 0; i < allBranches.length; i++) {
+        if (!takenBranches.has(i)) untakenBranches.add(i);
+      }
+      result.set(transition, {
+        totalBranches: allBranches.length,
+        takenBranches,
+        untakenBranches,
+        branchOutputs: allBranches
+      });
+    }
+    return createXorBranchAnalysis(result);
+  }
+};
+function createXorBranchAnalysis(transitionBranches) {
+  return {
+    transitionBranches,
+    unreachableBranches() {
+      const result = /* @__PURE__ */ new Map();
+      for (const [t, info] of transitionBranches) {
+        if (info.untakenBranches.size > 0) {
+          result.set(t, info.untakenBranches);
+        }
+      }
+      return result;
+    },
+    isXorComplete() {
+      for (const info of transitionBranches.values()) {
+        if (info.untakenBranches.size > 0) return false;
+      }
+      return true;
+    },
+    report() {
+      if (transitionBranches.size === 0) return "No XOR transitions in net.";
+      const lines = [];
+      lines.push("XOR Branch Coverage Analysis");
+      lines.push("============================\n");
+      for (const [t, info] of transitionBranches) {
+        lines.push(`Transition: ${t.name}`);
+        lines.push(`  Branches: ${info.totalBranches}`);
+        lines.push(`  Taken: [${[...info.takenBranches].join(", ")}]`);
+        if (info.untakenBranches.size > 0) {
+          lines.push(`  UNREACHABLE: [${[...info.untakenBranches].join(", ")}]`);
+          for (const idx of info.untakenBranches) {
+            const places = [...info.branchOutputs[idx]].map((p) => p.name).join(", ");
+            lines.push(`    Branch ${idx} outputs: [${places}]`);
+          }
+        } else {
+          lines.push("  All branches reachable");
+        }
+        lines.push("");
+      }
+      if (this.isXorComplete()) {
+        lines.push("RESULT: All XOR branches are reachable.");
+      } else {
+        lines.push("RESULT: Some XOR branches are unreachable!");
+      }
+      return lines.join("\n");
+    }
+  };
+}
+function computeBackwardReachability(scg, goals) {
+  const reachable = new Set(goals);
+  const queue = [...goals];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const pred of scg.predecessors(current)) {
+      if (!reachable.has(pred)) {
+        reachable.add(pred);
+        queue.push(pred);
+      }
+    }
+  }
+  return reachable;
+}
+var TimePetriNetAnalyzerBuilder = class {
+  net;
+  _initialMarking = MarkingState.empty();
+  _goalPlaces = /* @__PURE__ */ new Set();
+  _maxClasses = 1e5;
+  _environmentPlaces = /* @__PURE__ */ new Set();
+  _environmentMode = ignore();
+  constructor(net) {
+    this.net = net;
+  }
+  initialMarking(marking) {
+    this._initialMarking = marking;
+    return this;
+  }
+  goalPlaces(...places) {
+    for (const p of places) this._goalPlaces.add(p);
+    return this;
+  }
+  maxClasses(max) {
+    this._maxClasses = max;
+    return this;
+  }
+  environmentPlaces(...places) {
+    for (const ep of places) this._environmentPlaces.add(ep);
+    return this;
+  }
+  environmentMode(mode) {
+    this._environmentMode = mode;
+    return this;
+  }
+  build() {
+    if (this._goalPlaces.size === 0) {
+      throw new Error("At least one goal place must be specified");
+    }
+    return TimePetriNetAnalyzer.create(
+      this.net,
+      this._initialMarking,
+      this._goalPlaces,
+      this._maxClasses,
+      this._environmentPlaces,
+      this._environmentMode
+    );
+  }
+};
 export {
+  DBM,
   IncidenceMatrix,
   MarkingState,
   MarkingStateBuilder,
   SmtVerifier,
+  StateClass,
+  StateClassGraph,
+  TimePetriNetAnalyzer,
+  TimePetriNetAnalyzerBuilder,
+  alwaysAvailable as analysisAlwaysAvailable,
+  bounded2 as analysisBounded,
+  ignore as analysisIgnore,
   bounded,
   computePInvariants,
+  computeSCCs,
   createSpacerRunner,
   deadlockFree,
   decode,
   encode,
   findMaximalTrapIn,
   findMinimalSiphons,
+  findTerminalSCCs,
   flatNetIndexOf,
   flatNetPlaceCount,
   flatNetTransitionCount,