libpetri 2.7.0 → 2.8.0

package/dist/chunk-M3KT7BFO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/out.ts","../src/verification/marking-state.ts","../src/verification/smt-property.ts","../src/verification/encoding/flat-transition.ts","../src/verification/analysis/environment-analysis-mode.ts","../src/verification/encoding/net-flattener.ts","../src/verification/encoding/incidence-matrix.ts","../src/verification/invariant/p-invariant.ts","../src/verification/invariant/p-invariant-computer.ts","../src/verification/invariant/structural-check.ts","../src/verification/z3/spacer-runner.ts","../src/verification/encoding/flat-net.ts","../src/verification/z3/smt-encoder.ts","../src/verification/analysis/dbm.ts","../src/verification/analysis/state-class.ts","../src/verification/analysis/state-class-graph.ts","../src/verification/z3/counterexample-decoder.ts","../src/verification/z3/name-coloured-encoder.ts","../src/verification/analysis/name-fragment.ts","../src/verification/analysis/name-marking.ts","../src/verification/analysis/name-state-class.ts","../src/verification/analysis/name-state-class-graph.ts","../src/verification/nu-scg-verifier.ts","../src/verification/smt-verifier.ts","../src/verification/smt-verification-result.ts"],"sourcesContent":["import type { Place } from './place.js';\n\n/**\n * Output specification with explicit split semantics.\n * Supports composite structures (XOR of ANDs, AND of XORs, etc.)\n *\n * - And: ALL children must receive tokens\n * - Xor: EXACTLY ONE child receives token\n * - Place: Leaf node representing a single output place\n * - Timeout: Timeout branch that activates if action exceeds duration\n * - ForwardInput: Forward consumed input to output on timeout\n */\nexport type Out = OutAnd | OutXor | OutPlace | OutTimeout | OutForwardInput;\n\nexport interface OutAnd {\n  readonly type: 'and';\n  readonly children: readonly Out[];\n}\n\nexport interface OutXor {\n  readonly type: 'xor';\n  readonly children: readonly Out[];\n}\n\nexport interface OutPlace {\n  readonly type: 'place';\n  readonly place: Place<any>;\n}\n\nexport interface OutTimeout {\n  readonly type: 'timeout';\n  /** Timeout duration in milliseconds. */\n  readonly afterMs: number;\n  readonly child: Out;\n}\n\nexport interface OutForwardInput {\n  readonly type: 'forward-input';\n  readonly from: Place<any>;\n  readonly to: Place<any>;\n}\n\n// ==================== Factory Functions ====================\n\n/**\n * AND-split: all children must receive tokens.\n *\n * @example\n * ```ts\n * // AND of XOR branches: one of (A,B) AND one of (C,D)\n * and(xorPlaces(placeA, placeB), xorPlaces(placeC, placeD))\n *\n * // AND with a fixed place + XOR branch\n * and(outPlace(always), xorPlaces(left, right))\n * ```\n */\nexport function and(...children: Out[]): OutAnd {\n  if (children.length === 0) {\n    throw new Error('AND requires at least 1 child');\n  }\n  return { type: 'and', children };\n}\n\n/** AND-split from places: all places must receive tokens. */\nexport function andPlaces(...places: Place<any>[]): OutAnd {\n  return and(...places.map(outPlace));\n}\n\n/** XOR-split: exactly one child receives token. */\nexport function xor(...children: Out[]): OutXor {\n  if (children.length < 2) {\n    throw new Error('XOR requires at least 2 children');\n  }\n  return { type: 'xor', children };\n}\n\n/** XOR-split from places: exactly one place receives token. */\nexport function xorPlaces(...places: Place<any>[]): OutXor {\n  return xor(...places.map(outPlace));\n}\n\n/** Leaf output spec for a single place. */\nexport function outPlace(p: Place<any>): OutPlace {\n  return { type: 'place', place: p };\n}\n\n/** Timeout output: activates if action exceeds duration. */\nexport function timeout(afterMs: number, child: Out): OutTimeout {\n  if (afterMs <= 0) {\n    throw new Error(`Timeout must be positive: ${afterMs}`);\n  }\n  return { type: 'timeout', afterMs, child };\n}\n\n/** Timeout output pointing to a single place. */\nexport function timeoutPlace(afterMs: number, p: Place<any>): OutTimeout {\n  return timeout(afterMs, outPlace(p));\n}\n\n/** Forward consumed input value to output place on timeout. */\nexport function forwardInput(from: Place<any>, to: Place<any>): OutForwardInput {\n  return { type: 'forward-input', from, to };\n}\n\n// ==================== Helper Functions ====================\n\n/** Collects all leaf places from this output spec (flattened). */\nexport function allPlaces(out: Out): Set<Place<any>> {\n  const result = new Set<Place<any>>();\n  collectPlaces(out, result);\n  return result;\n}\n\nfunction collectPlaces(out: Out, result: Set<Place<any>>): void {\n  switch (out.type) {\n    case 'place':\n      result.add(out.place);\n      break;\n    case 'forward-input':\n      result.add(out.to);\n      break;\n    case 'and':\n    case 'xor':\n      for (const child of out.children) {\n        collectPlaces(child, result);\n      }\n      break;\n    case 'timeout':\n      collectPlaces(out.child, result);\n      break;\n  }\n}\n\n/**\n * Enumerates all possible output branches for structural analysis.\n *\n * - AND = single branch containing all child places (Cartesian product)\n * - XOR = one branch per alternative child\n * - Nested = Cartesian product for AND, union for XOR\n */\nexport function enumerateBranches(out: Out): ReadonlyArray<ReadonlySet<Place<any>>> {\n  switch (out.type) {\n    case 'place':\n      return [new Set([out.place])];\n\n    case 'forward-input':\n      return [new Set<Place<any>>([out.to])];\n\n    case 'and': {\n      let result: Set<Place<any>>[] = [new Set()];\n      for (const child of out.children) {\n        result = crossProduct(result, enumerateBranches(child) as Set<Place<any>>[]);\n      }\n      return result;\n    }\n\n    case 'xor': {\n      const result: Set<Place<any>>[] = [];\n      for (const child of out.children) {\n        result.push(...(enumerateBranches(child) as Set<Place<any>>[]));\n      }\n      return result;\n    }\n\n    case 'timeout':\n      return enumerateBranches(out.child);\n  }\n}\n\nfunction crossProduct(\n  a: Set<Place<any>>[],\n  b: ReadonlyArray<ReadonlySet<Place<any>>>,\n): Set<Place<any>>[] {\n  const result: Set<Place<any>>[] = [];\n  for (const setA of a) {\n    for (const setB of b) {\n      const merged = new Set<Place<any>>(setA);\n      for (const p of setB) merged.add(p);\n      result.push(merged);\n    }\n  }\n  return result;\n}\n","import type { Place } from '../core/place.js';\n\n/** @internal Symbol key restricting construction to the builder and factory methods. */\nconst MARKING_STATE_KEY = Symbol('MarkingState.internal');\n\n/**\n * Immutable snapshot of a Petri net marking for state space analysis.\n *\n * Maps places (by name) to integer token counts. Only stores places with count > 0.\n * Used for invariant computation and structural verification, not runtime execution.\n */\nexport class MarkingState {\n  private readonly tokenCounts: ReadonlyMap<string, number>;\n  private readonly placesByName: ReadonlyMap<string, Place<any>>;\n\n  /** @internal Use {@link MarkingState.builder} or {@link MarkingState.empty} to create instances. */\n  constructor(key: symbol, tokenCounts: Map<string, number>, placesByName: Map<string, Place<any>>) {\n    if (key !== MARKING_STATE_KEY) throw new Error('Use MarkingState.builder() to create instances');\n    this.tokenCounts = tokenCounts;\n    this.placesByName = placesByName;\n  }\n\n  /** Returns the token count for a place (0 if absent). */\n  tokens(place: Place<any>): number {\n    return this.tokenCounts.get(place.name) ?? 0;\n  }\n\n  /** Checks if a place has at least one token. */\n  hasTokens(place: Place<any>): boolean {\n    return this.tokens(place) > 0;\n  }\n\n  /** Checks if any of the given places has tokens. */\n  hasTokensInAny(places: Iterable<Place<any>>): boolean {\n    for (const p of places) {\n      if (this.hasTokens(p)) return true;\n    }\n    return false;\n  }\n\n  /** Returns all places with tokens > 0. */\n  placesWithTokens(): Place<any>[] {\n    return [...this.placesByName.values()];\n  }\n\n  /** Returns the total number of tokens. */\n  totalTokens(): number {\n    let sum = 0;\n    for (const count of this.tokenCounts.values()) sum += count;\n    return sum;\n  }\n\n  /** Checks if no tokens exist anywhere. */\n  isEmpty(): boolean {\n    return this.tokenCounts.size === 0;\n  }\n\n  toString(): string {\n    if (this.tokenCounts.size === 0) return '{}';\n    const entries = [...this.tokenCounts.entries()]\n      .sort(([a], [b]) => a.localeCompare(b))\n      .map(([name, count]) => `${name}:${count}`);\n    return `{${entries.join(', ')}}`;\n  }\n\n  static empty(): MarkingState {\n    return new MarkingState(MARKING_STATE_KEY, new Map(), new Map());\n  }\n\n  static builder(): MarkingStateBuilder {\n    return new MarkingStateBuilder();\n  }\n}\n\nexport class MarkingStateBuilder {\n  private readonly tokenCounts = new Map<string, number>();\n  private readonly placesByName = new Map<string, Place<any>>();\n\n  /** Sets the token count for a place. */\n  tokens(place: Place<any>, count: number): this {\n    if (count < 0) throw new Error(`Token count cannot be negative: ${count}`);\n    if (count > 0) {\n      this.tokenCounts.set(place.name, count);\n      this.placesByName.set(place.name, place);\n    } else {\n      this.tokenCounts.delete(place.name);\n      this.placesByName.delete(place.name);\n    }\n    return this;\n  }\n\n  /** Adds tokens to a place. */\n  addTokens(place: Place<any>, count: number): this {\n    if (count < 0) throw new Error(`Token count cannot be negative: ${count}`);\n    if (count > 0) {\n      const current = this.tokenCounts.get(place.name) ?? 0;\n      this.tokenCounts.set(place.name, current + count);\n      this.placesByName.set(place.name, place);\n    }\n    return this;\n  }\n\n  /** Removes tokens from a place. Throws if insufficient. */\n  removeTokens(place: Place<any>, count: number): this {\n    const current = this.tokenCounts.get(place.name) ?? 0;\n    const newCount = current - count;\n    if (newCount < 0) {\n      throw new Error(\n        `Cannot remove ${count} tokens from ${place.name} (has ${current})`,\n      );\n    }\n    if (newCount === 0) {\n      this.tokenCounts.delete(place.name);\n      this.placesByName.delete(place.name);\n    } else {\n      this.tokenCounts.set(place.name, newCount);\n    }\n    return this;\n  }\n\n  /** Copies all token counts from another marking state. */\n  copyFrom(other: MarkingState): this {\n    for (const p of other.placesWithTokens()) {\n      this.tokenCounts.set(p.name, other.tokens(p));\n      this.placesByName.set(p.name, p);\n    }\n    return this;\n  }\n\n  build(): MarkingState {\n    return new MarkingState(MARKING_STATE_KEY, new Map(this.tokenCounts), new Map(this.placesByName));\n  }\n}\n","import type { Place } from '../core/place.js';\n\n/**\n * Safety properties that can be verified via IC3/PDR.\n *\n * Each property is encoded as an error condition: if a reachable state\n * violates the property, Spacer finds a counterexample. If no violation\n * is reachable, the property is proven.\n */\nexport type SmtProperty =\n  | DeadlockFree\n  | MutualExclusion\n  | PlaceBound\n  | Unreachable\n  | BranchPlaceBound\n  | JoinedOrDeadLettered;\n\n/** Deadlock-freedom: no reachable marking has all transitions disabled. */\nexport interface DeadlockFree {\n  readonly type: 'deadlock-free';\n}\n\n/** Mutual exclusion: two places never have tokens simultaneously. */\nexport interface MutualExclusion {\n  readonly type: 'mutual-exclusion';\n  readonly p1: Place<any>;\n  readonly p2: Place<any>;\n}\n\n/** Place bound: a place never exceeds a given token count. */\nexport interface PlaceBound {\n  readonly type: 'place-bound';\n  readonly place: Place<any>;\n  readonly bound: number;\n}\n\n/** Unreachability: the given places never all have tokens simultaneously. */\nexport interface Unreachable {\n  readonly type: 'unreachable';\n  readonly places: ReadonlySet<Place<any>>;\n}\n\n/**\n * Branch / budget place bound: a ν-net budget or fork-branch place never\n * exceeds `bound` tokens — the bounded-budget decidability lever (NU-040).\n *\n * Encodes identically to {@link PlaceBound} (a linear-integer count bound), but\n * names the ν-net intent: the live correlation pool is bounded, keeping the\n * well-structured transition system finite. The matched-transition\n * over-approximation is sound for this safety bound — a `proven` verdict holds\n * for the real net, which fires strictly fewer joins than the over-approximation.\n */\nexport interface BranchPlaceBound {\n  readonly type: 'branch-place-bound';\n  readonly place: Place<any>;\n  readonly bound: number;\n}\n\n/**\n * Joined-or-dead-lettered: every forked name is eventually joined or\n * dead-lettered, so no reachable *quiescent* (deadlocked) marking still holds a\n * token in `pending` (NU-040). Violated when a reachable marking is both\n * quiescent and has `pending >= 1` — a stranded correlation group.\n */\nexport interface JoinedOrDeadLettered {\n  readonly type: 'joined-or-dead-lettered';\n  readonly pending: Place<any>;\n}\n\n// Factory functions\n\nexport function deadlockFree(): DeadlockFree {\n  return { type: 'deadlock-free' };\n}\n\nexport function mutualExclusion(p1: Place<any>, p2: Place<any>): MutualExclusion {\n  return { type: 'mutual-exclusion', p1, p2 };\n}\n\nexport function placeBound(place: Place<any>, bound: number): PlaceBound {\n  return { type: 'place-bound', place, bound };\n}\n\nexport function unreachable(places: ReadonlySet<Place<any>>): Unreachable {\n  return { type: 'unreachable', places: new Set(places) };\n}\n\n/** Branch / budget place bound (NU-040). See {@link BranchPlaceBound}. */\nexport function branchPlaceBound(place: Place<any>, bound: number): BranchPlaceBound {\n  return { type: 'branch-place-bound', place, bound };\n}\n\n/** Joined-or-dead-lettered at quiescence (NU-040). See {@link JoinedOrDeadLettered}. */\nexport function joinedOrDeadLettered(pending: Place<any>): JoinedOrDeadLettered {\n  return { type: 'joined-or-dead-lettered', pending };\n}\n\n/** Human-readable description of a property. */\nexport function propertyDescription(prop: SmtProperty): string {\n  switch (prop.type) {\n    case 'deadlock-free':\n      return 'Deadlock-freedom';\n    case 'mutual-exclusion':\n      return `Mutual exclusion of ${prop.p1.name} and ${prop.p2.name}`;\n    case 'place-bound':\n      return `Place ${prop.place.name} bounded by ${prop.bound}`;\n    case 'unreachable':\n      return `Unreachability of marking with tokens in {${[...prop.places].map(p => p.name).join(', ')}}`;\n    case 'branch-place-bound':\n      return `Branch place bound (ν-budget): ${prop.place.name} <= ${prop.bound}`;\n    case 'joined-or-dead-lettered':\n      return `Joined-or-dead-lettered: ${prop.pending.name} = 0 at quiescence`;\n  }\n}\n","import type { Transition } from '../../core/transition.js';\n\n/**\n * A flattened transition with pre/post vectors for SMT encoding.\n *\n * Each Transition with XOR outputs is expanded into multiple FlatTransitions\n * (one per branch). Non-XOR transitions map 1:1.\n */\nexport interface FlatTransition {\n  /** Display name (e.g. \"Search_b0\", \"Search_b1\"). */\n  readonly name: string;\n  /** The original transition. */\n  readonly source: Transition;\n  /** Which XOR branch (-1 if no XOR). */\n  readonly branchIndex: number;\n  /** Tokens consumed per place (indexed by place index). */\n  readonly preVector: readonly number[];\n  /** Tokens produced per place (indexed by place index). */\n  readonly postVector: readonly number[];\n  /** Place indices where inhibitor arcs block firing. */\n  readonly inhibitorPlaces: readonly number[];\n  /** Place indices requiring a token without consuming. */\n  readonly readPlaces: readonly number[];\n  /** Place indices set to 0 on firing. */\n  readonly resetPlaces: readonly number[];\n  /** True at index i means place i uses All/AtLeast semantics. */\n  readonly consumeAll: readonly boolean[];\n}\n\nexport function flatTransition(\n  name: string,\n  source: Transition,\n  branchIndex: number,\n  preVector: number[],\n  postVector: number[],\n  inhibitorPlaces: number[],\n  readPlaces: number[],\n  resetPlaces: number[],\n  consumeAll: boolean[],\n): FlatTransition {\n  return {\n    name,\n    source,\n    branchIndex,\n    preVector,\n    postVector,\n    inhibitorPlaces,\n    readPlaces,\n    resetPlaces,\n    consumeAll,\n  };\n}\n","/**\n * Analysis mode for environment places in state class graph construction.\n */\nexport type EnvironmentAnalysisMode =\n  | { readonly type: 'always-available' }\n  | { readonly type: 'bounded'; readonly maxTokens: number }\n  | { readonly type: 'ignore' };\n\n/** Assumes environment places always have sufficient tokens. */\nexport function alwaysAvailable(): EnvironmentAnalysisMode {\n  return { type: 'always-available' };\n}\n\n/** Analyzes with a bounded number of tokens in environment places. */\nexport function bounded(maxTokens: number): EnvironmentAnalysisMode {\n  if (maxTokens < 0) throw new Error('maxTokens must be non-negative');\n  return { type: 'bounded', maxTokens };\n}\n\n/** Treats environment places as regular places (default). */\nexport function ignore(): EnvironmentAnalysisMode {\n  return { type: 'ignore' };\n}\n","/**\n * @module net-flattener\n *\n * Flattens a PetriNet into integer-indexed pre/post vectors for SMT encoding.\n *\n * **XOR expansion**: Transitions with XOR output specs are expanded into multiple\n * flat transitions — one per deterministic branch. Each branch produces tokens to\n * exactly one XOR child's places. This converts non-deterministic output routing\n * into separate transitions that the SMT solver can reason about independently.\n *\n * **Vector construction**: For each flat transition, builds:\n * - `preVector[p]`: tokens consumed from place p (input cardinality)\n * - `postVector[p]`: tokens produced to place p (from the selected branch)\n * - `consumeAll[p]`: true for `all`/`at-least` inputs (consume everything)\n * - Index arrays for inhibitor, read, and reset arcs\n *\n * Places are sorted by name for stable, deterministic indexing across runs.\n */\nimport type { PetriNet } from '../../core/petri-net.js';\nimport type { Place, EnvironmentPlace } from '../../core/place.js';\nimport type { Out } from '../../core/out.js';\nimport type { FlatNet } from './flat-net.js';\nimport { flatTransition } from './flat-transition.js';\nimport { enumerateBranches, allPlaces as outAllPlaces } from '../../core/out.js';\nimport { type EnvironmentAnalysisMode, alwaysAvailable } from '../analysis/environment-analysis-mode.js';\n\n// The SMT path shares the single 3-mode EnvironmentAnalysisMode with the state\n// class graph (VER-006): AlwaysAvailable / Bounded(k) / Ignore. Re-exported here\n// for the encoding barrel so existing `libpetri/verification` consumers resolve it.\nexport { type EnvironmentAnalysisMode, alwaysAvailable, bounded, ignore } from '../analysis/environment-analysis-mode.js';\n\n/**\n * Flattens a PetriNet into a FlatNet suitable for SMT encoding.\n *\n * Flattening involves:\n * 1. Assigning each place a stable integer index (sorted by name)\n * 2. Expanding XOR outputs into separate flat transitions (one per branch)\n * 3. Building pre/post vectors from input/output specs\n * 4. Recording inhibitor, read, and reset arcs\n * 5. Setting environment bounds for bounded analysis mode\n */\nexport function flatten(\n  net: PetriNet,\n  environmentPlaces: Set<EnvironmentPlace<any>> = new Set(),\n  environmentMode: EnvironmentAnalysisMode = alwaysAvailable(),\n): FlatNet {\n  // 1. Collect ALL places\n  const allPlacesSet = new Map<string, Place<any>>();\n  for (const p of net.places) {\n    allPlacesSet.set(p.name, p);\n  }\n  for (const t of net.transitions) {\n    for (const inSpec of t.inputSpecs) {\n      allPlacesSet.set(inSpec.place.name, inSpec.place);\n    }\n    if (t.outputSpec !== null) {\n      for (const p of outAllPlaces(t.outputSpec)) {\n        allPlacesSet.set(p.name, p);\n      }\n    }\n    for (const arc of t.inhibitors) allPlacesSet.set(arc.place.name, arc.place);\n    for (const arc of t.reads) allPlacesSet.set(arc.place.name, arc.place);\n    for (const arc of t.resets) allPlacesSet.set(arc.place.name, arc.place);\n  }\n\n  // Sort by name for stable indexing\n  const places = [...allPlacesSet.values()].sort((a, b) => a.name.localeCompare(b.name));\n\n  const placeIndex = new Map<string, number>();\n  for (let i = 0; i < places.length; i++) {\n    placeIndex.set(places[i]!.name, i);\n  }\n\n  // 2. Compute environment bounds (legacy post-cap) and the injection map.\n  //    The injection map drives the encoder's env-injection rule and the\n  //    incidence-matrix injector columns; bounds remain a harmless extra cap.\n  const environmentBounds = new Map<string, number>();\n  const environmentInjection = new Map<string, number | null>();\n  switch (environmentMode.type) {\n    case 'always-available':\n      for (const ep of environmentPlaces) {\n        environmentInjection.set(ep.place.name, null);\n      }\n      break;\n    case 'bounded':\n      for (const ep of environmentPlaces) {\n        environmentBounds.set(ep.place.name, environmentMode.maxTokens);\n        environmentInjection.set(ep.place.name, environmentMode.maxTokens);\n      }\n      break;\n    case 'ignore':\n      // Not modeled: env places stay ordinary (frozen at their initial count).\n      break;\n  }\n\n  // 3. Expand transitions\n  const n = places.length;\n  const flatTransitions = [];\n\n  for (const transition of net.transitions) {\n    const branches = enumerateOutputBranches(transition);\n\n    for (let branchIdx = 0; branchIdx < branches.length; branchIdx++) {\n      const branchPlaces = branches[branchIdx]!;\n      const name = branches.length > 1\n        ? `${transition.name}_b${branchIdx}`\n        : transition.name;\n\n      // Build pre-vector and consumeAll flags\n      const preVector = new Array<number>(n).fill(0);\n      const consumeAll = new Array<boolean>(n).fill(false);\n\n      for (const inSpec of transition.inputSpecs) {\n        const idx = placeIndex.get(inSpec.place.name);\n        if (idx === undefined) continue;\n\n        switch (inSpec.type) {\n          case 'one':\n            preVector[idx] = 1;\n            break;\n          case 'exactly':\n            preVector[idx] = inSpec.count;\n            break;\n          case 'all':\n            preVector[idx] = 1;\n            consumeAll[idx] = true;\n            break;\n          case 'at-least':\n            preVector[idx] = inSpec.minimum;\n            consumeAll[idx] = true;\n            break;\n        }\n      }\n\n      // Build post-vector from branch output places\n      const postVector = new Array<number>(n).fill(0);\n      for (const p of branchPlaces) {\n        const idx = placeIndex.get(p.name);\n        if (idx !== undefined) {\n          postVector[idx] = 1;\n        }\n      }\n\n      // Inhibitor places\n      const inhibitorPlaces = transition.inhibitors\n        .map(arc => placeIndex.get(arc.place.name))\n        .filter((idx): idx is number => idx !== undefined);\n\n      // Read places\n      const readPlaces = transition.reads\n        .map(arc => placeIndex.get(arc.place.name))\n        .filter((idx): idx is number => idx !== undefined);\n\n      // Reset places\n      const resetPlaces = transition.resets\n        .map(arc => placeIndex.get(arc.place.name))\n        .filter((idx): idx is number => idx !== undefined);\n\n      flatTransitions.push(flatTransition(\n        name,\n        transition,\n        branches.length > 1 ? branchIdx : -1,\n        preVector,\n        postVector,\n        inhibitorPlaces,\n        readPlaces,\n        resetPlaces,\n        consumeAll,\n      ));\n    }\n  }\n\n  return {\n    places,\n    placeIndex,\n    transitions: flatTransitions,\n    environmentBounds,\n    environmentInjection,\n  };\n}\n\nfunction enumerateOutputBranches(t: { outputSpec: Out | null }): ReadonlySet<Place<any>>[] {\n  if (t.outputSpec !== null) {\n    return enumerateBranches(t.outputSpec) as ReadonlySet<Place<any>>[];\n  }\n  // No outputs (sink transition)\n  return [new Set()];\n}\n","import type { FlatNet } from './flat-net.js';\n\n/**\n * Incidence matrix for a flattened Petri net.\n *\n * The incidence matrix C is defined as C[t][p] = post[t][p] - pre[t][p].\n * It captures the net effect of each transition on each place.\n *\n * P-invariants are solutions to y^T * C = 0, found via null space\n * computation on C^T.\n */\nexport class IncidenceMatrix {\n  private readonly _pre: readonly (readonly number[])[];\n  private readonly _post: readonly (readonly number[])[];\n  private readonly _incidence: readonly (readonly number[])[];\n  private readonly _numTransitions: number;\n  private readonly _numPlaces: number;\n\n  private constructor(\n    pre: number[][],\n    post: number[][],\n    incidence: number[][],\n    numTransitions: number,\n    numPlaces: number,\n  ) {\n    this._pre = pre;\n    this._post = post;\n    this._incidence = incidence;\n    this._numTransitions = numTransitions;\n    this._numPlaces = numPlaces;\n  }\n\n  /**\n   * Computes the incidence matrix from a FlatNet.\n   *\n   * Environment-injected places (VER-006) each contribute one extra **injector\n   * column** (a virtual transition that produces one token into that place and\n   * consumes nothing). This makes P-invariant computation env-aware: a valid\n   * invariant `y` must satisfy `y^T·C = 0` for the injector column too, forcing\n   * `y[envPlace] = 0` and thereby discarding closed-net conservation laws (e.g.\n   * `IN + OUT = const`) that would otherwise vacuously bound an injectable place.\n   */\n  static from(flatNet: FlatNet): IncidenceMatrix {\n    const T = flatNet.transitions.length;\n    const P = flatNet.places.length;\n\n    const pre: number[][] = [];\n    const post: number[][] = [];\n    const incidence: number[][] = [];\n\n    for (let t = 0; t < T; t++) {\n      const ft = flatNet.transitions[t]!;\n      const preRow = new Array<number>(P);\n      const postRow = new Array<number>(P);\n      const incRow = new Array<number>(P);\n\n      for (let p = 0; p < P; p++) {\n        preRow[p] = ft.preVector[p]!;\n        postRow[p] = ft.postVector[p]!;\n        incRow[p] = postRow[p]! - preRow[p]!;\n      }\n\n      pre.push(preRow);\n      post.push(postRow);\n      incidence.push(incRow);\n    }\n\n    // Injector columns (one per injected environment place): pre = 0, post = e_p.\n    let injectorCount = 0;\n    for (const name of flatNet.environmentInjection.keys()) {\n      const idx = flatNet.placeIndex.get(name);\n      if (idx == null) continue;\n      const preRow = new Array<number>(P).fill(0);\n      const postRow = new Array<number>(P).fill(0);\n      const incRow = new Array<number>(P).fill(0);\n      postRow[idx] = 1;\n      incRow[idx] = 1;\n      pre.push(preRow);\n      post.push(postRow);\n      incidence.push(incRow);\n      injectorCount++;\n    }\n\n    return new IncidenceMatrix(pre, post, incidence, T + injectorCount, P);\n  }\n\n  /**\n   * Returns C^T (transpose of incidence matrix), dimensions [P][T].\n   * Used for P-invariant computation: null space of C^T gives P-invariants.\n   */\n  transposedIncidence(): number[][] {\n    const ct: number[][] = [];\n    for (let p = 0; p < this._numPlaces; p++) {\n      const row = new Array<number>(this._numTransitions);\n      for (let t = 0; t < this._numTransitions; t++) {\n        row[t] = this._incidence[t]![p]!;\n      }\n      ct.push(row);\n    }\n    return ct;\n  }\n\n  /** Returns the pre-matrix (tokens consumed). T×P. */\n  pre(): readonly (readonly number[])[] { return this._pre; }\n\n  /** Returns the post-matrix (tokens produced). T×P. */\n  post(): readonly (readonly number[])[] { return this._post; }\n\n  /** Returns the incidence matrix C[t][p] = post - pre. T×P. */\n  incidence(): readonly (readonly number[])[] { return this._incidence; }\n\n  numTransitions(): number { return this._numTransitions; }\n  numPlaces(): number { return this._numPlaces; }\n}\n","/**\n * A P-invariant (place invariant) of a Petri net.\n *\n * A P-invariant is a vector y such that y^T * C = 0, where C is the\n * incidence matrix. This means that for any reachable marking M:\n * sum(y_i * M_i) = constant, where constant = sum(y_i * M0_i).\n *\n * P-invariants provide structural bounds on places and are used as\n * strengthening lemmas for the IC3/PDR engine.\n */\nexport interface PInvariant {\n  /** Weight vector (one entry per place index). */\n  readonly weights: readonly number[];\n  /** The invariant value sum(y_i * M0_i). */\n  readonly constant: number;\n  /** Set of place indices where weight != 0. */\n  readonly support: ReadonlySet<number>;\n}\n\nexport function pInvariant(weights: number[], constant: number, support: Set<number>): PInvariant {\n  return { weights, constant, support };\n}\n\nexport function pInvariantToString(inv: PInvariant): string {\n  const parts: string[] = [];\n  for (const i of inv.support) {\n    if (inv.weights[i] !== 1) {\n      parts.push(`${inv.weights[i]}*p${i}`);\n    } else {\n      parts.push(`p${i}`);\n    }\n  }\n  return `PInvariant[${parts.join(' + ')} = ${inv.constant}]`;\n}\n","/**\n * @module p-invariant-computer\n *\n * Computes P-invariants of a Petri net via integer Gaussian elimination (Farkas' algorithm).\n *\n * **Algorithm**: A P-invariant is a non-negative integer vector y such that y^T · C = 0\n * (where C is the incidence matrix). This expresses a conservation law: the weighted\n * token sum Σ(y_i · M[i]) is constant across all reachable markings.\n *\n * **Farkas variant**: Constructs the augmented matrix [C^T | I_P] and row-reduces\n * the C^T portion to zero using integer elimination (no floating point). Rows where\n * the C^T part becomes all-zero yield invariant vectors from the identity part.\n * Row normalization by GCD keeps values small during elimination.\n *\n * **Integer Gaussian elimination**: Each elimination step multiplies rows by pivot\n * coefficients (a·row - b·pivotRow) to avoid fractions. This preserves integer\n * arithmetic throughout, critical for exact invariant computation.\n *\n * Invariants are used to strengthen SMT queries (added as constraints on M').\n */\nimport type { FlatNet } from '../encoding/flat-net.js';\nimport type { IncidenceMatrix } from '../encoding/incidence-matrix.js';\nimport type { MarkingState } from '../marking-state.js';\nimport type { PInvariant } from './p-invariant.js';\nimport { pInvariant } from './p-invariant.js';\n\n/**\n * Computes P-invariants of a Petri net via integer Gaussian elimination.\n *\n * P-invariants are non-negative integer vectors y where y^T * C = 0.\n * They express conservation laws: the weighted token sum is constant\n * across all reachable markings.\n *\n * Algorithm: compute the null space of C^T using integer row reduction\n * with an augmented identity matrix (Farkas' algorithm variant).\n */\nexport function computePInvariants(\n  matrix: IncidenceMatrix,\n  flatNet: FlatNet,\n  initialMarking: MarkingState,\n): PInvariant[] {\n  const P = matrix.numPlaces();\n  const T = matrix.numTransitions();\n\n  if (P === 0 || T === 0) return [];\n\n  // We want to find y such that y^T * C = 0, i.e., C^T * y = 0\n  // Start with augmented matrix [C^T | I_P]\n  // Row-reduce C^T part to zero; the I_P part gives the invariant vectors.\n  const ct = matrix.transposedIncidence(); // P × T\n\n  // Augmented matrix: P rows, T + P columns\n  // Use regular numbers (safe for nets with < ~50 places/transitions)\n  const cols = T + P;\n  const augmented: number[][] = [];\n  for (let i = 0; i < P; i++) {\n    const row = new Array<number>(cols).fill(0);\n    for (let j = 0; j < T; j++) {\n      row[j] = ct[i]![j]!;\n    }\n    row[T + i] = 1; // identity part\n    augmented.push(row);\n  }\n\n  // Integer Gaussian elimination on the C^T part (columns 0..T-1)\n  let pivotRow = 0;\n  for (let col = 0; col < T && pivotRow < P; col++) {\n    // Find pivot (non-zero entry in this column)\n    let pivot = -1;\n    for (let row = pivotRow; row < P; row++) {\n      if (augmented[row]![col] !== 0) {\n        pivot = row;\n        break;\n      }\n    }\n    if (pivot === -1) continue; // free variable\n\n    // Swap pivot row\n    if (pivot !== pivotRow) {\n      const tmp = augmented[pivotRow]!;\n      augmented[pivotRow] = augmented[pivot]!;\n      augmented[pivot] = tmp;\n    }\n\n    // Eliminate this column in all other rows\n    for (let row = 0; row < P; row++) {\n      if (row === pivotRow || augmented[row]![col] === 0) continue;\n\n      const a = augmented[pivotRow]![col]!;\n      const b = augmented[row]![col]!;\n\n      // row = a*row - b*pivotRow (keeps integers, eliminates col)\n      for (let c = 0; c < cols; c++) {\n        augmented[row]![c] = a * augmented[row]![c]! - b * augmented[pivotRow]![c]!;\n      }\n\n      // Normalize by GCD to keep values small\n      normalizeRow(augmented[row]!, cols);\n    }\n\n    pivotRow++;\n  }\n\n  // Extract invariants: rows where C^T part is all zeros\n  const invariants: PInvariant[] = [];\n  for (let row = 0; row < P; row++) {\n    let isZero = true;\n    for (let col = 0; col < T; col++) {\n      if (augmented[row]![col] !== 0) {\n        isZero = false;\n        break;\n      }\n    }\n    if (!isZero) continue;\n\n    // Extract the weight vector from the identity part\n    const weights = new Array<number>(P);\n    let allNonNegative = true;\n    let hasPositive = false;\n\n    for (let i = 0; i < P; i++) {\n      weights[i] = augmented[row]![T + i]!;\n      if (weights[i]! < 0) {\n        allNonNegative = false;\n        break;\n      }\n      if (weights[i]! > 0) hasPositive = true;\n    }\n\n    // We want semi-positive invariants (all weights >= 0, at least one > 0)\n    if (!allNonNegative) {\n      // Try negating\n      let allNonPositive = true;\n      for (let i = 0; i < P; i++) {\n        if (augmented[row]![T + i]! > 0) {\n          allNonPositive = false;\n          break;\n        }\n      }\n      if (allNonPositive) {\n        for (let i = 0; i < P; i++) {\n          weights[i] = -augmented[row]![T + i]!;\n        }\n        hasPositive = true;\n        allNonNegative = true;\n      }\n    }\n\n    if (!allNonNegative || !hasPositive) continue;\n\n    // Normalize: divide by GCD of weights\n    let g = 0;\n    for (const w of weights) {\n      if (w > 0) g = gcd(g, w);\n    }\n    if (g > 1) {\n      for (let i = 0; i < P; i++) {\n        weights[i] = weights[i]! / g;\n      }\n    }\n\n    // Compute support and constant\n    const support = new Set<number>();\n    let constant = 0;\n    for (let i = 0; i < P; i++) {\n      if (weights[i] !== 0) {\n        support.add(i);\n        const place = flatNet.places[i]!;\n        constant += weights[i]! * initialMarking.tokens(place);\n      }\n    }\n\n    invariants.push(pInvariant(weights, constant, support));\n  }\n\n  return invariants;\n}\n\n/**\n * Checks if every place is covered by at least one P-invariant.\n * If true, the net is structurally bounded.\n */\nexport function isCoveredByInvariants(invariants: readonly PInvariant[], numPlaces: number): boolean {\n  const covered = new Array<boolean>(numPlaces).fill(false);\n  for (const inv of invariants) {\n    for (const idx of inv.support) {\n      if (idx < numPlaces) covered[idx] = true;\n    }\n  }\n  return covered.every(c => c);\n}\n\nfunction normalizeRow(row: number[], cols: number): void {\n  let g = 0;\n  for (let c = 0; c < cols; c++) {\n    if (row[c] !== 0) {\n      g = gcd(g, Math.abs(row[c]!));\n    }\n  }\n  if (g > 1) {\n    for (let c = 0; c < cols; c++) {\n      row[c] = row[c]! / g;\n    }\n  }\n}\n\nfunction gcd(a: number, b: number): number {\n  while (b !== 0) {\n    const t = b;\n    b = a % b;\n    a = t;\n  }\n  return a;\n}\n","/**\n * @module structural-check\n *\n * Structural deadlock pre-check using siphon/trap analysis (Commoner's theorem).\n *\n * **Commoner's theorem**: A Petri net is deadlock-free if every siphon contains\n * an initially marked trap.\n *\n * **Siphon**: A set of places S where every transition that outputs to S also\n * inputs from S. Key property: once all places in a siphon become empty,\n * they can never be re-marked. An empty siphon can cause deadlock.\n *\n * **Trap**: A set of places S where every transition that inputs from S also\n * outputs to S. Key property: once any place in a trap is marked,\n * the trap remains marked forever.\n *\n * **Algorithm**: For each place, compute the minimal siphon containing it via\n * fixed-point expansion. For each siphon, find the maximal trap within it\n * (fixed-point contraction). If every siphon contains an initially-marked\n * trap, deadlock-freedom is proven structurally — no SMT query needed.\n *\n * Limited to nets with ≤50 places to bound enumeration cost.\n */\nimport type { FlatNet } from '../encoding/flat-net.js';\nimport type { MarkingState } from '../marking-state.js';\n\nconst MAX_PLACES_FOR_SIPHON_ANALYSIS = 50;\n\n/**\n * Result of structural deadlock check using siphon/trap analysis.\n */\nexport type StructuralCheckResult =\n  | { readonly type: 'no-potential-deadlock' }\n  | { readonly type: 'potential-deadlock'; readonly siphon: ReadonlySet<number> }\n  | { readonly type: 'inconclusive'; readonly reason: string };\n\n/**\n * Structural deadlock pre-check using siphon/trap analysis.\n *\n * Commoner's theorem: a Petri net is deadlock-free if every siphon\n * contains a marked trap.\n *\n * A siphon is a set of places S such that every transition with\n * an output in S also has an input in S. Once empty, a siphon stays empty.\n *\n * A trap is a set of places S such that every transition with\n * an input in S also has an output in S. Once marked, a trap stays marked.\n */\nexport function structuralCheck(flatNet: FlatNet, initialMarking: MarkingState): StructuralCheckResult {\n  const P = flatNet.places.length;\n\n  if (P === 0) {\n    return { type: 'no-potential-deadlock' };\n  }\n\n  if (P > MAX_PLACES_FOR_SIPHON_ANALYSIS) {\n    return { type: 'inconclusive', reason: `Net has ${P} places, siphon enumeration skipped` };\n  }\n\n  const siphons = findMinimalSiphons(flatNet);\n\n  if (siphons.length === 0) {\n    return { type: 'no-potential-deadlock' };\n  }\n\n  for (const siphon of siphons) {\n    const trap = findMaximalTrapIn(flatNet, siphon);\n\n    if (trap.size === 0 || !isMarked(trap, flatNet, initialMarking)) {\n      return { type: 'potential-deadlock', siphon };\n    }\n  }\n\n  return { type: 'no-potential-deadlock' };\n}\n\n/**\n * Finds minimal siphons by checking all non-empty subsets of deadlock-enabling places.\n * Uses a fixed-point approach: start from each place and grow the siphon.\n */\nexport function findMinimalSiphons(flatNet: FlatNet): ReadonlySet<number>[] {\n  const P = flatNet.places.length;\n  const siphons: Set<number>[] = [];\n\n  // Pre-compute: for each place, which transitions have it as output?\n  const placeAsOutput: number[][] = [];\n  for (let p = 0; p < P; p++) {\n    placeAsOutput.push([]);\n  }\n\n  for (let t = 0; t < flatNet.transitions.length; t++) {\n    const ft = flatNet.transitions[t]!;\n    for (let p = 0; p < P; p++) {\n      if (ft.postVector[p]! > 0) {\n        placeAsOutput[p]!.push(t);\n      }\n    }\n  }\n\n  for (let startPlace = 0; startPlace < P; startPlace++) {\n    const siphon = computeSiphonContaining(startPlace, flatNet, placeAsOutput);\n    if (siphon !== null && siphon.size > 0) {\n      let isMinimal = true;\n      const toRemove: number[] = [];\n      for (let i = 0; i < siphons.length; i++) {\n        const existing = siphons[i]!;\n        if (setsEqual(existing, siphon)) {\n          isMinimal = false;\n          break;\n        }\n        if (isSubsetOf(existing, siphon)) {\n          isMinimal = false;\n          break;\n        }\n        if (isSubsetOf(siphon, existing)) {\n          toRemove.push(i);\n        }\n      }\n      for (let i = toRemove.length - 1; i >= 0; i--) {\n        siphons.splice(toRemove[i]!, 1);\n      }\n      if (isMinimal) {\n        siphons.push(siphon);\n      }\n    }\n  }\n\n  return siphons;\n}\n\nfunction computeSiphonContaining(\n  startPlace: number,\n  flatNet: FlatNet,\n  placeAsOutput: number[][],\n): Set<number> | null {\n  const siphon = new Set<number>();\n  siphon.add(startPlace);\n\n  let changed = true;\n  while (changed) {\n    changed = false;\n    const snapshot = [...siphon];\n\n    for (const p of snapshot) {\n      for (const t of placeAsOutput[p]!) {\n        const ft = flatNet.transitions[t]!;\n\n        let hasInputInSiphon = false;\n        for (let q = 0; q < flatNet.places.length; q++) {\n          if (ft.preVector[q]! > 0 && siphon.has(q)) {\n            hasInputInSiphon = true;\n            break;\n          }\n        }\n\n        if (!hasInputInSiphon) {\n          let added = false;\n          for (let q = 0; q < flatNet.places.length; q++) {\n            if (ft.preVector[q]! > 0) {\n              if (!siphon.has(q)) {\n                siphon.add(q);\n                changed = true;\n              }\n              added = true;\n              break;\n            }\n          }\n          if (!added) {\n            return null;\n          }\n        }\n      }\n    }\n  }\n\n  return siphon;\n}\n\n/**\n * Finds the maximal trap within a given set of places.\n * Uses fixed-point: start with the full set and remove places that violate the trap condition.\n */\nexport function findMaximalTrapIn(flatNet: FlatNet, places: ReadonlySet<number>): ReadonlySet<number> {\n  const trap = new Set(places);\n\n  let changed = true;\n  while (changed) {\n    changed = false;\n    const toRemove: number[] = [];\n\n    for (const p of trap) {\n      let satisfies = true;\n      for (let t = 0; t < flatNet.transitions.length; t++) {\n        const ft = flatNet.transitions[t]!;\n        if (ft.preVector[p]! > 0) {\n          let outputsToTrap = false;\n          for (const q of trap) {\n            if (ft.postVector[q]! > 0) {\n              outputsToTrap = true;\n              break;\n            }\n          }\n          if (!outputsToTrap) {\n            satisfies = false;\n            break;\n          }\n        }\n      }\n      if (!satisfies) {\n        toRemove.push(p);\n      }\n    }\n\n    if (toRemove.length > 0) {\n      for (const p of toRemove) trap.delete(p);\n      changed = true;\n    }\n  }\n\n  return trap;\n}\n\nfunction isMarked(placeIndices: ReadonlySet<number>, flatNet: FlatNet, marking: MarkingState): boolean {\n  for (const idx of placeIndices) {\n    const place = flatNet.places[idx]!;\n    if (marking.tokens(place) > 0) return true;\n  }\n  return false;\n}\n\nfunction setsEqual(a: ReadonlySet<number>, b: ReadonlySet<number>): boolean {\n  if (a.size !== b.size) return false;\n  for (const v of a) {\n    if (!b.has(v)) return false;\n  }\n  return true;\n}\n\nfunction isSubsetOf(sub: ReadonlySet<number>, sup: ReadonlySet<number>): boolean {\n  if (sub.size > sup.size) return false;\n  for (const v of sub) {\n    if (!sup.has(v)) return false;\n  }\n  return true;\n}\n","import { init } from 'z3-solver';\nimport type { Bool, Expr, FuncDecl } from 'z3-solver';\n\n/**\n * Result of a Spacer query.\n */\nexport type QueryResult = QueryProven | QueryViolated | QueryUnknown;\n\n/** Property proven: no reachable error state (UNSAT). */\nexport interface QueryProven {\n  readonly type: 'proven';\n  readonly invariantFormula: string | null;\n  readonly levelInvariants: readonly string[];\n}\n\n/** Counterexample found (SAT). The answer is the derivation tree. */\nexport interface QueryViolated {\n  readonly type: 'violated';\n  readonly answer: Expr | null;\n}\n\n/** Solver could not determine (timeout, resource limit). */\nexport interface QueryUnknown {\n  readonly type: 'unknown';\n  readonly reason: string;\n}\n\n/**\n * The Z3 context and helpers returned by SpacerRunner.create().\n * Exposes the context object for building expressions.\n */\nexport interface SpacerContext {\n  /** The Z3 high-level context for building expressions. */\n  readonly ctx: ReturnType<Awaited<ReturnType<typeof init>>['Context']>;\n  /** The Z3 Fixedpoint solver instance (Spacer engine). Z3 types are complex; using any. */\n  readonly fp: any;\n\n  /** Queries whether the error state is reachable. */\n  query(errorExpr: Bool, reachableDecl?: FuncDecl): Promise<QueryResult>;\n\n  /** Releases Z3 resources. */\n  dispose(): void;\n}\n\n// Use a type alias for the Z3 context to avoid the deep inference\ntype Z3Context = ReturnType<Awaited<ReturnType<typeof init>>['Context']>;\n\n/**\n * Creates a Spacer runner with the given timeout.\n *\n * Uses Z3's Spacer engine (CHC solver based on IC3/PDR) to prove or\n * disprove safety properties.\n */\nexport async function createSpacerRunner(timeoutMs: number): Promise<SpacerContext> {\n  const { Context } = await init();\n  const ctx = new Context('main') as Z3Context;\n  const fp = new (ctx as any).Fixedpoint() as any;\n\n  // Configure Spacer engine\n  fp.set('engine', 'spacer');\n  if (timeoutMs > 0) {\n    fp.set('timeout', Math.min(timeoutMs, 2147483647));\n  }\n\n  async function query(errorExpr: Bool, reachableDecl?: FuncDecl): Promise<QueryResult> {\n    try {\n      const status = await fp.query(errorExpr);\n\n      if (status === 'unsat') {\n        let invariantFormula: string | null = null;\n        const levelInvariants: string[] = [];\n\n        try {\n          const answer = fp.getAnswer();\n          if (answer != null) {\n            invariantFormula = answer.toString();\n          }\n        } catch {\n          // Some configurations don't produce answers\n        }\n\n        if (reachableDecl != null) {\n          try {\n            const levels = fp.getNumLevels(reachableDecl);\n            for (let i = 0; i < levels; i++) {\n              const cover = fp.getCoverDelta(i, reachableDecl);\n              if (cover != null && !(ctx as any).isTrue(cover)) {\n                levelInvariants.push(`Level ${i}: ${cover.toString()}`);\n              }\n            }\n          } catch {\n            // Level queries may not be available\n          }\n        }\n\n        return { type: 'proven', invariantFormula, levelInvariants };\n      }\n\n      if (status === 'sat') {\n        let answer: Expr | null = null;\n        try {\n          answer = fp.getAnswer();\n        } catch {\n          // Some configurations don't produce answers\n        }\n        return { type: 'violated', answer };\n      }\n\n      // unknown\n      return { type: 'unknown', reason: fp.getReasonUnknown() };\n    } catch (e: any) {\n      return { type: 'unknown', reason: `Z3 exception: ${e.message ?? e}` };\n    }\n  }\n\n  function dispose(): void {\n    try {\n      fp.release();\n    } catch {\n      // ignore\n    }\n  }\n\n  return {\n    ctx,\n    fp,\n    query,\n    dispose,\n  } as SpacerContext;\n}\n","import type { Place } from '../../core/place.js';\nimport type { FlatTransition } from './flat-transition.js';\n\n/**\n * A flattened Petri net with indexed places and XOR-expanded transitions.\n *\n * Intermediate representation between the high-level PetriNet and Z3 CHC encoding.\n */\nexport interface FlatNet {\n  /** Ordered list of places (index = position). */\n  readonly places: readonly Place<any>[];\n  /** Reverse lookup: place name -> index. */\n  readonly placeIndex: ReadonlyMap<string, number>;\n  /** XOR-expanded flat transitions. */\n  readonly transitions: readonly FlatTransition[];\n  /** For bounded environment places: place name -> max tokens. */\n  readonly environmentBounds: ReadonlyMap<string, number>;\n  /**\n   * Environment places whose tokens the analysis MODELS as externally injected\n   * (VER-006). Maps env place name -> injection bound: a number caps injection\n   * (`Bounded(k)`), `null` means unbounded (`AlwaysAvailable`). Absent entries\n   * (incl. `Ignore` mode) are not injected. The encoder emits one injection CHC\n   * rule per entry and the incidence matrix gains one injector column per entry\n   * so closed-net P-invariants over these places are correctly discarded.\n   */\n  readonly environmentInjection: ReadonlyMap<string, number | null>;\n}\n\nexport function flatNetPlaceCount(net: FlatNet): number {\n  return net.places.length;\n}\n\nexport function flatNetTransitionCount(net: FlatNet): number {\n  return net.transitions.length;\n}\n\nexport function flatNetIndexOf(net: FlatNet, place: Place<any>): number {\n  return net.placeIndex.get(place.name) ?? -1;\n}\n","/**\n * @module smt-encoder\n *\n * Encodes a flattened Petri net as Constrained Horn Clauses (CHC) for Z3's Spacer engine.\n *\n * **CHC encoding strategy**: The net's state space is modeled as integer vectors\n * (one variable per place = token count). Three rule types:\n *\n * 1. **Init**: `Reachable(M0)` — the initial marking is reachable\n * 2. **Transition**: `Reachable(M') :- Reachable(M) ∧ enabled(M,t) ∧ fire(M,M',t)` —\n *    one rule per flat transition (XOR branches are separate transitions)\n * 3. **Error**: `Error() :- Reachable(M) ∧ violation(M)` — safety property violation\n *\n * Transition rules include: non-negativity constraints on M', P-invariant strengthening\n * clauses, and environment bounds for bounded analysis.\n *\n * Z3 types are complex and partially untyped; the ctx/fp parameters use `any`.\n */\nimport type { Arith, Bool, FuncDecl } from 'z3-solver';\nimport type { FlatNet } from '../encoding/flat-net.js';\nimport type { FlatTransition } from '../encoding/flat-transition.js';\nimport type { MarkingState } from '../marking-state.js';\nimport type { SmtProperty } from '../smt-property.js';\nimport type { PInvariant } from '../invariant/p-invariant.js';\nimport type { Place } from '../../core/place.js';\nimport { flatNetIndexOf } from '../encoding/flat-net.js';\n\n/** Z3 high-level context. Typed as `any` because z3-solver's TS types are incomplete. */\ntype Z3Context = any;\n/** Z3 Fixedpoint solver instance. Typed as `any` because z3-solver's TS types are incomplete. */\ntype Z3Fixedpoint = any;\n\n/**\n * Result of CHC encoding.\n */\nexport interface EncodingResult {\n  readonly errorExpr: Bool;\n  readonly reachableDecl: FuncDecl;\n}\n\n/**\n * Encodes a flattened Petri net as Constrained Horn Clauses (CHC) for Z3's Spacer engine.\n *\n * CHC rules:\n * - Reachable(M0) — initial state is reachable\n * - Reachable(M') :- Reachable(M) AND enabled(M,t) AND fire(M,M',t) — transition rules\n * - Error() :- Reachable(M) AND property_violation(M) — safety property\n */\nexport function encode(\n  ctx: Z3Context,\n  fp: Z3Fixedpoint,\n  flatNet: FlatNet,\n  initialMarking: MarkingState,\n  property: SmtProperty,\n  invariants: readonly PInvariant[],\n  sinkPlaces: ReadonlySet<Place<any>> = new Set(),\n): EncodingResult {\n  const P = flatNet.places.length;\n  const Int = ctx.Int;\n  const Bool_ = ctx.Bool;\n\n  // Create sorts array for function declaration\n  const intSort = Int.sort();\n  const boolSort = Bool_.sort();\n  const markingSorts: any[] = new Array(P).fill(intSort);\n\n  // Create the Reachable relation: (Int, Int, ...) -> Bool\n  const reachable: FuncDecl = ctx.Function.declare('Reachable', ...markingSorts, boolSort);\n  fp.registerRelation(reachable);\n\n  // Create the Error relation: () -> Bool\n  const error: FuncDecl = ctx.Function.declare('Error', boolSort);\n  fp.registerRelation(error);\n\n  // === Rule 1: Initial state ===\n  // Reachable(m0_0, m0_1, ..., m0_{P-1})\n  const m0Args: Arith[] = [];\n  for (let i = 0; i < P; i++) {\n    const tokens = initialMarking.tokens(flatNet.places[i]!);\n    m0Args.push(Int.val(tokens));\n  }\n  const initFact = (reachable as any).call(...m0Args) as Bool;\n  fp.addRule(initFact, 'init');\n\n  // === Rule 2: Transition rules ===\n  for (let t = 0; t < flatNet.transitions.length; t++) {\n    const ft = flatNet.transitions[t]!;\n    encodeTransitionRule(ctx, fp, reachable, ft, flatNet, invariants, P);\n  }\n\n  // === Rule 2b: Environment-injection rules (VER-006) ===\n  // Per injected env place p: Reachable(M') :- Reachable(M) ∧ [M[p] < bound] ∧\n  //   M'[p] = M[p]+1 ∧ (∀q≠p) M'[q] = M[q]. Unbounded (AlwaysAvailable) omits the\n  //   guard so p can grow without limit. These are NOT flat transitions, so the\n  //   deadlock encoding (which iterates flatNet.transitions) never sees them and\n  //   deadlock-freedom does not become trivially true. P-invariants are NOT\n  //   conjoined here — injection deliberately breaks closed-net conservation.\n  for (const [name, bound] of flatNet.environmentInjection) {\n    const idx = flatNet.placeIndex.get(name);\n    if (idx == null) continue;\n    encodeInjectionRule(ctx, fp, reachable, idx, bound, P);\n  }\n\n  // === Rule 3: Error rule (property violation) ===\n  encodeErrorRule(ctx, fp, reachable, error, flatNet, property, sinkPlaces, P);\n\n  return {\n    errorExpr: (error as any).call() as Bool,\n    reachableDecl: reachable,\n  };\n}\n\nfunction encodeTransitionRule(\n  ctx: Z3Context,\n  fp: Z3Fixedpoint,\n  reachable: FuncDecl,\n  ft: FlatTransition,\n  flatNet: FlatNet,\n  invariants: readonly PInvariant[],\n  P: number,\n): void {\n  const Int = ctx.Int;\n\n  // Create named variables for current and next marking\n  const mVars: Arith[] = [];\n  const mPrimeVars: Arith[] = [];\n  for (let i = 0; i < P; i++) {\n    mVars.push(Int.const(`m${i}`));\n    mPrimeVars.push(Int.const(`mp${i}`));\n  }\n\n  // Body: Reachable(M) AND enabled(M,t) AND fire(M,M',t) AND non-negativity(M') AND invariants(M') AND env bounds(M')\n  const reachBody = (reachable as any).call(...mVars) as Bool;\n  const enabled = encodeEnabled(ctx, ft, flatNet, mVars, P);\n  const fireRelation = encodeFire(ctx, ft, flatNet, mVars, mPrimeVars, P);\n\n  // Non-negativity of M'\n  let nonNeg: Bool = ctx.Bool.val(true);\n  for (let i = 0; i < P; i++) {\n    nonNeg = ctx.And(nonNeg, mPrimeVars[i]!.ge(0));\n  }\n\n  // P-invariant constraints on M'\n  const invConstraints = encodeInvariantConstraints(ctx, invariants, mPrimeVars, P);\n\n  // Environment bounds on M'\n  let envBounds: Bool = ctx.Bool.val(true);\n  for (const [name, bound] of flatNet.environmentBounds) {\n    const idx = flatNet.placeIndex.get(name);\n    if (idx != null) {\n      envBounds = ctx.And(envBounds, mPrimeVars[idx]!.le(bound));\n    }\n  }\n\n  // Body conjunction\n  const body = ctx.And(reachBody, enabled, fireRelation, nonNeg, invConstraints, envBounds);\n\n  // Head: Reachable(M')\n  const head = (reachable as any).call(...mPrimeVars) as Bool;\n\n  // Rule: forall M, M'. body => head\n  const allVars = [...mVars, ...mPrimeVars];\n  const rule = ctx.Implies(body, head);\n  const qRule = ctx.ForAll(allVars, rule);\n\n  fp.addRule(qRule, `t_${ft.name}`);\n}\n\n/**\n * Encodes one environment-injection rule (VER-006): the external world adds a\n * token to environment place `idx`. `bound === null` ⇒ unbounded (AlwaysAvailable);\n * a number ⇒ guarded so the place never exceeds `bound` (Bounded). All other\n * columns are copied unchanged. No P-invariant strengthening (injection breaks\n * conservation by design); non-negativity is implied by `M[idx] ≥ 0 ⇒ M'[idx] ≥ 1`.\n */\nfunction encodeInjectionRule(\n  ctx: Z3Context,\n  fp: Z3Fixedpoint,\n  reachable: FuncDecl,\n  idx: number,\n  bound: number | null,\n  P: number,\n): void {\n  const Int = ctx.Int;\n\n  const mVars: Arith[] = [];\n  const mPrimeVars: Arith[] = [];\n  for (let i = 0; i < P; i++) {\n    mVars.push(Int.const(`m${i}`));\n    mPrimeVars.push(Int.const(`mp${i}`));\n  }\n\n  const reachBody = (reachable as any).call(...mVars) as Bool;\n\n  let fire: Bool = ctx.Bool.val(true);\n  for (let i = 0; i < P; i++) {\n    if (i === idx) {\n      fire = ctx.And(fire, mPrimeVars[i]!.eq(mVars[i]!.add(1)));\n    } else {\n      fire = ctx.And(fire, mPrimeVars[i]!.eq(mVars[i]!));\n    }\n  }\n\n  // Bounded injection: only inject while still below the cap.\n  const guard: Bool = bound === null ? ctx.Bool.val(true) : mVars[idx]!.lt(bound);\n\n  const body = ctx.And(reachBody, guard, fire);\n  const head = (reachable as any).call(...mPrimeVars) as Bool;\n  const qRule = ctx.ForAll([...mVars, ...mPrimeVars], ctx.Implies(body, head));\n\n  fp.addRule(qRule, `env_inject_${idx}`);\n}\n\n/** Maps injected environment-place index -> injection bound (null = unbounded). */\nfunction injectedEnvIndices(flatNet: FlatNet): Map<number, number | null> {\n  const out = new Map<number, number | null>();\n  for (const [name, bound] of flatNet.environmentInjection) {\n    const idx = flatNet.placeIndex.get(name);\n    if (idx != null) out.set(idx, bound);\n  }\n  return out;\n}\n\n/**\n * Encodes the enablement predicate for a flat transition.\n *\n * When `relaxEnv` is true (used only by the deadlock check), input/read\n * requirements on injectable environment places are treated as satisfiable by\n * external injection — `AlwaysAvailable` always satisfies them, `Bounded(k)`\n * satisfies them iff the required cardinality is ≤ k (a compile-time check on the\n * arc weight, not on the marking). This mirrors the state class graph's\n * always-available enablement (VER-006) so a reactive net merely *waiting for\n * input* is not reported as a deadlock; only a marking that no injection could\n * ever re-enable counts. Transition firing rules always use the strict form\n * (`relaxEnv` false) because firing genuinely consumes tokens.\n */\nfunction encodeEnabled(\n  ctx: Z3Context,\n  ft: FlatTransition,\n  flatNet: FlatNet,\n  mVars: Arith[],\n  P: number,\n  relaxEnv = false,\n): Bool {\n  let result: Bool = ctx.Bool.val(true);\n  const envInj = relaxEnv ? injectedEnvIndices(flatNet) : undefined;\n\n  // Input requirements: M[p] >= pre[p] (relaxed for injectable env inputs).\n  for (let p = 0; p < P; p++) {\n    const pre = ft.preVector[p]!;\n    if (pre <= 0) continue;\n    if (envInj?.has(p)) {\n      const bound = envInj.get(p)!;\n      if (bound !== null && pre > bound) return ctx.Bool.val(false); // never enableable\n      continue; // satisfiable by injection\n    }\n    result = ctx.And(result, mVars[p]!.ge(pre));\n  }\n\n  // Read arcs: M[p] >= 1 (relaxed for injectable env inputs).\n  for (const p of ft.readPlaces) {\n    if (envInj?.has(p)) {\n      const bound = envInj.get(p)!;\n      if (bound !== null && bound < 1) return ctx.Bool.val(false);\n      continue;\n    }\n    result = ctx.And(result, mVars[p]!.ge(1));\n  }\n\n  // Inhibitor arcs: M[p] == 0\n  for (const p of ft.inhibitorPlaces) {\n    result = ctx.And(result, mVars[p]!.eq(0));\n  }\n\n  // Non-negativity of current marking\n  for (let p = 0; p < P; p++) {\n    result = ctx.And(result, mVars[p]!.ge(0));\n  }\n\n  return result;\n}\n\nfunction encodeFire(\n  ctx: Z3Context,\n  ft: FlatTransition,\n  _flatNet: FlatNet,\n  mVars: Arith[],\n  mPrimeVars: Arith[],\n  P: number,\n): Bool {\n  let result: Bool = ctx.Bool.val(true);\n\n  for (let p = 0; p < P; p++) {\n    const isReset = ft.resetPlaces.includes(p);\n\n    if (isReset || ft.consumeAll[p]) {\n      // Reset/consumeAll: M'[p] = post[p]\n      result = ctx.And(result, mPrimeVars[p]!.eq(ft.postVector[p]!));\n    } else {\n      // Standard: M'[p] = M[p] - pre[p] + post[p]\n      const delta = ft.postVector[p]! - ft.preVector[p]!;\n      if (delta === 0) {\n        result = ctx.And(result, mPrimeVars[p]!.eq(mVars[p]!));\n      } else {\n        result = ctx.And(result, mPrimeVars[p]!.eq(mVars[p]!.add(delta)));\n      }\n    }\n  }\n\n  return result;\n}\n\nfunction encodeErrorRule(\n  ctx: Z3Context,\n  fp: Z3Fixedpoint,\n  reachable: FuncDecl,\n  error: FuncDecl,\n  flatNet: FlatNet,\n  property: SmtProperty,\n  sinkPlaces: ReadonlySet<Place<any>>,\n  P: number,\n): void {\n  const Int = ctx.Int;\n\n  // Create variables for the error rule\n  const mVars: Arith[] = [];\n  for (let i = 0; i < P; i++) {\n    mVars.push(Int.const(`em${i}`));\n  }\n\n  const reachBody = (reachable as any).call(...mVars) as Bool;\n  const violation = encodePropertyViolation(ctx, flatNet, property, sinkPlaces, mVars, P);\n\n  const head = (error as any).call() as Bool;\n  const body = ctx.And(reachBody, violation);\n  const rule = ctx.Implies(body, head);\n  const qRule = ctx.ForAll(mVars, rule);\n\n  fp.addRule(qRule, `error_${property.type}`);\n}\n\nfunction encodePropertyViolation(\n  ctx: Z3Context,\n  flatNet: FlatNet,\n  property: SmtProperty,\n  sinkPlaces: ReadonlySet<Place<any>>,\n  mVars: Arith[],\n  P: number,\n): Bool {\n  switch (property.type) {\n    case 'deadlock-free': {\n      const deadlock = encodeDeadlock(ctx, flatNet, mVars, P);\n      if (sinkPlaces.size > 0) {\n        // Deadlock is only a violation if NOT at any expected sink place\n        let notAtSink: Bool = ctx.Bool.val(true);\n        for (const sink of sinkPlaces) {\n          const idx = flatNetIndexOf(flatNet, sink);\n          if (idx >= 0) {\n            notAtSink = ctx.And(notAtSink, mVars[idx]!.eq(0));\n          }\n        }\n        return ctx.And(deadlock, notAtSink);\n      }\n      return deadlock;\n    }\n\n    case 'mutual-exclusion': {\n      const idx1 = flatNetIndexOf(flatNet, property.p1);\n      const idx2 = flatNetIndexOf(flatNet, property.p2);\n      if (idx1 < 0) throw new Error(`MutualExclusion references unknown place: ${property.p1.name}`);\n      if (idx2 < 0) throw new Error(`MutualExclusion references unknown place: ${property.p2.name}`);\n      return ctx.And(mVars[idx1]!.ge(1), mVars[idx2]!.ge(1));\n    }\n\n    case 'place-bound': {\n      const idx = flatNetIndexOf(flatNet, property.place);\n      if (idx < 0) throw new Error(`PlaceBound references unknown place: ${property.place.name}`);\n      return mVars[idx]!.gt(property.bound);\n    }\n\n    case 'branch-place-bound': {\n      // ν-net budget lever (NU-040): a count bound, encoded identically to\n      // place-bound. Sound under the matched-transition over-approximation —\n      // the real net fires fewer joins, so it cannot exceed a bound the\n      // over-approximation respects.\n      const idx = flatNetIndexOf(flatNet, property.place);\n      if (idx < 0) throw new Error(`BranchPlaceBound references unknown place: ${property.place.name}`);\n      return mVars[idx]!.gt(property.bound);\n    }\n\n    case 'joined-or-dead-lettered': {\n      // NU-040: a quiescent (deadlocked) marking that still holds a `pending`\n      // token is a stranded correlation group. Reuse the deadlock predicate and\n      // conjoin pending non-emptiness.\n      const idx = flatNetIndexOf(flatNet, property.pending);\n      if (idx < 0) return ctx.Bool.val(false); // unknown pending place: no violation\n      const deadlock = encodeDeadlock(ctx, flatNet, mVars, P);\n      return ctx.And(deadlock, mVars[idx]!.ge(1));\n    }\n\n    case 'unreachable': {\n      let allMarked: Bool = ctx.Bool.val(true);\n      for (const place of property.places) {\n        const idx = flatNetIndexOf(flatNet, place);\n        if (idx >= 0) {\n          allMarked = ctx.And(allMarked, mVars[idx]!.ge(1));\n        }\n      }\n      return allMarked;\n    }\n  }\n}\n\n/**\n * Encodes the deadlock condition: no transition is enabled. Environment inputs\n * are treated as injectable (`relaxEnv`), so a marking that an external injection\n * could re-enable is NOT a deadlock — only a genuinely stuck marking is (VER-006).\n */\nfunction encodeDeadlock(\n  ctx: Z3Context,\n  flatNet: FlatNet,\n  mVars: Arith[],\n  P: number,\n): Bool {\n  let deadlock: Bool = ctx.Bool.val(true);\n\n  for (const ft of flatNet.transitions) {\n    const enabled = encodeEnabled(ctx, ft, flatNet, mVars, P, /* relaxEnv */ true);\n    deadlock = ctx.And(deadlock, ctx.Not(enabled));\n  }\n\n  return deadlock;\n}\n\nfunction encodeInvariantConstraints(\n  ctx: Z3Context,\n  invariants: readonly PInvariant[],\n  mVars: Arith[],\n  P: number,\n): Bool {\n  let result: Bool = ctx.Bool.val(true);\n\n  for (const inv of invariants) {\n    // sum(y_i * M[i]) == constant\n    let sum: Arith = ctx.Int.val(0);\n    for (const idx of inv.support) {\n      if (idx < P) {\n        sum = sum.add(mVars[idx]!.mul(inv.weights[idx]!));\n      }\n    }\n    result = ctx.And(result, sum.eq(inv.constant));\n  }\n\n  return result;\n}\n","const EPSILON = 1e-9;\n\n/**\n * Difference Bound Matrix (DBM) for Time Petri Net state class analysis.\n *\n * Implements the Berthomieu-Diaz (1991) algorithm for computing firing domains\n * and their successors. Matrix bounds[i][j] = upper bound on (xi - xj).\n * Index 0 is the reference clock; index i+1 is the clock for transition i.\n */\nexport class DBM {\n  private readonly bounds: Float64Array;\n  private readonly dim: number;\n  readonly clockNames: readonly string[];\n  private readonly _empty: boolean;\n\n  private constructor(bounds: Float64Array, dim: number, clockNames: readonly string[], empty: boolean) {\n    this.bounds = bounds;\n    this.dim = dim;\n    this.clockNames = clockNames;\n    this._empty = empty;\n  }\n\n  /** Creates an initial firing domain for enabled transitions. */\n  static create(clockNames: readonly string[], lowerBounds: number[], upperBounds: number[]): DBM {\n    const n = clockNames.length;\n    const dim = n + 1;\n    const bounds = makeMatrix(dim, Infinity);\n\n    for (let i = 0; i < n; i++) {\n      bounds[(0) * dim + (i + 1)] = -lowerBounds[i]!;\n      bounds[(i + 1) * dim + (0)] = upperBounds[i]!;\n    }\n\n    return new DBM(bounds, dim, clockNames, false).canonicalize();\n  }\n\n  /** Creates an empty (unsatisfiable) zone. */\n  static empty(clockNames: readonly string[]): DBM {\n    const b = new Float64Array(1);\n    b[0] = 0;\n    return new DBM(b, 1, clockNames, true);\n  }\n\n  isEmpty(): boolean {\n    return this._empty;\n  }\n\n  clockCount(): number {\n    return this.clockNames.length;\n  }\n\n  private get(i: number, j: number): number {\n    return this.bounds[i * this.dim + j]!;\n  }\n\n  /** Gets the lower bound (earliest firing time) for clock i. */\n  getLowerBound(clockIndex: number): number {\n    if (this._empty || clockIndex < 0 || clockIndex >= this.clockNames.length) return 0;\n    const val = -this.get(0, clockIndex + 1);\n    return val === 0 ? 0 : val; // normalize -0 to 0\n  }\n\n  /** Gets the upper bound (latest firing time / deadline) for clock i. */\n  getUpperBound(clockIndex: number): number {\n    if (this._empty || clockIndex < 0 || clockIndex >= this.clockNames.length) return Infinity;\n    return this.get(clockIndex + 1, 0);\n  }\n\n  /** Checks if transition can fire (lower bound <= 0 after time passage). */\n  canFire(clockIndex: number): boolean {\n    return !this._empty && this.getLowerBound(clockIndex) <= EPSILON;\n  }\n\n  /**\n   * Computes the successor firing domain after firing transition t_f.\n   * Implements the 5-step Berthomieu-Diaz successor formula.\n   */\n  fireTransition(\n    firedClock: number,\n    newClockNames: readonly string[],\n    newLowerBounds: number[],\n    newUpperBounds: number[],\n    persistentClocks: number[],\n  ): DBM {\n    if (this._empty) return this;\n\n    const n = this.clockNames.length;\n    if (firedClock < 0 || firedClock >= n) {\n      throw new Error(`Invalid fired clock index: ${firedClock}`);\n    }\n\n    // Step 1: Intersect with \"t_f fires first\" constraint\n    const constrained = new Float64Array(this.bounds);\n    const dim = this.dim;\n    const f = firedClock + 1;\n\n    for (let i = 0; i < n; i++) {\n      if (i !== firedClock) {\n        const idx = i + 1;\n        const pos = f * dim + idx;\n        constrained[pos] = Math.min(constrained[pos]!, 0);\n      }\n    }\n\n    // Step 2: Canonicalize\n    if (!canonicalizeInPlace(constrained, dim)) {\n      return DBM.empty([]);\n    }\n\n    // Steps 3 & 4: Substitution and Elimination\n    const newN = persistentClocks.length + newClockNames.length;\n    const newDim = newN + 1;\n    const newBounds = makeMatrix(newDim, Infinity);\n\n    // Copy persistent clocks with transformed bounds\n    for (let pi = 0; pi < persistentClocks.length; pi++) {\n      const oldIdx = persistentClocks[pi]! + 1;\n      const newIdx = pi + 1;\n\n      const upper = constrained[oldIdx * dim + f]!;\n      const lower = Math.max(0, -constrained[f * dim + oldIdx]!);\n\n      newBounds[0 * newDim + newIdx] = -lower;\n      newBounds[newIdx * newDim + 0] = upper;\n\n      // Inter-clock constraints between persistent transitions (preserved)\n      for (let pj = 0; pj < persistentClocks.length; pj++) {\n        const oldJ = persistentClocks[pj]! + 1;\n        const newJ = pj + 1;\n        newBounds[newIdx * newDim + newJ] = constrained[oldIdx * dim + oldJ]!;\n      }\n    }\n\n    // Step 5: Add fresh intervals for newly enabled transitions\n    const offset = persistentClocks.length;\n    for (let k = 0; k < newClockNames.length; k++) {\n      const idx = offset + k + 1;\n      newBounds[0 * newDim + idx] = -newLowerBounds[k]!;\n      newBounds[idx * newDim + 0] = newUpperBounds[k]!;\n    }\n\n    // Build new clock names\n    const allNames: string[] = [];\n    for (const idx of persistentClocks) {\n      allNames.push(this.clockNames[idx]!);\n    }\n    allNames.push(...newClockNames);\n\n    // Step 6: Final canonicalization\n    return new DBM(newBounds, newDim, allNames, false).canonicalize();\n  }\n\n  /** Lets time pass: set all lower bounds to 0. */\n  letTimePass(): DBM {\n    if (this._empty) return this;\n\n    const newBounds = new Float64Array(this.bounds);\n    for (let i = 1; i < this.dim; i++) {\n      newBounds[0 * this.dim + i] = 0;\n    }\n\n    return new DBM(newBounds, this.dim, this.clockNames, false).canonicalize();\n  }\n\n  private canonicalize(): DBM {\n    if (this._empty) return this;\n\n    const canon = new Float64Array(this.bounds);\n    if (!canonicalizeInPlace(canon, this.dim)) {\n      return DBM.empty(this.clockNames);\n    }\n    return new DBM(canon, this.dim, this.clockNames, false);\n  }\n\n  equals(other: DBM): boolean {\n    if (this === other) return true;\n    if (this._empty && other._empty) return true;\n    if (this._empty || other._empty) return false;\n    if (this.clockNames.length !== other.clockNames.length) return false;\n    for (let i = 0; i < this.clockNames.length; i++) {\n      if (this.clockNames[i] !== other.clockNames[i]) return false;\n    }\n    if (this.bounds.length !== other.bounds.length) return false;\n    for (let i = 0; i < this.bounds.length; i++) {\n      if (Math.abs(this.bounds[i]! - other.bounds[i]!) > EPSILON) return false;\n    }\n    return true;\n  }\n\n  toString(): string {\n    if (this._empty) return 'DBM[empty]';\n    const parts: string[] = [];\n    for (let i = 0; i < this.clockNames.length; i++) {\n      const lo = formatBound(this.getLowerBound(i));\n      const hi = formatBound(this.getUpperBound(i));\n      parts.push(`${this.clockNames[i]}:[${lo},${hi}]`);\n    }\n    return `DBM{${parts.join(', ')}}`;\n  }\n}\n\nfunction makeMatrix(dim: number, fill: number): Float64Array {\n  const m = new Float64Array(dim * dim).fill(fill);\n  for (let i = 0; i < dim; i++) {\n    m[i * dim + i] = 0;\n  }\n  return m;\n}\n\nfunction canonicalizeInPlace(dbm: Float64Array, dim: number): boolean {\n  for (let k = 0; k < dim; k++) {\n    for (let i = 0; i < dim; i++) {\n      for (let j = 0; j < dim; j++) {\n        const ik = dbm[i * dim + k]!;\n        const kj = dbm[k * dim + j]!;\n        if (ik < Infinity && kj < Infinity) {\n          const via = ik + kj;\n          if (via < dbm[i * dim + j]!) {\n            dbm[i * dim + j] = via;\n          }\n        }\n      }\n    }\n  }\n  for (let i = 0; i < dim; i++) {\n    if (dbm[i * dim + i]! < -EPSILON) return false;\n  }\n  return true;\n}\n\nfunction formatBound(b: number): string {\n  if (b >= Infinity / 2) return '\\u221e';\n  if (b === Math.trunc(b)) return String(b);\n  return b.toFixed(3);\n}\n","import type { Transition } from '../../core/transition.js';\nimport type { MarkingState } from '../marking-state.js';\nimport type { DBM } from './dbm.js';\n\n/**\n * A State Class in Time Petri Net analysis.\n *\n * A state class is a pair (M, D) where M is a marking and D is a firing domain (DBM).\n * State classes provide a finite abstraction of the infinite state space of Time Petri Nets.\n */\nexport class StateClass {\n  readonly marking: MarkingState;\n  readonly firingDomain: DBM;\n  readonly enabledTransitions: readonly Transition[];\n\n  constructor(marking: MarkingState, firingDomain: DBM, enabledTransitions: readonly Transition[]) {\n    this.marking = marking;\n    this.firingDomain = firingDomain;\n    this.enabledTransitions = [...enabledTransitions];\n  }\n\n  isEmpty(): boolean {\n    return this.firingDomain.isEmpty();\n  }\n\n  canFire(transition: Transition): boolean {\n    const idx = this.enabledTransitions.indexOf(transition);\n    if (idx < 0) return false;\n    return this.firingDomain.getUpperBound(idx) >= 0;\n  }\n\n  transitionIndex(transition: Transition): number {\n    return this.enabledTransitions.indexOf(transition);\n  }\n\n  equals(other: StateClass): boolean {\n    if (this === other) return true;\n    return this.marking.toString() === other.marking.toString()\n      && this.firingDomain.equals(other.firingDomain);\n  }\n\n  toString(): string {\n    return `StateClass{${this.marking}, ${this.firingDomain}}`;\n  }\n}\n","import type { Place } from '../../core/place.js';\nimport type { EnvironmentPlace } from '../../core/place.js';\nimport type { In } from '../../core/in.js';\nimport type { Transition } from '../../core/transition.js';\nimport type { PetriNet } from '../../core/petri-net.js';\nimport { earliest, latest } from '../../core/timing.js';\nimport { enumerateBranches } from '../../core/out.js';\nimport { MarkingState } from '../marking-state.js';\nimport { DBM } from './dbm.js';\nimport { StateClass } from './state-class.js';\nimport type { EnvironmentAnalysisMode } from './environment-analysis-mode.js';\nimport { ignore } from './environment-analysis-mode.js';\n\n/** Edge that tracks which XOR branch was taken. */\nexport interface BranchEdge {\n  readonly branchIndex: number;\n  readonly target: StateClass;\n}\n\nexport interface VirtualTransition {\n  readonly transition: Transition;\n  readonly branchIndex: number;\n  readonly outputPlaces: ReadonlySet<Place<any>>;\n}\n\n/**\n * State Class Graph for Time Petri Net analysis.\n *\n * Implements the Berthomieu-Diaz (1991) algorithm for computing the state class\n * graph of a bounded Time Petri Net.\n */\nexport class StateClassGraph {\n  readonly net: PetriNet;\n  readonly initialClass: StateClass;\n  private readonly _stateClasses: StateClass[];\n  private readonly _transitions: Map<StateClass, Map<Transition, BranchEdge[]>>;\n  private readonly _successors: Map<StateClass, Set<StateClass>>;\n  private readonly _predecessors: Map<StateClass, Set<StateClass>>;\n  private readonly _complete: boolean;\n\n  private constructor(\n    net: PetriNet,\n    initialClass: StateClass,\n    stateClasses: StateClass[],\n    transitions: Map<StateClass, Map<Transition, BranchEdge[]>>,\n    complete: boolean,\n  ) {\n    this.net = net;\n    this.initialClass = initialClass;\n    this._stateClasses = stateClasses;\n    this._transitions = transitions;\n    this._complete = complete;\n\n    // Build successor/predecessor maps\n    this._successors = new Map();\n    this._predecessors = new Map();\n    for (const sc of stateClasses) {\n      this._successors.set(sc, new Set());\n      this._predecessors.set(sc, new Set());\n    }\n    for (const [from, tMap] of transitions) {\n      for (const edges of tMap.values()) {\n        for (const edge of edges) {\n          this._successors.get(from)!.add(edge.target);\n          this._predecessors.get(edge.target)!.add(from);\n        }\n      }\n    }\n  }\n\n  /** Builds the state class graph for a Time Petri Net. */\n  static build(\n    net: PetriNet,\n    initialMarking: MarkingState,\n    maxClasses: number,\n    environmentPlaces?: Set<EnvironmentPlace<any>>,\n    environmentMode?: EnvironmentAnalysisMode,\n  ): StateClassGraph {\n    const envMode = environmentMode ?? ignore();\n    const envPlaces = new Set<Place<any>>();\n    if (environmentPlaces) {\n      for (const ep of environmentPlaces) {\n        envPlaces.add(ep.place);\n      }\n    }\n\n    const initialClass = initialStateClass(net, initialMarking, envPlaces, envMode);\n\n    // BFS exploration\n    const stateClasses: StateClass[] = [initialClass];\n    const stateClassSet = new Set<string>([classKey(initialClass)]);\n    const classMap = new Map<string, StateClass>([[classKey(initialClass), initialClass]]);\n    const transitionMap = new Map<StateClass, Map<Transition, BranchEdge[]>>();\n    transitionMap.set(initialClass, new Map());\n    const queue: StateClass[] = [initialClass];\n    let complete = true;\n\n    while (queue.length > 0) {\n      if (stateClasses.length >= maxClasses) {\n        complete = false;\n        break;\n      }\n\n      const current = queue.shift()!;\n\n      for (const transition of current.enabledTransitions) {\n        const virtualTransitions = expandTransition(transition);\n\n        for (const vt of virtualTransitions) {\n          const successor = computeSuccessor(net, current, vt, envPlaces, envMode);\n          if (successor === null || successor.isEmpty()) continue;\n\n          // Add edge with branch index\n          const tEdges = transitionMap.get(current)!;\n          if (!tEdges.has(transition)) tEdges.set(transition, []);\n          tEdges.get(transition)!.push({ branchIndex: vt.branchIndex, target: successor });\n\n          // Dedup state classes by key\n          const key = classKey(successor);\n          if (!stateClassSet.has(key)) {\n            stateClassSet.add(key);\n            classMap.set(key, successor);\n            stateClasses.push(successor);\n            transitionMap.set(successor, new Map());\n            queue.push(successor);\n          } else {\n            // Rewrite edge target to existing canonical instance\n            const canonical = classMap.get(key)!;\n            if (canonical !== successor) {\n              const edges = tEdges.get(transition)!;\n              edges[edges.length - 1] = { branchIndex: vt.branchIndex, target: canonical };\n            }\n          }\n        }\n      }\n    }\n\n    return new StateClassGraph(net, initialClass, stateClasses, transitionMap, complete);\n  }\n\n  stateClasses(): readonly StateClass[] {\n    return this._stateClasses;\n  }\n\n  size(): number {\n    return this._stateClasses.length;\n  }\n\n  isComplete(): boolean {\n    return this._complete;\n  }\n\n  successors(sc: StateClass): Set<StateClass> {\n    return this._successors.get(sc) ?? new Set();\n  }\n\n  predecessors(sc: StateClass): Set<StateClass> {\n    return this._predecessors.get(sc) ?? new Set();\n  }\n\n  /** Returns all outgoing transitions with their branch edges. */\n  outgoingBranchEdges(sc: StateClass): Map<Transition, BranchEdge[]> {\n    return this._transitions.get(sc) ?? new Map();\n  }\n\n  /** Returns the branch edges for a specific transition from a state class. */\n  branchEdges(sc: StateClass, transition: Transition): BranchEdge[] {\n    const map = this._transitions.get(sc);\n    if (!map) return [];\n    return map.get(transition) ?? [];\n  }\n\n  /** Returns all transitions that are enabled from a state class. */\n  enabledTransitions(sc: StateClass): Set<Transition> {\n    const map = this._transitions.get(sc);\n    if (!map) return new Set();\n    return new Set(map.keys());\n  }\n\n  /** Finds all state classes with a given marking. */\n  classesWithMarking(marking: MarkingState): StateClass[] {\n    const key = marking.toString();\n    return this._stateClasses.filter(sc => sc.marking.toString() === key);\n  }\n\n  /** Checks if a marking is reachable. */\n  isReachable(marking: MarkingState): boolean {\n    const key = marking.toString();\n    return this._stateClasses.some(sc => sc.marking.toString() === key);\n  }\n\n  /** Gets all reachable markings. */\n  reachableMarkings(): Set<string> {\n    const markings = new Set<string>();\n    for (const sc of this._stateClasses) {\n      markings.add(sc.marking.toString());\n    }\n    return markings;\n  }\n\n  /** Counts edges in the graph (each branch edge counts separately). */\n  edgeCount(): number {\n    let count = 0;\n    for (const map of this._transitions.values()) {\n      for (const edges of map.values()) {\n        count += edges.length;\n      }\n    }\n    return count;\n  }\n\n  toString(): string {\n    return `StateClassGraph[classes=${this.size()}, edges=${this.edgeCount()}, complete=${this._complete}]`;\n  }\n}\n\nfunction classKey(sc: StateClass): string {\n  return `${sc.marking.toString()}|${sc.firingDomain.toString()}`;\n}\n\n/**\n * Builds the initial state class (enabled set + firing-domain DBM after letting\n * time pass). Shared by the plain SCG and the name-aware ν-partition SCG\n * (NU-050, Route B).\n */\nexport function initialStateClass(\n  net: PetriNet,\n  initialMarking: MarkingState,\n  envPlaces: Set<Place<any>>,\n  envMode: EnvironmentAnalysisMode,\n): StateClass {\n  const enabledTransitions = findEnabledTransitions(net, initialMarking, envPlaces, envMode);\n  const clockNames = enabledTransitions.map(t => t.name);\n  const lowerBounds = enabledTransitions.map(t => earliest(t.timing) / 1000);\n  const upperBounds = enabledTransitions.map(t => latest(t.timing) / 1000);\n  let initialDBM = DBM.create(clockNames, lowerBounds, upperBounds);\n  initialDBM = initialDBM.letTimePass();\n  return new StateClass(initialMarking, initialDBM, enabledTransitions);\n}\n\nexport function expandTransition(t: Transition): VirtualTransition[] {\n  let branches: ReadonlyArray<ReadonlySet<Place<any>>>;\n\n  if (t.outputSpec !== null) {\n    branches = enumerateBranches(t.outputSpec);\n  } else {\n    branches = [new Set()];\n  }\n\n  return branches.map((outputPlaces, i) => ({\n    transition: t,\n    branchIndex: i,\n    outputPlaces: outputPlaces as ReadonlySet<Place<any>>,\n  }));\n}\n\nexport function computeSuccessor(\n  net: PetriNet,\n  current: StateClass,\n  fired: VirtualTransition,\n  environmentPlaces: Set<Place<any>>,\n  environmentMode: EnvironmentAnalysisMode,\n): StateClass | null {\n  const transition = fired.transition;\n\n  // 1. Compute new marking\n  const newMarking = fireTransition(current.marking, transition, fired.outputPlaces, environmentPlaces, environmentMode);\n\n  // 2. Determine persistent and newly enabled transitions\n  const newEnabledAll = findEnabledTransitions(net, newMarking, environmentPlaces, environmentMode);\n\n  const persistent: Transition[] = [];\n  const persistentIndices: number[] = [];\n  for (let i = 0; i < current.enabledTransitions.length; i++) {\n    const t = current.enabledTransitions[i]!;\n    if (t !== transition && newEnabledAll.includes(t)) {\n      persistent.push(t);\n      persistentIndices.push(i);\n    }\n  }\n\n  const newlyEnabled: Transition[] = [];\n  for (const t of newEnabledAll) {\n    if (!persistent.includes(t)) {\n      newlyEnabled.push(t);\n    }\n  }\n\n  // 3. Compute successor DBM\n  const firedIdx = current.transitionIndex(transition);\n  const newClockNames = newlyEnabled.map(t => t.name);\n  const newLowerBounds = newlyEnabled.map(t => earliest(t.timing) / 1000);\n  const newUpperBounds = newlyEnabled.map(t => latest(t.timing) / 1000);\n\n  let newDBM = current.firingDomain.fireTransition(\n    firedIdx,\n    newClockNames,\n    newLowerBounds,\n    newUpperBounds,\n    persistentIndices,\n  );\n\n  newDBM = newDBM.letTimePass();\n\n  const allEnabled = [...persistent, ...newlyEnabled];\n  return new StateClass(newMarking, newDBM, allEnabled);\n}\n\nfunction findEnabledTransitions(\n  net: PetriNet,\n  marking: MarkingState,\n  environmentPlaces: Set<Place<any>>,\n  environmentMode: EnvironmentAnalysisMode,\n): Transition[] {\n  const enabled: Transition[] = [];\n  for (const transition of net.transitions) {\n    if (isEnabled(transition, marking, environmentPlaces, environmentMode)) {\n      enabled.push(transition);\n    }\n  }\n  return enabled;\n}\n\nfunction isEnabled(\n  transition: Transition,\n  marking: MarkingState,\n  environmentPlaces: Set<Place<any>>,\n  environmentMode: EnvironmentAnalysisMode,\n): boolean {\n  for (const spec of transition.inputSpecs) {\n    const required = inputRequiredCount(spec);\n    if (!checkPlaceEnabled(spec.place, required, marking, environmentPlaces, environmentMode)) {\n      return false;\n    }\n  }\n\n  for (const arc of transition.reads) {\n    if (!checkPlaceEnabled(arc.place, 1, marking, environmentPlaces, environmentMode)) {\n      return false;\n    }\n  }\n\n  for (const arc of transition.inhibitors) {\n    if (marking.hasTokens(arc.place)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction inputRequiredCount(spec: In): number {\n  switch (spec.type) {\n    case 'one': return 1;\n    case 'exactly': return spec.count;\n    case 'all': return 1;\n    case 'at-least': return spec.minimum;\n  }\n}\n\nfunction inputConsumeCount(spec: In): number {\n  switch (spec.type) {\n    case 'one': return 1;\n    case 'exactly': return spec.count;\n    case 'all': return 1; // Analysis: consume minimum (1 token)\n    case 'at-least': return spec.minimum;\n  }\n}\n\nfunction checkPlaceEnabled(\n  place: Place<any>,\n  required: number,\n  marking: MarkingState,\n  environmentPlaces: Set<Place<any>>,\n  environmentMode: EnvironmentAnalysisMode,\n): boolean {\n  if (!environmentPlaces.has(place)) {\n    return marking.tokens(place) >= required;\n  }\n\n  switch (environmentMode.type) {\n    case 'always-available': return true;\n    case 'bounded': return required <= environmentMode.maxTokens;\n    case 'ignore': return marking.tokens(place) >= required;\n  }\n}\n\nfunction fireTransition(\n  marking: MarkingState,\n  transition: Transition,\n  outputPlaces: ReadonlySet<Place<any>>,\n  environmentPlaces: Set<Place<any>>,\n  environmentMode: EnvironmentAnalysisMode,\n): MarkingState {\n  const builder = MarkingState.builder().copyFrom(marking);\n\n  // Consume from inputs\n  for (const spec of transition.inputSpecs) {\n    const toConsume = inputConsumeCount(spec);\n    consumeFromPlace(builder, spec.place, toConsume, environmentPlaces, environmentMode);\n  }\n\n  // Reset places\n  for (const arc of transition.resets) {\n    const current = marking.tokens(arc.place);\n    if (current > 0) {\n      builder.removeTokens(arc.place, current);\n    }\n  }\n\n  // Produce to outputs\n  for (const place of outputPlaces) {\n    builder.addTokens(place, 1);\n  }\n\n  return builder.build();\n}\n\nfunction consumeFromPlace(\n  builder: ReturnType<typeof MarkingState.builder>,\n  place: Place<any>,\n  count: number,\n  environmentPlaces: Set<Place<any>>,\n  environmentMode: EnvironmentAnalysisMode,\n): void {\n  if (!environmentPlaces.has(place)) {\n    builder.removeTokens(place, count);\n    return;\n  }\n  if (environmentMode.type === 'ignore') {\n    builder.removeTokens(place, count);\n  }\n}\n","import type { Expr } from 'z3-solver';\nimport { MarkingState } from '../marking-state.js';\nimport type { FlatNet } from '../encoding/flat-net.js';\n\n/**\n * Result of counterexample decoding.\n */\nexport interface DecodedTrace {\n  readonly trace: readonly MarkingState[];\n  readonly transitions: readonly string[];\n}\n\n/**\n * Decodes Z3 Spacer counterexample answers into Petri net marking traces.\n *\n * When Spacer finds a counterexample (property violation), it produces\n * a derivation tree showing how the error state is reachable. This function\n * extracts the marking at each step to produce a human-readable trace.\n */\nexport function decode(ctx: any, answer: Expr | null, flatNet: FlatNet): DecodedTrace {\n  const trace: MarkingState[] = [];\n  const transitions: string[] = [];\n\n  if (answer == null) {\n    return { trace, transitions };\n  }\n\n  try {\n    extractTrace(ctx, answer, flatNet, trace, transitions);\n  } catch {\n    // Z3 answer format varies; gracefully degrade\n  }\n\n  return { trace, transitions };\n}\n\n/**\n * Recursively traverses the Z3 proof tree to extract marking states.\n */\nfunction extractTrace(\n  ctx: any,\n  expr: any,\n  flatNet: FlatNet,\n  trace: MarkingState[],\n  transitions: string[],\n): void {\n  if (expr == null) return;\n\n  // Check if this is a function application\n  if (!ctx.isApp(expr)) return;\n\n  let name: string;\n  try {\n    const decl = expr.decl();\n    name = String(decl.name());\n  } catch {\n    return;\n  }\n\n  // Check if this is a Reachable application with integer arguments\n  const P = flatNet.places.length;\n  if (name === 'Reachable') {\n    const numArgs = expr.numArgs();\n    if (numArgs === P) {\n      const marking = extractMarking(ctx, expr, flatNet);\n      if (marking != null) {\n        trace.push(marking);\n      }\n    }\n  }\n\n  // Recurse into children to find the derivation chain\n  try {\n    const numArgs = expr.numArgs();\n    for (let i = 0; i < numArgs; i++) {\n      const child = expr.arg(i);\n      extractTrace(ctx, child, flatNet, trace, transitions);\n    }\n  } catch {\n    // Not all expressions support arg()\n  }\n\n  // Try to extract transition name from rule application\n  if (name.startsWith('t_')) {\n    transitions.push(name.substring(2));\n  }\n}\n\n/**\n * Extracts a MarkingState from a Reachable(...) application.\n */\nfunction extractMarking(ctx: any, reachableApp: any, flatNet: FlatNet): MarkingState | null {\n  const P = flatNet.places.length;\n  if (reachableApp.numArgs() !== P) return null;\n\n  const builder = MarkingState.builder();\n  for (let i = 0; i < P; i++) {\n    const arg = reachableApp.arg(i);\n    if (ctx.isIntVal(arg)) {\n      const tokens = Number(arg.value());\n      if (tokens > 0) {\n        builder.tokens(flatNet.places[i]!, tokens);\n      }\n    } else {\n      // Non-concrete value in counterexample\n      return null;\n    }\n  }\n  return builder.build();\n}\n","/**\n * @module name-coloured-encoder\n *\n * Bounded **name-coloured** CHC encoding for ν-net join correlation\n * ([NU-050] #1, Route A — the EUF-style carve-out).\n *\n * The flat {@link module:smt-encoder} is a pure *counting* abstraction: a place\n * is one integer, and a matched (ν-join) transition is encoded name-blind — it\n * fires whenever the input *counts* allow, regardless of whether the consumed\n * tokens actually share a correlation name. That over-approximation is sound for\n * `proven` on reachability-safety bounds but can report a **spurious** `violated`\n * whose counterexample silently equates two *distinct* names.\n *\n * This encoder removes that imprecision for the bounded fragment. The\n * decidability lever ([NU-040]) is the budget: with a `Budget` place pre-seeded\n * with `k` tokens gating every mint, at most `k` correlation names are live at\n * once. So names are modelled as a **finite set of `k` colours**. Each coloured\n * place becomes `k` per-colour integer counts; a mint introduces a *globally\n * fresh* colour (one currently empty everywhere); a matched join consumes the\n * **same colour** from every correlated input. Within the budget bound the\n * encoding is *exact* — sound and complete — so no different-name counterexample\n * survives.\n *\n * **Supported fragment (tracer bullet)**: {@link buildColouredPlan} returns\n * `null` (and the verifier falls back to the sound over-approximation) unless the\n * net is in the simple **mint → matched-join** shape: coloured places = the\n * correlated inputs of every matched transition; each is produced only by minting\n * forks (count 1, no coloured input, costs ≥1 budget token) and consumed only by\n * matched joins (count 1, produces no coloured token); budget consumed only by\n * mints and produced only by joins (so live colours ≤ initial budget = `k`);\n * coloured places start empty; no inhibitor/read/reset/consume-all arc touches a\n * coloured place; no XOR output anywhere.\n *\n * Mirrors the Rust reference `name_coloured_encoder.rs` exactly; the difference\n * is that this builds z3-solver expressions rather than emitting SMT-LIB2 text.\n * Z3 types are partially untyped; the ctx/fp parameters use `any`.\n */\nimport type { Arith, Bool, FuncDecl } from 'z3-solver';\nimport type { PetriNet } from '../../core/petri-net.js';\nimport type { FlatNet } from '../encoding/flat-net.js';\nimport type { FlatTransition } from '../encoding/flat-transition.js';\nimport type { MarkingState } from '../marking-state.js';\nimport type { SmtProperty } from '../smt-property.js';\nimport type { PInvariant } from '../invariant/p-invariant.js';\nimport type { EncodingResult } from './smt-encoder.js';\nimport { flatNetIndexOf } from '../encoding/flat-net.js';\n\n/** Z3 high-level context. Typed as `any` because z3-solver's TS types are incomplete. */\ntype Z3Context = any;\n/** Z3 Fixedpoint solver instance. Typed as `any` because z3-solver's TS types are incomplete. */\ntype Z3Fixedpoint = any;\n\n/** How a transition relates to the coloured (correlation-carrying) places. */\ntype Klass =\n  | { readonly kind: 'mint'; readonly colouredOut: readonly number[] }\n  | { readonly kind: 'join'; readonly colouredIn: readonly number[] }\n  | { readonly kind: 'untouched' };\n\n/** A validated plan for the name-coloured encoding of a budget-bounded ν-net. */\nexport interface ColouredPlan {\n  /** Flat indices of the coloured places (ascending). */\n  readonly coloured: readonly number[];\n  /** Per flat place: whether it is coloured. */\n  readonly isColoured: readonly boolean[];\n  /** Colour bound — the number of simultaneously-live names (= initial budget). */\n  readonly k: number;\n  /** Classification per flat transition (1:1 — the fragment forbids XOR). */\n  readonly classes: readonly Klass[];\n}\n\n/**\n * Detects whether `net` is in the supported budget-bounded mint→matched-join\n * fragment and, if so, returns the plan for {@link encodeColoured}. Returns\n * `null` otherwise — the verifier then uses the sound over-approximation.\n */\nexport function buildColouredPlan(\n  net: PetriNet,\n  flat: FlatNet,\n  initial: MarkingState,\n  budgetNames: ReadonlySet<string>,\n): ColouredPlan | null {\n  const P = flat.places.length;\n\n  // No XOR: every original transition maps 1:1 to a flat row.\n  if (flat.transitions.length !== [...net.transitions].length) {\n    return null;\n  }\n\n  // 1. Coloured places = union of every matched transition's correlated inputs.\n  //    Read the match spec off each flat row's source transition.\n  const isColoured: boolean[] = new Array<boolean>(P).fill(false);\n  for (const ft of flat.transitions) {\n    const ms = ft.source.matchSpec;\n    if (ms) {\n      for (const key of ms.keys) {\n        const pid = flat.placeIndex.get(key.place.name);\n        if (pid == null) return null;\n        isColoured[pid] = true;\n      }\n    }\n  }\n  const coloured: number[] = [];\n  for (let i = 0; i < P; i++) if (isColoured[i]) coloured.push(i);\n  if (coloured.length === 0) return null;\n\n  // Coloured places must start empty — no initial colour assignment is modelled.\n  for (const pid of coloured) {\n    if (initial.tokens(flat.places[pid]!) !== 0) return null;\n  }\n\n  // Colour bound k = total initial budget tokens (the live-name ceiling).\n  const budgetIdx = new Set<number>();\n  for (const n of budgetNames) {\n    const i = flat.placeIndex.get(n);\n    if (i != null) budgetIdx.add(i);\n  }\n  if (budgetIdx.size === 0) return null;\n  let k = 0;\n  for (const b of budgetIdx) k += initial.tokens(flat.places[b]!);\n  if (k === 0) return null;\n\n  // No inhibitor/read/reset/consume-all arc may touch a coloured place.\n  for (const ft of flat.transitions) {\n    const touches =\n      ft.inhibitorPlaces.some((i) => isColoured[i]) ||\n      ft.readPlaces.some((i) => isColoured[i]) ||\n      ft.resetPlaces.some((i) => isColoured[i]) ||\n      ft.consumeAll.some((ca, i) => ca && isColoured[i]!);\n    if (touches) return null;\n  }\n\n  // 2. Classify each transition from its flat incidence.\n  const classes: Klass[] = [];\n  for (const ft of flat.transitions) {\n    const colouredIn = coloured.filter((pid) => ft.preVector[pid]! > 0);\n    const colouredOut = coloured.filter((pid) => ft.postVector[pid]! > 0);\n    const ms = ft.source.matchSpec;\n\n    if (ms) {\n      // Matched join: consumes coloured inputs (count 1), produces none.\n      if (colouredOut.length !== 0 || colouredIn.length === 0) return null;\n      if (colouredIn.some((pid) => ft.preVector[pid]! !== 1)) return null;\n      classes.push({ kind: 'join', colouredIn });\n    } else if (colouredOut.length !== 0) {\n      // Minting fork: produces coloured (count 1), consumes none, costs budget.\n      if (colouredIn.length !== 0) return null;\n      if (colouredOut.some((o) => ft.postVector[o]! !== 1)) return null;\n      let budgetConsumed = 0;\n      for (const b of budgetIdx) budgetConsumed += ft.preVector[b]!;\n      if (budgetConsumed < 1) return null;\n      classes.push({ kind: 'mint', colouredOut });\n    } else {\n      // Touches no coloured place at all.\n      if (colouredIn.length !== 0) return null;\n      classes.push({ kind: 'untouched' });\n    }\n  }\n\n  // 3. Budget discipline: consumed only by mints, produced only by joins, AND\n  //    conserved — a join may not refund MORE budget than the cheapest mint\n  //    consumes, else repeated mint→join cycles inflate the pool above k, the real\n  //    net can hold > k simultaneously-live names, and the k-colour encoding would\n  //    UNDER-approximate and report a false `Proven`. With this bound live colours\n  //    ≤ initial budget = k. Fail-closed (return null → sound over-approx) otherwise.\n  let minMintCost: number | null = null;\n  let maxJoinRefund = 0;\n  for (let ti = 0; ti < classes.length; ti++) {\n    const cls = classes[ti]!;\n    const ft = flat.transitions[ti]!;\n    for (const b of budgetIdx) {\n      if (ft.preVector[b]! > 0 && cls.kind !== 'mint') return null;\n      if (ft.postVector[b]! > 0 && cls.kind !== 'join') return null;\n    }\n    if (cls.kind === 'mint') {\n      let cost = 0;\n      for (const b of budgetIdx) cost += ft.preVector[b]!;\n      minMintCost = minMintCost === null ? cost : Math.min(minMintCost, cost);\n    } else if (cls.kind === 'join') {\n      let refund = 0;\n      for (const b of budgetIdx) refund += ft.postVector[b]!;\n      maxJoinRefund = Math.max(maxJoinRefund, refund);\n    }\n  }\n  if (minMintCost === null || maxJoinRefund > minMintCost) return null;\n\n  return { coloured, isColoured, k, classes };\n}\n\n/**\n * Column layout over the coloured state vector: uncoloured place → one var,\n * coloured place → `k` per-colour vars. The current/next-marking variables are\n * named consts reused across every rule (each `ForAll` scopes its own binding).\n */\ninterface Layout {\n  /** Column index of each uncoloured place (`-1` if coloured). */\n  readonly colUnc: number[];\n  /** Per coloured place: its `k` column indices (empty if uncoloured). */\n  readonly colCol: number[][];\n  /** Total column count. */\n  readonly nCols: number;\n  /** Current-marking vars, one per column. */\n  readonly cur: Arith[];\n  /** Next-marking vars, one per column. */\n  readonly nxt: Arith[];\n}\n\nfunction buildLayout(ctx: Z3Context, plan: ColouredPlan, P: number): Layout {\n  const colUnc: number[] = new Array<number>(P).fill(-1);\n  const colCol: number[][] = Array.from({ length: P }, () => []);\n  let nCols = 0;\n  for (let i = 0; i < P; i++) {\n    if (plan.isColoured[i]) {\n      const idxs: number[] = [];\n      for (let c = 0; c < plan.k; c++) idxs.push(nCols++);\n      colCol[i] = idxs;\n    } else {\n      colUnc[i] = nCols++;\n    }\n  }\n  const cur: Arith[] = [];\n  const nxt: Arith[] = [];\n  for (let col = 0; col < nCols; col++) {\n    cur.push(ctx.Int.const(`c${col}`));\n    nxt.push(ctx.Int.const(`cp${col}`));\n  }\n  return { colUnc, colCol, nCols, cur, nxt };\n}\n\n/** Contributes the enablement guards and the changed-column updates of a rule. */\ntype Fill = (enab: Bool[], upd: Map<number, Arith>) => void;\n\n/**\n * Encodes the supported ν-net as bounded name-coloured CHC for Z3 Spacer. Reuses\n * {@link EncodingResult}; with the query `(not Error)`, `sat` ⇒ PROVEN, `unsat` ⇒\n * VIOLATED (the Spacer convention shared with the flat encoder).\n */\nexport function encodeColoured(\n  ctx: Z3Context,\n  fp: Z3Fixedpoint,\n  plan: ColouredPlan,\n  flat: FlatNet,\n  initial: MarkingState,\n  property: SmtProperty,\n  invariants: readonly PInvariant[],\n): EncodingResult {\n  const P = flat.places.length;\n  const k = plan.k;\n  const lay = buildLayout(ctx, plan, P);\n\n  const intSort = ctx.Int.sort();\n  const boolSort = ctx.Bool.sort();\n  const markingSorts: any[] = new Array(lay.nCols).fill(intSort);\n  const reachable: FuncDecl = ctx.Function.declare('Reachable', ...markingSorts, boolSort);\n  fp.registerRelation(reachable);\n  const error: FuncDecl = ctx.Function.declare('Error', boolSort);\n  fp.registerRelation(error);\n\n  // Init: uncoloured places carry their initial count; coloured start empty.\n  const initArgs: Arith[] = new Array(lay.nCols);\n  for (let i = 0; i < P; i++) {\n    if (plan.isColoured[i]) {\n      for (let c = 0; c < k; c++) initArgs[lay.colCol[i]![c]!] = ctx.Int.val(0);\n    } else {\n      initArgs[lay.colUnc[i]!] = ctx.Int.val(initial.tokens(flat.places[i]!));\n    }\n  }\n  fp.addRule((reachable as any).call(...initArgs) as Bool, 'init');\n\n  // Transition rules.\n  for (let ti = 0; ti < plan.classes.length; ti++) {\n    const cls = plan.classes[ti]!;\n    const ft = flat.transitions[ti]!;\n    if (cls.kind === 'untouched') {\n      addRule(ctx, fp, reachable, lay, plan, invariants, `${ft.name}_u`, (enab, upd) =>\n        uncolouredIncidence(ctx, lay, plan, ft, enab, upd),\n      );\n    } else if (cls.kind === 'mint') {\n      const colouredOut = cls.colouredOut;\n      for (let c = 0; c < k; c++) {\n        const cc = c;\n        addRule(ctx, fp, reachable, lay, plan, invariants, `${ft.name}_mint_${cc}`, (enab, upd) => {\n          uncolouredIncidence(ctx, lay, plan, ft, enab, upd);\n          // Globally fresh colour: cc must be empty in every coloured place.\n          for (const q of plan.coloured) enab.push(lay.cur[lay.colCol[q]![cc]!]!.eq(0));\n          for (const o of colouredOut) {\n            const col = lay.colCol[o]![cc]!;\n            upd.set(col, lay.cur[col]!.add(1));\n          }\n        });\n      }\n    } else {\n      const colouredIn = cls.colouredIn;\n      for (let c = 0; c < k; c++) {\n        const cc = c;\n        addRule(ctx, fp, reachable, lay, plan, invariants, `${ft.name}_join_${cc}`, (enab, upd) => {\n          uncolouredIncidence(ctx, lay, plan, ft, enab, upd);\n          // Same colour cc present in every correlated input.\n          for (const ip of colouredIn) {\n            const col = lay.colCol[ip]![cc]!;\n            enab.push(lay.cur[col]!.ge(1));\n            upd.set(col, lay.cur[col]!.add(-1));\n          }\n        });\n      }\n    }\n  }\n\n  // Error rule.\n  addErrorRule(ctx, fp, reachable, error, lay, plan, flat, property);\n\n  return {\n    errorExpr: (error as any).call() as Bool,\n    reachableDecl: reachable,\n  };\n}\n\n/**\n * Builds one transition CHC rule. `fill` contributes the enablement guards and\n * the changed-column updates; every other column is copied unchanged, changed\n * columns get a non-negativity guard, and the (lifted) P-invariants constrain the\n * successor.\n */\nfunction addRule(\n  ctx: Z3Context,\n  fp: Z3Fixedpoint,\n  reachable: FuncDecl,\n  lay: Layout,\n  plan: ColouredPlan,\n  invariants: readonly PInvariant[],\n  ruleName: string,\n  fill: Fill,\n): void {\n  const enab: Bool[] = [];\n  const upd = new Map<number, Arith>();\n  fill(enab, upd);\n\n  const conds: Bool[] = [(reachable as any).call(...lay.cur) as Bool, ...enab];\n  for (let col = 0; col < lay.nCols; col++) {\n    const expr = upd.get(col);\n    if (expr !== undefined) {\n      conds.push(lay.nxt[col]!.eq(expr), lay.nxt[col]!.ge(0));\n    } else {\n      conds.push(lay.nxt[col]!.eq(lay.cur[col]!));\n    }\n  }\n  for (const inv of invariants) {\n    const eq = liftedInvariant(ctx, inv, plan, lay, lay.nxt);\n    if (eq) conds.push(eq);\n  }\n\n  const body = ctx.And(...conds);\n  const head = (reachable as any).call(...lay.nxt) as Bool;\n  const qRule = ctx.ForAll([...lay.cur, ...lay.nxt], ctx.Implies(body, head));\n  fp.addRule(qRule, ruleName);\n}\n\n/**\n * Pushes the enablement guards and column updates contributed by a transition's\n * **uncoloured** incidence (consume/produce on non-coloured places). Coloured\n * columns are handled by the caller (mint produces, join consumes). Mirrors the\n * Rust reference — no blanket current-marking non-negativity guard.\n */\nfunction uncolouredIncidence(\n  ctx: Z3Context,\n  lay: Layout,\n  plan: ColouredPlan,\n  ft: FlatTransition,\n  enab: Bool[],\n  upd: Map<number, Arith>,\n): void {\n  const P = ft.preVector.length;\n  for (let i = 0; i < P; i++) {\n    if (plan.isColoured[i]) continue;\n    const col = lay.colUnc[i]!;\n    const pre = ft.preVector[i]!;\n    if (pre > 0) enab.push(lay.cur[col]!.ge(pre));\n    if (ft.resetPlaces.includes(i) || ft.consumeAll[i]) {\n      upd.set(col, ctx.Int.val(ft.postVector[i]!));\n    } else {\n      const delta = ft.postVector[i]! - ft.preVector[i]!;\n      if (delta !== 0) upd.set(col, lay.cur[col]!.add(delta));\n    }\n  }\n  // Inhibitor / read arcs (all on uncoloured places — checked in buildColouredPlan).\n  for (const pid of ft.inhibitorPlaces) enab.push(lay.cur[lay.colUnc[pid]!]!.eq(0));\n  for (const pid of ft.readPlaces) enab.push(lay.cur[lay.colUnc[pid]!]!.ge(1));\n}\n\n/**\n * Aggregate token-count expression for a place over the given var-set: the single\n * uncoloured var, or the sum of its colours.\n */\nfunction aggregate(plan: ColouredPlan, lay: Layout, place: number, vars: readonly Arith[]): Arith {\n  if (plan.isColoured[place]) {\n    const cols = lay.colCol[place]!;\n    let sum = vars[cols[0]!]!;\n    for (let c = 1; c < cols.length; c++) sum = sum.add(vars[cols[c]!]!);\n    return sum;\n  }\n  return vars[lay.colUnc[place]!]!;\n}\n\n/**\n * Lifts a flat P-invariant to the coloured layout: a coloured place's variable\n * becomes the sum of its colours (= its aggregate count), so the (true) flat\n * invariant constrains the coloured successor without excluding any reachable\n * state.\n */\nfunction liftedInvariant(\n  ctx: Z3Context,\n  inv: PInvariant,\n  plan: ColouredPlan,\n  lay: Layout,\n  vars: readonly Arith[],\n): Bool | null {\n  if (inv.support.size === 0) return null;\n  let sum: Arith = ctx.Int.val(0);\n  for (const i of inv.support) {\n    const agg = aggregate(plan, lay, i, vars);\n    const w = inv.weights[i]!;\n    sum = sum.add(w === 1 ? agg : agg.mul(w));\n  }\n  return sum.eq(inv.constant);\n}\n\n/** Encodes the error rule: a reachable marking that violates the property. */\nfunction addErrorRule(\n  ctx: Z3Context,\n  fp: Z3Fixedpoint,\n  reachable: FuncDecl,\n  error: FuncDecl,\n  lay: Layout,\n  plan: ColouredPlan,\n  flat: FlatNet,\n  property: SmtProperty,\n): void {\n  const reachBody = (reachable as any).call(...lay.cur) as Bool;\n  const violation = encodeViolation(ctx, plan, lay, flat, property, lay.cur);\n  const body = ctx.And(reachBody, violation);\n  const head = (error as any).call() as Bool;\n  const qRule = ctx.ForAll([...lay.cur], ctx.Implies(body, head));\n  fp.addRule(qRule, 'error');\n}\n\n/**\n * Encodes the property-violation condition over the coloured current marking.\n * Only reachability-safety properties are routed here (the verifier guarantees\n * it); quiescence properties yield `false` (no violating state).\n */\nfunction encodeViolation(\n  ctx: Z3Context,\n  plan: ColouredPlan,\n  lay: Layout,\n  flat: FlatNet,\n  property: SmtProperty,\n  cur: readonly Arith[],\n): Bool {\n  switch (property.type) {\n    case 'place-bound':\n    case 'branch-place-bound': {\n      const idx = flatNetIndexOf(flat, property.place);\n      if (idx < 0) return ctx.Bool.val(false);\n      return aggregate(plan, lay, idx, cur).gt(property.bound);\n    }\n    case 'mutual-exclusion': {\n      const i1 = flatNetIndexOf(flat, property.p1);\n      const i2 = flatNetIndexOf(flat, property.p2);\n      if (i1 < 0 || i2 < 0) return ctx.Bool.val(false);\n      return ctx.And(aggregate(plan, lay, i1, cur).ge(1), aggregate(plan, lay, i2, cur).ge(1));\n    }\n    case 'unreachable': {\n      const conds: Bool[] = [];\n      for (const place of property.places) {\n        const idx = flatNetIndexOf(flat, place);\n        if (idx >= 0) conds.push(aggregate(plan, lay, idx, cur).ge(1));\n      }\n      if (conds.length === 0) return ctx.Bool.val(false);\n      return conds.length === 1 ? conds[0]! : ctx.And(...conds);\n    }\n    // Quiescence properties are never routed here.\n    case 'deadlock-free':\n    case 'joined-or-dead-lettered':\n      return ctx.Bool.val(false);\n  }\n}\n","/**\n * Name-correlation fragment classifier for the ν-aware state class graph\n * (NU-050, Route B). See the Rust/Java equivalents for the full contract.\n *\n * Identifies the coloured places (the correlated inputs of ν-joins) and the role\n * of each transition in the supported mint → matched-join fragment. Returns\n * `null` when the net is not a ν-net or falls outside the fragment (a non-match\n * transition consuming a coloured place, or a join re-minting into one).\n */\nimport type { PetriNet } from '../../core/petri-net.js';\nimport type { Transition } from '../../core/transition.js';\nimport { enumerateBranches } from '../../core/out.js';\n\nexport type Role =\n  | { readonly type: 'ordinary' }\n  | { readonly type: 'mint' }\n  | { readonly type: 'join'; readonly colouredIn: ReadonlyArray<readonly [string, number]> };\n\nexport interface NameFragment {\n  readonly colouredOrder: readonly string[];\n  isColoured(place: string): boolean;\n  role(transition: string): Role;\n}\n\nexport function classify(net: PetriNet): NameFragment | null {\n  const coloured = new Set<string>();\n  let anyMatch = false;\n  for (const t of net.transitions) {\n    if (t.matchSpec !== null) {\n      anyMatch = true;\n      for (const key of t.matchSpec.keys) coloured.add(key.place.name);\n    }\n  }\n  if (!anyMatch || coloured.size === 0) return null;\n\n  const roles = new Map<string, Role>();\n  for (const t of net.transitions) {\n    const consumesColoured = t.inputSpecs.some(s => coloured.has(s.place.name));\n    let producesColoured = false;\n    if (t.outputSpec !== null) {\n      for (const branch of enumerateBranches(t.outputSpec)) {\n        for (const p of branch) {\n          if (coloured.has(p.name)) producesColoured = true;\n        }\n      }\n    }\n\n    let role: Role;\n    if (t.matchSpec !== null) {\n      if (producesColoured) return null; // re-mint onto a coloured place — out of fragment\n      const colouredIn: Array<readonly [string, number]> = [];\n      for (const key of t.matchSpec.keys) {\n        const place = key.place.name;\n        // One/Exactly consume a fixed count of the matched name (faithfully\n        // modelled). All/AtLeast consume ALL matching tokens at runtime — the\n        // fixed-count SCG step would under-consume — so drop to the over-approx.\n        const required = fixedRequiredCount(t, place);\n        if (required === null) return null;\n        colouredIn.push([place, required] as const);\n      }\n      colouredIn.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));\n      role = { type: 'join', colouredIn };\n    } else if (producesColoured) {\n      if (consumesColoured) return null;\n      role = { type: 'mint' };\n    } else {\n      if (consumesColoured) return null;\n      role = { type: 'ordinary' };\n    }\n    roles.set(t.name, role);\n  }\n\n  const colouredOrder = [...coloured].sort();\n  return {\n    colouredOrder,\n    isColoured: (p) => coloured.has(p),\n    role: (tn) => roles.get(tn) ?? { type: 'ordinary' },\n  };\n}\n\n/**\n * The fixed per-firing consumption of the matched name for `t`'s input on\n * `placeName`, or `null` when the cardinality consumes ALL matching tokens\n * (all/at-least) or no such input exists — neither of which the fixed-count SCG\n * step can model faithfully.\n */\nfunction fixedRequiredCount(t: Transition, placeName: string): number | null {\n  for (const spec of t.inputSpecs) {\n    if (spec.place.name === placeName) {\n      switch (spec.type) {\n        case 'one': return 1;\n        case 'exactly': return spec.count;\n        case 'all': return null;\n        case 'at-least': return null;\n      }\n    }\n  }\n  return null;\n}\n","/**\n * The abstract **name-partition** layer for the ν-aware state class graph\n * (NU-050, Route B).\n *\n * The plain {@link StateClassGraph} is name-blind: a marking is a per-place token\n * count, so a ν-join fires whenever the counts allow, ignoring whether the\n * consumed tokens share a correlation name. This carries, beside the count\n * marking, an abstract partition of the correlation tokens into name-symbols. A\n * `Sym` is an opaque identity only (NU-001) — the analyzer never evaluates the\n * runtime name projection. {@link NameMarking.canonicalKey} quotients markings\n * that differ only by a permutation of symbols (the raw ids never appear in a\n * key), keeping the graph finite when the live-name count is structurally\n * bounded. The key string format matches the Rust and Java implementations.\n */\n\nexport type Sym = number;\n\nexport class NameMarking {\n  // place name -> (symbol -> count). Only coloured places appear; a place's\n  // total here equals its count in the base MarkingState.\n  private readonly perPlace: Map<string, Map<Sym, number>>;\n\n  constructor(perPlace?: Map<string, Map<Sym, number>>) {\n    this.perPlace = perPlace ?? new Map();\n  }\n\n  copy(): NameMarking {\n    const p = new Map<string, Map<Sym, number>>();\n    for (const [place, syms] of this.perPlace) {\n      p.set(place, new Map(syms));\n    }\n    return new NameMarking(p);\n  }\n\n  add(place: string, sym: Sym, count: number): void {\n    if (count === 0) return;\n    let syms = this.perPlace.get(place);\n    if (!syms) {\n      syms = new Map();\n      this.perPlace.set(place, syms);\n    }\n    syms.set(sym, (syms.get(sym) ?? 0) + count);\n  }\n\n  /** Removes `count` of `sym` from `place`; returns false (unchanged) if fewer present. */\n  remove(place: string, sym: Sym, count: number): boolean {\n    const syms = this.perPlace.get(place);\n    if (!syms) return false;\n    const have = syms.get(sym);\n    if (have === undefined || have < count) return false;\n    const left = have - count;\n    if (left === 0) {\n      syms.delete(sym);\n      if (syms.size === 0) this.perPlace.delete(place);\n    } else {\n      syms.set(sym, left);\n    }\n    return true;\n  }\n\n  countOf(place: string, sym: Sym): number {\n    return this.perPlace.get(place)?.get(sym) ?? 0;\n  }\n\n  symbolsIn(place: string): Sym[] {\n    const syms = this.perPlace.get(place);\n    return syms ? [...syms.keys()] : [];\n  }\n\n  private liveSymbols(): Sym[] {\n    const all = new Set<Sym>();\n    for (const syms of this.perPlace.values()) {\n      for (const s of syms.keys()) all.add(s);\n    }\n    return [...all];\n  }\n\n  /**\n   * Symmetry-canonical key over `colouredOrder` (the finiteness mechanism). Two\n   * markings differing only by a permutation of symbols produce an identical key\n   * (NU-001). Each symbol's signature is its count vector over `colouredOrder`;\n   * symbols are ranked by (signature, raw id) and emitted per place as a\n   * rank-multiset — a complete invariant of the symbol-permutation orbit.\n   */\n  canonicalKey(colouredOrder: readonly string[]): string {\n    const signature = (s: Sym): number[] => colouredOrder.map(p => this.countOf(p, s));\n    const ranked = this.liveSymbols().map(s => ({ sig: signature(s), sym: s }));\n    ranked.sort((a, b) => {\n      const c = compareNumberArrays(a.sig, b.sig);\n      return c !== 0 ? c : a.sym - b.sym;\n    });\n    const rankOf = new Map<Sym, number>();\n    ranked.forEach((r, i) => rankOf.set(r.sym, i));\n\n    const parts = colouredOrder.map(p => {\n      const syms = this.perPlace.get(p);\n      const entries: Array<[number, number]> = [];\n      if (syms) {\n        for (const [s, c] of syms) entries.push([rankOf.get(s)!, c]);\n      }\n      entries.sort((a, b) => (a[0] !== b[0] ? a[0] - b[0] : a[1] - b[1]));\n      const inner = entries.map(([r, c]) => `${r}x${c}`).join(',');\n      return `${p}:{${inner}}`;\n    });\n    return parts.join('#');\n  }\n}\n\nfunction compareNumberArrays(a: readonly number[], b: readonly number[]): number {\n  const n = Math.min(a.length, b.length);\n  for (let i = 0; i < n; i++) {\n    if (a[i]! !== b[i]!) return a[i]! - b[i]!;\n  }\n  return a.length - b.length;\n}\n","import type { StateClass } from './state-class.js';\nimport type { NameMarking } from './name-marking.js';\n\n/**\n * A name-aware state class (NU-050, Route B): the base count + DBM\n * {@link StateClass} plus the abstract {@link NameMarking} partition layer. The\n * base class is reused verbatim, so the timing/zone dimension is untouched —\n * name×time composition is automatic. The dedup `key` is the base key\n * (marking + DBM zone) joined with the symmetry-canonical name-partition key.\n */\nexport class NameStateClass {\n  readonly base: StateClass;\n  readonly names: NameMarking;\n  readonly key: string;\n\n  constructor(base: StateClass, names: NameMarking, colouredOrder: readonly string[]) {\n    this.base = base;\n    this.names = names;\n    this.key = `${base.marking.toString()}|${base.firingDomain.toString()}||${names.canonicalKey(colouredOrder)}`;\n  }\n}\n","/**\n * The ν-aware (name-partition quotient) State Class Graph (NU-050, Route B).\n *\n * Mirrors {@link StateClassGraph} — same Berthomieu-Diaz BFS, same count + DBM\n * successor step (reused verbatim via {@link computeSuccessor}) — but each class\n * additionally carries the abstract {@link NameMarking} partition. A ν-join is\n * enabled only when one shared name is present at the required multiplicity in\n * every correlated input; a mint introduces a globally-fresh name-symbol; dedup\n * is by the symmetry-canonical key so states differing only by a permutation of\n * names collapse. If BFS closes within `maxClasses` the graph is the complete\n * reachable quotient (exact); otherwise it truncates and the verifier reports\n * `unknown` (ν-PN reachability is undecidable).\n */\nimport type { PetriNet } from '../../core/petri-net.js';\nimport type { Place } from '../../core/place.js';\nimport type { EnvironmentPlace } from '../../core/place.js';\nimport type { MarkingState } from '../marking-state.js';\nimport type { EnvironmentAnalysisMode } from './environment-analysis-mode.js';\nimport { ignore } from './environment-analysis-mode.js';\nimport { initialStateClass, expandTransition, computeSuccessor } from './state-class-graph.js';\nimport { NameMarking, type Sym } from './name-marking.js';\nimport { NameStateClass } from './name-state-class.js';\nimport type { NameFragment, Role } from './name-fragment.js';\n\nexport interface NameEdge {\n  readonly from: number;\n  readonly to: number;\n  readonly transitionName: string;\n}\n\nexport class NameStateClassGraph {\n  readonly classes: NameStateClass[] = [];\n  readonly edges: NameEdge[] = [];\n  private readonly _successors: number[][] = [];\n  private _complete = true;\n\n  isComplete(): boolean {\n    return this._complete;\n  }\n\n  classCount(): number {\n    return this.classes.length;\n  }\n\n  successorsOf(idx: number): readonly number[] {\n    return this._successors[idx]!;\n  }\n\n  /** The base count-marking of class `idx` (for property queries). */\n  markingOf(idx: number): MarkingState {\n    return this.classes[idx]!.base.marking;\n  }\n\n  static build(\n    net: PetriNet,\n    initialMarking: MarkingState,\n    fragment: NameFragment,\n    maxClasses: number,\n    environmentPlaces?: Set<EnvironmentPlace<any>>,\n    environmentMode?: EnvironmentAnalysisMode,\n  ): NameStateClassGraph {\n    const envMode = environmentMode ?? ignore();\n    const envPlaces = new Set<Place<any>>();\n    if (environmentPlaces) {\n      for (const ep of environmentPlaces) envPlaces.add(ep.place);\n    }\n\n    const graph = new NameStateClassGraph();\n    const base0 = initialStateClass(net, initialMarking, envPlaces, envMode);\n    // Coloured places start empty in the supported fragment (the verifier guards\n    // this), so the initial name partition is empty.\n    const initial = new NameStateClass(base0, new NameMarking(), fragment.colouredOrder);\n\n    const indexOf = new Map<string, number>();\n    graph.pushClass(initial, indexOf);\n\n    const sym = { next: 0 as Sym };\n    const queue: number[] = [0];\n\n    while (queue.length > 0) {\n      if (graph.classes.length >= maxClasses) {\n        graph._complete = false;\n        break;\n      }\n      const curIdx = queue.shift()!;\n      const current = graph.classes[curIdx]!;\n\n      for (const transition of current.base.enabledTransitions) {\n        const role = fragment.role(transition.name);\n        for (const vt of expandTransition(transition)) {\n          const baseSucc = computeSuccessor(net, current.base, vt, envPlaces, envMode);\n          if (baseSucc === null || baseSucc.isEmpty()) continue;\n          const nameSuccs = nameSuccessors(role, current.names, vt.outputPlaces, fragment, sym);\n          for (const nm of nameSuccs) {\n            const succ = new NameStateClass(baseSucc, nm, fragment.colouredOrder);\n            let toIdx = indexOf.get(succ.key);\n            if (toIdx === undefined) {\n              toIdx = graph.classes.length;\n              graph.pushClass(succ, indexOf);\n              queue.push(toIdx);\n            }\n            graph.addEdge(curIdx, toIdx, transition.name);\n          }\n        }\n      }\n    }\n    return graph;\n  }\n\n  private pushClass(c: NameStateClass, indexOf: Map<string, number>): void {\n    const idx = this.classes.length;\n    this.classes.push(c);\n    this._successors.push([]);\n    indexOf.set(c.key, idx);\n  }\n\n  private addEdge(from: number, to: number, name: string): void {\n    this.edges.push({ from, to, transitionName: name });\n    this._successors[from]!.push(to);\n  }\n}\n\n/**\n * Name-layer successors of one firing. Ordinary passes the layer through; Mint\n * stamps one globally-fresh symbol into the coloured outputs of this branch (one\n * symbol into several = same-mint siblings); Join yields one successor per\n * enabling symbol (none ⇒ the join is name-disabled).\n */\nfunction nameSuccessors(\n  role: Role,\n  names: NameMarking,\n  outputPlaces: ReadonlySet<Place<any>>,\n  fragment: NameFragment,\n  sym: { next: Sym },\n): NameMarking[] {\n  switch (role.type) {\n    case 'ordinary':\n      return [names.copy()];\n    case 'mint': {\n      const colouredOut = [...outputPlaces].filter(p => fragment.isColoured(p.name)).map(p => p.name);\n      const nm = names.copy();\n      if (colouredOut.length > 0) {\n        const fresh = sym.next++;\n        for (const p of colouredOut) nm.add(p, fresh, 1);\n      }\n      return [nm];\n    }\n    case 'join': {\n      const result: NameMarking[] = [];\n      for (const s of enablingSymbols(names, role.colouredIn)) {\n        const nm = names.copy();\n        for (const [p, req] of role.colouredIn) nm.remove(p, s, req);\n        result.push(nm);\n      }\n      return result;\n    }\n  }\n}\n\n/**\n * Symbols that enable a join: present at the required multiplicity in EVERY\n * correlated input — the exactness core of NU-050 (a count-only check would\n * wrongly fire on two distinct names).\n */\nfunction enablingSymbols(names: NameMarking, colouredIn: ReadonlyArray<readonly [string, number]>): Sym[] {\n  if (colouredIn.length === 0) return [];\n  const [firstPlace, firstReq] = colouredIn[0]!;\n  const result: Sym[] = [];\n  for (const s of names.symbolsIn(firstPlace)) {\n    if (names.countOf(firstPlace, s) < firstReq) continue;\n    let ok = true;\n    for (let i = 1; i < colouredIn.length; i++) {\n      const [p, req] = colouredIn[i]!;\n      if (names.countOf(p, s) < req) {\n        ok = false;\n        break;\n      }\n    }\n    if (ok) result.push(s);\n  }\n  return result;\n}\n","/**\n * ν-net exact verification via the name-aware state-class-graph name-partition\n * quotient (NU-050, Route B). Bridges {@link NameStateClassGraph} to the\n * {@link SmtVerificationResult} verdict types.\n *\n * {@link verifyViaNameScg} returns `null` when the net is outside the supported\n * mint→matched-join fragment (the caller falls back to the SMT / Route A path);\n * otherwise an exact verdict when the symbolic graph closes, or `unknown` when it\n * truncates (the live correlation pool is unbounded).\n */\nimport type { PetriNet } from '../core/petri-net.js';\nimport type { Place } from '../core/place.js';\nimport type { EnvironmentPlace } from '../core/place.js';\nimport type { MarkingState } from './marking-state.js';\nimport type { EnvironmentAnalysisMode } from './analysis/environment-analysis-mode.js';\nimport { classify } from './analysis/name-fragment.js';\nimport { NameStateClassGraph } from './analysis/name-state-class-graph.js';\nimport type { SmtProperty } from './smt-property.js';\nimport type { Verdict } from './smt-verification-result.js';\n\nconst NOTE_EXACT =\n  '\\nNote: ν-join correlation decided exactly via the state-class-graph name-partition ' +\n  'quotient — the symbolic graph closed, so the verdict is sound AND complete (no spurious ' +\n  'different-name counterexample; quiescence is name-aware), beyond the bounded-budget ' +\n  'fragment (NU-050, Route B).\\n';\n\nexport interface NuScgOutcome {\n  readonly verdict: Verdict;\n  readonly trace: MarkingState[];\n  readonly transitions: string[];\n  readonly note: string;\n  readonly classCount: number;\n}\n\nexport function verifyViaNameScg(\n  net: PetriNet,\n  initial: MarkingState,\n  property: SmtProperty,\n  sinkPlaces: ReadonlySet<Place<any>>,\n  environmentPlaces: Set<EnvironmentPlace<any>>,\n  environmentMode: EnvironmentAnalysisMode,\n  maxClasses: number,\n): NuScgOutcome | null {\n  const fragment = classify(net);\n  if (fragment === null) return null;\n  // We model no initial colour assignment, so coloured places must start empty.\n  for (const p of initial.placesWithTokens()) {\n    if (fragment.isColoured(p.name)) return null;\n  }\n\n  const scg = NameStateClassGraph.build(net, initial, fragment, maxClasses, environmentPlaces, environmentMode);\n\n  if (!scg.isComplete()) {\n    return {\n      verdict: {\n        type: 'unknown',\n        reason:\n          `ν name-aware state-class graph truncated at ${maxClasses} classes — the live ` +\n          'correlation pool is not structurally bounded; reachability over unbounded fresh ' +\n          'names is undecidable (NU-050, Route B). Declare a budget place to bound the live ' +\n          'pool, or raise nuMaxClasses.',\n      },\n      trace: [],\n      transitions: [],\n      note: '',\n      classCount: scg.classCount(),\n    };\n  }\n\n  const violating = decide(scg, property, sinkPlaces);\n  if (violating >= 0) {\n    const [trace, transitions] = counterexamplePath(scg, violating);\n    return { verdict: { type: 'violated' }, trace, transitions, note: NOTE_EXACT, classCount: scg.classCount() };\n  }\n  return {\n    verdict: { type: 'proven', method: 'ν name-partition SCG (NU-050, Route B)', inductiveInvariant: null },\n    trace: [],\n    transitions: [],\n    note: NOTE_EXACT,\n    classCount: scg.classCount(),\n  };\n}\n\n/** Returns a witnessing class index for a violation, or -1 if the property holds. */\nfunction decide(scg: NameStateClassGraph, property: SmtProperty, sinkPlaces: ReadonlySet<Place<any>>): number {\n  const firstWhere = (pred: (i: number) => boolean): number => {\n    for (let i = 0; i < scg.classCount(); i++) {\n      if (pred(i)) return i;\n    }\n    return -1;\n  };\n\n  switch (property.type) {\n    case 'place-bound':\n    case 'branch-place-bound':\n      return firstWhere(i => scg.markingOf(i).tokens(property.place) > property.bound);\n    case 'unreachable':\n      return firstWhere(i => {\n        const m = scg.markingOf(i);\n        for (const p of property.places) {\n          if (!m.hasTokens(p)) return false;\n        }\n        return true;\n      });\n    case 'mutual-exclusion':\n      return firstWhere(i => {\n        const m = scg.markingOf(i);\n        return m.hasTokens(property.p1) && m.hasTokens(property.p2);\n      });\n    case 'deadlock-free':\n      return firstWhere(i => scg.successorsOf(i).length === 0 && !allTokensInSinks(scg.markingOf(i), sinkPlaces));\n    case 'joined-or-dead-lettered':\n      return firstWhere(i => scg.successorsOf(i).length === 0 && scg.markingOf(i).hasTokens(property.pending));\n  }\n}\n\nfunction allTokensInSinks(m: MarkingState, sinks: ReadonlySet<Place<any>>): boolean {\n  const sinkNames = new Set<string>();\n  for (const s of sinks) sinkNames.add(s.name);\n  for (const p of m.placesWithTokens()) {\n    if (!sinkNames.has(p.name)) return false;\n  }\n  return true;\n}\n\n/** Shortest firing sequence from the initial class (0) to `target`. */\nfunction counterexamplePath(scg: NameStateClassGraph, target: number): [MarkingState[], string[]] {\n  const n = scg.classCount();\n  const parent = new Array<number>(n).fill(-1);\n  const via = new Array<string>(n).fill('');\n  const visited = new Array<boolean>(n).fill(false);\n  visited[0] = true;\n  const queue: number[] = [0];\n  while (queue.length > 0) {\n    const u = queue.shift()!;\n    if (u === target) break;\n    for (const e of scg.edges) {\n      if (e.from === u && !visited[e.to]) {\n        visited[e.to] = true;\n        parent[e.to] = u;\n        via[e.to] = e.transitionName;\n        queue.push(e.to);\n      }\n    }\n  }\n  const chain: number[] = [];\n  for (let cur = target; cur !== -1; cur = parent[cur]!) {\n    chain.push(cur);\n  }\n  chain.reverse();\n  const markings = chain.map(i => scg.markingOf(i));\n  const transitions = chain.slice(1).map(i => via[i]!);\n  return [markings, transitions];\n}\n","import type { PetriNet } from '../core/petri-net.js';\nimport type { EnvironmentPlace, Place } from '../core/place.js';\nimport { MarkingState, MarkingStateBuilder } from './marking-state.js';\nimport type { SmtProperty } from './smt-property.js';\nimport { deadlockFree, propertyDescription } from './smt-property.js';\nimport type { SmtVerificationResult, SmtStatistics, Verdict } from './smt-verification-result.js';\nimport type { PInvariant } from './invariant/p-invariant.js';\nimport type { FlatNet } from './encoding/flat-net.js';\nimport { flatten } from './encoding/net-flattener.js';\nimport { type EnvironmentAnalysisMode, alwaysAvailable } from './analysis/environment-analysis-mode.js';\nimport { IncidenceMatrix } from './encoding/incidence-matrix.js';\nimport { computePInvariants, isCoveredByInvariants } from './invariant/p-invariant-computer.js';\nimport { structuralCheck } from './invariant/structural-check.js';\nimport { createSpacerRunner } from './z3/spacer-runner.js';\nimport { encode } from './z3/smt-encoder.js';\nimport { buildColouredPlan, encodeColoured, type ColouredPlan } from './z3/name-coloured-encoder.js';\nimport { verifyViaNameScg } from './nu-scg-verifier.js';\nimport { decode } from './z3/counterexample-decoder.js';\n\n/**\n * IC3/PDR-based safety verifier for Petri nets using Z3's Spacer engine.\n *\n * Proves safety properties (especially deadlock-freedom) without\n * enumerating all reachable states. IC3 constructs inductive invariants\n * incrementally, which works well for bounded nets.\n *\n * Key design decisions:\n * - Operates on the marking projection (integer vectors) — no timing\n * - An untimed deadlock-freedom proof is stronger than needed\n *   (timing can only restrict behavior)\n * - Guards are ignored — over-approximation is sound for safety properties\n * - If a counterexample is found, it may be spurious in timed/guarded\n *   semantics — the report notes this\n *\n * Verification Pipeline:\n * 1. Flatten — expand XOR, index places, build pre/post vectors\n * 2. Structural pre-check — siphon/trap analysis (may prove early)\n * 3. P-invariants — compute conservation laws for strengthening\n * 4. SMT encode + query — IC3/PDR via Z3 Spacer\n * 5. Decode result — proof or counterexample trace\n */\nexport class SmtVerifier {\n  private _initialMarking: MarkingState = MarkingState.empty();\n  private _property: SmtProperty = deadlockFree();\n  private readonly _environmentPlaces = new Set<EnvironmentPlace<any>>();\n  private readonly _sinkPlaces = new Set<Place<any>>();\n  private readonly _budgetPlaces = new Set<string>();\n  private _environmentMode: EnvironmentAnalysisMode = alwaysAvailable();\n  private _timeoutMs: number = 60_000;\n  private _nuMaxClasses: number = 100_000;\n\n  private constructor(private readonly net: PetriNet) {}\n\n  static forNet(net: PetriNet): SmtVerifier {\n    return new SmtVerifier(net);\n  }\n\n  initialMarking(marking: MarkingState): this;\n  initialMarking(configurator: (builder: MarkingStateBuilder) => void): this;\n  initialMarking(arg: MarkingState | ((builder: MarkingStateBuilder) => void)): this {\n    if (arg instanceof MarkingState) {\n      this._initialMarking = arg;\n    } else {\n      const builder = MarkingState.builder();\n      arg(builder);\n      this._initialMarking = builder.build();\n    }\n    return this;\n  }\n\n  property(property: SmtProperty): this {\n    this._property = property;\n    return this;\n  }\n\n  environmentPlaces(...places: EnvironmentPlace<any>[]): this {\n    for (const p of places) this._environmentPlaces.add(p);\n    return this;\n  }\n\n  environmentMode(mode: EnvironmentAnalysisMode): this {\n    this._environmentMode = mode;\n    return this;\n  }\n\n  /**\n   * Declares expected sink (terminal) places for deadlock-freedom analysis.\n   * Markings where any sink place has a token are not considered deadlocks.\n   */\n  sinkPlaces(...places: Place<any>[]): this {\n    for (const p of places) this._sinkPlaces.add(p);\n    return this;\n  }\n\n  /**\n   * Declares ν-net budget places (NU-040): places whose token count bounds the\n   * live correlation pool (they gate fresh-name minting). Declaring at least one\n   * places the net in the decidable bounded fragment, so reachability-safety\n   * properties over its ν-joins are verified (the matched transitions are\n   * over-approximated). Without any budget place, a net that mints fresh names\n   * is treated as unbounded and the verifier returns `unknown` (NU-050).\n   */\n  budgetPlaces(...places: Place<any>[]): this {\n    for (const p of places) this._budgetPlaces.add(p.name);\n    return this;\n  }\n\n  timeout(ms: number): this {\n    this._timeoutMs = ms;\n    return this;\n  }\n\n  /**\n   * Sets the class-count cap for the ν-aware state-class-graph analysis (NU-050,\n   * Route B). When the symbolic name-aware graph would exceed this, the analysis\n   * truncates and the verdict is `unknown` (the live correlation pool is not\n   * structurally bounded). Default 100_000.\n   */\n  nuMaxClasses(max: number): this {\n    this._nuMaxClasses = max;\n    return this;\n  }\n\n  /**\n   * Runs the verification pipeline.\n   */\n  async verify(): Promise<SmtVerificationResult> {\n    const start = performance.now();\n    const report: string[] = [];\n    report.push('=== IC3/PDR SAFETY VERIFICATION ===\\n');\n    report.push(`Net: ${this.net.name}`);\n    const propDesc = this._sinkPlaces.size === 0\n      ? propertyDescription(this._property)\n      : `${propertyDescription(this._property)} (sinks: ${[...this._sinkPlaces].map(p => p.name).join(', ')})`;\n    report.push(`Property: ${propDesc}`);\n    report.push(`Timeout: ${(this._timeoutMs / 1000).toFixed(0)}s\\n`);\n\n    // ν-net awareness (NU-040, NU-050). A transition with a match spec joins by\n    // name equality; the untimed encoder over-approximates that (name equality\n    // assumed satisfiable). Sound for reachability-safety bounds (proven holds —\n    // the real net fires strictly fewer joins) but NOT for quiescence-based\n    // properties, which name-blind firing distorts. `applyNuGuard` turns those\n    // cases into unknown.\n    const hasMatch = [...this.net.transitions].some(t => t.matchSpec !== null);\n    const nuBounded = this._budgetPlaces.size > 0;\n\n    // ν-net Route B (NU-050): the name-aware state-class-graph name-partition\n    // quotient decides ν-join correlation EXACTLY — including name×time and\n    // quiescence — without a budget. It \"fills the gaps\" the SMT / Route A path\n    // cannot answer exactly: quiescence properties on a ν-net, and unbudgeted\n    // reachability-safety. Budgeted, untimed reachability-safety in Route A's\n    // fragment stays on Route A below (this trigger is false there). If the net is\n    // outside the supported fragment, verifyViaNameScg returns null and we fall\n    // through to the existing pipeline (which applies the sound unknown downgrade).\n    if (hasMatch && (!isReachabilitySafety(this._property) || !nuBounded)) {\n      const outcome = verifyViaNameScg(\n        this.net, this._initialMarking, this._property, this._sinkPlaces,\n        this._environmentPlaces, this._environmentMode, this._nuMaxClasses,\n      );\n      if (outcome !== null) {\n        report.push('=== ν-net Route B: name-aware state-class graph (NU-050) ===');\n        report.push(`  Name-partition state classes: ${outcome.classCount}`);\n        report.push(outcome.note);\n        if (outcome.transitions.length > 0) {\n          report.push(`  Counterexample trace: ${outcome.trace.length} states, ${outcome.transitions.length} transitions`);\n        }\n        return buildResult(\n          outcome.verdict, report.join('\\n'), [], [], outcome.trace, outcome.transitions,\n          performance.now() - start,\n          {\n            places: [...this.net.places].length,\n            transitions: [...this.net.transitions].length,\n            invariantsFound: 0,\n            structuralResult: 'n/a (ν name-partition SCG)',\n          },\n        );\n      }\n    }\n\n    // Phase 1: Flatten\n    report.push('Phase 1: Flattening net...');\n    const flatNet = flatten(this.net, this._environmentPlaces, this._environmentMode);\n    report.push(`  Places: ${flatNet.places.length}`);\n    report.push(`  Transitions (expanded): ${flatNet.transitions.length}`);\n    if (flatNet.environmentBounds.size > 0) {\n      report.push(`  Environment bounds: ${flatNet.environmentBounds.size} places`);\n    }\n    report.push('');\n\n    // Phase 2: Structural pre-check\n    report.push('Phase 2: Structural pre-check (siphon/trap)...');\n    const structResult = structuralCheck(flatNet, this._initialMarking);\n    let structResultStr: string;\n    switch (structResult.type) {\n      case 'no-potential-deadlock':\n        structResultStr = 'no potential deadlock';\n        break;\n      case 'potential-deadlock':\n        structResultStr = `potential deadlock (siphon: {${[...structResult.siphon].join(',')}})`;\n        break;\n      case 'inconclusive':\n        structResultStr = `inconclusive (${structResult.reason})`;\n        break;\n    }\n    report.push(`  Result: ${structResultStr}\\n`);\n\n    // If structural check proves deadlock-freedom for DeadlockFree property\n    // (only valid when no sink places — structural check doesn't account for sinks).\n    // Skipped when environment places are registered: the siphon/trap analysis runs\n    // on the closed net and is blind to env injection (VER-006), so its early proof\n    // could be unsound — fall through to the (injection-aware) SMT encoding instead.\n    if (\n      this._property.type === 'deadlock-free' &&\n      !hasMatch &&\n      this._sinkPlaces.size === 0 &&\n      structResult.type === 'no-potential-deadlock' &&\n      this._environmentPlaces.size === 0\n    ) {\n      report.push('=== RESULT ===\\n');\n      report.push('PROVEN (structural): Deadlock-freedom verified by Commoner\\'s theorem.');\n      report.push('  All siphons contain initially marked traps.');\n      return buildResult(\n        { type: 'proven', method: 'structural', inductiveInvariant: null },\n        report.join('\\n'), [], [], [], [],\n        performance.now() - start,\n        { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: 0, structuralResult: structResultStr },\n      );\n    }\n\n    // Phase 3: P-invariants\n    report.push('Phase 3: Computing P-invariants...');\n    const matrix = IncidenceMatrix.from(flatNet);\n    const invariants = computePInvariants(matrix, flatNet, this._initialMarking);\n    report.push(`  Found: ${invariants.length} P-invariant(s)`);\n    const structurallyBounded = isCoveredByInvariants(invariants, flatNet.places.length);\n    report.push(`  Structurally bounded: ${structurallyBounded ? 'YES' : 'NO'}`);\n    for (const inv of invariants) {\n      report.push(`  ${formatInvariant(inv, flatNet)}`);\n    }\n    report.push('');\n\n    // Phase 4: SMT encode + query via Spacer\n    report.push('Phase 4: IC3/PDR verification via Z3 Spacer...');\n\n    // ν-net exact refinement (NU-050 #1, Route A). For a budget-bounded ν-net in\n    // the supported mint→matched-join fragment, encode names as a finite colour set\n    // (k = the declared budget) with exact same-colour join matching, instead of the\n    // name-blind over-approximation — this rules out spurious counterexamples that\n    // would equate two distinct names. Only reachability-safety properties are routed\n    // here; everything else (and any net outside the fragment) keeps the flat encoding.\n    const colouredPlan: ColouredPlan | null =\n      hasMatch && nuBounded && isReachabilitySafety(this._property)\n        ? buildColouredPlan(this.net, flatNet, this._initialMarking, this._budgetPlaces)\n        : null;\n\n    let runner;\n    try {\n      runner = await createSpacerRunner(this._timeoutMs);\n    } catch (e: any) {\n      report.push(`  ERROR: ${e.message ?? e}\\n`);\n      report.push('=== RESULT ===\\n');\n      report.push(`UNKNOWN: Z3 initialization error: ${e.message ?? e}`);\n      return buildResult(\n        { type: 'unknown', reason: `Z3 init error: ${e.message ?? e}` },\n        report.join('\\n'), invariants, [], [], [],\n        performance.now() - start,\n        { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr },\n      );\n    }\n\n    try {\n      let encoding;\n      if (colouredPlan != null) {\n        report.push(\n          `  ν-encoding: name-coloured (exact within budget k=${colouredPlan.k}; ` +\n            `${colouredPlan.coloured.length} coloured place(s))`,\n        );\n        encoding = encodeColoured(runner.ctx, runner.fp, colouredPlan, flatNet, this._initialMarking, this._property, invariants);\n      } else {\n        encoding = encode(runner.ctx, runner.fp, flatNet, this._initialMarking, this._property, invariants, this._sinkPlaces);\n      }\n      const queryResult = await runner.query(encoding.errorExpr, encoding.reachableDecl);\n\n      switch (queryResult.type) {\n        case 'proven': {\n          // Guard against silent vacuous proofs (VER-006): in `ignore` mode the\n          // encoding does not model env injection, so env-gated transitions never\n          // fire and ANY safety bound is trivially \"proven\". Refuse to certify —\n          // downgrade to UNKNOWN with actionable guidance.\n          if (this._environmentPlaces.size > 0 && this._environmentMode.type === 'ignore') {\n            const reason =\n              'environment places present but not modeled (mode=ignore); a proof would be ' +\n              'vacuous — use alwaysAvailable() or bounded(k) to model external injection';\n            report.push(`  Status: UNSAT, but vacuous under ignore mode\\n`);\n            report.push('=== RESULT ===\\n');\n            report.push(`UNKNOWN: ${reason}`);\n            return buildResult(\n              { type: 'unknown', reason },\n              report.join('\\n'), invariants, [], [], [],\n              performance.now() - start,\n              { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr },\n            );\n          }\n\n          report.push('  Status: UNSAT (property holds)\\n');\n\n          // Decode IC3-synthesized invariants with place name substitution\n          const discoveredInvariants: string[] = [];\n          if (queryResult.invariantFormula != null) {\n            discoveredInvariants.push(substituteNames(queryResult.invariantFormula, flatNet));\n          }\n          for (const level of queryResult.levelInvariants) {\n            discoveredInvariants.push(substituteNames(level, flatNet));\n          }\n\n          // Phase 5: Inductive invariant\n          if (discoveredInvariants.length > 0) {\n            report.push('Phase 5: Inductive invariant (discovered by IC3)');\n            report.push(`  Spacer synthesized: ${discoveredInvariants[0]}`);\n            report.push('  This formula is INDUCTIVE: preserved by all transitions.');\n            if (discoveredInvariants.length > 1) {\n              report.push('  Per-level clauses:');\n              for (let i = 1; i < discoveredInvariants.length; i++) {\n                report.push(`    ${discoveredInvariants[i]}`);\n              }\n            }\n            report.push('');\n          }\n\n          report.push('=== RESULT ===\\n');\n          report.push(`PROVEN (IC3/PDR): ${propDesc}`);\n          report.push('  Z3 Spacer proved no reachable state violates the property.');\n          report.push('  NOTE: Verification ignores timing constraints and JS guards.');\n          report.push('  An untimed proof is STRONGER than a timed one (timing only restricts behavior).');\n\n          return this.applyNuGuard(buildResult(\n            {\n              type: 'proven',\n              method: 'IC3/PDR',\n              inductiveInvariant: queryResult.invariantFormula != null\n                ? substituteNames(queryResult.invariantFormula, flatNet)\n                : null,\n            },\n            report.join('\\n'), invariants, discoveredInvariants, [], [],\n            performance.now() - start,\n            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr },\n          ), hasMatch, nuBounded, colouredPlan != null);\n        }\n\n        case 'violated': {\n          report.push('  Status: SAT (counterexample found)\\n');\n\n          const decoded = decode(runner.ctx, queryResult.answer, flatNet);\n\n          report.push('=== RESULT ===\\n');\n          report.push(`VIOLATED: ${propDesc}`);\n          if (decoded.trace.length > 0) {\n            report.push(`  Counterexample trace (${decoded.trace.length} states):`);\n            for (let i = 0; i < decoded.trace.length; i++) {\n              report.push(`    ${i}: ${decoded.trace[i]}`);\n            }\n          }\n          if (decoded.transitions.length > 0) {\n            report.push(`  Firing sequence: ${decoded.transitions.join(' -> ')}`);\n          }\n          report.push('\\n  WARNING: This counterexample is in UNTIMED semantics.');\n          report.push('  It may be spurious if timing constraints prevent this sequence.');\n          report.push('  JS guards are also ignored in this analysis.');\n\n          return this.applyNuGuard(buildResult(\n            { type: 'violated' },\n            report.join('\\n'), invariants, [], decoded.trace as MarkingState[], decoded.transitions as string[],\n            performance.now() - start,\n            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr },\n          ), hasMatch, nuBounded, colouredPlan != null);\n        }\n\n        case 'unknown': {\n          report.push(`  Status: UNKNOWN (${queryResult.reason})\\n`);\n          report.push('=== RESULT ===\\n');\n          report.push(`UNKNOWN: Could not determine ${propDesc}`);\n          report.push(`  Reason: ${queryResult.reason}`);\n\n          return buildResult(\n            { type: 'unknown', reason: queryResult.reason },\n            report.join('\\n'), invariants, [], [], [],\n            performance.now() - start,\n            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr },\n          );\n        }\n      }\n    } catch (e: any) {\n      report.push(`  ERROR: ${e.message ?? e}\\n`);\n      report.push('=== RESULT ===\\n');\n      report.push(`UNKNOWN: Z3 solver error: ${e.message ?? e}`);\n\n      return buildResult(\n        { type: 'unknown', reason: `Z3 error: ${e.message ?? e}` },\n        report.join('\\n'), invariants, [], [], [],\n        performance.now() - start,\n        { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr },\n      );\n    } finally {\n      runner.dispose();\n    }\n  }\n\n  /**\n   * ν-net soundness guard (NU-040, NU-050). Applied only when the net contains\n   * match (ν-join) transitions, and only to a proven/violated verdict (an\n   * existing unknown is left as-is).\n   *\n   * - Quiescence-based properties (deadlock / joined-or-dead-lettered): the\n   *   name-blind over-approximation over-fires joins, so it sees fewer quiescent\n   *   states and may miss a real stranded marking — downgraded to unknown\n   *   (exact quiescence reasoning is deferred to the SCG name-partition quotient).\n   * - Reachability-safety with unbounded fresh names (no budget declared):\n   *   reachability over unbounded fresh names is undecidable — unknown.\n   * - Bounded reachability-safety in the name-coloured fragment (`exact`): name\n   *   equality is encoded exactly via bounded name-colouring, so the verdict is\n   *   sound *and* complete within the budget — no spurious different-name\n   *   counterexample. The verdict is kept and the exact-path note is appended.\n   * - Bounded reachability-safety outside that fragment: `proven` is sound; a\n   *   `violated` may be spurious — the verdict is kept and the over-approximation\n   *   caveat is appended to the report.\n   */\n  private applyNuGuard(\n    result: SmtVerificationResult,\n    hasMatch: boolean,\n    nuBounded: boolean,\n    exact: boolean,\n  ): SmtVerificationResult {\n    if (!hasMatch || result.verdict.type === 'unknown') return result;\n    if (!isReachabilitySafety(this._property)) {\n      return downgradeToUnknown(\n        result,\n        'ν-matching transitions present and the property depends on quiescence ' +\n          '(deadlock / joined-or-dead-lettered); the name-blind over-approximation cannot ' +\n          'decide it soundly — deferred to the exact ν-analysis (NU-050)',\n      );\n    }\n    if (!nuBounded) {\n      return downgradeToUnknown(\n        result,\n        'ν-matching transitions present with unbounded fresh names (no budget place declared ' +\n          'via budgetPlaces(...)); reachability over unbounded fresh names is undecidable ' +\n          '(NU-040) — declare the budget place(s) that gate minting to verify within the ' +\n          'bounded fragment',\n      );\n    }\n    // Bounded reachability-safety. The exact path (NU-050 #1, Route A) encodes name\n    // equality exactly via bounded name-colouring, so both proven and violated are\n    // trustworthy; outside the fragment the matched transitions are\n    // over-approximated, so a violated may be spurious.\n    const note = exact\n      ? '\\nNote: ν-join name equality is encoded exactly via bounded name-colouring ' +\n        '(k = budget); the verdict is sound and complete within the budget bound — no spurious ' +\n        'different-name counterexample (NU-050 #1).\\n'\n      : \"\\nNote: matched (ν-join) transitions are over-approximated (name equality assumed \" +\n        \"satisfiable). 'proven' is sound; a 'violated' counterexample may be spurious pending \" +\n        'the exact ν-analysis (NU-050).\\n';\n    return { ...result, report: result.report + note };\n  }\n}\n\n/**\n * Whether a property is a reachability-safety property — one whose violation is\n * a reachable bad marking. For these the matched-transition over-approximation\n * is sound for `proven`. Quiescence-based properties (deadlock,\n * joined-or-dead-lettered) are not: their violation involves the absence of\n * enabled transitions, which the name-blind over-approximation distorts (NU-050).\n */\nfunction isReachabilitySafety(property: SmtProperty): boolean {\n  switch (property.type) {\n    case 'place-bound':\n    case 'branch-place-bound':\n    case 'mutual-exclusion':\n    case 'unreachable':\n      return true;\n    case 'deadlock-free':\n    case 'joined-or-dead-lettered':\n      return false;\n  }\n}\n\nfunction downgradeToUnknown(result: SmtVerificationResult, reason: string): SmtVerificationResult {\n  return {\n    ...result,\n    verdict: { type: 'unknown', reason },\n    report: result.report + `\\nDowngraded to UNKNOWN: ${reason}\\n`,\n    discoveredInvariants: [],\n    counterexampleTrace: [],\n    counterexampleTransitions: [],\n  };\n}\n\n/**\n * Substitutes Z3 variable names (m0, m1, ...) with place names in a formula string.\n */\nfunction substituteNames(formula: string, flatNet: FlatNet): string {\n  // Replace from highest index first to avoid m1 matching inside m10\n  for (let i = flatNet.places.length - 1; i >= 0; i--) {\n    formula = formula.replace(new RegExp(`\\\\bm${i}\\\\b`, 'g'), flatNet.places[i]!.name);\n  }\n  return formula;\n}\n\nfunction formatInvariant(inv: PInvariant, flatNet: FlatNet): string {\n  const parts: string[] = [];\n  for (const idx of inv.support) {\n    if (inv.weights[idx] !== 1) {\n      parts.push(`${inv.weights[idx]}*${flatNet.places[idx]!.name}`);\n    } else {\n      parts.push(flatNet.places[idx]!.name);\n    }\n  }\n  return `${parts.join(' + ')} = ${inv.constant}`;\n}\n\nfunction buildResult(\n  verdict: Verdict,\n  report: string,\n  invariants: readonly PInvariant[],\n  discoveredInvariants: readonly string[],\n  trace: readonly MarkingState[],\n  transitions: readonly string[],\n  elapsedMs: number,\n  statistics: SmtStatistics,\n): SmtVerificationResult {\n  return { verdict, report, invariants, discoveredInvariants, counterexampleTrace: trace, counterexampleTransitions: transitions, elapsedMs, statistics };\n}\n","import type { MarkingState } from './marking-state.js';\nimport type { PInvariant } from './invariant/p-invariant.js';\n\n/**\n * Verification verdict.\n */\nexport type Verdict = Proven | Violated | Unknown;\n\n/** Property proven safe. No reachable state violates it. */\nexport interface Proven {\n  readonly type: 'proven';\n  readonly method: string;\n  readonly inductiveInvariant: string | null;\n}\n\n/** Property violated. A counterexample trace is available. */\nexport interface Violated {\n  readonly type: 'violated';\n}\n\n/** Could not determine. */\nexport interface Unknown {\n  readonly type: 'unknown';\n  readonly reason: string;\n}\n\n/**\n * Solver statistics.\n */\nexport interface SmtStatistics {\n  readonly places: number;\n  readonly transitions: number;\n  readonly invariantsFound: number;\n  readonly structuralResult: string;\n}\n\n/**\n * Result of SMT-based verification.\n */\nexport interface SmtVerificationResult {\n  readonly verdict: Verdict;\n  readonly report: string;\n  readonly invariants: readonly PInvariant[];\n  readonly discoveredInvariants: readonly string[];\n  readonly counterexampleTrace: readonly MarkingState[];\n  readonly counterexampleTransitions: readonly string[];\n  readonly elapsedMs: number;\n  readonly statistics: SmtStatistics;\n}\n\nexport function isProven(result: SmtVerificationResult): boolean {\n  return result.verdict.type === 'proven';\n}\n\nexport function isViolated(result: SmtVerificationResult): boolean {\n  return result.verdict.type === 'violated';\n}\n"],"mappings":"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","names":[]}

package/dist/debug/index.d.ts

@@ -1,6 +1,6 @@
 import { Writable } from 'node:stream';
-import { P as PetriNet, b as Transition, T as Token } from '../petri-net-D73-PO6d.js';
-import { E as EventStore, N as NetEvent } from '../event-store-8XkpYUeU.js';
+import { P as PetriNet, b as Transition, T as Token } from '../petri-net-B4wQwsUj.js';
+import { E as EventStore, N as NetEvent } from '../event-store-CAkN_ayv.js';
 
 /**
  * Commands sent from debug UI client to server via WebSocket.

package/dist/debug/index.js

@@ -6,7 +6,8 @@ import {
   instancePrefixOf,
   parentOf,
   sanitize
-} from "../chunk-ULX3OG6H.js";
+} from "../chunk-JVI5HFRX.js";
+import "../chunk-E3ZWB645.js";
 import "../chunk-ATT7U5H5.js";
 
 // src/debug/debug-command.ts