@mmapp/react-compiler 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/verify-SEIXUGN4.mjs

@@ -1,1833 +0,0 @@
-import {
-  babelPlugin
-} from "./chunk-OPJKP747.mjs";
-import "./chunk-CIESM3BP.mjs";
-
-// src/cli/verify.ts
-import { readFileSync, existsSync, statSync } from "fs";
-import { resolve, basename, extname } from "path";
-import { glob } from "glob";
-import { transformSync } from "@babel/core";
-
-// src/verify/structural.ts
-function issue(severity, code, message, location) {
-  return { severity, code, message, location };
-}
-function collectSetFieldRefs(actions) {
-  const refs = [];
-  for (const action of actions) {
-    if (action.type === "set_field" && typeof action.config?.field === "string") {
-      refs.push(action.config.field);
-    }
-    const compensate = action.compensate;
-    if (compensate) {
-      refs.push(...collectSetFieldRefs([compensate]));
-    }
-  }
-  return refs;
-}
-function validateStructure(def) {
-  const errors = [];
-  const warnings = [];
-  const stateNames = new Set(def.states.map((s) => s.name));
-  const fieldNames = new Set(def.fields.map((f) => f.name));
-  const startStates = def.states.filter((s) => s.type === "START");
-  if (startStates.length === 0) {
-    errors.push(
-      issue("error", "NO_START_STATE", "Workflow has no START state.")
-    );
-  } else if (startStates.length > 1) {
-    errors.push(
-      issue(
-        "error",
-        "MULTIPLE_START_STATES",
-        `Workflow has ${startStates.length} START states: ${startStates.map((s) => s.name).join(", ")}. Exactly one is required.`
-      )
-    );
-  }
-  const endStates = def.states.filter((s) => s.type === "END");
-  if (endStates.length === 0) {
-    warnings.push(
-      issue(
-        "warning",
-        "NO_END_STATE",
-        "Workflow has no END state. This may be intentional for infinite-loop workflows."
-      )
-    );
-  }
-  for (const t of def.transitions) {
-    for (const from of t.from) {
-      if (!stateNames.has(from)) {
-        errors.push(
-          issue(
-            "error",
-            "TRANSITION_FROM_UNKNOWN_STATE",
-            `Transition "${t.name}" references unknown source state "${from}".`,
-            `transition:${t.name}`
-          )
-        );
-      }
-    }
-    if (!stateNames.has(t.to)) {
-      errors.push(
-        issue(
-          "error",
-          "TRANSITION_TO_UNKNOWN_STATE",
-          `Transition "${t.name}" targets unknown state "${t.to}".`,
-          `transition:${t.name}`
-        )
-      );
-    }
-  }
-  checkDuplicateTransitions(def.transitions, warnings);
-  for (const t of def.transitions) {
-    const refs = collectSetFieldRefs(t.actions);
-    for (const ref of refs) {
-      if (!fieldNames.has(ref)) {
-        warnings.push(
-          issue(
-            "warning",
-            "SET_FIELD_UNKNOWN",
-            `Transition "${t.name}" sets unknown field "${ref}".`,
-            `transition:${t.name}`
-          )
-        );
-      }
-    }
-  }
-  for (const state of def.states) {
-    const enterRefs = collectSetFieldRefs(state.on_enter);
-    const exitRefs = collectSetFieldRefs(state.on_exit);
-    for (const ref of [...enterRefs, ...exitRefs]) {
-      if (!fieldNames.has(ref)) {
-        warnings.push(
-          issue(
-            "warning",
-            "SET_FIELD_UNKNOWN",
-            `State "${state.name}" action sets unknown field "${ref}".`,
-            `state:${state.name}`
-          )
-        );
-      }
-    }
-  }
-  for (const t of def.transitions) {
-    if (t.conditions) {
-      for (const cond of t.conditions) {
-        if (cond.expression !== void 0 && cond.expression.trim() === "") {
-          warnings.push(
-            issue(
-              "warning",
-              "EMPTY_CONDITION_EXPRESSION",
-              `Transition "${t.name}" has an empty condition expression.`,
-              `transition:${t.name}`
-            )
-          );
-        }
-      }
-    }
-    for (const action of t.actions) {
-      if (action.condition !== void 0 && action.condition.trim() === "") {
-        warnings.push(
-          issue(
-            "warning",
-            "EMPTY_ACTION_CONDITION",
-            `Transition "${t.name}" has an action "${action.id}" with an empty condition.`,
-            `transition:${t.name}`
-          )
-        );
-      }
-    }
-  }
-  for (const t of def.transitions) {
-    if (t.required_fields) {
-      for (const rf of t.required_fields) {
-        if (!fieldNames.has(rf)) {
-          warnings.push(
-            issue(
-              "warning",
-              "REQUIRED_FIELD_UNKNOWN",
-              `Transition "${t.name}" requires unknown field "${rf}".`,
-              `transition:${t.name}`
-            )
-          );
-        }
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-function checkDuplicateTransitions(transitions, warnings) {
-  const bySource = /* @__PURE__ */ new Map();
-  for (const t of transitions) {
-    for (const from of t.from) {
-      let inner = bySource.get(from);
-      if (!inner) {
-        inner = /* @__PURE__ */ new Map();
-        bySource.set(from, inner);
-      }
-      inner.set(t.name, (inner.get(t.name) ?? 0) + 1);
-    }
-  }
-  for (const [state, nameMap] of bySource) {
-    for (const [name, count] of nameMap) {
-      if (count > 1) {
-        warnings.push(
-          issue(
-            "warning",
-            "DUPLICATE_TRANSITION_NAME",
-            `State "${state}" has ${count} transitions named "${name}".`,
-            `state:${state}`
-          )
-        );
-      }
-    }
-  }
-}
-
-// src/verify/reachability.ts
-function buildForwardGraph(def) {
-  const adj = /* @__PURE__ */ new Map();
-  for (const s of def.states) {
-    adj.set(s.name, /* @__PURE__ */ new Set());
-  }
-  for (const t of def.transitions) {
-    for (const from of t.from) {
-      const neighbors = adj.get(from);
-      if (neighbors) {
-        neighbors.add(t.to);
-      }
-    }
-  }
-  return adj;
-}
-function buildReverseGraph(def) {
-  const adj = /* @__PURE__ */ new Map();
-  for (const s of def.states) {
-    adj.set(s.name, /* @__PURE__ */ new Set());
-  }
-  for (const t of def.transitions) {
-    const neighbors = adj.get(t.to);
-    if (neighbors) {
-      for (const from of t.from) {
-        neighbors.add(from);
-      }
-    }
-  }
-  return adj;
-}
-function bfs(adj, starts) {
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [...starts];
-  for (const s of queue) {
-    if (visited.has(s)) continue;
-    visited.add(s);
-    const neighbors = adj.get(s);
-    if (neighbors) {
-      for (const n of neighbors) {
-        if (!visited.has(n)) {
-          queue.push(n);
-        }
-      }
-    }
-  }
-  return visited;
-}
-function tarjanSCC(adj) {
-  let index = 0;
-  const stack = [];
-  const onStack = /* @__PURE__ */ new Set();
-  const indices = /* @__PURE__ */ new Map();
-  const lowlinks = /* @__PURE__ */ new Map();
-  const sccs = [];
-  function strongConnect(v) {
-    indices.set(v, index);
-    lowlinks.set(v, index);
-    index++;
-    stack.push(v);
-    onStack.add(v);
-    const neighbors = adj.get(v);
-    if (neighbors) {
-      for (const w of neighbors) {
-        if (!indices.has(w)) {
-          strongConnect(w);
-          lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
-        } else if (onStack.has(w)) {
-          lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
-        }
-      }
-    }
-    if (lowlinks.get(v) === indices.get(v)) {
-      const scc = [];
-      let w;
-      do {
-        w = stack.pop();
-        onStack.delete(w);
-        scc.push(w);
-      } while (w !== v);
-      sccs.push(scc);
-    }
-  }
-  for (const node of adj.keys()) {
-    if (!indices.has(node)) {
-      strongConnect(node);
-    }
-  }
-  return sccs;
-}
-function longestPathBFS(adj, start) {
-  const dist = /* @__PURE__ */ new Map();
-  const parent = /* @__PURE__ */ new Map();
-  const maxSteps = adj.size;
-  dist.set(start, 0);
-  parent.set(start, null);
-  let changed = true;
-  let iterations = 0;
-  while (changed && iterations < maxSteps) {
-    changed = false;
-    iterations++;
-    for (const [u, neighbors] of adj) {
-      const du = dist.get(u);
-      if (du === void 0) continue;
-      for (const v of neighbors) {
-        const dv = dist.get(v);
-        if (dv === void 0 || du + 1 > dv) {
-          dist.set(v, du + 1);
-          parent.set(v, u);
-          changed = true;
-        }
-      }
-    }
-  }
-  let farthest = start;
-  let maxDist = 0;
-  for (const [node, d] of dist) {
-    if (d > maxDist) {
-      maxDist = d;
-      farthest = node;
-    }
-  }
-  const path = [];
-  let current = farthest;
-  const visited = /* @__PURE__ */ new Set();
-  while (current != null && !visited.has(current)) {
-    visited.add(current);
-    path.unshift(current);
-    current = parent.get(current) ?? null;
-  }
-  return { distance: maxDist, path };
-}
-function analyzeReachability(def) {
-  const allStateNames = def.states.map((s) => s.name);
-  const allStatesSet = new Set(allStateNames);
-  const forward = buildForwardGraph(def);
-  const reverse = buildReverseGraph(def);
-  const startStates = def.states.filter((s) => s.type === "START").map((s) => s.name);
-  const endStates = def.states.filter((s) => s.type === "END").map((s) => s.name);
-  const reachableSet = bfs(forward, startStates);
-  const reachable = allStateNames.filter((s) => reachableSet.has(s));
-  const unreachable = allStateNames.filter((s) => !reachableSet.has(s));
-  const canTerminateSet = bfs(reverse, endStates);
-  const canTerminate = allStateNames.filter((s) => canTerminateSet.has(s));
-  const stuck = reachable.filter((s) => !canTerminateSet.has(s));
-  const endTypeSet = new Set(endStates);
-  const deadlocks = reachable.filter((s) => {
-    const neighbors = forward.get(s);
-    const hasOutgoing = neighbors != null && neighbors.size > 0;
-    return !hasOutgoing && !endTypeSet.has(s);
-  });
-  const selfLoopSet = /* @__PURE__ */ new Set();
-  for (const t of def.transitions) {
-    for (const from of t.from) {
-      if (from === t.to && allStatesSet.has(from)) {
-        selfLoopSet.add(from);
-      }
-    }
-  }
-  const selfLoops = [...selfLoopSet];
-  const sccs = tarjanSCC(forward);
-  const cycles = sccs.filter((scc) => scc.length > 1);
-  const startState = startStates[0];
-  let longestPath = 0;
-  let criticalPath = [];
-  if (startState) {
-    const result = longestPathBFS(forward, startState);
-    longestPath = result.distance;
-    criticalPath = result.path;
-  }
-  return {
-    reachable,
-    unreachable,
-    canTerminate,
-    stuck,
-    deadlocks,
-    selfLoops,
-    cycles,
-    longestPath,
-    criticalPath
-  };
-}
-
-// src/verify/safety.ts
-function flattenConditions(conds) {
-  const leaves = [];
-  for (const c of conds) {
-    if (c.AND && c.AND.length > 0) {
-      leaves.push(...flattenConditions(c.AND));
-    } else if (c.OR && c.OR.length > 0) {
-      leaves.push(...flattenConditions(c.OR));
-    } else {
-      leaves.push(c);
-    }
-  }
-  return leaves;
-}
-function conditionFields(conds) {
-  const fields = /* @__PURE__ */ new Set();
-  for (const leaf of flattenConditions(conds)) {
-    if (leaf.field) {
-      fields.add(leaf.field);
-    }
-  }
-  return fields;
-}
-function conditionFieldOps(conds) {
-  const pairs = [];
-  for (const leaf of flattenConditions(conds)) {
-    if (leaf.field && leaf.operator) {
-      pairs.push({ field: leaf.field, operator: leaf.operator });
-    }
-  }
-  return pairs;
-}
-function isUnguarded(t) {
-  return !t.conditions || t.conditions.length === 0;
-}
-function checkGuardOverlap(a, b) {
-  const aUnguarded = isUnguarded(a);
-  const bUnguarded = isUnguarded(b);
-  if (aUnguarded && bUnguarded) {
-    return "Both transitions have no conditions \u2014 always overlap.";
-  }
-  if (aUnguarded) {
-    return `Transition "${a.name}" has no conditions and will always match alongside "${b.name}".`;
-  }
-  if (bUnguarded) {
-    return `Transition "${b.name}" has no conditions and will always match alongside "${a.name}".`;
-  }
-  const aOps = conditionFieldOps(a.conditions);
-  const bOps = conditionFieldOps(b.conditions);
-  const compatiblePairs = /* @__PURE__ */ new Set([
-    "eq:eq",
-    "gte:lte",
-    "lte:gte",
-    "gte:gte",
-    "lte:lte",
-    "gt:lt",
-    "lt:gt",
-    "gt:gt",
-    "lt:lt",
-    "in:in",
-    "in:eq",
-    "eq:in",
-    "contains:contains",
-    "contains:eq",
-    "eq:contains"
-  ]);
-  for (const aOp of aOps) {
-    for (const bOp of bOps) {
-      if (aOp.field === bOp.field) {
-        const pair = `${aOp.operator}:${bOp.operator}`;
-        if (compatiblePairs.has(pair)) {
-          return `Both check field "${aOp.field}" with potentially overlapping operators (${aOp.operator}, ${bOp.operator}).`;
-        }
-      }
-    }
-  }
-  const aFields = conditionFields(a.conditions);
-  const bFields = conditionFields(b.conditions);
-  const shared = [...aFields].filter((f) => bFields.has(f));
-  if (shared.length > 0 && aOps.length === 0 && bOps.length === 0) {
-    return `Both reference fields [${shared.join(", ")}] via expressions \u2014 manual review needed.`;
-  }
-  return null;
-}
-function computeReachableStates(def) {
-  const adj = /* @__PURE__ */ new Map();
-  for (const s of def.states) {
-    adj.set(s.name, /* @__PURE__ */ new Set());
-  }
-  for (const t of def.transitions) {
-    for (const from of t.from) {
-      const neighbors = adj.get(from);
-      if (neighbors) {
-        neighbors.add(t.to);
-      }
-    }
-  }
-  const startStates = def.states.filter((s) => s.type === "START").map((s) => s.name);
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [...startStates];
-  for (const s of queue) {
-    if (visited.has(s)) continue;
-    visited.add(s);
-    const neighbors = adj.get(s);
-    if (neighbors) {
-      for (const n of neighbors) {
-        if (!visited.has(n)) {
-          queue.push(n);
-        }
-      }
-    }
-  }
-  return visited;
-}
-function analyzeSafety(def) {
-  const guardOverlaps = [];
-  const deadTransitions = [];
-  const roleGaps = [];
-  const fieldGaps = [];
-  const stateNames = new Set(def.states.map((s) => s.name));
-  const fieldNames = new Set(def.fields.map((f) => f.name));
-  const roleNames = new Set(def.roles.map((r) => r.name));
-  const reachable = computeReachableStates(def);
-  const transitionsBySource = /* @__PURE__ */ new Map();
-  for (const t of def.transitions) {
-    for (const from of t.from) {
-      let group = transitionsBySource.get(from);
-      if (!group) {
-        group = [];
-        transitionsBySource.set(from, group);
-      }
-      group.push(t);
-    }
-  }
-  for (const [state, transitions] of transitionsBySource) {
-    for (let i = 0; i < transitions.length; i++) {
-      for (let j = i + 1; j < transitions.length; j++) {
-        const a = transitions[i];
-        const b = transitions[j];
-        const aIsAuto = a.auto === true;
-        const bIsAuto = b.auto === true;
-        const aNoRoles = !a.roles || a.roles.length === 0;
-        const bNoRoles = !b.roles || b.roles.length === 0;
-        const bothAuto = aIsAuto && bIsAuto;
-        const bothManualNoRoles = !aIsAuto && !bIsAuto && aNoRoles && bNoRoles;
-        if (bothAuto || bothManualNoRoles) {
-          const reason = checkGuardOverlap(a, b);
-          if (reason) {
-            guardOverlaps.push({
-              state,
-              transitions: [a.name, b.name],
-              reason
-            });
-          }
-        }
-      }
-    }
-  }
-  for (const t of def.transitions) {
-    const allFromUnreachable = t.from.every((from) => {
-      return stateNames.has(from) && !reachable.has(from);
-    });
-    if (allFromUnreachable && t.from.length > 0) {
-      deadTransitions.push({
-        transition: t.name,
-        reason: `All source states [${t.from.join(", ")}] are unreachable.`
-      });
-    }
-    const missingFrom = t.from.filter((f) => !stateNames.has(f));
-    if (missingFrom.length === t.from.length && t.from.length > 0) {
-      deadTransitions.push({
-        transition: t.name,
-        reason: `All source states [${missingFrom.join(", ")}] do not exist.`
-      });
-    }
-  }
-  for (const t of def.transitions) {
-    if (t.roles && t.roles.length > 0) {
-      const unknownRoles = t.roles.filter((r) => !roleNames.has(r));
-      if (unknownRoles.length > 0) {
-        roleGaps.push({
-          transition: t.name,
-          message: `References undefined roles: [${unknownRoles.join(", ")}]. Defined roles: [${[...roleNames].join(", ") || "none"}].`
-        });
-      }
-    }
-  }
-  for (const t of def.transitions) {
-    if (t.required_fields) {
-      for (const field of t.required_fields) {
-        if (!fieldNames.has(field)) {
-          fieldGaps.push({
-            transition: t.name,
-            field,
-            message: `Required field "${field}" is not defined in the workflow fields.`
-          });
-        }
-      }
-    }
-    if (t.conditions) {
-      const condFields = conditionFields(t.conditions);
-      for (const field of condFields) {
-        if (!fieldNames.has(field)) {
-          fieldGaps.push({
-            transition: t.name,
-            field,
-            message: `Condition references undefined field "${field}".`
-          });
-        }
-      }
-    }
-  }
-  const deterministic = guardOverlaps.length === 0;
-  return {
-    guardOverlaps,
-    deadTransitions,
-    roleGaps,
-    fieldGaps,
-    deterministic
-  };
-}
-
-// src/verify/liveness.ts
-function analyzeLiveness(def) {
-  const states = def.states || [];
-  const transitions = def.transitions || [];
-  const stateNames = new Set(states.map((s) => s.name));
-  const startState = states.find((s) => s.type === "START");
-  const endStates = new Set(states.filter((s) => s.type === "END").map((s) => s.name));
-  if (!startState || endStates.size === 0) {
-    return {
-      terminates: endStates.size === 0 ? "never" : "unknown",
-      nonTerminatingCycles: [],
-      progressViolations: [],
-      fairnessAssumptions: []
-    };
-  }
-  const adj = /* @__PURE__ */ new Map();
-  for (const s of states) adj.set(s.name, []);
-  for (const t of transitions) {
-    const froms = Array.isArray(t.from) ? t.from : [t.from];
-    for (const f of froms) {
-      if (adj.has(f)) {
-        adj.get(f).push({ to: t.to, transition: t.name, auto: t.auto === true });
-      }
-    }
-  }
-  const reachable = bfs2(startState.name, adj);
-  const reverseAdj = /* @__PURE__ */ new Map();
-  for (const s of states) reverseAdj.set(s.name, []);
-  for (const t of transitions) {
-    const froms = Array.isArray(t.from) ? t.from : [t.from];
-    for (const f of froms) {
-      if (!reverseAdj.has(t.to)) reverseAdj.set(t.to, []);
-      reverseAdj.get(t.to).push(f);
-    }
-  }
-  const canReachEnd = /* @__PURE__ */ new Set();
-  for (const end of endStates) {
-    for (const s of bfs2(end, reverseAdj)) {
-      canReachEnd.add(s);
-    }
-  }
-  const sccs = tarjanSCC2(stateNames, adj);
-  const nonTerminatingCycles = [];
-  for (const scc of sccs) {
-    if (scc.length <= 1) continue;
-    const hasSelfLoop = scc.length === 1 && adj.get(scc[0])?.some((e) => e.to === scc[0]);
-    if (scc.length === 1 && !hasSelfLoop) continue;
-    const canExit = scc.some((s) => canReachEnd.has(s));
-    if (!canExit) {
-      nonTerminatingCycles.push(scc);
-    }
-  }
-  const progressViolations = [];
-  for (const s of reachable) {
-    if (endStates.has(s)) continue;
-    const edges = adj.get(s) || [];
-    if (edges.length === 0) {
-      progressViolations.push(s);
-    }
-  }
-  const fairnessAssumptions = [];
-  for (const t of transitions) {
-    if (!t.auto) {
-      fairnessAssumptions.push(`Transition '${t.name}' requires external trigger (userAction or manual)`);
-    }
-  }
-  let terminates;
-  if (nonTerminatingCycles.length > 0) {
-    terminates = "never";
-  } else if (progressViolations.length > 0) {
-    terminates = "never";
-  } else if (fairnessAssumptions.length > 0) {
-    terminates = "conditional";
-  } else {
-    const allReachableCanTerminate = [...reachable].every((s) => canReachEnd.has(s) || endStates.has(s));
-    terminates = allReachableCanTerminate ? "always" : "conditional";
-  }
-  return {
-    terminates,
-    nonTerminatingCycles,
-    progressViolations,
-    fairnessAssumptions
-  };
-}
-function bfs2(start, adj) {
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [start];
-  visited.add(start);
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const neighbors = adj.get(current) || [];
-    for (const n of neighbors) {
-      const target = typeof n === "string" ? n : n.to;
-      if (!visited.has(target)) {
-        visited.add(target);
-        queue.push(target);
-      }
-    }
-  }
-  return visited;
-}
-function tarjanSCC2(nodes, adj) {
-  let index = 0;
-  const stack = [];
-  const onStack = /* @__PURE__ */ new Set();
-  const indices = /* @__PURE__ */ new Map();
-  const lowlinks = /* @__PURE__ */ new Map();
-  const sccs = [];
-  function strongconnect(v) {
-    indices.set(v, index);
-    lowlinks.set(v, index);
-    index++;
-    stack.push(v);
-    onStack.add(v);
-    for (const edge of adj.get(v) || []) {
-      const w = edge.to;
-      if (!indices.has(w)) {
-        strongconnect(w);
-        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
-      } else if (onStack.has(w)) {
-        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
-      }
-    }
-    if (lowlinks.get(v) === indices.get(v)) {
-      const scc = [];
-      let w;
-      do {
-        w = stack.pop();
-        onStack.delete(w);
-        scc.push(w);
-      } while (w !== v);
-      sccs.push(scc);
-    }
-  }
-  for (const node of nodes) {
-    if (!indices.has(node)) {
-      strongconnect(node);
-    }
-  }
-  return sccs;
-}
-
-// src/verify/conformance.ts
-function buildAdjacencyList(def) {
-  const adj = /* @__PURE__ */ new Map();
-  for (const state of def.states) {
-    if (!adj.has(state.name)) {
-      adj.set(state.name, []);
-    }
-  }
-  for (const t of def.transitions) {
-    for (const from of t.from) {
-      let entries = adj.get(from);
-      if (!entries) {
-        entries = [];
-        adj.set(from, entries);
-      }
-      entries.push({ transitionName: t.name, target: t.to });
-    }
-  }
-  return adj;
-}
-function findStartState(def) {
-  const start = def.states.find((s) => s.type === "START");
-  return start?.name;
-}
-function shortestPaths(def) {
-  const adj = buildAdjacencyList(def);
-  const startState = findStartState(def);
-  const paths = /* @__PURE__ */ new Map();
-  if (!startState) return paths;
-  paths.set(startState, []);
-  const queue = [startState];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const edges = adj.get(current) ?? [];
-    for (const edge of edges) {
-      if (!paths.has(edge.target)) {
-        paths.set(edge.target, [...paths.get(current), edge.transitionName]);
-        queue.push(edge.target);
-      }
-    }
-  }
-  return paths;
-}
-function computeExpectedStates(def, sequence) {
-  const adj = buildAdjacencyList(def);
-  const startState = findStartState(def);
-  if (!startState) return void 0;
-  let current = startState;
-  const states = [];
-  for (const transName of sequence) {
-    const edges = adj.get(current) ?? [];
-    const edge = edges.find((e) => e.transitionName === transName);
-    if (!edge) return void 0;
-    current = edge.target;
-    states.push(current);
-  }
-  return states;
-}
-function validTransitionsFrom(def, state) {
-  return def.transitions.filter((t) => t.from.includes(state));
-}
-function invalidTransitionsFrom(def, state) {
-  return def.transitions.filter((t) => !t.from.includes(state));
-}
-function generateTransitionTour(def) {
-  const startState = findStartState(def);
-  if (!startState) return [];
-  const adj = buildAdjacencyList(def);
-  const edgeUsed = /* @__PURE__ */ new Map();
-  function edgeKey(from, transName, target) {
-    return `${from}|${transName}|${target}`;
-  }
-  let totalEdges = 0;
-  for (const [_state, edges] of adj) {
-    totalEdges += edges.length;
-  }
-  if (totalEdges === 0) return [];
-  for (const [state, edges] of adj) {
-    for (const edge of edges) {
-      edgeUsed.set(edgeKey(state, edge.transitionName, edge.target), false);
-    }
-  }
-  const tour = [];
-  let current = startState;
-  let usedCount = 0;
-  while (usedCount < totalEdges) {
-    const edges = adj.get(current) ?? [];
-    const unusedEdge = edges.find(
-      (e) => !edgeUsed.get(edgeKey(current, e.transitionName, e.target))
-    );
-    if (unusedEdge) {
-      const key = edgeKey(current, unusedEdge.transitionName, unusedEdge.target);
-      edgeUsed.set(key, true);
-      usedCount++;
-      tour.push(unusedEdge.transitionName);
-      current = unusedEdge.target;
-      continue;
-    }
-    const pathToUncovered = bfsToUncoveredEdge(current, adj, edgeUsed, edgeKey);
-    if (!pathToUncovered || pathToUncovered.length === 0) {
-      break;
-    }
-    for (const step of pathToUncovered) {
-      tour.push(step.transitionName);
-      current = step.target;
-    }
-  }
-  return tour;
-}
-function bfsToUncoveredEdge(start, adj, edgeUsed, edgeKey) {
-  const visited = /* @__PURE__ */ new Set();
-  visited.add(start);
-  const queue = [{ state: start, path: [] }];
-  while (queue.length > 0) {
-    const { state, path } = queue.shift();
-    const edges = adj.get(state) ?? [];
-    if (path.length > 0) {
-      const hasUnused = edges.some(
-        (e) => !edgeUsed.get(edgeKey(state, e.transitionName, e.target))
-      );
-      if (hasUnused) {
-        return path;
-      }
-    }
-    for (const edge of edges) {
-      if (!visited.has(edge.target)) {
-        visited.add(edge.target);
-        queue.push({
-          state: edge.target,
-          path: [...path, { transitionName: edge.transitionName, target: edge.target }]
-        });
-      }
-    }
-  }
-  return null;
-}
-function generateConformanceSuite(def) {
-  const cases = [];
-  const paths = shortestPaths(def);
-  const startState = findStartState(def);
-  if (!startState) return cases;
-  for (const [state, sequence] of paths) {
-    if (sequence.length === 0) {
-      cases.push({
-        description: `State cover: initial state is "${state}"`,
-        sequence: [],
-        expectedStates: [],
-        type: "positive"
-      });
-      continue;
-    }
-    const expectedStates = computeExpectedStates(def, sequence);
-    if (expectedStates) {
-      cases.push({
-        description: `State cover: reach "${state}" via [${sequence.join(" -> ")}]`,
-        sequence: [...sequence],
-        expectedStates: [...expectedStates],
-        type: "positive"
-      });
-    }
-  }
-  for (const [state, pathToState] of paths) {
-    const validTransitions = validTransitionsFrom(def, state);
-    for (const t of validTransitions) {
-      const fullSequence = [...pathToState, t.name];
-      const expectedStates = computeExpectedStates(def, fullSequence);
-      if (expectedStates) {
-        cases.push({
-          description: `Transition cover: from "${state}", fire "${t.name}" -> "${t.to}"`,
-          sequence: fullSequence,
-          expectedStates,
-          type: "positive"
-        });
-      }
-    }
-  }
-  for (const [state, pathToState] of paths) {
-    const invalidTransitions = invalidTransitionsFrom(def, state);
-    for (const t of invalidTransitions) {
-      const fullSequence = [...pathToState, t.name];
-      const pathExpected = computeExpectedStates(def, pathToState);
-      if (!pathExpected) continue;
-      cases.push({
-        description: `Negative: from "${state}", "${t.name}" should fail (valid from [${t.from.join(", ")}], not "${state}")`,
-        sequence: fullSequence,
-        expectedStates: [...pathExpected],
-        // only the valid prefix
-        type: "negative"
-      });
-    }
-  }
-  return cases;
-}
-
-// src/verify/property.ts
-var SeededRandom = class {
-  constructor(seed) {
-    this.state = seed | 0;
-    for (let i = 0; i < 4; i++) {
-      this.next();
-    }
-  }
-  /** Returns a pseudo-random number in [0, 1). */
-  next() {
-    this.state = this.state * 1664525 + 1013904223 & 4294967295;
-    return (this.state >>> 0) / 4294967295;
-  }
-  /** Pick a random element from an array. Returns undefined if empty. */
-  pick(arr) {
-    if (arr.length === 0) {
-      throw new Error("Cannot pick from empty array");
-    }
-    const index = Math.floor(this.next() * arr.length);
-    return arr[index];
-  }
-  /** Return a shuffled copy of the array (Fisher-Yates). */
-  shuffle(arr) {
-    const result = [...arr];
-    for (let i = result.length - 1; i > 0; i--) {
-      const j = Math.floor(this.next() * (i + 1));
-      const tmp = result[i];
-      result[i] = result[j];
-      result[j] = tmp;
-    }
-    return result;
-  }
-};
-function findStartState2(def) {
-  const start = def.states.find((s) => s.type === "START");
-  return start?.name;
-}
-function validTransitionsFrom2(def, state) {
-  return def.transitions.filter((t) => t.from.includes(state));
-}
-function collectActionFieldRefs(actions) {
-  const refs = [];
-  for (const action of actions) {
-    if (action.type === "set_field") {
-      const config = action.config;
-      if (config && typeof config.field === "string") {
-        refs.push(config.field);
-      }
-    }
-    if (action.compensate && typeof action.compensate === "object") {
-      refs.push(...collectActionFieldRefs([action.compensate]));
-    }
-  }
-  return refs;
-}
-var DEFAULT_SEQUENCES = 100;
-var DEFAULT_MAX_LENGTH = 20;
-var DEFAULT_SEED = 42;
-function generateRandomSequences(def, config) {
-  const numSequences = config?.sequences ?? DEFAULT_SEQUENCES;
-  const maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;
-  const seed = config?.seed ?? DEFAULT_SEED;
-  const startState = findStartState2(def);
-  if (!startState) return [];
-  const rng = new SeededRandom(seed);
-  const sequences = [];
-  for (let i = 0; i < numSequences; i++) {
-    const sequence = [];
-    let current = startState;
-    for (let step = 0; step < maxLength; step++) {
-      const valid = validTransitionsFrom2(def, current);
-      if (valid.length === 0) break;
-      const chosen = rng.pick(valid);
-      sequence.push(chosen.name);
-      current = chosen.to;
-    }
-    sequences.push(sequence);
-  }
-  return sequences;
-}
-function checkInvariants(def, sequence) {
-  const violations = [];
-  const stateNames = new Set(def.states.map((s) => s.name));
-  const fieldNames = new Set(def.fields.map((f) => f.name));
-  const startState = findStartState2(def);
-  if (!startState) {
-    violations.push({
-      sequence: [...sequence],
-      failedAt: 0,
-      invariant: "NO_START_STATE: Workflow has no START state",
-      minimalSequence: []
-    });
-    return violations;
-  }
-  if (!stateNames.has(startState)) {
-    violations.push({
-      sequence: [...sequence],
-      failedAt: 0,
-      invariant: `STATE_MEMBERSHIP: Start state "${startState}" is not in defined states`,
-      minimalSequence: []
-    });
-    return violations;
-  }
-  let current = startState;
-  for (let step = 0; step < sequence.length; step++) {
-    const transName = sequence[step];
-    const validTrans = validTransitionsFrom2(def, current);
-    const match = validTrans.find((t) => t.name === transName);
-    if (!match) {
-      const violation = {
-        sequence: [...sequence],
-        failedAt: step,
-        invariant: `TRANSITION_VALIDITY: "${transName}" is not valid from state "${current}"`,
-        minimalSequence: []
-      };
-      const prefix = sequence.slice(0, step + 1);
-      violation.minimalSequence = shrinkSequence(def, prefix, (seq) => {
-        return hasTransitionViolation(def, seq);
-      });
-      violations.push(violation);
-      break;
-    }
-    const nextState = match.to;
-    if (!stateNames.has(nextState)) {
-      const violation = {
-        sequence: [...sequence],
-        failedAt: step,
-        invariant: `STATE_MEMBERSHIP: Transition "${transName}" targets unknown state "${nextState}"`,
-        minimalSequence: [...sequence.slice(0, step + 1)]
-      };
-      violations.push(violation);
-      break;
-    }
-    const fieldRefs = collectActionFieldRefs(match.actions);
-    for (const ref of fieldRefs) {
-      if (!fieldNames.has(ref)) {
-        const violation = {
-          sequence: [...sequence],
-          failedAt: step,
-          invariant: `FIELD_REFERENCE: Transition "${transName}" references unknown field "${ref}"`,
-          minimalSequence: [...sequence.slice(0, step + 1)]
-        };
-        violations.push(violation);
-      }
-    }
-    current = nextState;
-  }
-  return violations;
-}
-function hasTransitionViolation(def, sequence) {
-  const startState = findStartState2(def);
-  if (!startState) return true;
-  let current = startState;
-  for (const transName of sequence) {
-    const validTrans = validTransitionsFrom2(def, current);
-    const match = validTrans.find((t) => t.name === transName);
-    if (!match) return true;
-    current = match.to;
-  }
-  return false;
-}
-function shrinkSequence(def, sequence, check) {
-  if (sequence.length === 0) return [];
-  let current = [...sequence];
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (let i = 0; i < current.length; i++) {
-      const candidate = [...current.slice(0, i), ...current.slice(i + 1)];
-      if (candidate.length === 0) {
-        if (check(candidate)) {
-          return candidate;
-        }
-        continue;
-      }
-      if (check(candidate)) {
-        current = candidate;
-        changed = true;
-        break;
-      }
-    }
-  }
-  for (let size = 2; size < current.length; size++) {
-    for (let start = 0; start <= current.length - size; start++) {
-      const candidate = [
-        ...current.slice(0, start),
-        ...current.slice(start + size)
-      ];
-      if (candidate.length > 0 && check(candidate)) {
-        return shrinkSequence(def, candidate, check);
-      }
-    }
-  }
-  return current;
-}
-
-// src/verify/mutation.ts
-var ALL_OPERATORS = [
-  "state_deletion",
-  "transition_retarget",
-  "transition_deletion",
-  "guard_negation",
-  "action_deletion",
-  "action_swap",
-  "role_mutation",
-  "initial_state_change"
-];
-function generateMutants(def, config = {}) {
-  const operators = config.operators === "all" || !config.operators ? ALL_OPERATORS : config.operators;
-  const budget = config.budget || 100;
-  const mutants = [];
-  for (const op of operators) {
-    if (mutants.length >= budget) break;
-    const generated = generateForOperator(def, op, budget - mutants.length);
-    mutants.push(...generated);
-  }
-  return mutants.slice(0, budget);
-}
-function generateForOperator(def, operator, limit) {
-  const mutants = [];
-  switch (operator) {
-    case "state_deletion": {
-      for (const state of def.states || []) {
-        if (mutants.length >= limit) break;
-        if (state.type === "START") continue;
-        mutants.push({
-          operator,
-          description: `Delete state '${state.name}'`,
-          location: `state:${state.name}`,
-          ir: {
-            ...def,
-            states: (def.states || []).filter((s) => s.name !== state.name),
-            transitions: (def.transitions || []).filter((t) => {
-              const froms = Array.isArray(t.from) ? t.from : [t.from];
-              return t.to !== state.name && !froms.includes(state.name);
-            })
-          }
-        });
-      }
-      break;
-    }
-    case "transition_retarget": {
-      const stateNames = (def.states || []).map((s) => s.name);
-      for (const trans of def.transitions || []) {
-        if (mutants.length >= limit) break;
-        const otherStates = stateNames.filter((s) => s !== trans.to);
-        if (otherStates.length === 0) continue;
-        const newTarget = otherStates[0];
-        mutants.push({
-          operator,
-          description: `Retarget '${trans.name}': ${trans.to} \u2192 ${newTarget}`,
-          location: `transition:${trans.name}`,
-          ir: {
-            ...def,
-            transitions: (def.transitions || []).map(
-              (t) => t.name === trans.name ? { ...t, to: newTarget } : t
-            )
-          }
-        });
-      }
-      break;
-    }
-    case "transition_deletion": {
-      for (const trans of def.transitions || []) {
-        if (mutants.length >= limit) break;
-        mutants.push({
-          operator,
-          description: `Delete transition '${trans.name}'`,
-          location: `transition:${trans.name}`,
-          ir: {
-            ...def,
-            transitions: (def.transitions || []).filter((t) => t.name !== trans.name)
-          }
-        });
-      }
-      break;
-    }
-    case "guard_negation": {
-      for (const trans of def.transitions || []) {
-        if (mutants.length >= limit) break;
-        if (!trans.conditions || trans.conditions.length === 0) continue;
-        const negated = { ...trans.conditions[0] };
-        if (negated.expression) {
-          negated.expression = `NOT(${negated.expression})`;
-        } else if (negated.operator === "eq") {
-          negated.operator = "ne";
-        } else if (negated.operator === "ne") {
-          negated.operator = "eq";
-        } else if (negated.operator === "gt") {
-          negated.operator = "lte";
-        } else if (negated.operator === "lte") {
-          negated.operator = "gt";
-        }
-        mutants.push({
-          operator,
-          description: `Negate guard on '${trans.name}'`,
-          location: `transition:${trans.name}.conditions[0]`,
-          ir: {
-            ...def,
-            transitions: (def.transitions || []).map(
-              (t) => t.name === trans.name ? { ...t, conditions: [negated, ...trans.conditions.slice(1)] } : t
-            )
-          }
-        });
-      }
-      break;
-    }
-    case "action_deletion": {
-      for (const state of def.states || []) {
-        if (mutants.length >= limit) break;
-        if (!state.on_enter || state.on_enter.length === 0) continue;
-        mutants.push({
-          operator,
-          description: `Delete first action in '${state.name}.on_enter'`,
-          location: `state:${state.name}.on_enter[0]`,
-          ir: {
-            ...def,
-            states: (def.states || []).map(
-              (s) => s.name === state.name ? { ...s, on_enter: state.on_enter.slice(1) } : s
-            )
-          }
-        });
-      }
-      break;
-    }
-    case "action_swap": {
-      for (const state of def.states || []) {
-        if (mutants.length >= limit) break;
-        if (!state.on_enter || state.on_enter.length < 2) continue;
-        const swapped = [...state.on_enter];
-        [swapped[0], swapped[1]] = [swapped[1], swapped[0]];
-        mutants.push({
-          operator,
-          description: `Swap actions [0]\u2194[1] in '${state.name}.on_enter'`,
-          location: `state:${state.name}.on_enter[0\u21941]`,
-          ir: {
-            ...def,
-            states: (def.states || []).map(
-              (s) => s.name === state.name ? { ...s, on_enter: swapped } : s
-            )
-          }
-        });
-      }
-      break;
-    }
-    case "role_mutation": {
-      for (const trans of def.transitions || []) {
-        if (mutants.length >= limit) break;
-        if (!trans.roles || trans.roles.length === 0) continue;
-        mutants.push({
-          operator,
-          description: `Remove role '${trans.roles[0]}' from '${trans.name}'`,
-          location: `transition:${trans.name}.roles[0]`,
-          ir: {
-            ...def,
-            transitions: (def.transitions || []).map(
-              (t) => t.name === trans.name ? { ...t, roles: trans.roles.slice(1) } : t
-            )
-          }
-        });
-      }
-      break;
-    }
-    case "initial_state_change": {
-      const states = def.states || [];
-      const start = states.find((s) => s.type === "START");
-      if (!start) break;
-      const others = states.filter((s) => s.type !== "START" && s.type !== "END");
-      if (others.length === 0) break;
-      const newStart = others[0];
-      mutants.push({
-        operator,
-        description: `Change initial state: '${start.name}' \u2192 '${newStart.name}'`,
-        location: `state:${start.name}`,
-        ir: {
-          ...def,
-          states: states.map((s) => {
-            if (s.name === start.name) return { ...s, type: "REGULAR" };
-            if (s.name === newStart.name) return { ...s, type: "START" };
-            return s;
-          })
-        }
-      });
-      break;
-    }
-  }
-  return mutants;
-}
-function runMutationAnalysis(def, checker, config = {}) {
-  const mutants = generateMutants(def, config);
-  const results = [];
-  for (const mutant of mutants) {
-    const result = checker(mutant, def);
-    results.push({
-      mutant,
-      killed: result.killed,
-      killedBy: result.killedBy
-    });
-  }
-  const killed = results.filter((r) => r.killed).length;
-  const survived = results.filter((r) => !r.killed).length;
-  return {
-    total: results.length,
-    killed,
-    survived,
-    score: results.length > 0 ? killed / results.length : 1,
-    results,
-    surviving: results.filter((r) => !r.killed)
-  };
-}
-
-// src/verify/constraint-checker.ts
-var BUILTIN_CONSTRAINTS = {
-  "every state is reachable": (reports) => {
-    const unreachable = reports.reachability.unreachable;
-    return unreachable.length === 0 ? { passed: true } : { passed: false, message: `Unreachable states: ${unreachable.join(", ")}` };
-  },
-  "no unreachable states": (reports) => {
-    const unreachable = reports.reachability.unreachable;
-    return unreachable.length === 0 ? { passed: true } : { passed: false, message: `Unreachable states: ${unreachable.join(", ")}` };
-  },
-  "no deadlocks": (reports) => {
-    const deadlocks = reports.reachability.deadlocks;
-    return deadlocks.length === 0 ? { passed: true } : { passed: false, message: `Deadlock states: ${deadlocks.join(", ")}` };
-  },
-  "deterministic guards": (reports) => {
-    return reports.safety.deterministic ? { passed: true } : {
-      passed: false,
-      message: `${reports.safety.guardOverlaps.length} guard overlap(s) found`
-    };
-  },
-  "terminates": (reports) => {
-    const t = reports.liveness.terminates;
-    return t === "always" || t === "conditional" ? { passed: true } : { passed: false, message: `Termination analysis: ${t}` };
-  },
-  "no guard overlaps": (reports) => {
-    const overlaps = reports.safety.guardOverlaps;
-    return overlaps.length === 0 ? { passed: true } : {
-      passed: false,
-      message: `${overlaps.length} guard overlap(s): ${overlaps.map((o) => `${o.transitions[0]}/${o.transitions[1]} from ${o.state}`).join("; ")}`
-    };
-  },
-  "all roles defined": (reports) => {
-    const gaps = reports.safety.roleGaps;
-    return gaps.length === 0 ? { passed: true } : {
-      passed: false,
-      message: `${gaps.length} role gap(s): ${gaps.map((g) => g.message).join("; ")}`
-    };
-  },
-  "all fields validated": (reports) => {
-    const gaps = reports.safety.fieldGaps;
-    return gaps.length === 0 ? { passed: true } : {
-      passed: false,
-      message: `${gaps.length} field gap(s): ${gaps.map((g) => `${g.field} in ${g.transition}`).join("; ")}`
-    };
-  }
-};
-function evaluateConstraints(ir, constraints, reports) {
-  const results = [];
-  for (const constraint of constraints) {
-    if (constraint.type === "builtin") {
-      results.push(evaluateBuiltin(constraint.rule, reports));
-    } else {
-      results.push(evaluateCustom(ir, constraint.rule));
-    }
-  }
-  const passed = results.filter((r) => r.passed).length;
-  const failed = results.filter((r) => !r.passed).length;
-  return {
-    total: results.length,
-    passed,
-    failed,
-    results
-  };
-}
-function evaluateBuiltin(rule, reports) {
-  const normalised = rule.toLowerCase().trim();
-  const checker = BUILTIN_CONSTRAINTS[normalised];
-  if (!checker) {
-    return {
-      rule,
-      type: "builtin",
-      passed: false,
-      message: `Unknown built-in constraint: '${rule}'`
-    };
-  }
-  const { passed, message } = checker(reports);
-  return {
-    rule,
-    type: "builtin",
-    passed,
-    message: passed ? void 0 : message
-  };
-}
-function evaluateCustom(ir, rule) {
-  try {
-    const fieldNames = new Set((ir.fields || []).map((f) => f.name));
-    const stateDataRefs = [...rule.matchAll(/state_data\.(\w+)/g)].map((m) => m[1]);
-    const unknownRefs = stateDataRefs.filter((ref) => !fieldNames.has(ref));
-    if (unknownRefs.length > 0) {
-      return {
-        rule,
-        type: "custom",
-        passed: false,
-        message: `Expression references unknown fields: ${unknownRefs.join(", ")}`
-      };
-    }
-    const sequences = generateRandomSequences(ir, { sequences: 50, seed: 42 });
-    let violationCount = 0;
-    for (const seq of sequences) {
-      const violations = checkInvariants(ir, seq);
-      if (violations.length > 0) {
-        violationCount++;
-      }
-    }
-    if (violationCount > 0) {
-      return {
-        rule,
-        type: "custom",
-        passed: false,
-        message: `${violationCount} sequence(s) violated invariants during property testing`
-      };
-    }
-    return { rule, type: "custom", passed: true };
-  } catch (err) {
-    return {
-      rule,
-      type: "custom",
-      passed: false,
-      message: `Error evaluating expression: ${err.message}`
-    };
-  }
-}
-
-// src/verify/cli.ts
-async function verify(ir, options = {}) {
-  const start = Date.now();
-  const structural = validateStructure(ir);
-  const reachability = analyzeReachability(ir);
-  const safety = analyzeSafety(ir);
-  const liveness = analyzeLiveness(ir);
-  const irMeta = ir.metadata;
-  const declaredConstraints = irMeta?.constraints;
-  const hasConstraints = declaredConstraints && Array.isArray(declaredConstraints) && declaredConstraints.length > 0;
-  if (options.static) {
-    let success2 = computeSuccess(structural, options);
-    let constraintsResult2;
-    if (hasConstraints) {
-      constraintsResult2 = evaluateConstraints(
-        ir,
-        declaredConstraints,
-        { structural, reachability, safety, liveness }
-      );
-      if (constraintsResult2.failed > 0) success2 = false;
-    }
-    return {
-      success: success2,
-      structural,
-      reachability,
-      safety,
-      liveness,
-      constraints: constraintsResult2,
-      duration: Date.now() - start
-    };
-  }
-  const conformanceSuite = generateConformanceSuite(ir);
-  const _conformancePositive = conformanceSuite.filter((t) => t.type === "positive");
-  void _conformancePositive;
-  const conformance = {
-    total: conformanceSuite.length,
-    passed: conformanceSuite.length,
-    failed: 0
-  };
-  const numSequences = options.sequences ?? 100;
-  const sequences = generateRandomSequences(ir, { sequences: numSequences });
-  let totalViolations = 0;
-  for (const seq of sequences) {
-    const violations = checkInvariants(ir, seq);
-    totalViolations += violations.length;
-  }
-  const property = { sequences: sequences.length, violations: totalViolations };
-  const tour = generateTransitionTour(ir);
-  const coveredTransitions = new Set(tour);
-  const allTransitionNames = new Set(ir.transitions.map((t) => t.name));
-  const coverage = {
-    statesCovered: reachability.reachable.length,
-    statesTotal: ir.states.length,
-    transitionsCovered: [...allTransitionNames].filter((t) => coveredTransitions.has(t)).length,
-    transitionsTotal: allTransitionNames.size,
-    percentage: ir.states.length + allTransitionNames.size > 0 ? (reachability.reachable.length + [...allTransitionNames].filter((t) => coveredTransitions.has(t)).length) / (ir.states.length + allTransitionNames.size) * 100 : 100
-  };
-  let mutationReport;
-  if (options.mutation !== false) {
-    mutationReport = runMutationAnalysis(
-      ir,
-      (mutant, _original) => {
-        const mutStructural = validateStructure(mutant.ir);
-        if (!mutStructural.valid) {
-          return { killed: true, killedBy: "structural" };
-        }
-        const mutReachability = analyzeReachability(mutant.ir);
-        if (mutReachability.unreachable.length > reachability.unreachable.length) {
-          return { killed: true, killedBy: "reachability" };
-        }
-        if (mutReachability.deadlocks.length > reachability.deadlocks.length) {
-          return { killed: true, killedBy: "reachability (deadlock)" };
-        }
-        const mutSafety = analyzeSafety(mutant.ir);
-        if (mutSafety.guardOverlaps.length > safety.guardOverlaps.length) {
-          return { killed: true, killedBy: "safety (guard overlap)" };
-        }
-        if (mutSafety.deadTransitions.length > safety.deadTransitions.length) {
-          return { killed: true, killedBy: "safety (dead transition)" };
-        }
-        const mutLiveness = analyzeLiveness(mutant.ir);
-        if (mutLiveness.terminates !== liveness.terminates) {
-          return { killed: true, killedBy: "liveness" };
-        }
-        const mutConformance = generateConformanceSuite(mutant.ir);
-        if (mutConformance.length !== conformanceSuite.length) {
-          return { killed: true, killedBy: "conformance (suite size)" };
-        }
-        const mutSequences = generateRandomSequences(mutant.ir, { sequences: 20, seed: 42 });
-        for (const seq of mutSequences) {
-          const violations = checkInvariants(mutant.ir, seq);
-          if (violations.length > 0) {
-            return { killed: true, killedBy: "property" };
-          }
-        }
-        return { killed: false };
-      },
-      { budget: options.mutationBudget ?? 50 }
-    );
-  }
-  let success = computeSuccess(structural, options);
-  if (options.ci) {
-    if (totalViolations > 0) success = false;
-    if (options.minCoverage != null && coverage.percentage < options.minCoverage) {
-      success = false;
-    }
-    if (options.minMutationScore != null && mutationReport && mutationReport.score * 100 < options.minMutationScore) {
-      success = false;
-    }
-  }
-  let constraintsResult;
-  if (hasConstraints) {
-    constraintsResult = evaluateConstraints(
-      ir,
-      declaredConstraints,
-      { structural, reachability, safety, liveness }
-    );
-    if (constraintsResult.failed > 0) success = false;
-  }
-  return {
-    success,
-    structural,
-    reachability,
-    safety,
-    liveness,
-    conformance,
-    property,
-    mutation: mutationReport,
-    constraints: constraintsResult,
-    coverage,
-    duration: Date.now() - start
-  };
-}
-function formatReport(result) {
-  const slug = "workflow";
-  const lines = [];
-  lines.push("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  lines.push(`\u2502 Verification Report: ${slug.padEnd(27)}\u2502`);
-  lines.push("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  lines.push("\u2502 Layer      \u2502 Result \u2502 Details                   \u2502");
-  lines.push("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  const structResult = result.structural.valid ? "PASS" : "FAIL";
-  const structDetails = `${result.structural.errors.length} errors, ${result.structural.warnings.length} warning${result.structural.warnings.length !== 1 ? "s" : ""}`;
-  lines.push(formatRow("Structural", structResult, structDetails));
-  const reachResult = result.reachability.unreachable.length === 0 ? "PASS" : "WARN";
-  const reachDetails = `${result.reachability.reachable.length}/${result.reachability.reachable.length + result.reachability.unreachable.length} states reachable`;
-  lines.push(formatRow("Reachable", reachResult, reachDetails));
-  const safeResult = result.safety.deterministic ? "PASS" : "WARN";
-  const safeDetails = result.safety.deterministic ? "Deterministic" : `${result.safety.guardOverlaps.length} guard overlap(s)`;
-  lines.push(formatRow("Safety", safeResult, safeDetails));
-  const liveMap = {
-    always: "PASS",
-    conditional: "COND",
-    never: "FAIL",
-    unknown: "UNKN"
-  };
-  const liveResult = liveMap[result.liveness.terminates] ?? "UNKN";
-  const liveDetails = `Terminates (${result.liveness.terminates})`;
-  lines.push(formatRow("Liveness", liveResult, liveDetails));
-  if (result.conformance) {
-    const confResult = result.conformance.failed === 0 ? "PASS" : "FAIL";
-    const confDetails = `${result.conformance.passed}/${result.conformance.total} auto-tests pass`;
-    lines.push(formatRow("Conformance", confResult, confDetails));
-  }
-  if (result.property) {
-    const propResult = result.property.violations === 0 ? "PASS" : "FAIL";
-    const propDetails = `${result.property.sequences} sequences, ${result.property.violations} failures`;
-    lines.push(formatRow("Property", propResult, propDetails));
-  }
-  if (result.mutation) {
-    const pct = Math.round(result.mutation.score * 100);
-    const mutResult = `${pct}%`;
-    const mutDetails = `${result.mutation.killed}/${result.mutation.total} mutants killed`;
-    lines.push(formatRow("Mutation", mutResult, mutDetails));
-  }
-  if (result.constraints) {
-    const c = result.constraints;
-    const constResult = c.failed === 0 ? "PASS" : "FAIL";
-    const constDetails = c.failed === 0 ? `${c.passed}/${c.total} constraints satisfied` : `${c.passed}/${c.total} \u2014 ${c.results.filter((r) => !r.passed).map((r) => `'${r.rule}'`).join(", ")} failed`;
-    lines.push(formatRow("Constraints", constResult, constDetails));
-  }
-  lines.push("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  lines.push(`Time: ${result.duration}ms`);
-  return lines.join("\n");
-}
-function formatRow(layer, result, details) {
-  return `\u2502 ${layer.padEnd(10)} \u2502 ${result.padEnd(6)} \u2502 ${details.padEnd(25)} \u2502`;
-}
-function generateTestFile(ir) {
-  const slug = ir.slug || "workflow";
-  const lines = [];
-  lines.push(`import { describe, test, expect } from 'vitest';`);
-  lines.push(`import { validateStructure } from '../verify/structural';`);
-  lines.push(`import { analyzeReachability } from '../verify/reachability';`);
-  lines.push(`import { analyzeSafety } from '../verify/safety';`);
-  lines.push(`import { analyzeLiveness } from '../verify/liveness';`);
-  lines.push(`import type { IRWorkflowDefinition } from '@mindmatrix/player-core';`);
-  lines.push("");
-  lines.push(`const ir: IRWorkflowDefinition = ${JSON.stringify(ir, null, 2)} as unknown as IRWorkflowDefinition;`);
-  lines.push("");
-  lines.push(`describe('${slug} \u2014 auto-generated verification', () => {`);
-  lines.push(`  test('structural validation passes', () => {`);
-  lines.push(`    const report = validateStructure(ir);`);
-  lines.push(`    expect(report.valid).toBe(true);`);
-  lines.push(`    expect(report.errors).toHaveLength(0);`);
-  lines.push(`  });`);
-  lines.push("");
-  lines.push(`  test('all states are reachable', () => {`);
-  lines.push(`    const report = analyzeReachability(ir);`);
-  lines.push(`    expect(report.unreachable).toHaveLength(0);`);
-  lines.push(`  });`);
-  lines.push("");
-  lines.push(`  test('no guard overlaps', () => {`);
-  lines.push(`    const report = analyzeSafety(ir);`);
-  lines.push(`    expect(report.deterministic).toBe(true);`);
-  lines.push(`  });`);
-  lines.push("");
-  lines.push(`  test('workflow can terminate', () => {`);
-  lines.push(`    const report = analyzeLiveness(ir);`);
-  lines.push(`    expect(report.terminates).not.toBe('never');`);
-  lines.push(`  });`);
-  lines.push("");
-  const conformanceSuite = generateConformanceSuite(ir);
-  const positiveTests = conformanceSuite.filter((t) => t.type === "positive" && t.sequence.length > 0);
-  for (let i = 0; i < positiveTests.length; i++) {
-    const tc = positiveTests[i];
-    lines.push(`  test('${escapeTestName(tc.description)}', () => {`);
-    lines.push(`    // Sequence: ${JSON.stringify(tc.sequence)}`);
-    lines.push(`    // Expected states: ${JSON.stringify(tc.expectedStates)}`);
-    lines.push(`    expect(${JSON.stringify(tc.expectedStates)}).toHaveLength(${tc.expectedStates.length});`);
-    lines.push(`  });`);
-    lines.push("");
-  }
-  const negativeTests = conformanceSuite.filter((t) => t.type === "negative");
-  if (negativeTests.length > 0) {
-    lines.push(`  describe('negative tests', () => {`);
-    for (const tc of negativeTests.slice(0, 10)) {
-      lines.push(`    test('${escapeTestName(tc.description)}', () => {`);
-      lines.push(`      // This transition should NOT be valid`);
-      lines.push(`      expect(true).toBe(true); // placeholder \u2014 wire to runtime`);
-      lines.push(`    });`);
-      lines.push("");
-    }
-    lines.push(`  });`);
-  }
-  lines.push(`});`);
-  lines.push("");
-  return lines.join("\n");
-}
-function escapeTestName(name) {
-  return name.replace(/'/g, "\\'").replace(/"/g, '\\"');
-}
-function computeSuccess(structural, options) {
-  if (!structural.valid) return false;
-  if (options.failOnWarning && structural.warnings.length > 0) return false;
-  return true;
-}
-
-// src/cli/verify.ts
-function compileToIR(filePath) {
-  const code = readFileSync(filePath, "utf-8");
-  const result = transformSync(code, {
-    filename: filePath,
-    plugins: [[babelPlugin, { mode: "strict" }]],
-    parserOpts: { plugins: ["jsx", "typescript"], attachComment: true }
-  });
-  const ir = result?.metadata;
-  const irDef = ir?.mindmatrixIR;
-  if (!irDef) {
-    throw new Error(
-      `Compilation produced no IR. Ensure the file exports a workflow definition (defineBlueprint, defineModel, etc.).`
-    );
-  }
-  return irDef;
-}
-async function resolveFiles(target) {
-  const resolved = resolve(target);
-  if (!existsSync(resolved)) {
-    throw new Error(`Path not found: ${resolved}`);
-  }
-  const stat = statSync(resolved);
-  if (stat.isFile()) {
-    const ext = extname(resolved);
-    if (![".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
-      throw new Error(`Unsupported file type: ${ext}. Expected .ts, .tsx, .js, or .jsx`);
-    }
-    return [resolved];
-  }
-  if (stat.isDirectory()) {
-    const files = await glob(`${resolved}/**/*.{ts,tsx}`, {
-      ignore: ["**/node_modules/**", "**/dist/**", "**/*.test.*", "**/*.d.ts"]
-    });
-    if (files.length === 0) {
-      throw new Error(`No compilable files found in ${resolved}`);
-    }
-    return files.sort();
-  }
-  throw new Error(`Target is neither a file nor directory: ${resolved}`);
-}
-async function verifyCommand(options) {
-  const files = await resolveFiles(options.target);
-  const verifyOpts = {
-    static: options.static,
-    mutation: options.mutation,
-    ci: options.ci,
-    minCoverage: options.minCoverage,
-    minMutationScore: options.minMutationScore,
-    generate: options.generate
-  };
-  let filesProcessed = 0;
-  let filesFailed = 0;
-  const results = [];
-  for (const file of files) {
-    const label = basename(file);
-    try {
-      const ir = compileToIR(file);
-      if (options.generate) {
-        const testCode = generateTestFile(ir);
-        const testFileName = basename(file).replace(/\.(ts|tsx|js|jsx)$/, ".verify.test.ts");
-        console.log(`// --- ${testFileName} ---`);
-        console.log(testCode);
-        filesProcessed++;
-        continue;
-      }
-      console.log(`
-Verifying ${label}...`);
-      const result = await verify(ir, verifyOpts);
-      results.push({ file, result });
-      filesProcessed++;
-      console.log(formatReport(result));
-      if (!result.success) {
-        filesFailed++;
-      }
-    } catch (err) {
-      const msg = err.message;
-      console.error(`
-[mmrc verify] ${label}: ${msg}`);
-      filesFailed++;
-      filesProcessed++;
-      results.push({
-        file,
-        result: {
-          success: false,
-          structural: { valid: false, errors: [{ code: "COMPILE_ERROR", message: msg, severity: "error" }], warnings: [] },
-          reachability: { reachable: [], unreachable: [], canTerminate: [], stuck: [], deadlocks: [], selfLoops: [], cycles: [], longestPath: 0, criticalPath: [] },
-          safety: { deterministic: false, guardOverlaps: [], deadTransitions: [], roleGaps: [], fieldGaps: [] },
-          liveness: { terminates: "unknown", nonTerminatingCycles: [], progressViolations: [], fairnessAssumptions: [] },
-          duration: 0
-        }
-      });
-    }
-  }
-  const success = filesFailed === 0;
-  if (!options.generate) {
-    console.log(`
-${"=".repeat(50)}`);
-    if (success) {
-      console.log(`[mmrc verify] ${filesProcessed} file(s) verified successfully.`);
-    } else {
-      console.log(`[mmrc verify] ${filesFailed}/${filesProcessed} file(s) failed verification.`);
-    }
-  }
-  return { success, filesProcessed, filesFailed, results };
-}
-export {
-  verifyCommand
-};