libpetri 5.0.0 → 6.0.0

package/dist/chunk-75KEJQGC.js

@@ -1,4505 +0,0 @@
-import {
-  earliest,
-  latest
-} from "./chunk-ATT7U5H5.js";
-
-// src/core/in.ts
-function one(place) {
-  return { type: "one", place };
-}
-function exactly(count, place) {
-  if (count < 1) {
-    throw new Error(`count must be >= 1, got: ${count}`);
-  }
-  return { type: "exactly", place, count };
-}
-function all(place) {
-  return { type: "all", place };
-}
-function atLeast(minimum, place) {
-  if (minimum < 1) {
-    throw new Error(`minimum must be >= 1, got: ${minimum}`);
-  }
-  return { type: "at-least", place, minimum };
-}
-function requiredCount(spec) {
-  switch (spec.type) {
-    case "one":
-      return 1;
-    case "exactly":
-      return spec.count;
-    case "all":
-      return 1;
-    case "at-least":
-      return spec.minimum;
-  }
-}
-function consumptionCount(spec, available) {
-  if (available < requiredCount(spec)) {
-    throw new Error(
-      `Cannot consume from '${spec.place.name}': available=${available}, required=${requiredCount(spec)}`
-    );
-  }
-  switch (spec.type) {
-    case "one":
-      return 1;
-    case "exactly":
-      return spec.count;
-    case "all":
-      return available;
-    case "at-least":
-      return available;
-  }
-}
-
-// 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/core/transition-action.ts
-function passthrough() {
-  return PASSTHROUGH;
-}
-var PASSTHROUGH = async () => {
-};
-function isPassthrough(action) {
-  return action === PASSTHROUGH;
-}
-function transform(fn) {
-  return async (ctx) => {
-    const result = fn(ctx);
-    for (const outputPlace of ctx.outputPlaces()) {
-      ctx.output(outputPlace, result);
-    }
-  };
-}
-function fork() {
-  return transform((ctx) => {
-    const inputPlaces = ctx.inputPlaces();
-    if (inputPlaces.size !== 1) {
-      throw new Error(`Fork requires exactly 1 input place, found ${inputPlaces.size}`);
-    }
-    const inputPlace = inputPlaces.values().next().value;
-    return ctx.input(inputPlace);
-  });
-}
-function transformFrom(inputPlace, fn) {
-  return transform((ctx) => fn(ctx.input(inputPlace)));
-}
-function transformAsync(fn) {
-  return async (ctx) => {
-    const result = await fn(ctx);
-    for (const outputPlace of ctx.outputPlaces()) {
-      ctx.output(outputPlace, result);
-    }
-  };
-}
-function produce(place, value) {
-  return async (ctx) => {
-    ctx.output(place, value);
-  };
-}
-function withTimeout(action, timeoutMs, timeoutPlace2, timeoutValue) {
-  return (ctx) => {
-    return new Promise((resolve, reject) => {
-      let completed = false;
-      const timer = setTimeout(() => {
-        if (!completed) {
-          completed = true;
-          ctx.output(timeoutPlace2, timeoutValue);
-          resolve();
-        }
-      }, timeoutMs);
-      action(ctx).then(
-        () => {
-          if (!completed) {
-            completed = true;
-            clearTimeout(timer);
-            resolve();
-          }
-        },
-        (err) => {
-          if (!completed) {
-            completed = true;
-            clearTimeout(timer);
-            reject(err);
-          }
-        }
-      );
-    });
-  };
-}
-
-// 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 terminatesAtSink() {
-  return { type: "terminates-at-sink" };
-}
-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 "terminates-at-sink":
-      return "Terminates at a declared sink";
-    case "mutual-exclusion":
-      return `Mutual exclusion of ${prop.p1.name} and ${prop.p2.name}`;
-    case "place-bound":
-      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) => compareCodePoints(a.name, 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()];
-}
-function compareCodePoints(a, b) {
-  const ia = a[Symbol.iterator]();
-  const ib = b[Symbol.iterator]();
-  for (; ; ) {
-    const na = ia.next();
-    const nb = ib.next();
-    if (na.done && nb.done) return 0;
-    if (na.done) return -1;
-    if (nb.done) return 1;
-    const ca = na.value.codePointAt(0);
-    const cb = nb.value.codePointAt(0);
-    if (ca !== cb) return ca - cb;
-  }
-}
-
-// 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;
-    if (!rowIsExact(augmented[row], T, P)) {
-      invariants.push(rawInvariant(augmented[row], T, P, flatNet, initialMarking));
-      continue;
-    }
-    const weights = new Array(P);
-    let hasPositive = false;
-    let hasNegative = false;
-    for (let i = 0; i < P; i++) {
-      weights[i] = augmented[row][T + i];
-      if (weights[i] > 0) hasPositive = true;
-      if (weights[i] < 0) hasNegative = true;
-    }
-    if (!hasPositive && !hasNegative) continue;
-    if (!hasPositive) {
-      for (let i = 0; i < P; i++) weights[i] = -weights[i];
-    }
-    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 rowIsExact(row, T, P) {
-  for (let i = 0; i < P; i++) {
-    if (!Number.isSafeInteger(row[T + i])) return false;
-  }
-  return true;
-}
-function rawInvariant(row, T, P, flatNet, initialMarking) {
-  const weights = new Array(P);
-  const support = /* @__PURE__ */ new Set();
-  let constant = 0;
-  for (let i = 0; i < P; i++) {
-    weights[i] = row[T + i];
-    if (weights[i] !== 0) {
-      support.add(i);
-      constant += weights[i] * initialMarking.tokens(flatNet.places[i]);
-    }
-  }
-  return pInvariant(weights, constant, support);
-}
-function validateInvariantsExact(matrix, invariants, flatNet, initialMarking) {
-  const nonlinear = nonlinearPlaces(flatNet);
-  const valid = [];
-  const dropped = [];
-  for (const inv of invariants) {
-    const reason = exactCheckFailure(matrix, inv, nonlinear, flatNet, initialMarking);
-    if (reason === null) {
-      valid.push(inv);
-    } else {
-      dropped.push({ invariant: inv, reason });
-    }
-  }
-  return { valid, dropped };
-}
-function nonlinearPlaces(flatNet) {
-  const nonlinear = /* @__PURE__ */ new Set();
-  for (const ft of flatNet.transitions) {
-    for (let p = 0; p < ft.consumeAll.length; p++) {
-      if (ft.consumeAll[p]) nonlinear.add(p);
-    }
-    for (const p of ft.resetPlaces) nonlinear.add(p);
-  }
-  return nonlinear;
-}
-function exactCheckFailure(matrix, inv, nonlinear, flatNet, initialMarking) {
-  const P = matrix.numPlaces();
-  const T = matrix.numTransitions();
-  if (inv.weights.length !== P) {
-    return `weight vector has ${inv.weights.length} entries, expected ${P}`;
-  }
-  for (let p = 0; p < P; p++) {
-    if (!Number.isSafeInteger(inv.weights[p])) {
-      return `weight overflow at place '${placeName(flatNet, p)}' (exact value outside this implementation's integer extraction range)`;
-    }
-  }
-  if (!Number.isSafeInteger(inv.constant)) {
-    return `constant ${inv.constant} is outside the safe-integer range`;
-  }
-  for (let p = 0; p < inv.weights.length; p++) {
-    if (inv.weights[p] !== 0 && nonlinear.has(p)) {
-      return `support intersects consume-all/reset place '${placeName(flatNet, p)}' (non-linear consumption; see Strengthening.lean H1)`;
-    }
-  }
-  const y = inv.weights.map((w) => BigInt(w));
-  const incidence = matrix.incidence();
-  for (let t = 0; t < T; t++) {
-    const row = incidence[t];
-    let dot = 0n;
-    for (let p = 0; p < P; p++) {
-      if (y[p] === 0n) continue;
-      if (!Number.isSafeInteger(row[p])) {
-        return `incidence entry ${row[p]} at [t=${t}][p=${p}] is outside the safe-integer range`;
-      }
-      dot += y[p] * BigInt(row[p]);
-    }
-    if (dot !== 0n) {
-      return `y*C is ${dot} (not 0) at ${columnName(flatNet, t)}`;
-    }
-  }
-  let exact = 0n;
-  for (let p = 0; p < P; p++) {
-    if (y[p] === 0n) continue;
-    const tokens = initialMarking.tokens(flatNet.places[p]);
-    if (!Number.isSafeInteger(tokens)) {
-      return `initial marking of place ${p} (${tokens}) is outside the safe-integer range`;
-    }
-    exact += y[p] * BigInt(tokens);
-  }
-  if (exact !== BigInt(inv.constant)) {
-    return `constant ${inv.constant} does not match exact y*M0 = ${exact}`;
-  }
-  return null;
-}
-function placeName(flatNet, p) {
-  return flatNet.places[p]?.name ?? `#${p}`;
-}
-function columnName(flatNet, t) {
-  const ft = flatNet.transitions[t];
-  return ft != null ? `transition '${ft.name}'` : `env-injector column ${t - flatNet.transitions.length}`;
-}
-function sameInvariant(a, b) {
-  if (a.constant !== b.constant || a.weights.length !== b.weights.length) return false;
-  for (let i = 0; i < a.weights.length; i++) {
-    if (a.weights[i] !== b.weights[i]) return false;
-  }
-  return true;
-}
-function strengthenWithSemiflows(invariants, semiflows) {
-  const strengthened = [...invariants];
-  let added = 0;
-  for (const sf of semiflows) {
-    if (!strengthened.some((inv) => sameInvariant(inv, sf))) {
-      strengthened.push(sf);
-      added++;
-    }
-  }
-  return { invariants: strengthened, added };
-}
-function computePSemiflows(matrix, flatNet, initialMarking) {
-  const np = matrix.numPlaces();
-  const nt = matrix.numTransitions();
-  if (np === 0) return [];
-  const incidence = matrix.incidence();
-  let rows = [];
-  for (let p = 0; p < np; p++) {
-    const sig = new Array(nt);
-    for (let t = 0; t < nt; t++) sig[t] = incidence[t][p];
-    const weight = new Array(np).fill(0);
-    weight[p] = 1;
-    rows.push({ sig, weight });
-  }
-  for (let t = 0; t < nt; t++) {
-    const next = rows.filter((r) => r.sig[t] === 0);
-    const pos = rows.filter((r) => r.sig[t] > 0);
-    const neg = rows.filter((r) => r.sig[t] < 0);
-    for (const rp of pos) {
-      for (const rn of neg) {
-        const cp = -rn.sig[t];
-        const cn = rp.sig[t];
-        const sig = combineRow(cp, rp.sig, cn, rn.sig);
-        const weight = combineRow(cp, rp.weight, cn, rn.weight);
-        if (sig === null || weight === null) continue;
-        reduceGcd(sig, weight);
-        next.push({ sig, weight });
-      }
-    }
-    rows = keepSupportMinimal(next);
-    if (rows.length > 8192) rows.length = 8192;
-  }
-  const semiflows = [];
-  for (const { weight } of rows) {
-    if (!weight.some((x) => x !== 0)) continue;
-    const support = /* @__PURE__ */ new Set();
-    let constant = 0;
-    for (let p = 0; p < np; p++) {
-      if (weight[p] !== 0) {
-        support.add(p);
-        constant += weight[p] * initialMarking.tokens(flatNet.places[p]);
-      }
-    }
-    if (!Number.isSafeInteger(constant)) continue;
-    semiflows.push(pInvariant(weight, constant, support));
-  }
-  return semiflows;
-}
-function combineRow(cp, a, cn, b) {
-  const out = new Array(a.length);
-  for (let i = 0; i < a.length; i++) {
-    const v = cp * a[i] + cn * b[i];
-    if (!Number.isSafeInteger(v)) return null;
-    out[i] = v;
-  }
-  return out;
-}
-function reduceGcd(sig, weight) {
-  let g = 0;
-  for (const v of sig) g = gcd(g, Math.abs(v));
-  for (const v of weight) g = gcd(g, Math.abs(v));
-  if (g > 1) {
-    for (let i = 0; i < sig.length; i++) sig[i] = sig[i] / g;
-    for (let i = 0; i < weight.length; i++) weight[i] = weight[i] / g;
-  }
-}
-function keepSupportMinimal(rows) {
-  const supports = rows.map((r) => {
-    const s = [];
-    for (let i = 0; i < r.weight.length; i++) if (r.weight[i] !== 0) s.push(i);
-    return s;
-  });
-  const keep = new Array(rows.length).fill(true);
-  for (let i = 0; i < rows.length; i++) {
-    if (!keep[i]) continue;
-    for (let j = 0; j < rows.length; j++) {
-      if (i === j || !keep[j]) continue;
-      if (supports[j].length < supports[i].length && supports[j].every((p) => supports[i].includes(p))) {
-        keep[i] = false;
-        break;
-      }
-    }
-  }
-  return rows.filter((_, i) => keep[i]);
-}
-function isCoveredByInvariants(invariants, numPlaces) {
-  const covered = new Array(numPlaces).fill(false);
-  for (const inv of invariants) {
-    if (inv.weights.some((w) => w < 0)) continue;
-    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;
-}
-function canonicalInvariantOrder(invariants) {
-  const lex = (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;
-  };
-  const support = (inv) => [...inv.support].sort((x, y) => x - y);
-  return [...invariants].sort(
-    (a, b) => lex(support(a), support(b)) || lex(a.weights, b.weights) || a.constant - b.constant
-  );
-}
-
-// 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/z3-process.ts
-import { spawn, spawnSync } from "child_process";
-import { existsSync, mkdirSync, statSync, writeFileSync } from "fs";
-import * as path from "path";
-
-// src/verification/z3/smt-text.ts
-function classifyFirstLine(stdout) {
-  for (const raw of stdout.split("\n")) {
-    const line = raw.trim();
-    if (line === "sat" || line === "unsat" || line === "unknown") return line;
-  }
-  return null;
-}
-function timeoutLine(stdout) {
-  return stdout.split("\n").some((l) => l.trim() === "timeout");
-}
-function errorLine(text) {
-  for (const raw of text.split("\n")) {
-    const line = raw.trim();
-    if (line.startsWith("(error")) return line;
-  }
-  return null;
-}
-function sexprEnd(s, start) {
-  let depth = 0;
-  let inString = false;
-  let inSymbol = false;
-  for (let i = start; i < s.length; i++) {
-    const c = s[i];
-    if (inString) {
-      if (c === '"') inString = false;
-    } else if (inSymbol) {
-      if (c === "|") inSymbol = false;
-    } else if (c === '"') {
-      inString = true;
-    } else if (c === "|") {
-      inSymbol = true;
-    } else if (c === "(") {
-      depth++;
-    } else if (c === ")") {
-      depth--;
-      if (depth === 0) return i + 1;
-    }
-  }
-  return -1;
-}
-function extractDefineFuns(output) {
-  const defs = [];
-  let from = 0;
-  for (; ; ) {
-    const pos = output.indexOf("(define-fun", from);
-    if (pos < 0) break;
-    const end = sexprEnd(output, pos);
-    if (end < 0) break;
-    defs.push(output.slice(pos, end));
-    from = end;
-  }
-  return defs;
-}
-function extractInvariant(output) {
-  const defs = extractDefineFuns(output);
-  return defs.length === 0 ? null : defs.join("\n");
-}
-
-// src/verification/z3/z3-process.ts
-var Z3_ENV = "LIBPETRI_Z3";
-var DUMP_ENV = "LIBPETRI_SMT_DUMP";
-var GRACE_MS = 1e3;
-var VERSION_PROBE_MS = 5e3;
-var MIN_Z3_VERSION = { major: 4, minor: 8, patch: 0 };
-function parseZ3Version(text) {
-  const m = /Z3 version (\d+)\.(\d+)(?:\.(\d+))?/.exec(text);
-  if (m == null) return null;
-  return { major: Number(m[1]), minor: Number(m[2]), patch: m[3] == null ? 0 : Number(m[3]) };
-}
-function formatZ3Version(v) {
-  return `${v.major}.${v.minor}.${v.patch}`;
-}
-function compareZ3Version(a, b) {
-  return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
-}
-var Z3Unavailable = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "Z3Unavailable";
-  }
-};
-var Z3ProcessError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "Z3ProcessError";
-  }
-};
-function replySucceeded(reply) {
-  return reply.exit.kind === "exited" && reply.exit.code === 0;
-}
-function argsFor(timeoutMs) {
-  return ["-smt2", "-in", `-t:${timeoutMs}`, `-T:${hardTimeoutSecs(timeoutMs)}`];
-}
-function hardTimeoutSecs(timeoutMs) {
-  return Math.max(1, Math.ceil((timeoutMs + GRACE_MS) / 1e3));
-}
-function watchdogMs(timeoutMs) {
-  return timeoutMs + 2 * GRACE_MS;
-}
-function timeoutBudget(timeoutMs) {
-  return Math.max(1, Math.floor(Number.isFinite(timeoutMs) ? timeoutMs : 1));
-}
-function failureReason(reply, timeoutMs) {
-  if (timeoutLine(reply.stdout)) {
-    return `z3 hard timeout after ${hardTimeoutSecs(timeoutMs)}s`;
-  }
-  if (reply.exit.kind === "killed") {
-    return `z3 did not exit within ${watchdogMs(timeoutMs)} ms and was killed`;
-  }
-  const err = errorLine(reply.stdout) ?? errorLine(reply.stderr);
-  if (err != null) return `Z3 error: ${err}`;
-  const stderr = reply.stderr.trim();
-  if (stderr !== "") return `Z3 error: ${stderr}`;
-  return `Unexpected Z3 output: ${reply.stdout.trim()}`;
-}
-function locateZ3(program, env = process.env) {
-  const isFile = (p) => {
-    try {
-      return existsSync(p) && statSync(p).isFile();
-    } catch {
-      return false;
-    }
-  };
-  if (program.includes("/") || program.includes(path.sep) || path.isAbsolute(program)) {
-    return isFile(program) ? program : null;
-  }
-  const searchPath = env["PATH"] ?? "";
-  const windows = process.platform === "win32";
-  for (const dir of searchPath.split(path.delimiter)) {
-    if (dir === "") continue;
-    const candidate2 = path.join(dir, program);
-    if (isFile(candidate2)) return candidate2;
-    if (windows && isFile(candidate2 + ".exe")) return candidate2 + ".exe";
-  }
-  return null;
-}
-function z3SolverAt(program, env = process.env) {
-  const located = locateZ3(program, env);
-  if (located == null) {
-    throw new Z3Unavailable(
-      `z3 binary not found: ${program}; install z3 >= ${formatZ3Version(MIN_Z3_VERSION)} or set ${Z3_ENV}`
-    );
-  }
-  const probe = spawnSync(located, ["--version"], {
-    encoding: "utf8",
-    timeout: VERSION_PROBE_MS,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (probe.error != null) {
-    if (probe.error.code === "ETIMEDOUT") {
-      throw new Z3Unavailable(`${program} --version did not answer within ${VERSION_PROBE_MS} ms`);
-    }
-    throw new Z3Unavailable(`failed to spawn ${program}: ${probe.error.message}`);
-  }
-  const version = parseZ3Version(probe.stdout ?? "");
-  if (version == null) {
-    const line = `${probe.stdout ?? ""}
-${probe.stderr ?? ""}`.split("\n").map((l) => l.trim()).find((l) => l !== "") ?? "";
-    throw new Z3Unavailable(`z3 --version did not report a version: ${line}`);
-  }
-  if (compareZ3Version(version, MIN_Z3_VERSION) < 0) {
-    throw new Z3Unavailable(
-      `z3 ${formatZ3Version(version)} is older than the minimum ${formatZ3Version(MIN_Z3_VERSION)}`
-    );
-  }
-  return { program: located, version, dumpDir: null };
-}
-function resolveZ3(env = process.env) {
-  const configured = env[Z3_ENV];
-  const program = configured == null || configured.trim() === "" ? "z3" : configured;
-  const dump = env[DUMP_ENV];
-  const solver = z3SolverAt(program, env);
-  return { ...solver, dumpDir: dump == null || dump.trim() === "" ? null : dump };
-}
-function z3Available(env = process.env) {
-  try {
-    resolveZ3(env);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var dumpCounter = 0;
-function dumpSlot(solver, phase, script2) {
-  if (solver.dumpDir == null) return null;
-  dumpCounter += 1;
-  try {
-    mkdirSync(solver.dumpDir, { recursive: true });
-    const base = path.join(solver.dumpDir, `${String(dumpCounter).padStart(3, "0")}-${phase}`);
-    writeFileSync(`${base}.smt2`, script2);
-    return base;
-  } catch {
-    return null;
-  }
-}
-function dumpWrite(file, text) {
-  try {
-    writeFileSync(file, text);
-  } catch {
-  }
-}
-function runZ3Text(solver, script2, phase, timeoutMs, extraArgs = []) {
-  const budget = timeoutBudget(timeoutMs);
-  const base = dumpSlot(solver, phase, script2);
-  return new Promise((resolve, reject) => {
-    const child = spawn(solver.program, [...argsFor(budget), ...extraArgs], {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const out = [];
-    const err = [];
-    let killed = false;
-    let settled = false;
-    child.stdout.on("data", (chunk) => out.push(chunk));
-    child.stderr.on("data", (chunk) => err.push(chunk));
-    child.stdin.on("error", () => {
-    });
-    const watchdog = setTimeout(() => {
-      killed = true;
-      child.kill("SIGKILL");
-    }, watchdogMs(budget));
-    child.on("error", (e) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(watchdog);
-      reject(new Z3ProcessError(`failed to spawn ${solver.program}: ${e.message}`));
-    });
-    child.on("close", (code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(watchdog);
-      const reply = {
-        stdout: Buffer.concat(out).toString("utf8"),
-        stderr: Buffer.concat(err).toString("utf8"),
-        exit: killed ? { kind: "killed" } : { kind: "exited", code }
-      };
-      if (base != null) {
-        dumpWrite(`${base}.out`, reply.stdout);
-        if (reply.stderr.trim() !== "") dumpWrite(`${base}.err`, reply.stderr);
-      }
-      resolve(reply);
-    });
-    child.stdin.end(script2);
-  });
-}
-
-// src/verification/z3/spacer-runner.ts
-async function runZ3Spacer(solver, timeoutMs, smt2, phase) {
-  let reply;
-  try {
-    reply = await runZ3Text(solver, smt2, phase, timeoutMs, ["fp.engine=spacer"]);
-  } catch (e) {
-    return { type: "unknown", reason: String(e?.message ?? e) };
-  }
-  const stdout = reply.stdout.trim();
-  switch (classifyFirstLine(stdout)) {
-    // unsat => no inductive invariant excludes the bad state => VIOLATED.
-    case "unsat":
-      return { type: "violated", answer: stdout };
-    // sat => an inductive invariant exists => PROVEN.
-    case "sat":
-      return { type: "proven", invariantFormula: extractInvariant(stdout) };
-    case "unknown":
-      return { type: "unknown", reason: "Z3 answered unknown" };
-    default:
-      return { type: "unknown", reason: failureReason(reply, timeoutBudget(timeoutMs)) };
-  }
-}
-
-// src/verification/z3/smt-encoder.ts
-function encode(flatNet, initialMarking, property, invariants, sinkPlaces = /* @__PURE__ */ new Set(), produceProofs = false) {
-  const P = flatNet.places.length;
-  const lines = [];
-  const envInject = resolveEnvInjection(flatNet);
-  if (produceProofs) lines.push("(set-option :produce-proofs true)");
-  lines.push("(set-logic HORN)");
-  lines.push("");
-  lines.push(`(declare-fun Reachable (${ints(P).join(" ")}) Bool)`);
-  lines.push("(declare-fun Error () Bool)");
-  lines.push("");
-  const mVars = vars(P, "");
-  const mpVars = vars(P, "p");
-  const m0 = [];
-  for (let i = 0; i < P; i++) m0.push(String(initialMarking.tokens(flatNet.places[i])));
-  lines.push(`(assert (Reachable ${m0.join(" ")}))`);
-  lines.push("");
-  for (const ft of flatNet.transitions) {
-    lines.push(encodeTransitionRule(flatNet, ft, mVars, mpVars, invariants));
-  }
-  for (const inj of envInject) {
-    lines.push(encodeInjectionRule(P, inj.pid, inj.bound, mVars, mpVars));
-  }
-  lines.push("");
-  lines.push(encodeErrorRule(flatNet, property, mVars, sinkPlaces, envInject));
-  lines.push("");
-  lines.push("(assert (not Error))");
-  lines.push("(check-sat)");
-  if (produceProofs) lines.push("(get-proof)");
-  lines.push("(get-model)");
-  return { smt2: lines.join("\n"), placeCount: P };
-}
-function resolveEnvInjection(flatNet) {
-  const out = [];
-  for (const [name, bound] of flatNet.environmentInjection) {
-    const pid = flatNet.placeIndex.get(name);
-    if (pid != null) out.push({ pid, bound });
-  }
-  out.sort((a, b) => a.pid - b.pid);
-  return out;
-}
-function envBounds(flatNet) {
-  const out = [];
-  for (const [name, max] of flatNet.environmentBounds) {
-    const pid = flatNet.placeIndex.get(name);
-    if (pid != null) out.push([pid, max]);
-  }
-  out.sort((a, b) => a[0] - b[0]);
-  return out;
-}
-function ints(n) {
-  return new Array(n).fill("Int");
-}
-function vars(P, suffix) {
-  const out = [];
-  for (let i = 0; i < P; i++) out.push(`m${i}${suffix}`);
-  return out;
-}
-function quantified(names) {
-  return names.map((v) => `(${v} Int)`).join(" ");
-}
-function firingConditions(flatNet, ft, mVars, mpVars) {
-  const P = flatNet.places.length;
-  const conditions = [];
-  for (let i = 0; i < P; i++) {
-    if (ft.preVector[i] > 0) conditions.push(`(>= ${mVars[i]} ${ft.preVector[i]})`);
-  }
-  for (const inh of ft.inhibitorPlaces) conditions.push(`(= ${mVars[inh]} 0)`);
-  for (const rd of ft.readPlaces) conditions.push(`(>= ${mVars[rd]} 1)`);
-  for (let i = 0; i < P; i++) {
-    if (ft.resetPlaces.includes(i) || ft.consumeAll[i]) {
-      conditions.push(`(= ${mpVars[i]} ${ft.postVector[i]})`);
-    } else {
-      const delta = ft.postVector[i] - ft.preVector[i];
-      if (delta > 0) conditions.push(`(= ${mpVars[i]} (+ ${mVars[i]} ${delta}))`);
-      else if (delta < 0) conditions.push(`(= ${mpVars[i]} (- ${mVars[i]} ${-delta}))`);
-      else conditions.push(`(= ${mpVars[i]} ${mVars[i]})`);
-    }
-  }
-  for (let i = 0; i < P; i++) conditions.push(`(>= ${mpVars[i]} 0)`);
-  return conditions;
-}
-function invariantConditions(invariants, names) {
-  const conditions = [];
-  for (const inv of invariants) {
-    const terms = [...inv.support].sort((a, b) => a - b).map((i) => `(* ${inv.weights[i]} ${names[i]})`);
-    if (terms.length === 0) continue;
-    const sum = terms.length === 1 ? terms[0] : `(+ ${terms.join(" ")})`;
-    conditions.push(`(= ${sum} ${inv.constant})`);
-  }
-  return conditions;
-}
-function envBoundConditions(flatNet, mpVars) {
-  return envBounds(flatNet).map(([pid, max]) => `(<= ${mpVars[pid]} ${max})`);
-}
-function injectionConditions(P, pid, bound, mVars, mpVars) {
-  const conditions = [];
-  if (bound != null) conditions.push(`(< ${mVars[pid]} ${bound})`);
-  for (let i = 0; i < P; i++) {
-    if (i === pid) conditions.push(`(= ${mpVars[i]} (+ ${mVars[i]} 1))`);
-    else conditions.push(`(= ${mpVars[i]} ${mVars[i]})`);
-  }
-  return conditions;
-}
-function encodeTransitionRule(flatNet, ft, mVars, mpVars, invariants) {
-  const conditions = [`(Reachable ${mVars.join(" ")})`];
-  conditions.push(...firingConditions(flatNet, ft, mVars, mpVars));
-  conditions.push(...invariantConditions(invariants, mpVars));
-  conditions.push(...envBoundConditions(flatNet, mpVars));
-  const body = `(and ${conditions.join("\n            ")})`;
-  return `(assert (forall (${quantified([...mVars, ...mpVars])})
-  (=> ${body}
-      (Reachable ${mpVars.join(" ")}))))`;
-}
-function encodeInjectionRule(P, pid, bound, mVars, mpVars) {
-  const conditions = [`(Reachable ${mVars.join(" ")})`];
-  conditions.push(...injectionConditions(P, pid, bound, mVars, mpVars));
-  const body = `(and ${conditions.join("\n            ")})`;
-  return `(assert (forall (${quantified([...mVars, ...mpVars])})
-  (=> ${body}
-      (Reachable ${mpVars.join(" ")}))))`;
-}
-function conjoin(conditions) {
-  if (conditions.length === 0) return "true";
-  if (conditions.length === 1) return conditions[0];
-  return `(and ${conditions.join(" ")})`;
-}
-function encodeStepRelationSmt2(flatNet) {
-  const P = flatNet.places.length;
-  const mVars = vars(P, "");
-  const mpVars = vars(P, "p");
-  const disjuncts = [];
-  for (const ft of flatNet.transitions) {
-    const conditions = firingConditions(flatNet, ft, mVars, mpVars);
-    conditions.push(...envBoundConditions(flatNet, mpVars));
-    disjuncts.push(conjoin(conditions));
-  }
-  for (const inj of resolveEnvInjection(flatNet)) {
-    disjuncts.push(conjoin(injectionConditions(P, inj.pid, inj.bound, mVars, mpVars)));
-  }
-  if (disjuncts.length === 0) return "false";
-  if (disjuncts.length === 1) return disjuncts[0];
-  return `(or ${disjuncts.join("\n    ")})`;
-}
-function encodeErrorRule(flatNet, property, mVars, sinkPlaces, envInject) {
-  const violation = encodePropertyViolation(flatNet, property, mVars, sinkPlaces, envInject);
-  return `(assert (forall (${quantified(mVars)})
-  (=> (and (Reachable ${mVars.join(" ")}) ${violation})
-      Error)))`;
-}
-function indexOrdered(flatNet, places) {
-  const idx = /* @__PURE__ */ new Set();
-  for (const place of places) {
-    const i = flatNet.placeIndex.get(place.name);
-    if (i != null) idx.add(i);
-  }
-  return [...idx].sort((a, b) => a - b);
-}
-function encodePropertyViolation(flatNet, property, mVars, sinkPlaces, envInject) {
-  switch (property.type) {
-    // DeadlockFree (VER-002): a quiescent marking that STRANDS a token — holds one
-    // in a place that is not a declared sink. The empty marking strands nothing and
-    // is therefore not a violation (AC4).
-    case "deadlock-free": {
-      const conditions = encodeQuiescent(flatNet, mVars, envInject);
-      if (conditions == null) return "false";
-      const sinks = new Set(indexOrdered(flatNet, sinkPlaces));
-      const stranded = [];
-      for (let pid = 0; pid < flatNet.places.length; pid++) {
-        if (!sinks.has(pid)) stranded.push(`(>= ${mVars[pid]} 1)`);
-      }
-      if (stranded.length === 0) return "false";
-      conditions.push(`(or ${stranded.join(" ")})`);
-      return joinConditions(conditions);
-    }
-    // TerminatesAtSink (VER-002): a quiescent marking that reached NO declared sink.
-    // This is the predicate DeadlockFree carried before the VER-002 split, unchanged.
-    case "terminates-at-sink": {
-      const conditions = encodeQuiescent(flatNet, mVars, envInject);
-      if (conditions == null) return "false";
-      for (const pid of indexOrdered(flatNet, sinkPlaces)) {
-        conditions.push(`(= ${mVars[pid]} 0)`);
-      }
-      return joinConditions(conditions);
-    }
-    case "mutual-exclusion": {
-      const conditions = indexOrdered(flatNet, [property.p1, property.p2]).map((i) => `(>= ${mVars[i]} 1)`);
-      return conditions.length === 0 ? "false" : `(and ${conditions.join(" ")})`;
-    }
-    case "place-bound":
-    case "branch-place-bound": {
-      const pid = flatNet.placeIndex.get(property.place.name);
-      return pid == null ? "false" : `(> ${mVars[pid]} ${property.bound})`;
-    }
-    case "unreachable": {
-      const conditions = indexOrdered(flatNet, property.places).map((i) => `(>= ${mVars[i]} 1)`);
-      return conditions.length === 0 ? "false" : `(and ${conditions.join(" ")})`;
-    }
-    // JoinedOrDeadLettered (NU-040 AC4): a quiescent state that still holds a
-    // `pending` token is a stranded correlation group. Carries NO sink clause — a
-    // declared sink must not excuse a stranded group.
-    case "joined-or-dead-lettered": {
-      const pid = flatNet.placeIndex.get(property.pending.name);
-      if (pid == null) return "false";
-      const conditions = encodeQuiescent(flatNet, mVars, envInject);
-      if (conditions == null) return "false";
-      conditions.push(`(>= ${mVars[pid]} 1)`);
-      return joinConditions(conditions);
-    }
-  }
-}
-function joinConditions(conditions) {
-  return conditions.length === 0 ? "true" : `(and ${conditions.join("\n         ")})`;
-}
-function encodeQuiescent(flatNet, mVars, envInject) {
-  const envBound = /* @__PURE__ */ new Map();
-  for (const inj of envInject) envBound.set(inj.pid, inj.bound);
-  const disabledConditions = [];
-  for (const ft of flatNet.transitions) {
-    const disableReasons = [];
-    let permanentlyDisabled = false;
-    for (let i = 0; i < flatNet.places.length; i++) {
-      if (ft.preVector[i] > 0) {
-        if (envBound.has(i)) {
-          const k = envBound.get(i);
-          if (k != null && ft.preVector[i] > k) permanentlyDisabled = true;
-          continue;
-        }
-        disableReasons.push(`(< ${mVars[i]} ${ft.preVector[i]})`);
-      }
-    }
-    for (const inh of ft.inhibitorPlaces) disableReasons.push(`(> ${mVars[inh]} 0)`);
-    for (const rd of ft.readPlaces) {
-      if (envBound.has(rd)) {
-        const k = envBound.get(rd);
-        if (k != null && k < 1) permanentlyDisabled = true;
-        continue;
-      }
-      disableReasons.push(`(< ${mVars[rd]} 1)`);
-    }
-    if (permanentlyDisabled) {
-      disabledConditions.push("true");
-      continue;
-    }
-    if (disableReasons.length === 0) return null;
-    disabledConditions.push(`(or ${disableReasons.join(" ")})`);
-  }
-  return disabledConditions;
-}
-function injectionMap(flatNet) {
-  const out = /* @__PURE__ */ new Map();
-  for (const inj of resolveEnvInjection(flatNet)) out.set(inj.pid, inj.bound);
-  return out;
-}
-
-// src/verification/z3/certificate-checker.ts
-var VC_LABELS = ["initiation (VC1)", "consecution (VC2)", "safety (VC3)"];
-async function checkCertificate(certificate, flatNet, initialMarking, property, invariants, sinkPlaces, solver, timeoutMs) {
-  if (certificate == null) {
-    return {
-      type: "unavailable",
-      reason: "no inductive invariant (define-fun block) could be extracted from the z3 model",
-      invariant: null
-    };
-  }
-  const shape = shapeFailure(flatNet, invariants);
-  if (shape != null) return { type: "unavailable", reason: shape, invariant: certificate };
-  if (!certificate.includes("(define-fun Reachable ") && !certificate.includes("(define-fun |Reachable| ")) {
-    return { type: "unavailable", reason: "certificate does not define Reachable", invariant: certificate };
-  }
-  const vcs = buildVerificationConditions(certificate, flatNet, initialMarking, property, sinkPlaces, invariants);
-  let results;
-  try {
-    results = await runVcScript(script(vcs), timeoutMs, solver);
-  } catch (e) {
-    return { type: "unavailable", reason: String(e?.message ?? e), invariant: certificate };
-  }
-  for (let i = 0; i < results.length; i++) {
-    if (results[i] !== "unsat") {
-      const detail = await detailFor(vcs, i, results[i], flatNet, timeoutMs, solver);
-      return { type: "failed", vc: VC_LABELS[i], detail, invariant: certificate };
-    }
-  }
-  return { type: "passed", invariant: certificate };
-}
-function vcScript(certificate, flatNet, initialMarking, property, sinkPlaces, invariants) {
-  return script(buildVerificationConditions(certificate, flatNet, initialMarking, property, sinkPlaces, invariants));
-}
-function shapeFailure(flatNet, invariants) {
-  const P = flatNet.places.length;
-  for (const inv of invariants) {
-    if (inv.weights.length !== P) {
-      return `P-invariant has ${inv.weights.length} weights for a ${P}-place net`;
-    }
-    for (const pid of inv.support) {
-      if (pid >= P || pid < 0) return `P-invariant support names place index ${pid} in a ${P}-place net`;
-    }
-  }
-  return null;
-}
-var VcFailure = class extends Error {
-};
-async function runVcScript(text, timeoutMs, solver) {
-  const reply = await runZ3Text(solver, text, "certificate", timeoutMs, []);
-  const budget = timeoutBudget(timeoutMs);
-  const err = errorLine(reply.stderr);
-  if (err != null) throw new VcFailure(`z3 reported an error on stderr: ${err}`);
-  if (timeoutLine(reply.stdout)) {
-    throw new VcFailure(`z3 hard timeout after ${hardTimeoutSecs(budget)}s while checking the certificate`);
-  }
-  if (reply.exit.kind === "killed") {
-    throw new VcFailure(`z3 did not exit within ${watchdogMs(budget)} ms while checking the certificate and was killed`);
-  }
-  const results = parseVcResults(reply.stdout);
-  if (!replySucceeded(reply)) {
-    const status = reply.exit.kind === "exited" ? `exit status: ${reply.exit.code}` : "the watchdog kill";
-    throw new VcFailure(`z3 exited with ${status} after answering [${results.join(", ")}]`);
-  }
-  return results;
-}
-function parseVcResults(stdout) {
-  const err = errorLine(stdout);
-  if (err != null) throw new VcFailure(`z3 error while checking the certificate: ${err}`);
-  if (timeoutLine(stdout)) throw new VcFailure("z3 hard timeout while checking the certificate");
-  const results = stdout.split("\n").map((l) => l.trim()).filter((l) => l === "sat" || l === "unsat" || l === "unknown");
-  if (results.length !== 3) {
-    throw new VcFailure(`expected 3 VC answers from z3, got ${results.length}: [${results.join(", ")}]`);
-  }
-  return results;
-}
-function buildVerificationConditions(certificate, flatNet, initialMarking, property, sinkPlaces, invariants) {
-  const P = flatNet.places.length;
-  const mVars = [];
-  const mpVars = [];
-  for (let i = 0; i < P; i++) {
-    mVars.push(`m${i}`);
-    mpVars.push(`m${i}p`);
-  }
-  const prelude = [
-    "; IC3/PDR certificate check (plain SMT-LIB2, not HORN):",
-    "; each VC below must be unsat for the certificate to stand.",
-    certificate,
-    ""
-  ];
-  for (const v of mVars) prelude.push(`(declare-const ${v} Int)`);
-  for (const v of mpVars) prelude.push(`(declare-const ${v} Int)`);
-  const m0 = [];
-  for (let i = 0; i < P; i++) m0.push(String(initialMarking.tokens(flatNet.places[i])));
-  const vc1 = [`(assert (not ${candidate(m0, invariants)}))`];
-  const nonNegative = mVars.map((v) => `(assert (>= ${v} 0))`);
-  const step = encodeStepRelationSmt2(flatNet);
-  const vc2 = [
-    ...nonNegative,
-    `(assert ${candidate(mVars, invariants)})`,
-    `(assert ${step})`,
-    `(assert (not ${candidate(mpVars, invariants)}))`
-  ];
-  const bad = encodePropertyViolation(flatNet, property, mVars, sinkPlaces, resolveEnvInjection(flatNet));
-  const vc3 = [...nonNegative, `(assert ${candidate(mVars, invariants)})`, `(assert ${bad})`];
-  return { prelude, asserts: [vc1, vc2, vc3] };
-}
-function script(vcs) {
-  const lines = [...vcs.prelude];
-  for (let i = 0; i < vcs.asserts.length; i++) {
-    lines.push("");
-    lines.push(`; VC${i + 1} ${VC_LABELS[i]}`);
-    lines.push("(push)");
-    lines.push(...vcs.asserts[i]);
-    lines.push("(check-sat)");
-    lines.push("(pop)");
-  }
-  return lines.join("\n");
-}
-async function detailFor(vcs, i, answer, flatNet, timeoutMs, solver) {
-  const lines = ["(set-option :produce-models true)", ...vcs.prelude, ...vcs.asserts[i], "(check-sat)"];
-  lines.push(answer === "sat" ? "(get-model)" : "(get-info :reason-unknown)");
-  let reply = "";
-  try {
-    reply = (await runZ3Text(solver, lines.join("\n"), "certificate-detail", timeoutMs, [])).stdout;
-  } catch {
-    reply = "";
-  }
-  if (answer === "sat") {
-    const w = witness(reply, flatNet);
-    return w == null ? "solver returned SATISFIABLE" : `solver returned SATISFIABLE (witness: ${w})`;
-  }
-  const r = reasonUnknown(reply);
-  return r == null ? "solver returned UNKNOWN" : `solver returned UNKNOWN (${r})`;
-}
-function witness(model, flatNet) {
-  const parts = [];
-  for (let i = 0; i < flatNet.places.length; i++) {
-    const needle = `(define-fun m${i} () Int`;
-    const at = model.indexOf(needle);
-    if (at < 0) continue;
-    const rest = model.slice(at + needle.length).trimStart();
-    let value;
-    if (rest.startsWith("(")) {
-      const end = sexprEnd(rest, 0);
-      if (end < 0) continue;
-      value = rest.slice(1, end - 1).trim().split(/\s+/).join("");
-    } else {
-      let end = 0;
-      while (end < rest.length && !/\s/.test(rest[end]) && rest[end] !== ")") end++;
-      if (end === 0) continue;
-      value = rest.slice(0, end);
-    }
-    parts.push(`${flatNet.places[i].name}=${value}`);
-  }
-  return parts.length === 0 ? null : parts.join(", ");
-}
-function reasonUnknown(reply) {
-  const at = reply.indexOf(":reason-unknown");
-  if (at < 0) return null;
-  const rest = reply.slice(at + ":reason-unknown".length).trimStart();
-  const end = rest.indexOf(")");
-  if (end < 0) return null;
-  let reason = rest.slice(0, end).trim();
-  if (reason.startsWith('"') && reason.endsWith('"') && reason.length >= 2) reason = reason.slice(1, -1);
-  reason = reason.trim();
-  return reason === "" ? null : reason;
-}
-function candidate(names, invariants) {
-  return conjoin([`(Reachable ${names.join(" ")})`, ...invariantConditions(invariants, names)]);
-}
-
-// 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;
-  /**
-   * Class-relative earliest-ready time (seconds) of each enabled transition,
-   * parallel to `enabledTransitions`. Captured from the firing-domain DBM
-   * (`getLowerBound(k)`) *before* `letTimePass()` zeroes the lower bounds, i.e.
-   * the minimum time from class entry at which clock `k` may fire.
-   *
-   * Purely additive: base timed-reachability (marking + DBM zone, `equals`,
-   * `classKey`) ignores it. Read only by the ν conflict-priority prune (NU-052,
-   * `priorityDominated`), where comparing `readyEarliest[H] <= readyEarliest[L]`
-   * decides whether the strictly higher-priority `H` becomes ready no later than
-   * `L` and so pre-empts it.
-   */
-  readyEarliest;
-  constructor(marking, firingDomain, enabledTransitions, readyEarliest) {
-    this.marking = marking;
-    this.firingDomain = firingDomain;
-    this.enabledTransitions = [...enabledTransitions];
-    this.readyEarliest = [...readyEarliest];
-  }
-  isEmpty() {
-    return this.firingDomain.isEmpty();
-  }
-  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/core/internal/output-action-check.ts
-function requireOutputProducingActions(net) {
-  for (const t of net.transitions) {
-    if (t.outputSpec !== null && isPassthrough(t.action)) {
-      throw new Error(
-        `Transition '${t.name}' declares an output spec but carries passthrough(), which produces no tokens. Every firing would fail output validation (IO-015) and the declared output would never arrive. Bind an action that produces it \u2014 fork() moves the input token across \u2014 or drop the output spec if the transition is meant to be a sink.`
-      );
-    }
-  }
-}
-
-// 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.
-   *
-   * @throws Error if the net violates CORE-043 — analysis rejects the same nets execution rejects.
-   */
-  static build(net, initialMarking, maxClasses, environmentPlaces, environmentMode) {
-    requireOutputProducingActions(net);
-    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);
-  const baseDBM = DBM.create(clockNames, lowerBounds, upperBounds);
-  const readyEarliest = enabledTransitions.map((_, k) => baseDBM.getLowerBound(k));
-  const initialDBM = baseDBM.letTimePass();
-  return new StateClass(initialMarking, initialDBM, enabledTransitions, readyEarliest);
-}
-function expandTransition(t) {
-  let branches;
-  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);
-  const firedDBM = current.firingDomain.fireTransition(
-    firedIdx,
-    newClockNames,
-    newLowerBounds,
-    newUpperBounds,
-    persistentIndices
-  );
-  const allEnabled = [...persistent, ...newlyEnabled];
-  const readyEarliest = allEnabled.map((_, k) => firedDBM.getLowerBound(k));
-  const newDBM = firedDBM.letTimePass();
-  return new StateClass(newMarking, newDBM, allEnabled, readyEarliest);
-}
-function findEnabledTransitions(net, marking, environmentPlaces, environmentMode) {
-  const enabled = [];
-  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, available) {
-  return consumptionCount(spec, available);
-}
-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 available = marking.tokens(spec.place);
-    if (available < inputRequiredCount(spec)) {
-      continue;
-    }
-    const toConsume = inputConsumeCount(spec, available);
-    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(answer, flatNet) {
-  const states = decodeStateSet(answer, flatNet);
-  return { states, note: states.size === 0 ? "no ground Reachable states in the z3 proof" : null };
-}
-function decodeStateSet(answer, flatNet) {
-  const byKey = /* @__PURE__ */ new Map();
-  const P = flatNet.places.length;
-  for (const head of ["(Reachable", "(|Reachable|"]) {
-    let from = 0;
-    for (; ; ) {
-      const start = answer.indexOf(head, from);
-      if (start < 0) break;
-      from = start + head.length;
-      if (head === "(Reachable") {
-        const next = answer[from];
-        if (next == null || !(/\s/.test(next) || next === ")")) continue;
-      }
-      const end = sexprEnd(answer, start);
-      if (end < 0) break;
-      const inner = answer.slice(start + head.length, end - 1);
-      const args = parseGroundIntArgs(inner);
-      if (args != null && args.length === P) {
-        const marking = toMarking(args, flatNet);
-        const key = marking.toString();
-        if (!byKey.has(key)) byKey.set(key, marking);
-      }
-    }
-  }
-  return new Set(byKey.values());
-}
-function toMarking(args, flatNet) {
-  const builder = MarkingState.builder();
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] > 0) builder.tokens(flatNet.places[i], args[i]);
-  }
-  return builder.build();
-}
-function parseGroundIntArgs(inner) {
-  const args = [];
-  let rest = inner.trimStart();
-  while (rest !== "") {
-    if (rest.startsWith("(")) {
-      const stripped = rest.slice(1);
-      const close = stripped.indexOf(")");
-      if (close < 0) return null;
-      const body = stripped.slice(0, close);
-      if (body.includes("(")) return null;
-      const trimmed = body.trim();
-      if (!trimmed.startsWith("-")) return null;
-      const n = parseInt64(trimmed.slice(1).trim());
-      if (n == null) return null;
-      args.push(-n);
-      rest = stripped.slice(close + 1).trimStart();
-    } else {
-      let tokenEnd = rest.length;
-      for (let i = 0; i < rest.length; i++) {
-        const c = rest[i];
-        if (/\s/.test(c) || c === "(" || c === ")") {
-          tokenEnd = i;
-          break;
-        }
-      }
-      const n = parseInt64(rest.slice(0, tokenEnd));
-      if (n == null) return null;
-      args.push(n);
-      rest = rest.slice(tokenEnd).trimStart();
-    }
-  }
-  return args;
-}
-function parseInt64(token) {
-  return /^-?\d+$/.test(token) ? Number(token) : null;
-}
-
-// 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/abstract-replayer.ts
-function stepName(step) {
-  return step.kind === "fire" ? step.transition : `inject(${step.place})`;
-}
-function stateKey(state) {
-  return state.join(",");
-}
-function vectorize(marking, flatNet) {
-  return flatNet.places.map((p) => marking.tokens(p));
-}
-function toMarkingState(state, flatNet) {
-  const builder = MarkingState.builder();
-  for (let i = 0; i < flatNet.places.length; i++) {
-    if (state[i] > 0) builder.tokens(flatNet.places[i], state[i]);
-  }
-  return builder.build();
-}
-function enabledA(state, ft) {
-  const P = state.length;
-  for (let p = 0; p < P; p++) {
-    if (ft.preVector[p] > 0 && state[p] < ft.preVector[p]) return false;
-  }
-  for (const p of ft.readPlaces) {
-    if (state[p] < 1) return false;
-  }
-  for (const p of ft.inhibitorPlaces) {
-    if (state[p] !== 0) return false;
-  }
-  return true;
-}
-function fireIndexed(state, ft, resets) {
-  const P = state.length;
-  const next = new Array(P);
-  for (let p = 0; p < P; p++) {
-    if (resets.has(p) || ft.consumeAll[p]) {
-      next[p] = ft.postVector[p];
-    } else {
-      next[p] = state[p] - ft.preVector[p] + ft.postVector[p];
-    }
-  }
-  return next;
-}
-function injectA(state, idx) {
-  const next = [...state];
-  next[idx] = next[idx] + 1;
-  return next;
-}
-function buildIndex(flatNet) {
-  const resetSets = flatNet.transitions.map((ft) => new Set(ft.resetPlaces));
-  const envInj = /* @__PURE__ */ new Map();
-  for (const [name, bound] of flatNet.environmentInjection) {
-    const idx = flatNet.placeIndex.get(name);
-    if (idx != null) envInj.set(idx, bound);
-  }
-  const envCaps = [];
-  for (const [name, cap] of flatNet.environmentBounds) {
-    const idx = flatNet.placeIndex.get(name);
-    if (idx != null) envCaps.push([idx, cap]);
-  }
-  return { flatNet, resetSets, envInj, envCaps };
-}
-function withinEnvBounds(index, state) {
-  for (const [idx, cap] of index.envCaps) {
-    if (state[idx] > cap) return false;
-  }
-  return true;
-}
-function successorsIndexed(index, state) {
-  const out = [];
-  const transitions = index.flatNet.transitions;
-  for (let t = 0; t < transitions.length; t++) {
-    const ft = transitions[t];
-    if (!enabledA(state, ft)) continue;
-    const next = fireIndexed(state, ft, index.resetSets[t]);
-    if (!withinEnvBounds(index, next)) continue;
-    out.push({ state: next, step: { kind: "fire", transition: ft.name } });
-  }
-  for (const [name, bound] of index.flatNet.environmentInjection) {
-    const idx = index.flatNet.placeIndex.get(name);
-    if (idx == null) continue;
-    if (bound === null || state[idx] < bound) {
-      out.push({ state: injectA(state, idx), step: { kind: "inject", place: name } });
-    }
-  }
-  return out;
-}
-function enabledRelaxEnv(state, ft, envInj) {
-  const P = state.length;
-  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 false;
-      continue;
-    }
-    if (state[p] < pre) return false;
-  }
-  for (const p of ft.readPlaces) {
-    if (envInj.has(p)) {
-      const bound = envInj.get(p);
-      if (bound !== null && bound < 1) return false;
-      continue;
-    }
-    if (state[p] < 1) return false;
-  }
-  for (const p of ft.inhibitorPlaces) {
-    if (state[p] !== 0) return false;
-  }
-  return true;
-}
-function isQuiescent(index, state) {
-  for (const ft of index.flatNet.transitions) {
-    if (enabledRelaxEnv(state, ft, index.envInj)) return false;
-  }
-  return true;
-}
-function sinkIndices(flatNet, sinkPlaces) {
-  const idx = /* @__PURE__ */ new Set();
-  for (const sink of sinkPlaces) {
-    const i = flatNetIndexOf(flatNet, sink);
-    if (i >= 0) idx.add(i);
-  }
-  return idx;
-}
-function satisfiesBadIndexed(index, state, property, sinkPlaces) {
-  const flatNet = index.flatNet;
-  switch (property.type) {
-    // DeadlockFree (VER-002): quiescent AND some marked place is not a declared
-    // sink. Mirrors the encoder's `stranded` disjunction.
-    case "deadlock-free": {
-      if (!isQuiescent(index, state)) return false;
-      const sinks = sinkIndices(flatNet, sinkPlaces);
-      for (let pid = 0; pid < flatNet.places.length; pid++) {
-        if (!sinks.has(pid) && state[pid] >= 1) return true;
-      }
-      return false;
-    }
-    // TerminatesAtSink (VER-002): quiescent AND no declared sink marked.
-    case "terminates-at-sink": {
-      if (!isQuiescent(index, state)) return false;
-      for (const pid of sinkIndices(flatNet, sinkPlaces)) {
-        if (state[pid] !== 0) return false;
-      }
-      return true;
-    }
-    case "mutual-exclusion": {
-      const idx1 = flatNetIndexOf(flatNet, property.p1);
-      const idx2 = flatNetIndexOf(flatNet, property.p2);
-      if (idx1 < 0 || idx2 < 0) return false;
-      return state[idx1] >= 1 && state[idx2] >= 1;
-    }
-    case "place-bound":
-    case "branch-place-bound": {
-      const idx = flatNetIndexOf(flatNet, property.place);
-      if (idx < 0) return false;
-      return state[idx] > property.bound;
-    }
-    // JoinedOrDeadLettered (NU-040 AC4): quiescent AND `pending` marked. No sink
-    // clause — a marked sink must not excuse a stranded group.
-    case "joined-or-dead-lettered": {
-      const idx = flatNetIndexOf(flatNet, property.pending);
-      if (idx < 0) return false;
-      return isQuiescent(index, state) && state[idx] >= 1;
-    }
-    case "unreachable": {
-      let resolved = 0;
-      for (const p of property.places) {
-        const idx = flatNetIndexOf(flatNet, p);
-        if (idx < 0) continue;
-        resolved++;
-        if (state[idx] < 1) return false;
-      }
-      return resolved > 0;
-    }
-  }
-}
-function replayCounterexample(flatNet, initial, decodedStates, property, sinkPlaces, options = {}) {
-  const segmentBudget = options.segmentBudget ?? 3;
-  const nodeBudget = options.nodeBudget ?? 1e4;
-  const anchors = /* @__PURE__ */ new Set();
-  for (const s of decodedStates) anchors.add(stateKey(s));
-  if (anchors.size === 0) {
-    return { kind: "exhausted", reason: "no decoded states to replay", nodesExplored: 0 };
-  }
-  const initKey = stateKey(initial);
-  if (!anchors.has(initKey)) {
-    return {
-      kind: "exhausted",
-      reason: "the initial marking is not among the decoded states",
-      nodesExplored: 0
-    };
-  }
-  const index = buildIndex(flatNet);
-  if (satisfiesBadIndexed(index, initial, property, sinkPlaces)) {
-    return { kind: "confirmed", states: [initial], steps: [], nodesExplored: 1 };
-  }
-  const nodes = [{ state: initial, step: null, parent: -1, segment: 0 }];
-  const bestSegment = /* @__PURE__ */ new Map([[initKey, 0]]);
-  const queue = [0];
-  let truncated = false;
-  for (let head = 0; head < queue.length; head++) {
-    const idx = queue[head];
-    const node = nodes[idx];
-    if (node.segment >= segmentBudget) {
-      truncated = true;
-      continue;
-    }
-    for (const succ of successorsIndexed(index, node.state)) {
-      const key = stateKey(succ.state);
-      const segment = anchors.has(key) ? 0 : node.segment + 1;
-      const prior = bestSegment.get(key);
-      if (prior !== void 0 && prior <= segment) continue;
-      bestSegment.set(key, segment);
-      if (nodes.length >= nodeBudget) {
-        return {
-          kind: "exhausted",
-          reason: `search budget exhausted (${nodeBudget} nodes) before reaching a violating state`,
-          nodesExplored: nodes.length
-        };
-      }
-      nodes.push({ state: succ.state, step: succ.step, parent: idx, segment });
-      const childIdx = nodes.length - 1;
-      if (satisfiesBadIndexed(index, succ.state, property, sinkPlaces)) {
-        const chain = reconstruct(nodes, childIdx);
-        return { kind: "confirmed", ...chain, nodesExplored: nodes.length };
-      }
-      queue.push(childIdx);
-    }
-  }
-  if (truncated) {
-    return {
-      kind: "exhausted",
-      reason: `no violating state within ${segmentBudget} abstract step(s) of a decoded state (${bestSegment.size} state(s) explored)`,
-      nodesExplored: nodes.length
-    };
-  }
-  return { kind: "no-chain", nodesExplored: nodes.length };
-}
-function reconstruct(nodes, last) {
-  const states = [];
-  const steps = [];
-  for (let i = last; i >= 0; i = nodes[i].parent) {
-    const node = nodes[i];
-    states.push(node.state);
-    if (node.step != null) steps.push(node.step);
-  }
-  states.reverse();
-  steps.reverse();
-  return { states, steps };
-}
-
-// src/verification/z3/name-coloured-encoder.ts
-function colourSlotBound(coloured, semiflows) {
-  const w = (inv, pid) => inv.weights[pid] ?? 0;
-  const isSemiflow = (inv) => inv.weights.every((x) => x >= 0);
-  let single = null;
-  for (const inv of semiflows) {
-    if (isSemiflow(inv) && coloured.every((pid) => w(inv, pid) >= 1)) {
-      if (single === null || inv.constant < single) single = inv.constant;
-    }
-  }
-  if (single !== null) return single;
-  const covered = new Array(coloured.length).fill(false);
-  for (const inv of semiflows) {
-    if (!isSemiflow(inv) || inv.constant !== 0) continue;
-    for (let i = 0; i < coloured.length; i++) {
-      if (w(inv, coloured[i]) >= 1) covered[i] = true;
-    }
-  }
-  const free = [...covered];
-  let sumConst = 0;
-  for (const inv of semiflows) {
-    if (!isSemiflow(inv) || inv.constant === 0) continue;
-    if (!coloured.some((pid, i) => !free[i] && w(inv, pid) >= 1)) continue;
-    for (let i = 0; i < coloured.length; i++) {
-      if (w(inv, coloured[i]) >= 1) covered[i] = true;
-    }
-    sumConst += inv.constant;
-  }
-  if (covered.every((c) => c)) return sumConst;
-  return null;
-}
-function buildColouredPlan(net, flat, initial, budgetNames, fragmentMode, carrierPlaces, semiflows) {
-  const P = flat.places.length;
-  const isColoured = new Array(P).fill(false);
-  for (const t of net.transitions) {
-    const ms = t.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;
-      }
-    }
-  }
-  if (fragmentMode === "extended") {
-    for (const c of carrierPlaces) {
-      const pid = flat.placeIndex.get(c);
-      if (pid != null) isColoured[pid] = true;
-    }
-  }
-  const coloured = [];
-  for (let i = 0; i < P; i++) if (isColoured[i]) coloured.push(i);
-  if (coloured.length === 0) return null;
-  for (const pid of coloured) {
-    if (initial.tokens(flat.places[pid]) !== 0) return null;
-  }
-  const k = colourSlotBound(coloured, semiflows);
-  if (k === null) return null;
-  if (k === 0 && coloured.length === P) return null;
-  const budgetIdx = /* @__PURE__ */ new Set();
-  for (const n of budgetNames) {
-    const i = flat.placeIndex.get(n);
-    if (i != null) budgetIdx.add(i);
-  }
-  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 (colouredIn.length !== 0) {
-      if (fragmentMode !== "extended") return null;
-      if (colouredIn.length !== 1 || ft.preVector[colouredIn[0]] !== 1) return null;
-      if (colouredOut.some((o) => ft.postVector[o] !== 1)) return null;
-      classes.push({ kind: "consume", inputCol: colouredIn[0], colouredOut });
-    } else if (colouredOut.length !== 0) {
-      if (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 {
-      classes.push({ kind: "untouched" });
-    }
-  }
-  return { coloured, isColoured, k, classes };
-}
-function buildLayout(plan, P) {
-  const colUnc = new Array(P).fill(-1);
-  const colCol = Array.from({ length: P }, () => []);
-  const cur = [];
-  const nxt = [];
-  for (let i = 0; i < P; i++) {
-    if (plan.isColoured[i]) {
-      const idxs = [];
-      for (let c = 0; c < plan.k; c++) {
-        idxs.push(cur.length);
-        cur.push(`m${i}_${c}`);
-        nxt.push(`m${i}_${c}p`);
-      }
-      colCol[i] = idxs;
-    } else {
-      colUnc[i] = cur.length;
-      cur.push(`m${i}`);
-      nxt.push(`m${i}p`);
-    }
-  }
-  return { colUnc, colCol, cur, nxt };
-}
-function quantified2(names) {
-  return names.map((v) => `(${v} Int)`).join(" ");
-}
-function encodeColoured(plan, flat, initial, property, invariants, sinkPlaces) {
-  const P = flat.places.length;
-  const k = plan.k;
-  const lay = buildLayout(plan, P);
-  const nCols = lay.cur.length;
-  const lines = [];
-  lines.push("(set-logic HORN)");
-  lines.push("");
-  lines.push(`(declare-fun Reachable (${new Array(nCols).fill("Int").join(" ")}) Bool)`);
-  lines.push("(declare-fun Error () Bool)");
-  lines.push("");
-  const init = [];
-  for (let i = 0; i < P; i++) {
-    if (plan.isColoured[i]) {
-      for (let c = 0; c < k; c++) init.push("0");
-    } else {
-      init.push(String(initial.tokens(flat.places[i])));
-    }
-  }
-  lines.push(`(assert (Reachable ${init.join(" ")}))`);
-  lines.push("");
-  for (let ti = 0; ti < plan.classes.length; ti++) {
-    const cls = plan.classes[ti];
-    const ft = flat.transitions[ti];
-    switch (cls.kind) {
-      case "untouched":
-        lines.push(encodeRule(plan, lay, invariants, (enab, upd) => uncolouredIncidence(lay, plan, ft, enab, upd)));
-        break;
-      case "mint":
-        for (let c = 0; c < k; c++) {
-          lines.push(encodeRule(plan, lay, invariants, (enab, upd) => {
-            uncolouredIncidence(lay, plan, ft, enab, upd);
-            for (const q of plan.coloured) enab.push(`(= ${lay.cur[lay.colCol[q][c]]} 0)`);
-            for (const o of cls.colouredOut) {
-              const col = lay.colCol[o][c];
-              upd.push({ col, expr: `(+ ${lay.cur[col]} 1)` });
-            }
-          }));
-        }
-        break;
-      case "join":
-        for (let c = 0; c < k; c++) {
-          lines.push(encodeRule(plan, lay, invariants, (enab, upd) => {
-            uncolouredIncidence(lay, plan, ft, enab, upd);
-            for (const ip of cls.colouredIn) {
-              const col = lay.colCol[ip][c];
-              enab.push(`(>= ${lay.cur[col]} 1)`);
-              upd.push({ col, expr: `(- ${lay.cur[col]} 1)` });
-            }
-          }));
-        }
-        break;
-      case "consume":
-        for (let c = 0; c < k; c++) {
-          lines.push(encodeRule(plan, lay, invariants, (enab, upd) => {
-            uncolouredIncidence(lay, plan, ft, enab, upd);
-            const icol = lay.colCol[cls.inputCol][c];
-            enab.push(`(>= ${lay.cur[icol]} 1)`);
-            upd.push({ col: icol, expr: `(- ${lay.cur[icol]} 1)` });
-            for (const o of cls.colouredOut) {
-              const ocol = lay.colCol[o][c];
-              upd.push({ col: ocol, expr: `(+ ${lay.cur[ocol]} 1)` });
-            }
-          }));
-        }
-        break;
-    }
-  }
-  lines.push("");
-  const error = encodeError(plan, lay, flat, property, sinkPlaces, injectionMap(flat));
-  if (error == null) return null;
-  lines.push(error);
-  lines.push("");
-  lines.push("(assert (not Error))");
-  lines.push("(check-sat)");
-  return { smt2: lines.join("\n"), placeCount: P };
-}
-function encodeRule(plan, lay, invariants, fill) {
-  const enab = [];
-  const upd = [];
-  fill(enab, upd);
-  const conditions = [`(Reachable ${lay.cur.join(" ")})`, ...enab];
-  const changed = new Array(lay.cur.length).fill(null);
-  for (const u of upd) changed[u.col] = u.expr;
-  for (let col = 0; col < lay.cur.length; col++) {
-    const expr = changed[col];
-    if (expr != null) {
-      conditions.push(`(= ${lay.nxt[col]} ${expr})`);
-      conditions.push(`(>= ${lay.nxt[col]} 0)`);
-    } else {
-      conditions.push(`(= ${lay.nxt[col]} ${lay.cur[col]})`);
-    }
-  }
-  for (const inv of invariants) {
-    const eq = liftedInvariant(inv, plan, lay, lay.nxt);
-    if (eq != null) conditions.push(eq);
-  }
-  const body = `(and ${conditions.join("\n            ")})`;
-  return `(assert (forall (${quantified2([...lay.cur, ...lay.nxt])})
-  (=> ${body}
-      (Reachable ${lay.nxt.join(" ")}))))`;
-}
-function uncolouredIncidence(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]} ${pre})`);
-    if (ft.resetPlaces.includes(i) || ft.consumeAll[i]) {
-      upd.push({ col, expr: String(ft.postVector[i]) });
-    } else {
-      const delta = ft.postVector[i] - ft.preVector[i];
-      if (delta > 0) upd.push({ col, expr: `(+ ${lay.cur[col]} ${delta})` });
-      else if (delta < 0) upd.push({ col, expr: `(- ${lay.cur[col]} ${-delta})` });
-    }
-  }
-  for (const pid of ft.inhibitorPlaces) enab.push(`(= ${lay.cur[lay.colUnc[pid]]} 0)`);
-  for (const pid of ft.readPlaces) enab.push(`(>= ${lay.cur[lay.colUnc[pid]]} 1)`);
-}
-function aggregate(plan, lay, place, names) {
-  if (plan.isColoured[place]) {
-    const cols = lay.colCol[place];
-    if (cols.length === 0) return "0";
-    if (cols.length === 1) return names[cols[0]];
-    return `(+ ${cols.map((c) => names[c]).join(" ")})`;
-  }
-  return names[lay.colUnc[place]];
-}
-function liftedInvariant(inv, plan, lay, names) {
-  const terms = [];
-  for (const i of [...inv.support].sort((a, b) => a - b)) {
-    const agg = aggregate(plan, lay, i, names);
-    const w = inv.weights[i];
-    terms.push(w === 1 ? agg : `(* ${w} ${agg})`);
-  }
-  if (terms.length === 0) return null;
-  const sum = terms.length === 1 ? terms[0] : `(+ ${terms.join(" ")})`;
-  return `(= ${sum} ${inv.constant})`;
-}
-function encodeError(plan, lay, flat, property, sinkPlaces, envInj) {
-  const violation = encodeViolation(plan, lay, flat, property, sinkPlaces, envInj);
-  if (violation == null) return null;
-  return `(assert (forall (${quantified2(lay.cur)})
-  (=> (and (Reachable ${lay.cur.join(" ")}) ${violation})
-      Error)))`;
-}
-function encodeViolation(plan, lay, flat, property, sinkPlaces, envInj) {
-  const anyPlacePresent = (places) => {
-    const conds = indexOrdered(flat, places).map((pid) => `(>= ${aggregate(plan, lay, pid, lay.cur)} 1)`);
-    return conds.length === 0 ? "false" : `(and ${conds.join(" ")})`;
-  };
-  switch (property.type) {
-    case "place-bound":
-    case "branch-place-bound": {
-      const pid = flat.placeIndex.get(property.place.name);
-      if (pid == null) return null;
-      return `(> ${aggregate(plan, lay, pid, lay.cur)} ${property.bound})`;
-    }
-    case "mutual-exclusion":
-      return anyPlacePresent([property.p1, property.p2]);
-    case "unreachable":
-      return anyPlacePresent(property.places);
-    // DeadlockFree (VER-002): quiescent AND some marked place is not a declared
-    // sink. Mirrors the flat encoder's `stranded` disjunction.
-    case "deadlock-free": {
-      const conds = encodeColouredQuiescent(plan, lay, flat, envInj);
-      if (conds == null) return "false";
-      const sinks = new Set(indexOrdered(flat, sinkPlaces));
-      const stranded = [];
-      for (let pid = 0; pid < flat.places.length; pid++) {
-        if (!sinks.has(pid)) stranded.push(`(>= ${aggregate(plan, lay, pid, lay.cur)} 1)`);
-      }
-      if (stranded.length === 0) return "false";
-      conds.push(`(or ${stranded.join(" ")})`);
-      return joinColoured(conds);
-    }
-    // TerminatesAtSink (VER-002): quiescent AND no declared sink marked.
-    case "terminates-at-sink": {
-      const conds = encodeColouredQuiescent(plan, lay, flat, envInj);
-      if (conds == null) return "false";
-      for (const pid of indexOrdered(flat, sinkPlaces)) {
-        conds.push(`(= ${aggregate(plan, lay, pid, lay.cur)} 0)`);
-      }
-      return joinColoured(conds);
-    }
-    // JoinedOrDeadLettered (NU-040 AC4): quiescent AND `pending` marked, with NO
-    // sink clause.
-    case "joined-or-dead-lettered": {
-      const pid = flat.placeIndex.get(property.pending.name);
-      if (pid == null) return null;
-      const conds = encodeColouredQuiescent(plan, lay, flat, envInj);
-      if (conds == null) return "false";
-      conds.push(`(>= ${aggregate(plan, lay, pid, lay.cur)} 1)`);
-      return joinColoured(conds);
-    }
-  }
-}
-function uncolouredDisable(ft, lay, plan, envInj, reasons) {
-  let permanentlyDisabled = false;
-  const P = ft.preVector.length;
-  for (let i = 0; i < P; i++) {
-    if (plan.isColoured[i] || ft.preVector[i] === 0) continue;
-    if (envInj.has(i)) {
-      const bound = envInj.get(i);
-      if (bound != null && ft.preVector[i] > bound) permanentlyDisabled = true;
-      continue;
-    }
-    reasons.push(`(< ${lay.cur[lay.colUnc[i]]} ${ft.preVector[i]})`);
-  }
-  for (const inh of ft.inhibitorPlaces) reasons.push(`(> ${lay.cur[lay.colUnc[inh]]} 0)`);
-  for (const rd of ft.readPlaces) {
-    if (envInj.has(rd)) {
-      const bound = envInj.get(rd);
-      if (bound != null && bound < 1) permanentlyDisabled = true;
-      continue;
-    }
-    reasons.push(`(< ${lay.cur[lay.colUnc[rd]]} 1)`);
-  }
-  return permanentlyDisabled;
-}
-function colouredDisabledTerm(cls, plan, lay) {
-  const k = plan.k;
-  if (k === 0) {
-    return cls.kind === "untouched" ? null : "true";
-  }
-  switch (cls.kind) {
-    case "untouched":
-      return null;
-    case "mint": {
-      const perColour = [];
-      for (let c = 0; c < k; c++) {
-        const present = plan.coloured.map((q) => `(>= ${lay.cur[lay.colCol[q][c]]} 1)`);
-        perColour.push(`(or ${present.join(" ")})`);
-      }
-      return `(and ${perColour.join(" ")})`;
-    }
-    case "join": {
-      const perColour = [];
-      for (let c = 0; c < k; c++) {
-        const missing = cls.colouredIn.map((i) => `(= ${lay.cur[lay.colCol[i][c]]} 0)`);
-        perColour.push(`(or ${missing.join(" ")})`);
-      }
-      return `(and ${perColour.join(" ")})`;
-    }
-    case "consume": {
-      const perColour = [];
-      for (let c = 0; c < k; c++) perColour.push(`(= ${lay.cur[lay.colCol[cls.inputCol][c]]} 0)`);
-      return `(and ${perColour.join(" ")})`;
-    }
-  }
-}
-function joinColoured(conds) {
-  return conds.length === 0 ? "true" : `(and ${conds.join(" ")})`;
-}
-function encodeColouredQuiescent(plan, lay, flat, envInj) {
-  const disabledConditions = [];
-  for (let ti = 0; ti < plan.classes.length; ti++) {
-    const cls = plan.classes[ti];
-    const ft = flat.transitions[ti];
-    const reasons = [];
-    const permanentlyDisabled = uncolouredDisable(ft, lay, plan, envInj, reasons);
-    if (permanentlyDisabled) {
-      disabledConditions.push("true");
-      continue;
-    }
-    const term = colouredDisabledTerm(cls, plan, lay);
-    if (term != null) reasons.push(term);
-    if (reasons.length === 0) return null;
-    disabledConditions.push(reasons.length === 1 ? reasons[0] : `(or ${reasons.join(" ")})`);
-  }
-  return disabledConditions;
-}
-
-// src/verification/analysis/name-fragment.ts
-function classify(net, mode, carrierPlaces) {
-  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;
-  if (mode === "extended") {
-    for (const c of carrierPlaces) coloured.add(c);
-  }
-  for (const t of net.transitions) {
-    if (t.resets.some((r) => coloured.has(r.place.name)) || t.reads.some((r) => coloured.has(r.place.name)) || t.inhibitors.some((i) => coloured.has(i.place.name))) {
-      return null;
-    }
-  }
-  const roles = /* @__PURE__ */ new Map();
-  for (const t of net.transitions) {
-    const colouredInputs = t.inputSpecs.filter((s) => coloured.has(s.place.name));
-    const consumesColoured = colouredInputs.length > 0;
-    let producesColoured = false;
-    if (t.outputSpec !== null) {
-      for (const branch of enumerateBranches(t.outputSpec)) {
-        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 (consumesColoured) {
-      if (mode === "base") return null;
-      if (colouredInputs.length !== 1) return null;
-      const spec = colouredInputs[0];
-      const countOne = spec.type === "one" || spec.type === "exactly" && spec.count === 1;
-      if (!countOne) return null;
-      role = { type: "consume", colouredInput: spec.place.name };
-    } else if (producesColoured) {
-      role = { type: "mint" };
-    } else {
-      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, placeName2) {
-  for (const spec of t.inputSpecs) {
-    if (spec.place.name === placeName2) {
-      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 all2 = /* @__PURE__ */ new Set();
-    for (const syms of this.perPlace.values()) {
-      for (const s of syms.keys()) all2.add(s);
-    }
-    return [...all2];
-  }
-  /**
-   * 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;
-  /** The symmetry-canonical name-partition key (the name layer's intern key). */
-  nameKey;
-  constructor(base, names, colouredOrder, nameKey) {
-    this.base = base;
-    this.names = names;
-    this.nameKey = nameKey ?? names.canonicalKey(colouredOrder);
-  }
-  /** Full dedup key: the base key (marking + DBM zone) joined with the name key. */
-  get key() {
-    return `${baseKeyOf(this.base)}||${this.nameKey}`;
-  }
-};
-function baseKeyOf(base) {
-  return `${base.marking.toString()}|${base.firingDomain.toString()}`;
-}
-
-// 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, prioritySemantics = "none") {
-    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 baseIntern = /* @__PURE__ */ new Map();
-    const nameIntern = /* @__PURE__ */ new Map();
-    const indexOf = /* @__PURE__ */ new Map();
-    const b0 = internBase(baseIntern, base0);
-    const n0 = internNames(nameIntern, new NameMarking(), fragment.colouredOrder);
-    graph.pushClass(
-      new NameStateClass(b0.base, n0.names, fragment.colouredOrder, n0.nameKey),
-      classId(b0.id, n0.id),
-      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];
-      const enabled = current.base.enabledTransitions;
-      for (let idxL = 0; idxL < enabled.length; idxL++) {
-        const transition = enabled[idxL];
-        if (prioritySemantics === "conflict" && priorityDominated(
-          transition,
-          idxL,
-          enabled,
-          current.base.readyEarliest,
-          current.base.marking,
-          current.names,
-          fragment
-        )) {
-          continue;
-        }
-        const role = fragment.role(transition.name);
-        for (const vt of expandTransition(transition)) {
-          const baseSucc = computeSuccessor(net, current.base, vt, envPlaces, envMode);
-          if (baseSucc === null || baseSucc.isEmpty()) continue;
-          const nameSuccs = nameSuccessors(role, current.names, vt.outputPlaces, fragment, sym);
-          const shared = internBase(baseIntern, baseSucc);
-          for (const nm of nameSuccs) {
-            const sharedNames = internNames(nameIntern, nm, fragment.colouredOrder);
-            const id = classId(shared.id, sharedNames.id);
-            let toIdx = indexOf.get(id);
-            if (toIdx === void 0) {
-              toIdx = graph.classes.length;
-              graph.pushClass(
-                new NameStateClass(shared.base, sharedNames.names, fragment.colouredOrder, sharedNames.nameKey),
-                id,
-                indexOf
-              );
-              queue.push(toIdx);
-            }
-            graph.addEdge(curIdx, toIdx, transition.name);
-          }
-        }
-      }
-    }
-    return graph;
-  }
-  pushClass(c, id, indexOf) {
-    const idx = this.classes.length;
-    this.classes.push(c);
-    this._successors.push([]);
-    indexOf.set(id, idx);
-  }
-  addEdge(from, to, name) {
-    this.edges.push({ from, to, transitionName: name });
-    this._successors[from].push(to);
-  }
-};
-function classId(baseId, nameId) {
-  return `${baseId}:${nameId}`;
-}
-function internBase(intern, base) {
-  const key = `${baseKeyOf(base)}#${base.readyEarliest.join(",")}`;
-  let entry = intern.get(key);
-  if (entry === void 0) {
-    entry = { id: intern.size, base };
-    intern.set(key, entry);
-  }
-  return entry;
-}
-function internNames(intern, names, colouredOrder) {
-  const nameKey = names.canonicalKey(colouredOrder);
-  let entry = intern.get(nameKey);
-  if (entry === void 0) {
-    entry = { id: intern.size, names, nameKey };
-    intern.set(nameKey, entry);
-  }
-  return entry;
-}
-var READY_EPS = 1e-9;
-function priorityDominated(l, idxL, enabled, readyEarliest, marking, names, fragment) {
-  return enabled.some(
-    (h, idxH) => h !== l && h.priority > l.priority && readyEarliest[idxH] <= readyEarliest[idxL] + READY_EPS && willFire(h, names, fragment) && sharesConsumedInput(h, l, marking)
-  );
-}
-function willFire(h, names, fragment) {
-  const role = fragment.role(h.name);
-  switch (role.type) {
-    case "join":
-      return enablingSymbols(names, role.colouredIn).length > 0;
-    case "consume":
-      return names.symbolsIn(role.colouredInput).length > 0;
-    case "ordinary":
-    case "mint":
-      return true;
-    default: {
-      const _exhaustive = role;
-      return _exhaustive;
-    }
-  }
-}
-function sharesConsumedInput(h, l, marking) {
-  const lIns = /* @__PURE__ */ new Set();
-  for (const p of l.inputPlaces()) lIns.add(p.name);
-  for (const p of h.inputPlaces()) {
-    if (lIns.has(p.name) && marking.tokens(p) < consumedDemand(h, p.name) + consumedDemand(l, p.name)) {
-      return true;
-    }
-  }
-  return false;
-}
-function consumedDemand(t, placeName2) {
-  let demand = 0;
-  for (const spec of t.inputSpecs) {
-    if (spec.place.name === placeName2) demand += inputRequiredCount2(spec);
-  }
-  return demand;
-}
-function inputRequiredCount2(spec) {
-  switch (spec.type) {
-    case "one":
-      return 1;
-    case "exactly":
-      return spec.count;
-    case "all":
-      return 1;
-    case "at-least":
-      return spec.minimum;
-  }
-}
-function colouredOutputs(outputPlaces, fragment) {
-  return [...outputPlaces].filter((p) => fragment.isColoured(p.name)).map((p) => p.name);
-}
-function nameSuccessors(role, names, outputPlaces, fragment, sym) {
-  switch (role.type) {
-    case "ordinary":
-      return [names.copy()];
-    case "mint": {
-      const colouredOut = colouredOutputs(outputPlaces, fragment);
-      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;
-    }
-    case "consume": {
-      const colouredOut = colouredOutputs(outputPlaces, fragment);
-      const result = [];
-      for (const s of names.symbolsIn(role.colouredInput)) {
-        const nm = names.copy();
-        nm.remove(role.colouredInput, s, 1);
-        for (const p of colouredOut) nm.add(p, s, 1);
-        result.push(nm);
-      }
-      return result;
-    }
-  }
-}
-function enablingSymbols(names, colouredIn) {
-  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, fragmentMode, carrierPlaces, prioritySemantics) {
-  const fragment = classify(net, fragmentMode, carrierPlaces);
-  if (fragment === null) return null;
-  for (const p of initial.placesWithTokens()) {
-    if (fragment.isColoured(p.name)) return null;
-  }
-  const scg = NameStateClassGraph.build(
-    net,
-    initial,
-    fragment,
-    maxClasses,
-    environmentPlaces,
-    environmentMode,
-    prioritySemantics
-  );
-  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);
-      });
-    // DeadlockFree (VER-002): a quiescent class that strands a token — some marked
-    // place is not a declared sink. The empty marking strands nothing (AC4).
-    case "deadlock-free":
-      return firstWhere((i) => scg.successorsOf(i).length === 0 && !allTokensInSinks(scg.markingOf(i), sinkPlaces));
-    // TerminatesAtSink (VER-002): a quiescent class that marks NO declared sink.
-    // Inverts with DeadlockFree on the empty marking, by design.
-    case "terminates-at-sink":
-      return firstWhere((i) => scg.successorsOf(i).length === 0 && !anySinkMarked(scg.markingOf(i), sinkPlaces));
-    // JoinedOrDeadLettered (NU-040 AC4): a quiescent class still holding a pending
-    // token. No sink clause.
-    case "joined-or-dead-lettered":
-      return firstWhere((i) => scg.successorsOf(i).length === 0 && scg.markingOf(i).hasTokens(property.pending));
-  }
-}
-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 anySinkMarked(m, sinks) {
-  const sinkNames = /* @__PURE__ */ new Set();
-  for (const s of sinks) sinkNames.add(s.name);
-  for (const p of m.placesWithTokens()) {
-    if (sinkNames.has(p.name)) return true;
-  }
-  return false;
-}
-function counterexamplePath(scg, target) {
-  const n = scg.classCount();
-  const parent = new Array(n).fill(-1);
-  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 IGNORE_MODE_VACUITY_REASON = "environment places present but not modeled (mode=ignore); a proof would be vacuous \u2014 use alwaysAvailable() or bounded(k) to model external injection";
-var SmtVerifier = class _SmtVerifier {
-  constructor(net) {
-    this.net = net;
-  }
-  net;
-  _initialMarking = MarkingState.empty();
-  _property = deadlockFree();
-  _environmentPlaces = /* @__PURE__ */ new Set();
-  _sinkPlaces = /* @__PURE__ */ new Set();
-  _budgetPlaces = /* @__PURE__ */ new Set();
-  _environmentMode = alwaysAvailable();
-  _timeoutMs = 6e4;
-  _certificateCheck = true;
-  _counterexampleReplay = true;
-  _semiflowInvariants = false;
-  _nuMaxClasses = 1e5;
-  _fragmentMode = "base";
-  _carrierPlaces = /* @__PURE__ */ new Set();
-  _prioritySemantics = "none";
-  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;
-  }
-  /**
-   * Enables/disables the independent IC3 certificate check (default: enabled).
-   *
-   * When a proven verdict comes from the IC3/Spacer path on the flat count
-   * encoding, the synthesized inductive invariant is re-validated with a plain
-   * solver against the UNSTRENGTHENED step relation — VC1 (init), VC2
-   * (consecution), VC3 (safety) — so a Spacer or encoder defect cannot certify
-   * a false PROVEN. A certificate that fails validation downgrades the verdict
-   * to unknown. Structural proofs and the coloured ν-encoding are unaffected.
-   */
-  certificateCheck(enabled) {
-    this._certificateCheck = enabled;
-    return this;
-  }
-  /**
-   * Enables/disables abstract counterexample replay (default: enabled).
-   *
-   * When a violated verdict comes from the flat count encoding, the decoded
-   * counterexample states (an order-free set — the derivation tree is walked in
-   * traversal order, not firing order) are re-executed TS-side against the
-   * abstract semantics the encoder emits (Lean's `fireA`, Basic.lean), searching
-   * for a firing order from M₀ to a property-violating marking. See
-   * `SmtVerificationResult.counterexampleConfirmed` for how each outcome lands.
-   */
-  counterexampleReplay(enabled) {
-    this._counterexampleReplay = enabled;
-    return this;
-  }
-  /**
-   * Also hands the validated **P-semiflows** to the encoders as invariants
-   * (VER-007; default: disabled — the encoders then see only the null-space basis).
-   *
-   * Every validated semiflow is a conservation law in its own right (`y >= 0`,
-   * `y·C = 0`, `y·M0` exact, zero weight on every reset / consume-all place), and
-   * the Farkas enumeration returns the *minimal* laws of the net. The null-space
-   * basis the encoders get by default is one basis of many: elimination hands back
-   * mixed-sign rows (discarded as not semi-positive) or rows that fold a reset place
-   * into a chain whose other combinations avoid it (dropped by the H1 guard). On a
-   * net with a few reset arcs that can lose every law of the chains those arcs
-   * touch, and without them IC3 has to rediscover the conservation of each chain —
-   * on a ~100-place net it does not within any practical budget.
-   *
-   * **Turn this on if the net has any `all()` / `atLeast(n)` or reset arc on a busy
-   * place** — draining an input queue is the everyday case. Every basis row whose
-   * support touches such a place fails the H1 guard and is dropped, so the encoders
-   * run on a deficient invariant set and nothing in the report says a law is missing
-   * beyond the `Dropped` lines.
-   *
-   * This reaches the **name-coloured** encoder (NU-050) as well as the flat one, and
-   * it matters most there. On a 113-place ν-net, whole-net deadlock-freedom went from
-   * `unknown` after 50 minutes to `proven` in about 15 seconds with this option as the
-   * only change; on the flat path, reachability-safety queries that timed out at 120 s
-   * close in about a second.
-   *
-   * Soundness is unchanged: the semiflows pass the same exact re-validation as the
-   * basis rows, the union is pure strengthening (`Semiflow.lean`,
-   * `semiflow_union_sound`), and the certificate check re-proves the strengthened
-   * invariant — that check is flat-path only, so a coloured `proven` reports
-   * `Certificate check: not applicable (name-coloured encoding)`. Off by default so
-   * reports stay byte-equal.
-   */
-  semiflowInvariants(enabled) {
-    this._semiflowInvariants = enabled;
-    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;
-  }
-  /**
-   * Selects the ν-net coloured-place fragment for Route B (NU-051). `base`
-   * (default) admits the shipped mint → matched-join fragment only; `extended`
-   * additionally admits the opt-in coloured-consumer (drain/relay) role and the
-   * declared {@link carrierPlaces}. When `extended` is requested but the net
-   * falls outside the coloured-consumer fragment, Route B declines and a short
-   * note is appended to the report before falling back to the sound
-   * over-approximation.
-   */
-  fragmentMode(mode) {
-    this._fragmentMode = mode;
-    return this;
-  }
-  /**
-   * Declares ν-net *carrier* places (NU-051, EXTENDED only): intermediate places
-   * that carry a fresh name from the minting fork onward to a ν-join input. Under
-   * {@link fragmentMode} `extended` they are unioned into the coloured set so the
-   * existing mint co-mints one fresh name into all of them; under `base` they are
-   * ignored. Accumulating. Throws if a declared place is not in the net — a
-   * mistyped carrier name would let two fork branches mint independent names, so
-   * the join never becomes name-enabled and the verifier would otherwise report a
-   * confident false deadlock; it must surface, never silently proceed.
-   */
-  carrierPlaces(...places) {
-    for (const p of places) {
-      if (![...this.net.places].some((np) => np.name === p.name)) {
-        throw new Error(`declared carrier place '${p.name}' not in the net`);
-      }
-      this._carrierPlaces.add(p.name);
-    }
-    return this;
-  }
-  /**
-   * Selects how the Route-B name-aware analyzer treats transition priority
-   * (NU-052). Defaults to `'none'` (the priority-blind over-approximation).
-   * `'conflict'` models the executor's conflict-only priority resolution, so a
-   * lower-priority transition pre-empted by a conflicting, no-later-ready,
-   * strictly-higher-priority one is not explored — removing spurious
-   * dead-letter-drain stalls the eager, priority-ordered executor never produces.
-   */
-  prioritySemantics(semantics) {
-    this._prioritySemantics = semantics;
-    return this;
-  }
-  /**
-   * The name-coloured plan and its encoding, or a null plan when the net is outside
-   * the fragment (NU-050) and a null encoding when the property names a place the net
-   * does not resolve.
-   *
-   * {@link verify} and {@link encodeScripts} share this deliberately. They used to
-   * invoke `buildColouredPlan` and `encodeColoured` separately, so handing the encoder
-   * the wrong one of the two lists changed only one of them — and the script-parity
-   * goldens are generated from `encodeScripts`. Unifying the invocation closes that. It
-   * does not make the two paths identical: each still computes its own invariant and
-   * semiflow lists, so they can still drift through the arguments rather than the call.
-   *
-   * `invariants` is what the encoder conjoins into every rule body (the null-space
-   * basis, unioned with the semiflows when VER-007 is enabled); `semiflows` sets the
-   * colour-slot bound k (NU-053). They are not the same list.
-   */
-  colouredAttempt(flatNet, invariants, semiflows) {
-    const hasMatch = [...this.net.transitions].some((t) => t.matchSpec !== null);
-    const nuBounded = this._budgetPlaces.size > 0;
-    if (!hasMatch || !nuBounded) return { plan: null, encoding: null };
-    const plan = buildColouredPlan(
-      this.net,
-      flatNet,
-      this._initialMarking,
-      this._budgetPlaces,
-      this._fragmentMode,
-      this._carrierPlaces,
-      semiflows
-    );
-    if (plan == null) return { plan: null, encoding: null };
-    return {
-      plan,
-      encoding: encodeColoured(
-        plan,
-        flatNet,
-        this._initialMarking,
-        this._property,
-        invariants,
-        this._sinkPlaces
-      )
-    };
-  }
-  /**
-   * The SMT-LIB2 scripts {@link verify} would send to z3 for this configuration,
-   * without running a solver (VER-013 AC1): the HORN query (flat, or name-coloured
-   * when a declared budget puts the net on Route A's exact encoding) and, for the
-   * flat encoding, the certificate-check script built around
-   * {@link placeholderCertificate}. This is what the cross-language golden tests diff
-   * byte for byte. Route B, the structural pre-check and the unresolved-place
-   * refusal are bypassed: it is what Route A encodes.
-   */
-  encodeScripts() {
-    requireOutputProducingActions(this.net);
-    const flatNet = flatten(this.net, this._environmentPlaces, this._environmentMode);
-    const matrix = IncidenceMatrix.from(flatNet);
-    const { valid: basis } = validateInvariantsExact(
-      matrix,
-      computePInvariants(matrix, flatNet, this._initialMarking),
-      flatNet,
-      this._initialMarking
-    );
-    const { valid: semiflows } = validateInvariantsExact(
-      matrix,
-      computePSemiflows(matrix, flatNet, this._initialMarking),
-      flatNet,
-      this._initialMarking
-    );
-    let invariants = basis;
-    if (this._semiflowInvariants) invariants = strengthenWithSemiflows(basis, semiflows).invariants;
-    invariants = canonicalInvariantOrder(invariants);
-    const attempt = this.colouredAttempt(flatNet, invariants, semiflows);
-    if (attempt.encoding != null) {
-      return { horn: attempt.encoding.smt2, certificate: null, coloured: true };
-    }
-    const horn = encode(flatNet, this._initialMarking, this._property, invariants, this._sinkPlaces, this._counterexampleReplay).smt2;
-    const certificate = vcScript(
-      placeholderCertificate(flatNet.places.length),
-      flatNet,
-      this._initialMarking,
-      this._property,
-      this._sinkPlaces,
-      invariants
-    );
-    return { horn, certificate, coloured: false };
-  }
-  /**
-   * Runs the verification pipeline.
-   *
-   * @throws Error if the net violates CORE-043 — verification rejects the same nets execution rejects.
-   */
-  async verify() {
-    requireOutputProducingActions(this.net);
-    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,
-        this._fragmentMode,
-        this._carrierPlaces,
-        this._prioritySemantics
-      );
-      const deferToRouteA = outcome !== null && outcome.verdict.type === "unknown" && !isReachabilitySafety(this._property) && nuBounded;
-      if (outcome !== null && !deferToRouteA) {
-        report.push("=== \u03BD-net Route B: name-aware state-class graph (NU-050) ===");
-        report.push(`  Name-partition state classes: ${outcome.classCount}`);
-        report.push(outcome.note);
-        if (outcome.transitions.length > 0) {
-          report.push(`  Counterexample trace: ${outcome.trace.length} states, ${outcome.transitions.length} transitions`);
-        }
-        let routeBVerdict = outcome.verdict;
-        if (routeBVerdict.type === "proven" && this._environmentPlaces.size > 0 && this._environmentMode.type === "ignore") {
-          report.push(`  Downgraded to UNKNOWN: ${IGNORE_MODE_VACUITY_REASON}`);
-          routeBVerdict = { type: "unknown", reason: IGNORE_MODE_VACUITY_REASON };
-        }
-        return buildResult(
-          routeBVerdict,
-          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)"
-          }
-        );
-      } else if (deferToRouteA) {
-        report.push(
-          "\u03BD-net Route B inconclusive (name-partition truncated); deferring to Route A coloured IC3/PDR (NU-053)."
-        );
-      }
-      if (this._fragmentMode === "extended" && !deferToRouteA) {
-        report.push(
-          "\u03BD-net Route B (EXTENDED) declined: net outside coloured-consumer fragment (a coloured place consumed count != 1 or by multiple inputs, carries a reset/read/inhibitor arc, or a join re-mints a coloured place); verified via sound over-approximation instead."
-        );
-      }
-    }
-    report.push("Phase 1: Flattening net...");
-    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.");
-      report.push("  Certificate check: not applicable (structural proof)");
-      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 { valid: basisInvariants, dropped: droppedInvariants } = validateInvariantsExact(
-      matrix,
-      computePInvariants(matrix, flatNet, this._initialMarking),
-      flatNet,
-      this._initialMarking
-    );
-    const { valid: semiflows, dropped: droppedSemiflows } = validateInvariantsExact(
-      matrix,
-      computePSemiflows(matrix, flatNet, this._initialMarking),
-      flatNet,
-      this._initialMarking
-    );
-    report.push(`  Found: ${basisInvariants.length} P-invariant(s)`);
-    let invariants = basisInvariants;
-    if (this._semiflowInvariants) {
-      const { invariants: strengthened, added } = strengthenWithSemiflows(basisInvariants, semiflows);
-      invariants = strengthened;
-      report.push(`  Semiflows encoded as invariants: ${added}`);
-    }
-    invariants = canonicalInvariantOrder(invariants);
-    const structurallyBounded = isCoveredByInvariants(invariants, flatNet.places.length);
-    report.push(`  Structurally bounded: ${structurallyBounded ? "YES" : "NO"}`);
-    for (const inv of invariants) {
-      report.push(`  ${formatInvariant(inv, flatNet)}`);
-    }
-    for (const { invariant, reason } of droppedInvariants) {
-      report.push(`  Dropped invariant: ${formatInvariant(invariant, flatNet)} - ${reason}`);
-    }
-    if (droppedInvariants.length > 0) {
-      report.push(`  Dropped: ${droppedInvariants.length} invariant(s) failed the exact re-check`);
-    }
-    for (const { invariant, reason } of droppedSemiflows) {
-      report.push(`  Dropped semiflow: ${formatInvariant(invariant, flatNet)} - ${reason}`);
-    }
-    if (droppedSemiflows.length > 0) {
-      report.push(`  Dropped: ${droppedSemiflows.length} semiflow(s) failed the exact re-check`);
-    }
-    report.push("");
-    report.push("Phase 4: IC3/PDR verification via Z3 Spacer...");
-    const stats = {
-      places: flatNet.places.length,
-      transitions: flatNet.transitions.length,
-      invariantsFound: invariants.length,
-      structuralResult: structResultStr
-    };
-    let solver;
-    try {
-      solver = resolveZ3();
-    } catch (e) {
-      const reason = e instanceof Z3Unavailable ? e.message : String(e?.message ?? e);
-      report.push(`  Solver: z3 unavailable (${reason})`);
-      report.push(`  Status: UNKNOWN (${reason})
-`);
-      report.push("=== RESULT ===\n");
-      report.push(`UNKNOWN: Could not determine ${propDesc}`);
-      report.push(`  Reason: ${reason}`);
-      return buildResult({ type: "unknown", reason }, report.join("\n"), invariants, [], [], [], performance.now() - start, stats);
-    }
-    report.push(`  Solver: z3 ${formatZ3Version(solver.version)}`);
-    const colouredAttempt = this.colouredAttempt(flatNet, invariants, semiflows);
-    const colouredPlan = colouredAttempt.plan;
-    let encoding;
-    if (colouredPlan != null) {
-      report.push(
-        `  \u03BD-encoding: name-coloured (exact within budget k=${colouredPlan.k}; ${colouredPlan.coloured.length} coloured place(s))`
-      );
-      const coloured = colouredAttempt.encoding;
-      if (coloured == null) {
-        const reason = "property names a place that does not resolve in the net; refusing to certify (the encoding would be vacuously proven)";
-        report.push("  Status: UNKNOWN (unresolved property place)\n");
-        report.push("=== RESULT ===\n");
-        report.push(`UNKNOWN: ${reason}`);
-        return buildResult({ type: "unknown", reason }, report.join("\n"), invariants, [], [], [], performance.now() - start, stats);
-      }
-      encoding = coloured;
-    } else {
-      const unresolved = unresolvedPropertyPlace(flatNet, this._property);
-      if (unresolved != null) {
-        const reason = `property names a place that does not resolve in the net ('${unresolved}'); refusing to certify (the encoding would be vacuously proven)`;
-        report.push("  Status: UNKNOWN (unresolved property place)\n");
-        report.push("=== RESULT ===\n");
-        report.push(`UNKNOWN: ${reason}`);
-        return buildResult({ type: "unknown", reason }, report.join("\n"), invariants, [], [], [], performance.now() - start, stats);
-      }
-      encoding = encode(flatNet, this._initialMarking, this._property, invariants, this._sinkPlaces, this._counterexampleReplay);
-    }
-    const queryResult = await runZ3Spacer(
-      solver,
-      this._timeoutMs,
-      encoding.smt2,
-      colouredPlan != null ? "horn-coloured" : "horn"
-    );
-    switch (queryResult.type) {
-      case "proven": {
-        if (this._environmentPlaces.size > 0 && this._environmentMode.type === "ignore") {
-          const reason = IGNORE_MODE_VACUITY_REASON;
-          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, stats);
-        }
-        report.push("  Status: UNSAT (property holds)");
-        if (colouredPlan != null) {
-          report.push("  Certificate check: not applicable (name-coloured encoding)");
-        } else if (!this._certificateCheck) {
-          report.push("  Certificate check: not applicable (disabled)");
-        } else {
-          const certificate = await checkCertificate(
-            queryResult.invariantFormula,
-            flatNet,
-            this._initialMarking,
-            this._property,
-            invariants,
-            this._sinkPlaces,
-            solver,
-            this._timeoutMs
-          );
-          const reason = certificateDowngradeReason(certificate);
-          if (reason != null) {
-            report.push("  Certificate check: FAILED");
-            if (certificate.type !== "passed" && certificate.invariant != null) {
-              report.push("  Uncertified invariant:");
-              for (const line of certificate.invariant.split("\n")) report.push(`    ${line}`);
-            }
-            report.push("");
-            report.push("=== RESULT ===\n");
-            report.push(`UNKNOWN: ${reason}`);
-            return buildResult({ type: "unknown", reason }, report.join("\n"), invariants, [], [], [], performance.now() - start, stats);
-          }
-          report.push("  Certificate check: PASSED (init, consecution, safety)");
-        }
-        report.push("");
-        const formula = queryResult.invariantFormula;
-        const discoveredInvariants = formula != null ? [formula] : [];
-        if (formula != null) {
-          report.push("Phase 5: Inductive invariant (discovered by IC3)");
-          report.push("  Spacer synthesized:");
-          for (const line of formula.split("\n")) report.push(`    ${line}`);
-          report.push("  This formula is INDUCTIVE: preserved by all transitions.");
-          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.");
-        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: formula },
-          report.join("\n"),
-          invariants,
-          discoveredInvariants,
-          [],
-          [],
-          performance.now() - start,
-          stats
-        ), hasMatch, nuBounded, colouredPlan != null);
-      }
-      case "violated": {
-        report.push("  Status: SAT (counterexample found)\n");
-        const decoded = decode(queryResult.answer, flatNet);
-        if (decoded.note != null) report.push(`  Counterexample decoding: ${decoded.note}`);
-        let confirmed = null;
-        let trace = [...decoded.states];
-        let transitions = [];
-        let replayed = false;
-        if (colouredPlan == null && this._counterexampleReplay) {
-          const assessment = assessCounterexample(
-            flatNet,
-            this._initialMarking,
-            decoded.states,
-            this._property,
-            this._sinkPlaces
-          );
-          if (assessment.kind === "confirmed") {
-            confirmed = true;
-            replayed = true;
-            trace = assessment.trace;
-            transitions = assessment.firings;
-            report.push("  Counterexample replay: CONFIRMED (abstract chain M0 -> bad re-executed)");
-          } else if (assessment.kind === "unconfirmed") {
-            confirmed = false;
-            report.push(`  Counterexample replay: UNCONFIRMED (${assessment.note})`);
-            report.push("  The verdict rests on Spacer's answer.");
-          } else {
-            report.push("  Counterexample replay: FAILED");
-            report.push(`  Decoded states (order-free set, ${decoded.states.size}):`);
-            for (const m of decoded.states) report.push(`    ${m}`);
-            report.push(`  Raw Z3 answer: ${truncate(queryResult.answer, 2e3)}`);
-            report.push("");
-            report.push("=== RESULT ===\n");
-            report.push(`UNKNOWN: ${assessment.reason}`);
-            return buildResult(
-              { type: "unknown", reason: assessment.reason },
-              report.join("\n"),
-              invariants,
-              [],
-              [],
-              [],
-              performance.now() - start,
-              stats,
-              false
-            );
-          }
-        }
-        report.push("=== RESULT ===\n");
-        report.push(`VIOLATED: ${propDesc}`);
-        if (trace.length > 0) {
-          report.push(`  Counterexample trace (${replayed ? "replay order, " : "proof order, "}${trace.length} states):`);
-          for (let i = 0; i < trace.length; i++) report.push(`    ${i}: ${trace[i]}`);
-        }
-        if (transitions.length > 0) report.push(`  Firing sequence: ${transitions.join(" -> ")}`);
-        report.push("\n  WARNING: This counterexample is in UNTIMED semantics.");
-        report.push("  It may be spurious if timing constraints prevent this sequence.");
-        return this.applyNuGuard(buildResult(
-          { type: "violated" },
-          report.join("\n"),
-          invariants,
-          [],
-          trace,
-          transitions,
-          performance.now() - start,
-          stats,
-          confirmed
-        ), 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,
-          stats
-        );
-      }
-    }
-  }
-  /**
-   * ν-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 (exact) {
-      const note2 = "\nNote: \u03BD-join name equality is encoded exactly via bounded name-colouring (k = budget); the verdict is sound and complete within the budget bound \u2014 no spurious different-name counterexample (NU-050 #1 / NU-053).\n";
-      return { ...result, report: result.report + note2 };
-    }
-    if (!isReachabilitySafety(this._property)) {
-      return downgradeToUnknown(
-        result,
-        "\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 = "\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 "terminates-at-sink":
-    case "joined-or-dead-lettered":
-      return false;
-  }
-}
-function assessCounterexample(flatNet, initialMarking, decodedStates, property, sinkPlaces) {
-  if (decodedStates.size === 0) {
-    return {
-      kind: "unconfirmed",
-      note: "no counterexample states could be decoded from the Spacer answer, so the abstract replay could not run"
-    };
-  }
-  let outcome;
-  try {
-    outcome = replayCounterexample(
-      flatNet,
-      vectorize(initialMarking, flatNet),
-      [...decodedStates].map((m) => vectorize(m, flatNet)),
-      property,
-      sinkPlaces
-    );
-  } catch (e) {
-    outcome = { kind: "exhausted", reason: `replay threw: ${e?.message ?? e}`, nodesExplored: 0 };
-  }
-  switch (outcome.kind) {
-    case "confirmed":
-      return {
-        kind: "confirmed",
-        trace: outcome.states.map((s) => toMarkingState(s, flatNet)),
-        firings: outcome.steps.map(stepName)
-      };
-    case "exhausted":
-      return { kind: "unconfirmed", note: `abstract replay did not complete: ${outcome.reason}` };
-    case "no-chain":
-      return {
-        kind: "downgraded",
-        reason: "counterexample replay found no firing chain to the violation under the abstract semantics, so VIOLATED is withheld"
-      };
-  }
-}
-function certificateDowngradeReason(outcome) {
-  switch (outcome.type) {
-    case "passed":
-      return null;
-    case "failed":
-      return `certificate check failed: ${outcome.vc} was not UNSAT - ${outcome.detail}; the IC3 certificate could not be independently re-validated against the unstrengthened step relation, so PROVEN is withheld`;
-    case "unavailable":
-      return `certificate check could not run: ${outcome.reason}; PROVEN is withheld without an independently validated certificate`;
-  }
-}
-function placeholderCertificate(placeCount) {
-  const params = [];
-  for (let i = 0; i < placeCount; i++) params.push(`(x!${i} Int)`);
-  return `(define-fun Reachable (${params.join(" ")}) Bool
-    true)`;
-}
-function downgradeToUnknown(result, reason) {
-  return {
-    ...result,
-    verdict: { type: "unknown", reason },
-    report: result.report + `
-Downgraded to UNKNOWN: ${reason}
-`,
-    discoveredInvariants: [],
-    counterexampleTrace: [],
-    counterexampleTransitions: [],
-    counterexampleConfirmed: null
-  };
-}
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max)}\u2026 (${s.length - max} chars truncated)`;
-}
-function unresolvedPropertyPlace(flatNet, property) {
-  const named = (() => {
-    switch (property.type) {
-      case "deadlock-free":
-        return [];
-      case "terminates-at-sink":
-        return [];
-      case "mutual-exclusion":
-        return [property.p1, property.p2];
-      case "place-bound":
-        return [property.place];
-      case "branch-place-bound":
-        return [property.place];
-      case "unreachable":
-        return [...property.places];
-      case "joined-or-dead-lettered":
-        return [property.pending];
-    }
-  })();
-  for (const place of named) {
-    if (!flatNet.placeIndex.has(place.name)) return place.name;
-  }
-  return null;
-}
-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.length === 0 ? "0" : parts.join(" + ")} = ${inv.constant}`;
-}
-function buildResult(verdict, report, invariants, discoveredInvariants, trace, transitions, elapsedMs, statistics, counterexampleConfirmed = null) {
-  return { verdict, report, invariants, discoveredInvariants, counterexampleTrace: trace, counterexampleTransitions: transitions, counterexampleConfirmed, 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 {
-  one,
-  exactly,
-  all,
-  atLeast,
-  requiredCount,
-  consumptionCount,
-  and,
-  andPlaces,
-  xor,
-  xorPlaces,
-  outPlace,
-  timeout,
-  timeoutPlace,
-  forwardInput,
-  allPlaces,
-  enumerateBranches,
-  passthrough,
-  isPassthrough,
-  transform,
-  fork,
-  transformFrom,
-  transformAsync,
-  produce,
-  withTimeout,
-  MarkingState,
-  MarkingStateBuilder,
-  deadlockFree,
-  terminatesAtSink,
-  mutualExclusion,
-  placeBound,
-  unreachable,
-  branchPlaceBound,
-  joinedOrDeadLettered,
-  propertyDescription,
-  flatTransition,
-  alwaysAvailable,
-  bounded,
-  ignore,
-  flatten,
-  IncidenceMatrix,
-  pInvariant,
-  pInvariantToString,
-  computePInvariants,
-  strengthenWithSemiflows,
-  computePSemiflows,
-  isCoveredByInvariants,
-  canonicalInvariantOrder,
-  structuralCheck,
-  findMinimalSiphons,
-  findMaximalTrapIn,
-  Z3_ENV,
-  DUMP_ENV,
-  MIN_Z3_VERSION,
-  parseZ3Version,
-  formatZ3Version,
-  Z3Unavailable,
-  Z3ProcessError,
-  z3SolverAt,
-  resolveZ3,
-  z3Available,
-  runZ3Text,
-  runZ3Spacer,
-  encode,
-  encodeStepRelationSmt2,
-  checkCertificate,
-  vcScript,
-  DBM,
-  StateClass,
-  requireOutputProducingActions,
-  StateClassGraph,
-  decode,
-  decodeStateSet,
-  flatNetPlaceCount,
-  flatNetTransitionCount,
-  flatNetIndexOf,
-  replayCounterexample,
-  SmtVerifier,
-  placeholderCertificate,
-  isProven,
-  isViolated
-};
-//# sourceMappingURL=chunk-75KEJQGC.js.map