libpetri 2.7.1 → 2.9.0

package/dist/chunk-M3KT7BFO.js

@@ -0,0 +1,2773 @@
+import {
+  earliest,
+  latest
+} from "./chunk-ATT7U5H5.js";
+
+// src/core/out.ts
+function and(...children) {
+  if (children.length === 0) {
+    throw new Error("AND requires at least 1 child");
+  }
+  return { type: "and", children };
+}
+function andPlaces(...places) {
+  return and(...places.map(outPlace));
+}
+function xor(...children) {
+  if (children.length < 2) {
+    throw new Error("XOR requires at least 2 children");
+  }
+  return { type: "xor", children };
+}
+function xorPlaces(...places) {
+  return xor(...places.map(outPlace));
+}
+function outPlace(p) {
+  return { type: "place", place: p };
+}
+function timeout(afterMs, child) {
+  if (afterMs <= 0) {
+    throw new Error(`Timeout must be positive: ${afterMs}`);
+  }
+  return { type: "timeout", afterMs, child };
+}
+function timeoutPlace(afterMs, p) {
+  return timeout(afterMs, outPlace(p));
+}
+function forwardInput(from, to) {
+  return { type: "forward-input", from, to };
+}
+function allPlaces(out) {
+  const result = /* @__PURE__ */ new Set();
+  collectPlaces(out, result);
+  return result;
+}
+function collectPlaces(out, result) {
+  switch (out.type) {
+    case "place":
+      result.add(out.place);
+      break;
+    case "forward-input":
+      result.add(out.to);
+      break;
+    case "and":
+    case "xor":
+      for (const child of out.children) {
+        collectPlaces(child, result);
+      }
+      break;
+    case "timeout":
+      collectPlaces(out.child, result);
+      break;
+  }
+}
+function enumerateBranches(out) {
+  switch (out.type) {
+    case "place":
+      return [/* @__PURE__ */ new Set([out.place])];
+    case "forward-input":
+      return [/* @__PURE__ */ new Set([out.to])];
+    case "and": {
+      let result = [/* @__PURE__ */ new Set()];
+      for (const child of out.children) {
+        result = crossProduct(result, enumerateBranches(child));
+      }
+      return result;
+    }
+    case "xor": {
+      const result = [];
+      for (const child of out.children) {
+        result.push(...enumerateBranches(child));
+      }
+      return result;
+    }
+    case "timeout":
+      return enumerateBranches(out.child);
+  }
+}
+function crossProduct(a, b) {
+  const result = [];
+  for (const setA of a) {
+    for (const setB of b) {
+      const merged = new Set(setA);
+      for (const p of setB) merged.add(p);
+      result.push(merged);
+    }
+  }
+  return result;
+}
+
+// src/verification/marking-state.ts
+var MARKING_STATE_KEY = /* @__PURE__ */ Symbol("MarkingState.internal");
+var MarkingState = class _MarkingState {
+  tokenCounts;
+  placesByName;
+  /** @internal Use {@link MarkingState.builder} or {@link MarkingState.empty} to create instances. */
+  constructor(key, tokenCounts, placesByName) {
+    if (key !== MARKING_STATE_KEY) throw new Error("Use MarkingState.builder() to create instances");
+    this.tokenCounts = tokenCounts;
+    this.placesByName = placesByName;
+  }
+  /** Returns the token count for a place (0 if absent). */
+  tokens(place) {
+    return this.tokenCounts.get(place.name) ?? 0;
+  }
+  /** Checks if a place has at least one token. */
+  hasTokens(place) {
+    return this.tokens(place) > 0;
+  }
+  /** Checks if any of the given places has tokens. */
+  hasTokensInAny(places) {
+    for (const p of places) {
+      if (this.hasTokens(p)) return true;
+    }
+    return false;
+  }
+  /** Returns all places with tokens > 0. */
+  placesWithTokens() {
+    return [...this.placesByName.values()];
+  }
+  /** Returns the total number of tokens. */
+  totalTokens() {
+    let sum = 0;
+    for (const count of this.tokenCounts.values()) sum += count;
+    return sum;
+  }
+  /** Checks if no tokens exist anywhere. */
+  isEmpty() {
+    return this.tokenCounts.size === 0;
+  }
+  toString() {
+    if (this.tokenCounts.size === 0) return "{}";
+    const entries = [...this.tokenCounts.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, count]) => `${name}:${count}`);
+    return `{${entries.join(", ")}}`;
+  }
+  static empty() {
+    return new _MarkingState(MARKING_STATE_KEY, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
+  }
+  static builder() {
+    return new MarkingStateBuilder();
+  }
+};
+var MarkingStateBuilder = class {
+  tokenCounts = /* @__PURE__ */ new Map();
+  placesByName = /* @__PURE__ */ new Map();
+  /** Sets the token count for a place. */
+  tokens(place, count) {
+    if (count < 0) throw new Error(`Token count cannot be negative: ${count}`);
+    if (count > 0) {
+      this.tokenCounts.set(place.name, count);
+      this.placesByName.set(place.name, place);
+    } else {
+      this.tokenCounts.delete(place.name);
+      this.placesByName.delete(place.name);
+    }
+    return this;
+  }
+  /** Adds tokens to a place. */
+  addTokens(place, count) {
+    if (count < 0) throw new Error(`Token count cannot be negative: ${count}`);
+    if (count > 0) {
+      const current = this.tokenCounts.get(place.name) ?? 0;
+      this.tokenCounts.set(place.name, current + count);
+      this.placesByName.set(place.name, place);
+    }
+    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));
+  }
+};
+
+// src/verification/smt-property.ts
+function deadlockFree() {
+  return { type: "deadlock-free" };
+}
+function mutualExclusion(p1, p2) {
+  return { type: "mutual-exclusion", p1, p2 };
+}
+function placeBound(place, bound) {
+  return { type: "place-bound", place, bound };
+}
+function unreachable(places) {
+  return { type: "unreachable", places: new Set(places) };
+}
+function branchPlaceBound(place, bound) {
+  return { type: "branch-place-bound", place, bound };
+}
+function joinedOrDeadLettered(pending) {
+  return { type: "joined-or-dead-lettered", pending };
+}
+function propertyDescription(prop) {
+  switch (prop.type) {
+    case "deadlock-free":
+      return "Deadlock-freedom";
+    case "mutual-exclusion":
+      return `Mutual exclusion of ${prop.p1.name} and ${prop.p2.name}`;
+    case "place-bound":
+      return `Place ${prop.place.name} bounded by ${prop.bound}`;
+    case "unreachable":
+      return `Unreachability of marking with tokens in {${[...prop.places].map((p) => p.name).join(", ")}}`;
+    case "branch-place-bound":
+      return `Branch place bound (\u03BD-budget): ${prop.place.name} <= ${prop.bound}`;
+    case "joined-or-dead-lettered":
+      return `Joined-or-dead-lettered: ${prop.pending.name} = 0 at quiescence`;
+  }
+}
+
+// src/verification/encoding/flat-transition.ts
+function flatTransition(name, source, branchIndex, preVector, postVector, inhibitorPlaces, readPlaces, resetPlaces, consumeAll) {
+  return {
+    name,
+    source,
+    branchIndex,
+    preVector,
+    postVector,
+    inhibitorPlaces,
+    readPlaces,
+    resetPlaces,
+    consumeAll
+  };
+}
+
+// src/verification/analysis/environment-analysis-mode.ts
+function alwaysAvailable() {
+  return { type: "always-available" };
+}
+function bounded(maxTokens) {
+  if (maxTokens < 0) throw new Error("maxTokens must be non-negative");
+  return { type: "bounded", maxTokens };
+}
+function ignore() {
+  return { type: "ignore" };
+}
+
+// src/verification/encoding/net-flattener.ts
+function flatten(net, environmentPlaces = /* @__PURE__ */ new Set(), environmentMode = alwaysAvailable()) {
+  const allPlacesSet = /* @__PURE__ */ new Map();
+  for (const p of net.places) {
+    allPlacesSet.set(p.name, p);
+  }
+  for (const t of net.transitions) {
+    for (const inSpec of t.inputSpecs) {
+      allPlacesSet.set(inSpec.place.name, inSpec.place);
+    }
+    if (t.outputSpec !== null) {
+      for (const p of allPlaces(t.outputSpec)) {
+        allPlacesSet.set(p.name, p);
+      }
+    }
+    for (const arc of t.inhibitors) allPlacesSet.set(arc.place.name, arc.place);
+    for (const arc of t.reads) allPlacesSet.set(arc.place.name, arc.place);
+    for (const arc of t.resets) allPlacesSet.set(arc.place.name, arc.place);
+  }
+  const places = [...allPlacesSet.values()].sort((a, b) => a.name.localeCompare(b.name));
+  const placeIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < places.length; i++) {
+    placeIndex.set(places[i].name, i);
+  }
+  const environmentBounds = /* @__PURE__ */ new Map();
+  const environmentInjection = /* @__PURE__ */ new Map();
+  switch (environmentMode.type) {
+    case "always-available":
+      for (const ep of environmentPlaces) {
+        environmentInjection.set(ep.place.name, null);
+      }
+      break;
+    case "bounded":
+      for (const ep of environmentPlaces) {
+        environmentBounds.set(ep.place.name, environmentMode.maxTokens);
+        environmentInjection.set(ep.place.name, environmentMode.maxTokens);
+      }
+      break;
+    case "ignore":
+      break;
+  }
+  const n = places.length;
+  const flatTransitions = [];
+  for (const transition of net.transitions) {
+    const branches = enumerateOutputBranches(transition);
+    for (let branchIdx = 0; branchIdx < branches.length; branchIdx++) {
+      const branchPlaces = branches[branchIdx];
+      const name = branches.length > 1 ? `${transition.name}_b${branchIdx}` : transition.name;
+      const preVector = new Array(n).fill(0);
+      const consumeAll = new Array(n).fill(false);
+      for (const inSpec of transition.inputSpecs) {
+        const idx = placeIndex.get(inSpec.place.name);
+        if (idx === void 0) continue;
+        switch (inSpec.type) {
+          case "one":
+            preVector[idx] = 1;
+            break;
+          case "exactly":
+            preVector[idx] = inSpec.count;
+            break;
+          case "all":
+            preVector[idx] = 1;
+            consumeAll[idx] = true;
+            break;
+          case "at-least":
+            preVector[idx] = inSpec.minimum;
+            consumeAll[idx] = true;
+            break;
+        }
+      }
+      const postVector = new Array(n).fill(0);
+      for (const p of branchPlaces) {
+        const idx = placeIndex.get(p.name);
+        if (idx !== void 0) {
+          postVector[idx] = 1;
+        }
+      }
+      const inhibitorPlaces = transition.inhibitors.map((arc) => placeIndex.get(arc.place.name)).filter((idx) => idx !== void 0);
+      const readPlaces = transition.reads.map((arc) => placeIndex.get(arc.place.name)).filter((idx) => idx !== void 0);
+      const resetPlaces = transition.resets.map((arc) => placeIndex.get(arc.place.name)).filter((idx) => idx !== void 0);
+      flatTransitions.push(flatTransition(
+        name,
+        transition,
+        branches.length > 1 ? branchIdx : -1,
+        preVector,
+        postVector,
+        inhibitorPlaces,
+        readPlaces,
+        resetPlaces,
+        consumeAll
+      ));
+    }
+  }
+  return {
+    places,
+    placeIndex,
+    transitions: flatTransitions,
+    environmentBounds,
+    environmentInjection
+  };
+}
+function enumerateOutputBranches(t) {
+  if (t.outputSpec !== null) {
+    return enumerateBranches(t.outputSpec);
+  }
+  return [/* @__PURE__ */ new Set()];
+}
+
+// src/verification/encoding/incidence-matrix.ts
+var IncidenceMatrix = class _IncidenceMatrix {
+  _pre;
+  _post;
+  _incidence;
+  _numTransitions;
+  _numPlaces;
+  constructor(pre, post, incidence, numTransitions, numPlaces) {
+    this._pre = pre;
+    this._post = post;
+    this._incidence = incidence;
+    this._numTransitions = numTransitions;
+    this._numPlaces = numPlaces;
+  }
+  /**
+   * Computes the incidence matrix from a FlatNet.
+   *
+   * Environment-injected places (VER-006) each contribute one extra **injector
+   * column** (a virtual transition that produces one token into that place and
+   * consumes nothing). This makes P-invariant computation env-aware: a valid
+   * invariant `y` must satisfy `y^T·C = 0` for the injector column too, forcing
+   * `y[envPlace] = 0` and thereby discarding closed-net conservation laws (e.g.
+   * `IN + OUT = const`) that would otherwise vacuously bound an injectable place.
+   */
+  static from(flatNet) {
+    const T = flatNet.transitions.length;
+    const P = flatNet.places.length;
+    const pre = [];
+    const post = [];
+    const incidence = [];
+    for (let t = 0; t < T; t++) {
+      const ft = flatNet.transitions[t];
+      const preRow = new Array(P);
+      const postRow = new Array(P);
+      const incRow = new Array(P);
+      for (let p = 0; p < P; p++) {
+        preRow[p] = ft.preVector[p];
+        postRow[p] = ft.postVector[p];
+        incRow[p] = postRow[p] - preRow[p];
+      }
+      pre.push(preRow);
+      post.push(postRow);
+      incidence.push(incRow);
+    }
+    let injectorCount = 0;
+    for (const name of flatNet.environmentInjection.keys()) {
+      const idx = flatNet.placeIndex.get(name);
+      if (idx == null) continue;
+      const preRow = new Array(P).fill(0);
+      const postRow = new Array(P).fill(0);
+      const incRow = new Array(P).fill(0);
+      postRow[idx] = 1;
+      incRow[idx] = 1;
+      pre.push(preRow);
+      post.push(postRow);
+      incidence.push(incRow);
+      injectorCount++;
+    }
+    return new _IncidenceMatrix(pre, post, incidence, T + injectorCount, P);
+  }
+  /**
+   * Returns C^T (transpose of incidence matrix), dimensions [P][T].
+   * Used for P-invariant computation: null space of C^T gives P-invariants.
+   */
+  transposedIncidence() {
+    const ct = [];
+    for (let p = 0; p < this._numPlaces; p++) {
+      const row = new Array(this._numTransitions);
+      for (let t = 0; t < this._numTransitions; t++) {
+        row[t] = this._incidence[t][p];
+      }
+      ct.push(row);
+    }
+    return ct;
+  }
+  /** Returns the pre-matrix (tokens consumed). T×P. */
+  pre() {
+    return this._pre;
+  }
+  /** Returns the post-matrix (tokens produced). T×P. */
+  post() {
+    return this._post;
+  }
+  /** Returns the incidence matrix C[t][p] = post - pre. T×P. */
+  incidence() {
+    return this._incidence;
+  }
+  numTransitions() {
+    return this._numTransitions;
+  }
+  numPlaces() {
+    return this._numPlaces;
+  }
+};
+
+// src/verification/invariant/p-invariant.ts
+function pInvariant(weights, constant, support) {
+  return { weights, constant, support };
+}
+function pInvariantToString(inv) {
+  const parts = [];
+  for (const i of inv.support) {
+    if (inv.weights[i] !== 1) {
+      parts.push(`${inv.weights[i]}*p${i}`);
+    } else {
+      parts.push(`p${i}`);
+    }
+  }
+  return `PInvariant[${parts.join(" + ")} = ${inv.constant}]`;
+}
+
+// src/verification/invariant/p-invariant-computer.ts
+function computePInvariants(matrix, flatNet, initialMarking) {
+  const P = matrix.numPlaces();
+  const T = matrix.numTransitions();
+  if (P === 0 || T === 0) return [];
+  const ct = matrix.transposedIncidence();
+  const cols = T + P;
+  const augmented = [];
+  for (let i = 0; i < P; i++) {
+    const row = new Array(cols).fill(0);
+    for (let j = 0; j < T; j++) {
+      row[j] = ct[i][j];
+    }
+    row[T + i] = 1;
+    augmented.push(row);
+  }
+  let pivotRow = 0;
+  for (let col = 0; col < T && pivotRow < P; col++) {
+    let pivot = -1;
+    for (let row = pivotRow; row < P; row++) {
+      if (augmented[row][col] !== 0) {
+        pivot = row;
+        break;
+      }
+    }
+    if (pivot === -1) continue;
+    if (pivot !== pivotRow) {
+      const tmp = augmented[pivotRow];
+      augmented[pivotRow] = augmented[pivot];
+      augmented[pivot] = tmp;
+    }
+    for (let row = 0; row < P; row++) {
+      if (row === pivotRow || augmented[row][col] === 0) continue;
+      const a = augmented[pivotRow][col];
+      const b = augmented[row][col];
+      for (let c = 0; c < cols; c++) {
+        augmented[row][c] = a * augmented[row][c] - b * augmented[pivotRow][c];
+      }
+      normalizeRow(augmented[row], cols);
+    }
+    pivotRow++;
+  }
+  const invariants = [];
+  for (let row = 0; row < P; row++) {
+    let isZero = true;
+    for (let col = 0; col < T; col++) {
+      if (augmented[row][col] !== 0) {
+        isZero = false;
+        break;
+      }
+    }
+    if (!isZero) continue;
+    const weights = new Array(P);
+    let allNonNegative = true;
+    let hasPositive = false;
+    for (let i = 0; i < P; i++) {
+      weights[i] = augmented[row][T + i];
+      if (weights[i] < 0) {
+        allNonNegative = false;
+        break;
+      }
+      if (weights[i] > 0) hasPositive = true;
+    }
+    if (!allNonNegative) {
+      let allNonPositive = true;
+      for (let i = 0; i < P; i++) {
+        if (augmented[row][T + i] > 0) {
+          allNonPositive = false;
+          break;
+        }
+      }
+      if (allNonPositive) {
+        for (let i = 0; i < P; i++) {
+          weights[i] = -augmented[row][T + i];
+        }
+        hasPositive = true;
+        allNonNegative = true;
+      }
+    }
+    if (!allNonNegative || !hasPositive) continue;
+    let g = 0;
+    for (const w of weights) {
+      if (w > 0) g = gcd(g, w);
+    }
+    if (g > 1) {
+      for (let i = 0; i < P; i++) {
+        weights[i] = weights[i] / g;
+      }
+    }
+    const support = /* @__PURE__ */ new Set();
+    let constant = 0;
+    for (let i = 0; i < P; i++) {
+      if (weights[i] !== 0) {
+        support.add(i);
+        const place = flatNet.places[i];
+        constant += weights[i] * initialMarking.tokens(place);
+      }
+    }
+    invariants.push(pInvariant(weights, constant, support));
+  }
+  return invariants;
+}
+function isCoveredByInvariants(invariants, numPlaces) {
+  const covered = new Array(numPlaces).fill(false);
+  for (const inv of invariants) {
+    for (const idx of inv.support) {
+      if (idx < numPlaces) covered[idx] = true;
+    }
+  }
+  return covered.every((c) => c);
+}
+function normalizeRow(row, cols) {
+  let g = 0;
+  for (let c = 0; c < cols; c++) {
+    if (row[c] !== 0) {
+      g = gcd(g, Math.abs(row[c]));
+    }
+  }
+  if (g > 1) {
+    for (let c = 0; c < cols; c++) {
+      row[c] = row[c] / g;
+    }
+  }
+}
+function gcd(a, b) {
+  while (b !== 0) {
+    const t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+}
+
+// src/verification/invariant/structural-check.ts
+var MAX_PLACES_FOR_SIPHON_ANALYSIS = 50;
+function structuralCheck(flatNet, initialMarking) {
+  const P = flatNet.places.length;
+  if (P === 0) {
+    return { type: "no-potential-deadlock" };
+  }
+  if (P > MAX_PLACES_FOR_SIPHON_ANALYSIS) {
+    return { type: "inconclusive", reason: `Net has ${P} places, siphon enumeration skipped` };
+  }
+  const siphons = findMinimalSiphons(flatNet);
+  if (siphons.length === 0) {
+    return { type: "no-potential-deadlock" };
+  }
+  for (const siphon of siphons) {
+    const trap = findMaximalTrapIn(flatNet, siphon);
+    if (trap.size === 0 || !isMarked(trap, flatNet, initialMarking)) {
+      return { type: "potential-deadlock", siphon };
+    }
+  }
+  return { type: "no-potential-deadlock" };
+}
+function findMinimalSiphons(flatNet) {
+  const P = flatNet.places.length;
+  const siphons = [];
+  const placeAsOutput = [];
+  for (let p = 0; p < P; p++) {
+    placeAsOutput.push([]);
+  }
+  for (let t = 0; t < flatNet.transitions.length; t++) {
+    const ft = flatNet.transitions[t];
+    for (let p = 0; p < P; p++) {
+      if (ft.postVector[p] > 0) {
+        placeAsOutput[p].push(t);
+      }
+    }
+  }
+  for (let startPlace = 0; startPlace < P; startPlace++) {
+    const siphon = computeSiphonContaining(startPlace, flatNet, placeAsOutput);
+    if (siphon !== null && siphon.size > 0) {
+      let isMinimal = true;
+      const toRemove = [];
+      for (let i = 0; i < siphons.length; i++) {
+        const existing = siphons[i];
+        if (setsEqual(existing, siphon)) {
+          isMinimal = false;
+          break;
+        }
+        if (isSubsetOf(existing, siphon)) {
+          isMinimal = false;
+          break;
+        }
+        if (isSubsetOf(siphon, existing)) {
+          toRemove.push(i);
+        }
+      }
+      for (let i = toRemove.length - 1; i >= 0; i--) {
+        siphons.splice(toRemove[i], 1);
+      }
+      if (isMinimal) {
+        siphons.push(siphon);
+      }
+    }
+  }
+  return siphons;
+}
+function computeSiphonContaining(startPlace, flatNet, placeAsOutput) {
+  const siphon = /* @__PURE__ */ new Set();
+  siphon.add(startPlace);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const snapshot = [...siphon];
+    for (const p of snapshot) {
+      for (const t of placeAsOutput[p]) {
+        const ft = flatNet.transitions[t];
+        let hasInputInSiphon = false;
+        for (let q = 0; q < flatNet.places.length; q++) {
+          if (ft.preVector[q] > 0 && siphon.has(q)) {
+            hasInputInSiphon = true;
+            break;
+          }
+        }
+        if (!hasInputInSiphon) {
+          let added = false;
+          for (let q = 0; q < flatNet.places.length; q++) {
+            if (ft.preVector[q] > 0) {
+              if (!siphon.has(q)) {
+                siphon.add(q);
+                changed = true;
+              }
+              added = true;
+              break;
+            }
+          }
+          if (!added) {
+            return null;
+          }
+        }
+      }
+    }
+  }
+  return siphon;
+}
+function findMaximalTrapIn(flatNet, places) {
+  const trap = new Set(places);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const toRemove = [];
+    for (const p of trap) {
+      let satisfies = true;
+      for (let t = 0; t < flatNet.transitions.length; t++) {
+        const ft = flatNet.transitions[t];
+        if (ft.preVector[p] > 0) {
+          let outputsToTrap = false;
+          for (const q of trap) {
+            if (ft.postVector[q] > 0) {
+              outputsToTrap = true;
+              break;
+            }
+          }
+          if (!outputsToTrap) {
+            satisfies = false;
+            break;
+          }
+        }
+      }
+      if (!satisfies) {
+        toRemove.push(p);
+      }
+    }
+    if (toRemove.length > 0) {
+      for (const p of toRemove) trap.delete(p);
+      changed = true;
+    }
+  }
+  return trap;
+}
+function isMarked(placeIndices, flatNet, marking) {
+  for (const idx of placeIndices) {
+    const place = flatNet.places[idx];
+    if (marking.tokens(place) > 0) return true;
+  }
+  return false;
+}
+function setsEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const v of a) {
+    if (!b.has(v)) return false;
+  }
+  return true;
+}
+function isSubsetOf(sub, sup) {
+  if (sub.size > sup.size) return false;
+  for (const v of sub) {
+    if (!sup.has(v)) return false;
+  }
+  return true;
+}
+
+// src/verification/z3/spacer-runner.ts
+import { init } from "z3-solver";
+async function createSpacerRunner(timeoutMs) {
+  const { Context } = await init();
+  const ctx = new Context("main");
+  const fp = new ctx.Fixedpoint();
+  fp.set("engine", "spacer");
+  if (timeoutMs > 0) {
+    fp.set("timeout", Math.min(timeoutMs, 2147483647));
+  }
+  async function query(errorExpr, reachableDecl) {
+    try {
+      const status = await fp.query(errorExpr);
+      if (status === "unsat") {
+        let invariantFormula = null;
+        const levelInvariants = [];
+        try {
+          const answer = fp.getAnswer();
+          if (answer != null) {
+            invariantFormula = answer.toString();
+          }
+        } catch {
+        }
+        if (reachableDecl != null) {
+          try {
+            const levels = fp.getNumLevels(reachableDecl);
+            for (let i = 0; i < levels; i++) {
+              const cover = fp.getCoverDelta(i, reachableDecl);
+              if (cover != null && !ctx.isTrue(cover)) {
+                levelInvariants.push(`Level ${i}: ${cover.toString()}`);
+              }
+            }
+          } catch {
+          }
+        }
+        return { type: "proven", invariantFormula, levelInvariants };
+      }
+      if (status === "sat") {
+        let answer = null;
+        try {
+          answer = fp.getAnswer();
+        } catch {
+        }
+        return { type: "violated", answer };
+      }
+      return { type: "unknown", reason: fp.getReasonUnknown() };
+    } catch (e) {
+      return { type: "unknown", reason: `Z3 exception: ${e.message ?? e}` };
+    }
+  }
+  function dispose() {
+    try {
+      fp.release();
+    } catch {
+    }
+  }
+  return {
+    ctx,
+    fp,
+    query,
+    dispose
+  };
+}
+
+// src/verification/encoding/flat-net.ts
+function flatNetPlaceCount(net) {
+  return net.places.length;
+}
+function flatNetTransitionCount(net) {
+  return net.transitions.length;
+}
+function flatNetIndexOf(net, place) {
+  return net.placeIndex.get(place.name) ?? -1;
+}
+
+// src/verification/z3/smt-encoder.ts
+function encode(ctx, fp, flatNet, initialMarking, property, invariants, sinkPlaces = /* @__PURE__ */ new Set()) {
+  const P = flatNet.places.length;
+  const Int = ctx.Int;
+  const Bool_ = ctx.Bool;
+  const intSort = Int.sort();
+  const boolSort = Bool_.sort();
+  const markingSorts = new Array(P).fill(intSort);
+  const reachable = ctx.Function.declare("Reachable", ...markingSorts, boolSort);
+  fp.registerRelation(reachable);
+  const error = ctx.Function.declare("Error", boolSort);
+  fp.registerRelation(error);
+  const m0Args = [];
+  for (let i = 0; i < P; i++) {
+    const tokens = initialMarking.tokens(flatNet.places[i]);
+    m0Args.push(Int.val(tokens));
+  }
+  const initFact = reachable.call(...m0Args);
+  fp.addRule(initFact, "init");
+  for (let t = 0; t < flatNet.transitions.length; t++) {
+    const ft = flatNet.transitions[t];
+    encodeTransitionRule(ctx, fp, reachable, ft, flatNet, invariants, P);
+  }
+  for (const [name, bound] of flatNet.environmentInjection) {
+    const idx = flatNet.placeIndex.get(name);
+    if (idx == null) continue;
+    encodeInjectionRule(ctx, fp, reachable, idx, bound, P);
+  }
+  encodeErrorRule(ctx, fp, reachable, error, flatNet, property, sinkPlaces, P);
+  return {
+    errorExpr: error.call(),
+    reachableDecl: reachable
+  };
+}
+function encodeTransitionRule(ctx, fp, reachable, ft, flatNet, invariants, P) {
+  const Int = ctx.Int;
+  const mVars = [];
+  const mPrimeVars = [];
+  for (let i = 0; i < P; i++) {
+    mVars.push(Int.const(`m${i}`));
+    mPrimeVars.push(Int.const(`mp${i}`));
+  }
+  const reachBody = reachable.call(...mVars);
+  const enabled = encodeEnabled(ctx, ft, flatNet, mVars, P);
+  const fireRelation = encodeFire(ctx, ft, flatNet, mVars, mPrimeVars, P);
+  let nonNeg = ctx.Bool.val(true);
+  for (let i = 0; i < P; i++) {
+    nonNeg = ctx.And(nonNeg, mPrimeVars[i].ge(0));
+  }
+  const invConstraints = encodeInvariantConstraints(ctx, invariants, mPrimeVars, P);
+  let envBounds = ctx.Bool.val(true);
+  for (const [name, bound] of flatNet.environmentBounds) {
+    const idx = flatNet.placeIndex.get(name);
+    if (idx != null) {
+      envBounds = ctx.And(envBounds, mPrimeVars[idx].le(bound));
+    }
+  }
+  const body = ctx.And(reachBody, enabled, fireRelation, nonNeg, invConstraints, envBounds);
+  const head = reachable.call(...mPrimeVars);
+  const allVars = [...mVars, ...mPrimeVars];
+  const rule = ctx.Implies(body, head);
+  const qRule = ctx.ForAll(allVars, rule);
+  fp.addRule(qRule, `t_${ft.name}`);
+}
+function encodeInjectionRule(ctx, fp, reachable, idx, bound, P) {
+  const Int = ctx.Int;
+  const mVars = [];
+  const mPrimeVars = [];
+  for (let i = 0; i < P; i++) {
+    mVars.push(Int.const(`m${i}`));
+    mPrimeVars.push(Int.const(`mp${i}`));
+  }
+  const reachBody = reachable.call(...mVars);
+  let fire = ctx.Bool.val(true);
+  for (let i = 0; i < P; i++) {
+    if (i === idx) {
+      fire = ctx.And(fire, mPrimeVars[i].eq(mVars[i].add(1)));
+    } else {
+      fire = ctx.And(fire, mPrimeVars[i].eq(mVars[i]));
+    }
+  }
+  const guard = bound === null ? ctx.Bool.val(true) : mVars[idx].lt(bound);
+  const body = ctx.And(reachBody, guard, fire);
+  const head = reachable.call(...mPrimeVars);
+  const qRule = ctx.ForAll([...mVars, ...mPrimeVars], ctx.Implies(body, head));
+  fp.addRule(qRule, `env_inject_${idx}`);
+}
+function injectedEnvIndices(flatNet) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, bound] of flatNet.environmentInjection) {
+    const idx = flatNet.placeIndex.get(name);
+    if (idx != null) out.set(idx, bound);
+  }
+  return out;
+}
+function encodeEnabled(ctx, ft, flatNet, mVars, P, relaxEnv = false) {
+  let result = ctx.Bool.val(true);
+  const envInj = relaxEnv ? injectedEnvIndices(flatNet) : void 0;
+  for (let p = 0; p < P; p++) {
+    const pre = ft.preVector[p];
+    if (pre <= 0) continue;
+    if (envInj?.has(p)) {
+      const bound = envInj.get(p);
+      if (bound !== null && pre > bound) return ctx.Bool.val(false);
+      continue;
+    }
+    result = ctx.And(result, mVars[p].ge(pre));
+  }
+  for (const p of ft.readPlaces) {
+    if (envInj?.has(p)) {
+      const bound = envInj.get(p);
+      if (bound !== null && bound < 1) return ctx.Bool.val(false);
+      continue;
+    }
+    result = ctx.And(result, mVars[p].ge(1));
+  }
+  for (const p of ft.inhibitorPlaces) {
+    result = ctx.And(result, mVars[p].eq(0));
+  }
+  for (let p = 0; p < P; p++) {
+    result = ctx.And(result, mVars[p].ge(0));
+  }
+  return result;
+}
+function encodeFire(ctx, ft, _flatNet, mVars, mPrimeVars, P) {
+  let result = ctx.Bool.val(true);
+  for (let p = 0; p < P; p++) {
+    const isReset = ft.resetPlaces.includes(p);
+    if (isReset || ft.consumeAll[p]) {
+      result = ctx.And(result, mPrimeVars[p].eq(ft.postVector[p]));
+    } else {
+      const delta = ft.postVector[p] - ft.preVector[p];
+      if (delta === 0) {
+        result = ctx.And(result, mPrimeVars[p].eq(mVars[p]));
+      } else {
+        result = ctx.And(result, mPrimeVars[p].eq(mVars[p].add(delta)));
+      }
+    }
+  }
+  return result;
+}
+function encodeErrorRule(ctx, fp, reachable, error, flatNet, property, sinkPlaces, P) {
+  const Int = ctx.Int;
+  const mVars = [];
+  for (let i = 0; i < P; i++) {
+    mVars.push(Int.const(`em${i}`));
+  }
+  const reachBody = reachable.call(...mVars);
+  const violation = encodePropertyViolation(ctx, flatNet, property, sinkPlaces, mVars, P);
+  const head = error.call();
+  const body = ctx.And(reachBody, violation);
+  const rule = ctx.Implies(body, head);
+  const qRule = ctx.ForAll(mVars, rule);
+  fp.addRule(qRule, `error_${property.type}`);
+}
+function encodePropertyViolation(ctx, flatNet, property, sinkPlaces, mVars, P) {
+  switch (property.type) {
+    case "deadlock-free": {
+      const deadlock = encodeDeadlock(ctx, flatNet, mVars, P);
+      if (sinkPlaces.size > 0) {
+        let notAtSink = ctx.Bool.val(true);
+        for (const sink of sinkPlaces) {
+          const idx = flatNetIndexOf(flatNet, sink);
+          if (idx >= 0) {
+            notAtSink = ctx.And(notAtSink, mVars[idx].eq(0));
+          }
+        }
+        return ctx.And(deadlock, notAtSink);
+      }
+      return deadlock;
+    }
+    case "mutual-exclusion": {
+      const idx1 = flatNetIndexOf(flatNet, property.p1);
+      const idx2 = flatNetIndexOf(flatNet, property.p2);
+      if (idx1 < 0) throw new Error(`MutualExclusion references unknown place: ${property.p1.name}`);
+      if (idx2 < 0) throw new Error(`MutualExclusion references unknown place: ${property.p2.name}`);
+      return ctx.And(mVars[idx1].ge(1), mVars[idx2].ge(1));
+    }
+    case "place-bound": {
+      const idx = flatNetIndexOf(flatNet, property.place);
+      if (idx < 0) throw new Error(`PlaceBound references unknown place: ${property.place.name}`);
+      return mVars[idx].gt(property.bound);
+    }
+    case "branch-place-bound": {
+      const idx = flatNetIndexOf(flatNet, property.place);
+      if (idx < 0) throw new Error(`BranchPlaceBound references unknown place: ${property.place.name}`);
+      return mVars[idx].gt(property.bound);
+    }
+    case "joined-or-dead-lettered": {
+      const idx = flatNetIndexOf(flatNet, property.pending);
+      if (idx < 0) return ctx.Bool.val(false);
+      const deadlock = encodeDeadlock(ctx, flatNet, mVars, P);
+      return ctx.And(deadlock, mVars[idx].ge(1));
+    }
+    case "unreachable": {
+      let allMarked = ctx.Bool.val(true);
+      for (const place of property.places) {
+        const idx = flatNetIndexOf(flatNet, place);
+        if (idx >= 0) {
+          allMarked = ctx.And(allMarked, mVars[idx].ge(1));
+        }
+      }
+      return allMarked;
+    }
+  }
+}
+function encodeDeadlock(ctx, flatNet, mVars, P) {
+  let deadlock = ctx.Bool.val(true);
+  for (const ft of flatNet.transitions) {
+    const enabled = encodeEnabled(
+      ctx,
+      ft,
+      flatNet,
+      mVars,
+      P,
+      /* relaxEnv */
+      true
+    );
+    deadlock = ctx.And(deadlock, ctx.Not(enabled));
+  }
+  return deadlock;
+}
+function encodeInvariantConstraints(ctx, invariants, mVars, P) {
+  let result = ctx.Bool.val(true);
+  for (const inv of invariants) {
+    let sum = ctx.Int.val(0);
+    for (const idx of inv.support) {
+      if (idx < P) {
+        sum = sum.add(mVars[idx].mul(inv.weights[idx]));
+      }
+    }
+    result = ctx.And(result, sum.eq(inv.constant));
+  }
+  return result;
+}
+
+// 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/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 initialClass = initialStateClass(net, initialMarking, envPlaces, envMode);
+    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 initialStateClass(net, initialMarking, envPlaces, envMode) {
+  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();
+  return new StateClass(initialMarking, initialDBM, enabledTransitions);
+}
+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/z3/counterexample-decoder.ts
+function decode(ctx, answer, flatNet) {
+  const trace = [];
+  const transitions = [];
+  if (answer == null) {
+    return { trace, transitions };
+  }
+  try {
+    extractTrace(ctx, answer, flatNet, trace, transitions);
+  } catch {
+  }
+  return { trace, transitions };
+}
+function extractTrace(ctx, expr, flatNet, trace, transitions) {
+  if (expr == null) return;
+  if (!ctx.isApp(expr)) return;
+  let name;
+  try {
+    const decl = expr.decl();
+    name = String(decl.name());
+  } catch {
+    return;
+  }
+  const P = flatNet.places.length;
+  if (name === "Reachable") {
+    const numArgs = expr.numArgs();
+    if (numArgs === P) {
+      const marking = extractMarking(ctx, expr, flatNet);
+      if (marking != null) {
+        trace.push(marking);
+      }
+    }
+  }
+  try {
+    const numArgs = expr.numArgs();
+    for (let i = 0; i < numArgs; i++) {
+      const child = expr.arg(i);
+      extractTrace(ctx, child, flatNet, trace, transitions);
+    }
+  } catch {
+  }
+  if (name.startsWith("t_")) {
+    transitions.push(name.substring(2));
+  }
+}
+function extractMarking(ctx, reachableApp, flatNet) {
+  const P = flatNet.places.length;
+  if (reachableApp.numArgs() !== P) return null;
+  const builder = MarkingState.builder();
+  for (let i = 0; i < P; i++) {
+    const arg = reachableApp.arg(i);
+    if (ctx.isIntVal(arg)) {
+      const tokens = Number(arg.value());
+      if (tokens > 0) {
+        builder.tokens(flatNet.places[i], tokens);
+      }
+    } else {
+      return null;
+    }
+  }
+  return builder.build();
+}
+
+// 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;
+  }
+  const isColoured = new Array(P).fill(false);
+  for (const ft of flat.transitions) {
+    const ms = ft.source.matchSpec;
+    if (ms) {
+      for (const key of ms.keys) {
+        const pid = flat.placeIndex.get(key.place.name);
+        if (pid == null) return 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 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;
+  }
+  const classes = [];
+  for (const ft of flat.transitions) {
+    const colouredIn = coloured.filter((pid) => ft.preVector[pid] > 0);
+    const colouredOut = coloured.filter((pid) => ft.postVector[pid] > 0);
+    const ms = ft.source.matchSpec;
+    if (ms) {
+      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 (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) {
+  const colUnc = new Array(P).fill(-1);
+  const colCol = Array.from({ length: P }, () => []);
+  let nCols = 0;
+  for (let i = 0; i < P; i++) {
+    if (plan.isColoured[i]) {
+      const idxs = [];
+      for (let c = 0; c < plan.k; c++) idxs.push(nCols++);
+      colCol[i] = idxs;
+    } else {
+      colUnc[i] = nCols++;
+    }
+  }
+  const cur = [];
+  const nxt = [];
+  for (let col = 0; col < nCols; col++) {
+    cur.push(ctx.Int.const(`c${col}`));
+    nxt.push(ctx.Int.const(`cp${col}`));
+  }
+  return { colUnc, colCol, nCols, cur, nxt };
+}
+function encodeColoured(ctx, fp, plan, flat, initial, property, invariants) {
+  const P = flat.places.length;
+  const k = plan.k;
+  const lay = buildLayout(ctx, plan, P);
+  const intSort = ctx.Int.sort();
+  const boolSort = ctx.Bool.sort();
+  const markingSorts = new Array(lay.nCols).fill(intSort);
+  const reachable = ctx.Function.declare("Reachable", ...markingSorts, boolSort);
+  fp.registerRelation(reachable);
+  const error = ctx.Function.declare("Error", boolSort);
+  fp.registerRelation(error);
+  const initArgs = new Array(lay.nCols);
+  for (let i = 0; i < P; i++) {
+    if (plan.isColoured[i]) {
+      for (let c = 0; c < k; c++) initArgs[lay.colCol[i][c]] = ctx.Int.val(0);
+    } else {
+      initArgs[lay.colUnc[i]] = ctx.Int.val(initial.tokens(flat.places[i]));
+    }
+  }
+  fp.addRule(reachable.call(...initArgs), "init");
+  for (let ti = 0; ti < plan.classes.length; ti++) {
+    const cls = plan.classes[ti];
+    const ft = flat.transitions[ti];
+    if (cls.kind === "untouched") {
+      addRule(
+        ctx,
+        fp,
+        reachable,
+        lay,
+        plan,
+        invariants,
+        `${ft.name}_u`,
+        (enab, upd) => uncolouredIncidence(ctx, lay, plan, ft, enab, upd)
+      );
+    } else if (cls.kind === "mint") {
+      const colouredOut = cls.colouredOut;
+      for (let c = 0; c < k; c++) {
+        const cc = c;
+        addRule(ctx, fp, reachable, lay, plan, invariants, `${ft.name}_mint_${cc}`, (enab, upd) => {
+          uncolouredIncidence(ctx, lay, plan, ft, enab, upd);
+          for (const q of plan.coloured) enab.push(lay.cur[lay.colCol[q][cc]].eq(0));
+          for (const o of colouredOut) {
+            const col = lay.colCol[o][cc];
+            upd.set(col, lay.cur[col].add(1));
+          }
+        });
+      }
+    } else {
+      const colouredIn = cls.colouredIn;
+      for (let c = 0; c < k; c++) {
+        const cc = c;
+        addRule(ctx, fp, reachable, lay, plan, invariants, `${ft.name}_join_${cc}`, (enab, upd) => {
+          uncolouredIncidence(ctx, lay, plan, ft, enab, upd);
+          for (const ip of colouredIn) {
+            const col = lay.colCol[ip][cc];
+            enab.push(lay.cur[col].ge(1));
+            upd.set(col, lay.cur[col].add(-1));
+          }
+        });
+      }
+    }
+  }
+  addErrorRule(ctx, fp, reachable, error, lay, plan, flat, property);
+  return {
+    errorExpr: error.call(),
+    reachableDecl: reachable
+  };
+}
+function addRule(ctx, fp, reachable, lay, plan, invariants, ruleName, fill) {
+  const enab = [];
+  const upd = /* @__PURE__ */ new Map();
+  fill(enab, upd);
+  const conds = [reachable.call(...lay.cur), ...enab];
+  for (let col = 0; col < lay.nCols; col++) {
+    const expr = upd.get(col);
+    if (expr !== void 0) {
+      conds.push(lay.nxt[col].eq(expr), lay.nxt[col].ge(0));
+    } else {
+      conds.push(lay.nxt[col].eq(lay.cur[col]));
+    }
+  }
+  for (const inv of invariants) {
+    const eq = liftedInvariant(ctx, inv, plan, lay, lay.nxt);
+    if (eq) conds.push(eq);
+  }
+  const body = ctx.And(...conds);
+  const head = reachable.call(...lay.nxt);
+  const qRule = ctx.ForAll([...lay.cur, ...lay.nxt], ctx.Implies(body, head));
+  fp.addRule(qRule, ruleName);
+}
+function uncolouredIncidence(ctx, lay, plan, ft, enab, upd) {
+  const P = ft.preVector.length;
+  for (let i = 0; i < P; i++) {
+    if (plan.isColoured[i]) continue;
+    const col = lay.colUnc[i];
+    const pre = ft.preVector[i];
+    if (pre > 0) enab.push(lay.cur[col].ge(pre));
+    if (ft.resetPlaces.includes(i) || ft.consumeAll[i]) {
+      upd.set(col, ctx.Int.val(ft.postVector[i]));
+    } else {
+      const delta = ft.postVector[i] - ft.preVector[i];
+      if (delta !== 0) upd.set(col, lay.cur[col].add(delta));
+    }
+  }
+  for (const pid of ft.inhibitorPlaces) enab.push(lay.cur[lay.colUnc[pid]].eq(0));
+  for (const pid of ft.readPlaces) enab.push(lay.cur[lay.colUnc[pid]].ge(1));
+}
+function aggregate(plan, lay, place, vars) {
+  if (plan.isColoured[place]) {
+    const cols = lay.colCol[place];
+    let sum = vars[cols[0]];
+    for (let c = 1; c < cols.length; c++) sum = sum.add(vars[cols[c]]);
+    return sum;
+  }
+  return vars[lay.colUnc[place]];
+}
+function liftedInvariant(ctx, inv, plan, lay, vars) {
+  if (inv.support.size === 0) return null;
+  let sum = ctx.Int.val(0);
+  for (const i of inv.support) {
+    const agg = aggregate(plan, lay, i, vars);
+    const w = inv.weights[i];
+    sum = sum.add(w === 1 ? agg : agg.mul(w));
+  }
+  return sum.eq(inv.constant);
+}
+function addErrorRule(ctx, fp, reachable, error, lay, plan, flat, property) {
+  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");
+}
+function encodeViolation(ctx, plan, lay, flat, property, cur) {
+  switch (property.type) {
+    case "place-bound":
+    case "branch-place-bound": {
+      const idx = flatNetIndexOf(flat, property.place);
+      if (idx < 0) return ctx.Bool.val(false);
+      return aggregate(plan, lay, idx, cur).gt(property.bound);
+    }
+    case "mutual-exclusion": {
+      const i1 = flatNetIndexOf(flat, property.p1);
+      const i2 = flatNetIndexOf(flat, property.p2);
+      if (i1 < 0 || i2 < 0) return ctx.Bool.val(false);
+      return ctx.And(aggregate(plan, lay, i1, cur).ge(1), aggregate(plan, lay, i2, cur).ge(1));
+    }
+    case "unreachable": {
+      const conds = [];
+      for (const place of property.places) {
+        const idx = flatNetIndexOf(flat, place);
+        if (idx >= 0) conds.push(aggregate(plan, lay, idx, cur).ge(1));
+      }
+      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 ctx.Bool.val(false);
+  }
+}
+
+// src/verification/analysis/name-fragment.ts
+function classify(net) {
+  const coloured = /* @__PURE__ */ new Set();
+  let anyMatch = false;
+  for (const t of net.transitions) {
+    if (t.matchSpec !== null) {
+      anyMatch = true;
+      for (const key of t.matchSpec.keys) coloured.add(key.place.name);
+    }
+  }
+  if (!anyMatch || coloured.size === 0) return null;
+  const roles = /* @__PURE__ */ new Map();
+  for (const t of net.transitions) {
+    const consumesColoured = t.inputSpecs.some((s) => coloured.has(s.place.name));
+    let producesColoured = false;
+    if (t.outputSpec !== null) {
+      for (const branch of enumerateBranches(t.outputSpec)) {
+        for (const p of branch) {
+          if (coloured.has(p.name)) producesColoured = true;
+        }
+      }
+    }
+    let role;
+    if (t.matchSpec !== null) {
+      if (producesColoured) return null;
+      const colouredIn = [];
+      for (const key of t.matchSpec.keys) {
+        const place = key.place.name;
+        const required = fixedRequiredCount(t, place);
+        if (required === null) return null;
+        colouredIn.push([place, required]);
+      }
+      colouredIn.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+      role = { type: "join", colouredIn };
+    } else if (producesColoured) {
+      if (consumesColoured) return null;
+      role = { type: "mint" };
+    } else {
+      if (consumesColoured) return null;
+      role = { type: "ordinary" };
+    }
+    roles.set(t.name, role);
+  }
+  const colouredOrder = [...coloured].sort();
+  return {
+    colouredOrder,
+    isColoured: (p) => coloured.has(p),
+    role: (tn) => roles.get(tn) ?? { type: "ordinary" }
+  };
+}
+function fixedRequiredCount(t, placeName) {
+  for (const spec of t.inputSpecs) {
+    if (spec.place.name === placeName) {
+      switch (spec.type) {
+        case "one":
+          return 1;
+        case "exactly":
+          return spec.count;
+        case "all":
+          return null;
+        case "at-least":
+          return null;
+      }
+    }
+  }
+  return null;
+}
+
+// src/verification/analysis/name-marking.ts
+var NameMarking = class _NameMarking {
+  // place name -> (symbol -> count). Only coloured places appear; a place's
+  // total here equals its count in the base MarkingState.
+  perPlace;
+  constructor(perPlace) {
+    this.perPlace = perPlace ?? /* @__PURE__ */ new Map();
+  }
+  copy() {
+    const p = /* @__PURE__ */ new Map();
+    for (const [place, syms] of this.perPlace) {
+      p.set(place, new Map(syms));
+    }
+    return new _NameMarking(p);
+  }
+  add(place, sym, count) {
+    if (count === 0) return;
+    let syms = this.perPlace.get(place);
+    if (!syms) {
+      syms = /* @__PURE__ */ new Map();
+      this.perPlace.set(place, syms);
+    }
+    syms.set(sym, (syms.get(sym) ?? 0) + count);
+  }
+  /** Removes `count` of `sym` from `place`; returns false (unchanged) if fewer present. */
+  remove(place, sym, count) {
+    const syms = this.perPlace.get(place);
+    if (!syms) return false;
+    const have = syms.get(sym);
+    if (have === void 0 || have < count) return false;
+    const left = have - count;
+    if (left === 0) {
+      syms.delete(sym);
+      if (syms.size === 0) this.perPlace.delete(place);
+    } else {
+      syms.set(sym, left);
+    }
+    return true;
+  }
+  countOf(place, sym) {
+    return this.perPlace.get(place)?.get(sym) ?? 0;
+  }
+  symbolsIn(place) {
+    const syms = this.perPlace.get(place);
+    return syms ? [...syms.keys()] : [];
+  }
+  liveSymbols() {
+    const all = /* @__PURE__ */ new Set();
+    for (const syms of this.perPlace.values()) {
+      for (const s of syms.keys()) all.add(s);
+    }
+    return [...all];
+  }
+  /**
+   * Symmetry-canonical key over `colouredOrder` (the finiteness mechanism). Two
+   * markings differing only by a permutation of symbols produce an identical key
+   * (NU-001). Each symbol's signature is its count vector over `colouredOrder`;
+   * symbols are ranked by (signature, raw id) and emitted per place as a
+   * rank-multiset — a complete invariant of the symbol-permutation orbit.
+   */
+  canonicalKey(colouredOrder) {
+    const signature = (s) => colouredOrder.map((p) => this.countOf(p, s));
+    const ranked = this.liveSymbols().map((s) => ({ sig: signature(s), sym: s }));
+    ranked.sort((a, b) => {
+      const c = compareNumberArrays(a.sig, b.sig);
+      return c !== 0 ? c : a.sym - b.sym;
+    });
+    const rankOf = /* @__PURE__ */ new Map();
+    ranked.forEach((r, i) => rankOf.set(r.sym, i));
+    const parts = colouredOrder.map((p) => {
+      const syms = this.perPlace.get(p);
+      const entries = [];
+      if (syms) {
+        for (const [s, c] of syms) entries.push([rankOf.get(s), c]);
+      }
+      entries.sort((a, b) => a[0] !== b[0] ? a[0] - b[0] : a[1] - b[1]);
+      const inner = entries.map(([r, c]) => `${r}x${c}`).join(",");
+      return `${p}:{${inner}}`;
+    });
+    return parts.join("#");
+  }
+};
+function compareNumberArrays(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    if (a[i] !== b[i]) return a[i] - b[i];
+  }
+  return a.length - b.length;
+}
+
+// src/verification/analysis/name-state-class.ts
+var NameStateClass = class {
+  base;
+  names;
+  key;
+  constructor(base, names, colouredOrder) {
+    this.base = base;
+    this.names = names;
+    this.key = `${base.marking.toString()}|${base.firingDomain.toString()}||${names.canonicalKey(colouredOrder)}`;
+  }
+};
+
+// src/verification/analysis/name-state-class-graph.ts
+var NameStateClassGraph = class _NameStateClassGraph {
+  classes = [];
+  edges = [];
+  _successors = [];
+  _complete = true;
+  isComplete() {
+    return this._complete;
+  }
+  classCount() {
+    return this.classes.length;
+  }
+  successorsOf(idx) {
+    return this._successors[idx];
+  }
+  /** The base count-marking of class `idx` (for property queries). */
+  markingOf(idx) {
+    return this.classes[idx].base.marking;
+  }
+  static build(net, initialMarking, fragment, maxClasses, environmentPlaces, environmentMode) {
+    const envMode = environmentMode ?? ignore();
+    const envPlaces = /* @__PURE__ */ new Set();
+    if (environmentPlaces) {
+      for (const ep of environmentPlaces) envPlaces.add(ep.place);
+    }
+    const graph = new _NameStateClassGraph();
+    const base0 = initialStateClass(net, initialMarking, envPlaces, envMode);
+    const initial = new NameStateClass(base0, new NameMarking(), fragment.colouredOrder);
+    const indexOf = /* @__PURE__ */ new Map();
+    graph.pushClass(initial, indexOf);
+    const sym = { next: 0 };
+    const queue = [0];
+    while (queue.length > 0) {
+      if (graph.classes.length >= maxClasses) {
+        graph._complete = false;
+        break;
+      }
+      const curIdx = queue.shift();
+      const current = graph.classes[curIdx];
+      for (const transition of current.base.enabledTransitions) {
+        const role = fragment.role(transition.name);
+        for (const vt of expandTransition(transition)) {
+          const baseSucc = computeSuccessor(net, current.base, vt, envPlaces, envMode);
+          if (baseSucc === null || baseSucc.isEmpty()) continue;
+          const nameSuccs = nameSuccessors(role, current.names, vt.outputPlaces, fragment, sym);
+          for (const nm of nameSuccs) {
+            const succ = new NameStateClass(baseSucc, nm, fragment.colouredOrder);
+            let toIdx = indexOf.get(succ.key);
+            if (toIdx === void 0) {
+              toIdx = graph.classes.length;
+              graph.pushClass(succ, indexOf);
+              queue.push(toIdx);
+            }
+            graph.addEdge(curIdx, toIdx, transition.name);
+          }
+        }
+      }
+    }
+    return graph;
+  }
+  pushClass(c, indexOf) {
+    const idx = this.classes.length;
+    this.classes.push(c);
+    this._successors.push([]);
+    indexOf.set(c.key, idx);
+  }
+  addEdge(from, to, name) {
+    this.edges.push({ from, to, transitionName: name });
+    this._successors[from].push(to);
+  }
+};
+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 nm = names.copy();
+      if (colouredOut.length > 0) {
+        const fresh = sym.next++;
+        for (const p of colouredOut) nm.add(p, fresh, 1);
+      }
+      return [nm];
+    }
+    case "join": {
+      const result = [];
+      for (const s of enablingSymbols(names, role.colouredIn)) {
+        const nm = names.copy();
+        for (const [p, req] of role.colouredIn) nm.remove(p, s, req);
+        result.push(nm);
+      }
+      return result;
+    }
+  }
+}
+function enablingSymbols(names, colouredIn) {
+  if (colouredIn.length === 0) return [];
+  const [firstPlace, firstReq] = colouredIn[0];
+  const result = [];
+  for (const s of names.symbolsIn(firstPlace)) {
+    if (names.countOf(firstPlace, s) < firstReq) continue;
+    let ok = true;
+    for (let i = 1; i < colouredIn.length; i++) {
+      const [p, req] = colouredIn[i];
+      if (names.countOf(p, s) < req) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) result.push(s);
+  }
+  return result;
+}
+
+// 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);
+  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);
+  if (!scg.isComplete()) {
+    return {
+      verdict: {
+        type: "unknown",
+        reason: `\u03BD name-aware state-class graph truncated at ${maxClasses} classes \u2014 the live correlation pool is not structurally bounded; reachability over unbounded fresh names is undecidable (NU-050, Route B). Declare a budget place to bound the live pool, or raise nuMaxClasses.`
+      },
+      trace: [],
+      transitions: [],
+      note: "",
+      classCount: scg.classCount()
+    };
+  }
+  const violating = decide(scg, property, sinkPlaces);
+  if (violating >= 0) {
+    const [trace, transitions] = counterexamplePath(scg, violating);
+    return { verdict: { type: "violated" }, trace, transitions, note: NOTE_EXACT, classCount: scg.classCount() };
+  }
+  return {
+    verdict: { type: "proven", method: "\u03BD name-partition SCG (NU-050, Route B)", inductiveInvariant: null },
+    trace: [],
+    transitions: [],
+    note: NOTE_EXACT,
+    classCount: scg.classCount()
+  };
+}
+function decide(scg, property, sinkPlaces) {
+  const firstWhere = (pred) => {
+    for (let i = 0; i < scg.classCount(); i++) {
+      if (pred(i)) return i;
+    }
+    return -1;
+  };
+  switch (property.type) {
+    case "place-bound":
+    case "branch-place-bound":
+      return firstWhere((i) => scg.markingOf(i).tokens(property.place) > property.bound);
+    case "unreachable":
+      return firstWhere((i) => {
+        const m = scg.markingOf(i);
+        for (const p of property.places) {
+          if (!m.hasTokens(p)) return false;
+        }
+        return true;
+      });
+    case "mutual-exclusion":
+      return firstWhere((i) => {
+        const m = scg.markingOf(i);
+        return m.hasTokens(property.p1) && m.hasTokens(property.p2);
+      });
+    case "deadlock-free":
+      return firstWhere((i) => scg.successorsOf(i).length === 0 && !allTokensInSinks(scg.markingOf(i), sinkPlaces));
+    case "joined-or-dead-lettered":
+      return firstWhere((i) => scg.successorsOf(i).length === 0 && scg.markingOf(i).hasTokens(property.pending));
+  }
+}
+function allTokensInSinks(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 false;
+  }
+  return true;
+}
+function counterexamplePath(scg, target) {
+  const n = scg.classCount();
+  const parent = new Array(n).fill(-1);
+  const via = new Array(n).fill("");
+  const visited = new Array(n).fill(false);
+  visited[0] = true;
+  const queue = [0];
+  while (queue.length > 0) {
+    const u = queue.shift();
+    if (u === target) break;
+    for (const e of scg.edges) {
+      if (e.from === u && !visited[e.to]) {
+        visited[e.to] = true;
+        parent[e.to] = u;
+        via[e.to] = e.transitionName;
+        queue.push(e.to);
+      }
+    }
+  }
+  const chain = [];
+  for (let cur = target; cur !== -1; cur = parent[cur]) {
+    chain.push(cur);
+  }
+  chain.reverse();
+  const markings = chain.map((i) => scg.markingOf(i));
+  const transitions = chain.slice(1).map((i) => via[i]);
+  return [markings, transitions];
+}
+
+// src/verification/smt-verifier.ts
+var SmtVerifier = class _SmtVerifier {
+  constructor(net) {
+    this.net = net;
+  }
+  _initialMarking = MarkingState.empty();
+  _property = deadlockFree();
+  _environmentPlaces = /* @__PURE__ */ new Set();
+  _sinkPlaces = /* @__PURE__ */ new Set();
+  _budgetPlaces = /* @__PURE__ */ new Set();
+  _environmentMode = alwaysAvailable();
+  _timeoutMs = 6e4;
+  _nuMaxClasses = 1e5;
+  static forNet(net) {
+    return new _SmtVerifier(net);
+  }
+  initialMarking(arg) {
+    if (arg instanceof MarkingState) {
+      this._initialMarking = arg;
+    } else {
+      const builder = MarkingState.builder();
+      arg(builder);
+      this._initialMarking = builder.build();
+    }
+    return this;
+  }
+  property(property) {
+    this._property = property;
+    return this;
+  }
+  environmentPlaces(...places) {
+    for (const p of places) this._environmentPlaces.add(p);
+    return this;
+  }
+  environmentMode(mode) {
+    this._environmentMode = mode;
+    return this;
+  }
+  /**
+   * Declares expected sink (terminal) places for deadlock-freedom analysis.
+   * Markings where any sink place has a token are not considered deadlocks.
+   */
+  sinkPlaces(...places) {
+    for (const p of places) this._sinkPlaces.add(p);
+    return this;
+  }
+  /**
+   * Declares ν-net budget places (NU-040): places whose token count bounds the
+   * live correlation pool (they gate fresh-name minting). Declaring at least one
+   * places the net in the decidable bounded fragment, so reachability-safety
+   * properties over its ν-joins are verified (the matched transitions are
+   * over-approximated). Without any budget place, a net that mints fresh names
+   * is treated as unbounded and the verifier returns `unknown` (NU-050).
+   */
+  budgetPlaces(...places) {
+    for (const p of places) this._budgetPlaces.add(p.name);
+    return this;
+  }
+  timeout(ms) {
+    this._timeoutMs = ms;
+    return this;
+  }
+  /**
+   * Sets the class-count cap for the ν-aware state-class-graph analysis (NU-050,
+   * Route B). When the symbolic name-aware graph would exceed this, the analysis
+   * truncates and the verdict is `unknown` (the live correlation pool is not
+   * structurally bounded). Default 100_000.
+   */
+  nuMaxClasses(max) {
+    this._nuMaxClasses = max;
+    return this;
+  }
+  /**
+   * Runs the verification pipeline.
+   */
+  async verify() {
+    const start = performance.now();
+    const report = [];
+    report.push("=== IC3/PDR SAFETY VERIFICATION ===\n");
+    report.push(`Net: ${this.net.name}`);
+    const propDesc = this._sinkPlaces.size === 0 ? propertyDescription(this._property) : `${propertyDescription(this._property)} (sinks: ${[...this._sinkPlaces].map((p) => p.name).join(", ")})`;
+    report.push(`Property: ${propDesc}`);
+    report.push(`Timeout: ${(this._timeoutMs / 1e3).toFixed(0)}s
+`);
+    const hasMatch = [...this.net.transitions].some((t) => t.matchSpec !== null);
+    const nuBounded = this._budgetPlaces.size > 0;
+    if (hasMatch && (!isReachabilitySafety(this._property) || !nuBounded)) {
+      const outcome = verifyViaNameScg(
+        this.net,
+        this._initialMarking,
+        this._property,
+        this._sinkPlaces,
+        this._environmentPlaces,
+        this._environmentMode,
+        this._nuMaxClasses
+      );
+      if (outcome !== null) {
+        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);
+        if (outcome.transitions.length > 0) {
+          report.push(`  Counterexample trace: ${outcome.trace.length} states, ${outcome.transitions.length} transitions`);
+        }
+        return buildResult(
+          outcome.verdict,
+          report.join("\n"),
+          [],
+          [],
+          outcome.trace,
+          outcome.transitions,
+          performance.now() - start,
+          {
+            places: [...this.net.places].length,
+            transitions: [...this.net.transitions].length,
+            invariantsFound: 0,
+            structuralResult: "n/a (\u03BD name-partition SCG)"
+          }
+        );
+      }
+    }
+    report.push("Phase 1: Flattening net...");
+    const flatNet = flatten(this.net, this._environmentPlaces, this._environmentMode);
+    report.push(`  Places: ${flatNet.places.length}`);
+    report.push(`  Transitions (expanded): ${flatNet.transitions.length}`);
+    if (flatNet.environmentBounds.size > 0) {
+      report.push(`  Environment bounds: ${flatNet.environmentBounds.size} places`);
+    }
+    report.push("");
+    report.push("Phase 2: Structural pre-check (siphon/trap)...");
+    const structResult = structuralCheck(flatNet, this._initialMarking);
+    let structResultStr;
+    switch (structResult.type) {
+      case "no-potential-deadlock":
+        structResultStr = "no potential deadlock";
+        break;
+      case "potential-deadlock":
+        structResultStr = `potential deadlock (siphon: {${[...structResult.siphon].join(",")}})`;
+        break;
+      case "inconclusive":
+        structResultStr = `inconclusive (${structResult.reason})`;
+        break;
+    }
+    report.push(`  Result: ${structResultStr}
+`);
+    if (this._property.type === "deadlock-free" && !hasMatch && this._sinkPlaces.size === 0 && structResult.type === "no-potential-deadlock" && this._environmentPlaces.size === 0) {
+      report.push("=== RESULT ===\n");
+      report.push("PROVEN (structural): Deadlock-freedom verified by Commoner's theorem.");
+      report.push("  All siphons contain initially marked traps.");
+      return buildResult(
+        { type: "proven", method: "structural", inductiveInvariant: null },
+        report.join("\n"),
+        [],
+        [],
+        [],
+        [],
+        performance.now() - start,
+        { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: 0, structuralResult: structResultStr }
+      );
+    }
+    report.push("Phase 3: Computing P-invariants...");
+    const matrix = IncidenceMatrix.from(flatNet);
+    const invariants = computePInvariants(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"}`);
+    for (const inv of invariants) {
+      report.push(`  ${formatInvariant(inv, flatNet)}`);
+    }
+    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;
+    let runner;
+    try {
+      runner = await createSpacerRunner(this._timeoutMs);
+    } catch (e) {
+      report.push(`  ERROR: ${e.message ?? e}
+`);
+      report.push("=== RESULT ===\n");
+      report.push(`UNKNOWN: Z3 initialization error: ${e.message ?? e}`);
+      return buildResult(
+        { type: "unknown", reason: `Z3 init error: ${e.message ?? e}` },
+        report.join("\n"),
+        invariants,
+        [],
+        [],
+        [],
+        performance.now() - start,
+        { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+      );
+    }
+    try {
+      let encoding;
+      if (colouredPlan != null) {
+        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);
+      } else {
+        encoding = encode(runner.ctx, runner.fp, flatNet, this._initialMarking, this._property, invariants, this._sinkPlaces);
+      }
+      const queryResult = await runner.query(encoding.errorExpr, encoding.reachableDecl);
+      switch (queryResult.type) {
+        case "proven": {
+          if (this._environmentPlaces.size > 0 && this._environmentMode.type === "ignore") {
+            const reason = "environment places present but not modeled (mode=ignore); a proof would be vacuous \u2014 use alwaysAvailable() or bounded(k) to model external injection";
+            report.push(`  Status: UNSAT, but vacuous under ignore mode
+`);
+            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 }
+            );
+          }
+          report.push("  Status: UNSAT (property holds)\n");
+          const discoveredInvariants = [];
+          if (queryResult.invariantFormula != null) {
+            discoveredInvariants.push(substituteNames(queryResult.invariantFormula, flatNet));
+          }
+          for (const level of queryResult.levelInvariants) {
+            discoveredInvariants.push(substituteNames(level, flatNet));
+          }
+          if (discoveredInvariants.length > 0) {
+            report.push("Phase 5: Inductive invariant (discovered by IC3)");
+            report.push(`  Spacer synthesized: ${discoveredInvariants[0]}`);
+            report.push("  This formula is INDUCTIVE: preserved by all transitions.");
+            if (discoveredInvariants.length > 1) {
+              report.push("  Per-level clauses:");
+              for (let i = 1; i < discoveredInvariants.length; i++) {
+                report.push(`    ${discoveredInvariants[i]}`);
+              }
+            }
+            report.push("");
+          }
+          report.push("=== RESULT ===\n");
+          report.push(`PROVEN (IC3/PDR): ${propDesc}`);
+          report.push("  Z3 Spacer proved no reachable state violates the property.");
+          report.push("  NOTE: Verification ignores timing constraints and JS guards.");
+          report.push("  An untimed proof is STRONGER than a timed one (timing only restricts behavior).");
+          return this.applyNuGuard(buildResult(
+            {
+              type: "proven",
+              method: "IC3/PDR",
+              inductiveInvariant: queryResult.invariantFormula != null ? substituteNames(queryResult.invariantFormula, flatNet) : null
+            },
+            report.join("\n"),
+            invariants,
+            discoveredInvariants,
+            [],
+            [],
+            performance.now() - start,
+            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+          ), hasMatch, nuBounded, colouredPlan != null);
+        }
+        case "violated": {
+          report.push("  Status: SAT (counterexample found)\n");
+          const decoded = decode(runner.ctx, queryResult.answer, flatNet);
+          report.push("=== RESULT ===\n");
+          report.push(`VIOLATED: ${propDesc}`);
+          if (decoded.trace.length > 0) {
+            report.push(`  Counterexample trace (${decoded.trace.length} states):`);
+            for (let i = 0; i < decoded.trace.length; i++) {
+              report.push(`    ${i}: ${decoded.trace[i]}`);
+            }
+          }
+          if (decoded.transitions.length > 0) {
+            report.push(`  Firing sequence: ${decoded.transitions.join(" -> ")}`);
+          }
+          report.push("\n  WARNING: This counterexample is in UNTIMED semantics.");
+          report.push("  It may be spurious if timing constraints prevent this sequence.");
+          report.push("  JS guards are also ignored in this analysis.");
+          return this.applyNuGuard(buildResult(
+            { type: "violated" },
+            report.join("\n"),
+            invariants,
+            [],
+            decoded.trace,
+            decoded.transitions,
+            performance.now() - start,
+            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+          ), hasMatch, nuBounded, colouredPlan != null);
+        }
+        case "unknown": {
+          report.push(`  Status: UNKNOWN (${queryResult.reason})
+`);
+          report.push("=== RESULT ===\n");
+          report.push(`UNKNOWN: Could not determine ${propDesc}`);
+          report.push(`  Reason: ${queryResult.reason}`);
+          return buildResult(
+            { type: "unknown", reason: queryResult.reason },
+            report.join("\n"),
+            invariants,
+            [],
+            [],
+            [],
+            performance.now() - start,
+            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+          );
+        }
+      }
+    } catch (e) {
+      report.push(`  ERROR: ${e.message ?? e}
+`);
+      report.push("=== RESULT ===\n");
+      report.push(`UNKNOWN: Z3 solver error: ${e.message ?? e}`);
+      return buildResult(
+        { type: "unknown", reason: `Z3 error: ${e.message ?? e}` },
+        report.join("\n"),
+        invariants,
+        [],
+        [],
+        [],
+        performance.now() - start,
+        { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+      );
+    } finally {
+      runner.dispose();
+    }
+  }
+  /**
+   * ν-net soundness guard (NU-040, NU-050). Applied only when the net contains
+   * match (ν-join) transitions, and only to a proven/violated verdict (an
+   * existing unknown is left as-is).
+   *
+   * - Quiescence-based properties (deadlock / joined-or-dead-lettered): the
+   *   name-blind over-approximation over-fires joins, so it sees fewer quiescent
+   *   states and may miss a real stranded marking — downgraded to unknown
+   *   (exact quiescence reasoning is deferred to the SCG name-partition quotient).
+   * - Reachability-safety with unbounded fresh names (no budget declared):
+   *   reachability over unbounded fresh names is undecidable — unknown.
+   * - Bounded reachability-safety in the name-coloured fragment (`exact`): name
+   *   equality is encoded exactly via bounded name-colouring, so the verdict is
+   *   sound *and* complete within the budget — no spurious different-name
+   *   counterexample. The verdict is kept and the exact-path note is appended.
+   * - Bounded reachability-safety outside that fragment: `proven` is sound; a
+   *   `violated` may be spurious — the verdict is kept and the over-approximation
+   *   caveat is appended to the report.
+   */
+  applyNuGuard(result, hasMatch, nuBounded, exact) {
+    if (!hasMatch || result.verdict.type === "unknown") return result;
+    if (!isReachabilitySafety(this._property)) {
+      return downgradeToUnknown(
+        result,
+        "\u03BD-matching transitions present and the property depends on quiescence (deadlock / joined-or-dead-lettered); the name-blind over-approximation cannot decide it soundly \u2014 deferred to the exact \u03BD-analysis (NU-050)"
+      );
+    }
+    if (!nuBounded) {
+      return downgradeToUnknown(
+        result,
+        "\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";
+    return { ...result, report: result.report + note };
+  }
+};
+function isReachabilitySafety(property) {
+  switch (property.type) {
+    case "place-bound":
+    case "branch-place-bound":
+    case "mutual-exclusion":
+    case "unreachable":
+      return true;
+    case "deadlock-free":
+    case "joined-or-dead-lettered":
+      return false;
+  }
+}
+function downgradeToUnknown(result, reason) {
+  return {
+    ...result,
+    verdict: { type: "unknown", reason },
+    report: result.report + `
+Downgraded to UNKNOWN: ${reason}
+`,
+    discoveredInvariants: [],
+    counterexampleTrace: [],
+    counterexampleTransitions: []
+  };
+}
+function substituteNames(formula, flatNet) {
+  for (let i = flatNet.places.length - 1; i >= 0; i--) {
+    formula = formula.replace(new RegExp(`\\bm${i}\\b`, "g"), flatNet.places[i].name);
+  }
+  return formula;
+}
+function formatInvariant(inv, flatNet) {
+  const parts = [];
+  for (const idx of inv.support) {
+    if (inv.weights[idx] !== 1) {
+      parts.push(`${inv.weights[idx]}*${flatNet.places[idx].name}`);
+    } else {
+      parts.push(flatNet.places[idx].name);
+    }
+  }
+  return `${parts.join(" + ")} = ${inv.constant}`;
+}
+function buildResult(verdict, report, invariants, discoveredInvariants, trace, transitions, elapsedMs, statistics) {
+  return { verdict, report, invariants, discoveredInvariants, counterexampleTrace: trace, counterexampleTransitions: transitions, elapsedMs, statistics };
+}
+
+// src/verification/smt-verification-result.ts
+function isProven(result) {
+  return result.verdict.type === "proven";
+}
+function isViolated(result) {
+  return result.verdict.type === "violated";
+}
+
+export {
+  and,
+  andPlaces,
+  xor,
+  xorPlaces,
+  outPlace,
+  timeout,
+  timeoutPlace,
+  forwardInput,
+  allPlaces,
+  enumerateBranches,
+  MarkingState,
+  MarkingStateBuilder,
+  deadlockFree,
+  mutualExclusion,
+  placeBound,
+  unreachable,
+  branchPlaceBound,
+  joinedOrDeadLettered,
+  propertyDescription,
+  flatTransition,
+  alwaysAvailable,
+  bounded,
+  ignore,
+  flatten,
+  IncidenceMatrix,
+  pInvariant,
+  pInvariantToString,
+  computePInvariants,
+  isCoveredByInvariants,
+  structuralCheck,
+  findMinimalSiphons,
+  findMaximalTrapIn,
+  createSpacerRunner,
+  flatNetPlaceCount,
+  flatNetTransitionCount,
+  flatNetIndexOf,
+  encode,
+  DBM,
+  StateClass,
+  StateClassGraph,
+  decode,
+  SmtVerifier,
+  isProven,
+  isViolated
+};
+//# sourceMappingURL=chunk-M3KT7BFO.js.map