gemini back 3

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/matching/HeuristicEventMatchingEngine.java

@@ -12,27 +12,49 @@ public class HeuristicEventMatchingEngine implements EventMatchingEngine {
             return false;
         }
 
-        String triggerEvent = simplify(triggerPoint.getEvent());
+        String rawTriggerEvent = triggerPoint.getEvent();
         String smEventRaw = stateMachineEvent.fullIdentifier() != null ? stateMachineEvent.fullIdentifier() : stateMachineEvent.rawName();
         String smEvent = simplify(smEventRaw);
 
-        boolean isWildcard = isWildcardVariable(triggerEvent);
+        boolean isWildcard = isWildcardVariable(rawTriggerEvent);
 
         List<String> polyEvents = triggerPoint.getPolymorphicEvents() != null ? triggerPoint.getPolymorphicEvents() : java.util.Collections.emptyList();
         
         boolean hasPolyMatch = false;
         for (String pe : polyEvents) {
+            if (pe.contains(".") && smEventRaw.contains(".")) {
+                if (smEventRaw.equals(pe) || smEventRaw.endsWith("." + pe)) {
+                    hasPolyMatch = true;
+                    break;
+                }
+                continue;
+            }
+
             String simplePe = pe;
             if (pe.contains(".")) {
                 simplePe = pe.substring(pe.lastIndexOf('.') + 1);
             }
-            if (simplePe.equals(smEventRaw) || simplePe.equals(smEvent)) {
+            String simplifiedPe = simplify(simplePe);
+
+            if (simplePe.equals(smEventRaw) || simplePe.equals(smEvent) || 
+                simplePe.equalsIgnoreCase(smEvent) || simplifiedPe.equalsIgnoreCase(smEvent)) {
                 hasPolyMatch = true;
                 break;
             }
         }
 
-        return hasPolyMatch || smEvent.equals(triggerEvent) || (polyEvents.isEmpty() && isWildcard);
+        if (hasPolyMatch) return true;
+        if (polyEvents.isEmpty() && isWildcard) return true;
+
+        if (rawTriggerEvent.contains(".") && smEventRaw.contains(".")) {
+            if (smEventRaw.equals(rawTriggerEvent) || smEventRaw.endsWith("." + rawTriggerEvent)) {
+                return true;
+            }
+            return false;
+        }
+
+        String triggerEvent = simplify(rawTriggerEvent);
+        return smEvent.equals(triggerEvent);
     }
 
     private boolean isWildcardVariable(String eventStr) {

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/path/ForwardPathEstimationEnricher.java

@@ -0,0 +1,69 @@
+package click.kamil.springstatemachineexporter.analysis.enricher.path;
+
+import click.kamil.springstatemachineexporter.analysis.enricher.AnalysisEnricher;
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.analysis.service.CodebaseIntelligenceProvider;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class ForwardPathEstimationEnricher implements AnalysisEnricher {
+
+    private final boolean isEnabled;
+    private final PathValueEstimator estimator;
+
+    public ForwardPathEstimationEnricher() {
+        this.isEnabled = Boolean.parseBoolean(System.getProperty("analyzer.forward-path-estimation.enabled", "false"));
+        this.estimator = new SymbolicPathValueEstimator();
+    }
+
+    @Override
+    public void enrich(AnalysisResult result, CodebaseContext context, CodebaseIntelligenceProvider intelligence) {
+        if (!isEnabled || result.getMetadata() == null || result.getMetadata().getCallChains() == null) {
+            return;
+        }
+
+        log.info("Running Symbolic Forward Path Analysis for {}", result.getName());
+        
+        List<CallChain> chains = result.getMetadata().getCallChains();
+        List<CallChain> updatedChains = chains.stream().map(chain -> {
+            if (chain.getTriggerPoint() == null || chain.getTriggerPoint().getEvent() == null) return chain;
+            
+            // If the event looks like a dynamic variable (no dots, not an enum format)
+            if (!chain.getTriggerPoint().getEvent().contains(".")) {
+                List<String> estimatedValues = estimator.estimatePossibleValues(chain, context);
+                if (estimatedValues != null && !estimatedValues.isEmpty()) {
+                    log.info("Symbolic Path Analysis estimated values for {} -> {}", chain.getTriggerPoint().getEvent(), estimatedValues);
+                    
+                    List<String> polyEvents = new ArrayList<>();
+                    if (chain.getTriggerPoint().getPolymorphicEvents() != null) {
+                        polyEvents.addAll(chain.getTriggerPoint().getPolymorphicEvents());
+                    }
+                    polyEvents.addAll(estimatedValues);
+                    
+                    TriggerPoint newTp = chain.getTriggerPoint().toBuilder()
+                            .polymorphicEvents(polyEvents)
+                            .build();
+                            
+                    return chain.toBuilder().triggerPoint(newTp).build();
+                }
+            }
+            return chain;
+        }).collect(Collectors.toList());
+        click.kamil.springstatemachineexporter.analysis.model.CodebaseMetadata updatedMetadata = 
+                click.kamil.springstatemachineexporter.analysis.model.CodebaseMetadata.builder()
+                .triggers(result.getMetadata().getTriggers())
+                .entryPoints(result.getMetadata().getEntryPoints())
+                .callChains(updatedChains)
+                .properties(result.getMetadata().getProperties())
+                .build();
+
+        result.setMetadata(updatedMetadata);
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/path/PathValueEstimator.java

@@ -0,0 +1,10 @@
+package click.kamil.springstatemachineexporter.analysis.enricher.path;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+
+import java.util.List;
+
+public interface PathValueEstimator {
+    List<String> estimatePossibleValues(CallChain chain, CodebaseContext context);
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/path/SymbolicPathValueEstimator.java

@@ -0,0 +1,130 @@
+package click.kamil.springstatemachineexporter.analysis.enricher.path;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.eclipse.jdt.core.dom.*;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class SymbolicPathValueEstimator implements PathValueEstimator {
+
+    @Override
+    public List<String> estimatePossibleValues(CallChain chain, CodebaseContext context) {
+        if (chain.getMethodChain() == null || chain.getMethodChain().isEmpty()) {
+            return null;
+        }
+
+        Set<String> collectedConstants = new HashSet<>();
+
+        for (String methodFqn : chain.getMethodChain()) {
+            int lastDot = methodFqn.lastIndexOf('.');
+            if (lastDot == -1) continue;
+            
+            String className = methodFqn.substring(0, lastDot);
+            String methodName = methodFqn.substring(lastDot + 1);
+
+            TypeDeclaration td = context.getTypeDeclaration(className);
+            if (td == null) continue;
+
+            MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+            if (md == null || md.getBody() == null) continue;
+
+            md.getBody().accept(new ASTVisitor() {
+                @Override
+                public boolean visit(MethodInvocation node) {
+                    if ((node.getName().getIdentifier().equals("equals") || node.getName().getIdentifier().equals("equalsIgnoreCase")) 
+                        && node.arguments().size() == 1) {
+                        
+                        Expression caller = node.getExpression();
+                        Expression arg = (Expression) node.arguments().get(0);
+                        
+                        click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver resolver = new click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver();
+                        
+                        String callerVal = resolver.resolve(caller, context);
+                        if (callerVal != null && !callerVal.isEmpty()) {
+                            addValue(collectedConstants, callerVal);
+                        }
+                        
+                        String argVal = resolver.resolve(arg, context);
+                        if (argVal != null && !argVal.isEmpty()) {
+                            addValue(collectedConstants, argVal);
+                        }
+                    }
+                    return super.visit(node);
+                }
+
+                @Override
+                public boolean visit(InfixExpression node) {
+                    if (node.getOperator() == InfixExpression.Operator.EQUALS) {
+                        click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver resolver = new click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver();
+                        String left = resolver.resolve(node.getLeftOperand(), context);
+                        if (left != null && !left.isEmpty()) {
+                            addValue(collectedConstants, left);
+                        }
+                        String right = resolver.resolve(node.getRightOperand(), context);
+                        if (right != null && !right.isEmpty()) {
+                            addValue(collectedConstants, right);
+                        }
+                    }
+                    return super.visit(node);
+                }
+
+                @Override
+                public boolean visit(SwitchStatement node) {
+                    for (Object stmt : node.statements()) {
+                        if (stmt instanceof SwitchCase sc && !sc.isDefault()) {
+                            for (Object expr : sc.expressions()) {
+                                click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver resolver = new click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver();
+                                String val = resolver.resolve((Expression) expr, context);
+                                if (val != null && !val.isEmpty()) {
+                                    addValue(collectedConstants, val);
+                                }
+                            }
+                        }
+                    }
+                    return super.visit(node);
+                }
+                
+                @Override
+                public boolean visit(SwitchExpression node) {
+                    for (Object stmt : node.statements()) {
+                        if (stmt instanceof SwitchCase sc && !sc.isDefault()) {
+                            for (Object expr : sc.expressions()) {
+                                click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver resolver = new click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver();
+                                String val = resolver.resolve((Expression) expr, context);
+                                if (val != null && !val.isEmpty()) {
+                                    addValue(collectedConstants, val);
+                                }
+                            }
+                        }
+                    }
+                    return super.visit(node);
+                }
+            });
+        }
+
+        if (collectedConstants.isEmpty()) return null;
+        return new ArrayList<>(collectedConstants);
+    }
+    
+    private void addValue(Set<String> collectedConstants, String val) {
+        if (val.startsWith("ENUM_SET:")) {
+            for (String eVal : val.substring(9).split(",")) {
+                String parsed = parseEnumSetElement(eVal);
+                if (!collectedConstants.contains(parsed)) collectedConstants.add(parsed);
+            }
+        } else {
+            collectedConstants.add(val);
+        }
+    }
+    
+    private String parseEnumSetElement(String element) {
+        if (element.contains(".")) {
+            return element.substring(element.lastIndexOf('.') + 1);
+        }
+        return element;
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/model/CallEdge.java

@@ -1,11 +1,20 @@
 package click.kamil.springstatemachineexporter.analysis.model;
 
 import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
 
 import java.util.List;
 
 @Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class CallEdge {
-    private final String targetMethod;
-    private final List<String> arguments;
+    private String targetMethod;
+    private List<String> arguments;
+    private String receiver;
+
+    public CallEdge(String targetMethod, List<String> arguments) {
+        this(targetMethod, arguments, null);
+    }
 }

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/model/TriggerPoint.java

@@ -8,7 +8,7 @@ import lombok.extern.jackson.Jacksonized;
 import java.util.Map;
 
 @Data
-@Builder
+@Builder(toBuilder = true)
 @Jacksonized
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class TriggerPoint {

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/resolver/ConstantResolver.java

@@ -14,9 +14,30 @@ public class ConstantResolver {
         return resolveInternal(expr, context, new HashSet<>());
     }
 
+    public String evaluateSwitchWithParams(org.eclipse.jdt.core.dom.SwitchExpression se, java.util.Map<String, String> paramValues, CodebaseContext context) {
+        return evaluateSwitchExpression(se, paramValues, context, new HashSet<>());
+    }
+
+    public String evaluateSwitchWithParams(org.eclipse.jdt.core.dom.SwitchStatement ss, java.util.Map<String, String> paramValues, CodebaseContext context) {
+        return evaluateSwitchStatement(ss, paramValues, context, new HashSet<>());
+    }
+
     private String resolveInternal(Expression expr, CodebaseContext context, Set<String> visited) {
         if (expr == null) return null;
 
+        // Unwrap common wrappers
+        if (expr instanceof CastExpression ce) {
+            return resolveInternal(ce.getExpression(), context, visited);
+        }
+        if (expr instanceof ParenthesizedExpression pe) {
+            return resolveInternal(pe.getExpression(), context, visited);
+        }
+        if (expr instanceof MethodInvocation mi && (mi.getName().getIdentifier().equals("requireNonNull") || mi.getName().getIdentifier().equals("notNull"))) {
+            if (!mi.arguments().isEmpty()) {
+                return resolveInternal((Expression) mi.arguments().get(0), context, visited);
+            }
+        }
+
         // 1. Literal?
         if (expr instanceof StringLiteral sl) {
             return sl.getLiteralValue();
@@ -51,6 +72,9 @@ public class ConstantResolver {
             String val = resolveManual(qn, context, visited);
             return val != null ? val : qn.toString();
         }
+        if (expr instanceof FieldAccess fa) {
+            return resolveManual(fa.getName(), context, visited);
+        }
         if (expr instanceof SimpleName sn) {
             return resolveManual(sn, context, visited);
         }
@@ -74,7 +98,14 @@ public class ConstantResolver {
                     return sn.getIdentifier();
                 }
             }
-
+                
+            if ("valueOf".equals(mi.getName().getIdentifier()) && mi.getExpression() != null) {
+                java.util.List<String> enumValues = context.getEnumValues(mi.getExpression().toString());
+                if (enumValues != null && !enumValues.isEmpty()) {
+                    return "ENUM_SET:" + String.join(",", enumValues);
+                }
+            }
+            
             IMethodBinding mb = mi.resolveMethodBinding();
             if (mb != null) {
                 ITypeBinding returnType = mb.getReturnType();
@@ -85,13 +116,43 @@ public class ConstantResolver {
                     }
                 }
             } else {
-                TypeDeclaration td = findEnclosingType(mi);
+                TypeDeclaration td = null;
+                if (mi.getExpression() != null) {
+                    ITypeBinding typeBinding = mi.getExpression().resolveTypeBinding();
+                    if (typeBinding != null) {
+                        String typeName = typeBinding.getQualifiedName();
+                        if (typeName != null && !typeName.isEmpty()) {
+                            td = context.getTypeDeclaration(typeName);
+                        }
+                    }
+                }
+                
+                if (td == null && mi.getExpression() instanceof SimpleName sn) {
+                    String typeName = resolveLocalType(sn);
+                    if (typeName != null) {
+                        td = context.getTypeDeclaration(typeName);
+                        if (td == null) {
+                            CompilationUnit cu = (CompilationUnit) mi.getRoot();
+                            td = context.getTypeDeclaration(typeName, cu);
+                        }
+                    }
+                }
+                
+                if (td == null) {
+                    td = findEnclosingType(mi);
+                }
+                
                 if (td != null) {
                     MethodDeclaration md = context.findMethodDeclaration(td, mi.getName().getIdentifier(), true);
-                    if (md != null && md.getReturnType2() != null) {
-                        java.util.List<String> values = context.getEnumValues(md.getReturnType2().toString());
-                        if (values != null && !values.isEmpty()) {
-                            return "ENUM_SET:" + String.join(",", values);
+                    if (md != null) {
+                        String evaluated = evaluateMethodOutput(mi, md, context, visited);
+                        if (evaluated != null) return evaluated;
+                        
+                        if (md.getReturnType2() != null) {
+                            java.util.List<String> values = context.getEnumValues(md.getReturnType2().toString());
+                            if (values != null && !values.isEmpty()) {
+                                return "ENUM_SET:" + String.join(",", values);
+                            }
                         }
                     }
                 }
@@ -101,6 +162,269 @@ public class ConstantResolver {
         return null;
     }
 
+    private String evaluateMethodOutput(MethodInvocation mi, MethodDeclaration md, CodebaseContext context, Set<String> visited) {
+        if (md.getBody() == null || mi.arguments().size() != md.parameters().size()) return null;
+
+        TypeDeclaration td = findEnclosingType(md);
+        if (td == null) return null;
+        String methodFqn = context.getFqn(td) + "." + md.getName().getIdentifier();
+        
+        if (!visited.add(methodFqn)) {
+            return null; // Cycle detected in method evaluation
+        }
+
+        try {
+            java.util.Map<String, String> localVars = new java.util.HashMap<>();
+            java.util.Set<String> declaredLocals = new java.util.HashSet<>();
+
+            for (int i = 0; i < mi.arguments().size(); i++) {
+                Expression arg = (Expression) mi.arguments().get(i);
+                String val = resolveInternal(arg, context, visited);
+                if (val != null) {
+                    org.eclipse.jdt.core.dom.SingleVariableDeclaration param =
+                            (org.eclipse.jdt.core.dom.SingleVariableDeclaration) md.parameters().get(i);
+                    String paramName = param.getName().getIdentifier();
+                    localVars.put(paramName, val);
+                    declaredLocals.add(paramName);
+                }
+            }
+
+            return evaluateBody(md.getBody(), localVars, declaredLocals, context, visited);
+        } finally {
+            visited.remove(methodFqn);
+        }
+    }
+
+    /**
+     * Evaluates a method body with pre-supplied local values (e.g. field values derived
+     * from the specific {@code ClassInstanceCreation} that created the receiver object).
+     * Used by {@link click.kamil.springstatemachineexporter.analysis.service.AbstractCallGraphEngine}
+     * to resolve transforming getters — methods that map a constructor-injected enum to a
+     * different state-machine enum via switch expressions.
+     */
+    public String evaluateMethodBodyWithLocals(MethodDeclaration md,
+                                        java.util.Map<String, String> prebuiltLocals,
+                                        CodebaseContext context,
+                                        Set<String> visited) {
+        if (md.getBody() == null) return null;
+        
+        TypeDeclaration td = findEnclosingType(md);
+        if (td == null) return null;
+        String methodFqn = context.getFqn(td) + "." + md.getName().getIdentifier();
+        
+        if (!visited.add(methodFqn)) {
+            return null; // Cycle detected in method evaluation
+        }
+
+        try {
+            java.util.Map<String, String> localVars = new java.util.HashMap<>(prebuiltLocals);
+            java.util.Set<String> declaredLocals = new java.util.HashSet<>(prebuiltLocals.keySet());
+            return evaluateBody(md.getBody(), localVars, declaredLocals, context, visited);
+        } finally {
+            visited.remove(methodFqn);
+        }
+    }
+
+    /**
+     * Core body-evaluation logic shared by {@link #evaluateMethodOutput} and
+     * {@link #evaluateMethodBodyWithLocals}.  Visits the block, tracks assignments,
+     * evaluates switch statements/expressions, and captures the first resolved return value.
+     */
+    private String evaluateBody(org.eclipse.jdt.core.dom.Block body,
+                                 java.util.Map<String, String> localVars,
+                                 java.util.Set<String> declaredLocals,
+                                 CodebaseContext context,
+                                 Set<String> visited) {
+        String[] finalResult = new String[1];
+
+        body.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(VariableDeclarationStatement vds) {
+                for (Object fragmentObj : vds.fragments()) {
+                    if (fragmentObj instanceof VariableDeclarationFragment fragment) {
+                        String varName = fragment.getName().getIdentifier();
+                        declaredLocals.add(varName);
+                        if (fragment.getInitializer() != null) {
+                            String rhsVal = resolveExpressionWithParams(fragment.getInitializer(), localVars);
+                            if (rhsVal == null) rhsVal = resolveInternal(fragment.getInitializer(), context, visited);
+                            if (rhsVal != null) localVars.put(varName, rhsVal);
+                        }
+                    }
+                }
+                return super.visit(vds);
+            }
+
+            @Override
+            public boolean visit(Assignment assignment) {
+                Expression lhs = assignment.getLeftHandSide();
+                String varName = null;
+                if (lhs instanceof SimpleName sn) {
+                    varName = sn.getIdentifier();
+                } else if (lhs instanceof FieldAccess fa) {
+                    varName = "this." + fa.getName().getIdentifier();
+                }
+                String rhsVal = resolveExpressionWithParams(assignment.getRightHandSide(), localVars);
+                if (rhsVal == null) rhsVal = resolveInternal(assignment.getRightHandSide(), context, visited);
+                if (varName != null && rhsVal != null) {
+                    if (varName.startsWith("this.")) {
+                        localVars.put(varName, rhsVal);
+                        String bareName = varName.substring(5);
+                        if (!declaredLocals.contains(bareName)) localVars.put(bareName, rhsVal);
+                    } else {
+                        localVars.put(varName, rhsVal);
+                        if (!declaredLocals.contains(varName)) localVars.put("this." + varName, rhsVal);
+                    }
+                }
+                return super.visit(assignment);
+            }
+
+            @Override
+            public boolean visit(org.eclipse.jdt.core.dom.SwitchStatement ss) {
+                if (finalResult[0] == null) {
+                    String result = evaluateSwitchStatement(ss, localVars, context, visited);
+                    if (result != null) finalResult[0] = result;
+                }
+                return false; // children handled inside evaluateSwitchStatement
+            }
+
+            @Override
+            public boolean visit(org.eclipse.jdt.core.dom.ReturnStatement rs) {
+                if (finalResult[0] == null) {
+                    if (rs.getExpression() instanceof org.eclipse.jdt.core.dom.SwitchExpression se) {
+                        String result = evaluateSwitchExpression(se, localVars, context, visited);
+                        if (result != null) finalResult[0] = result;
+                    } else if (rs.getExpression() != null) {
+                        String result = resolveExpressionWithParams(rs.getExpression(), localVars);
+                        if (result == null) result = resolveInternal(rs.getExpression(), context, visited);
+                        if (result != null) finalResult[0] = result;
+                    }
+                }
+                return super.visit(rs);
+            }
+        });
+
+        return finalResult[0];
+    }
+
+    private String evaluateSwitchStatement(org.eclipse.jdt.core.dom.SwitchStatement ss, java.util.Map<String, String> paramValues, CodebaseContext context, Set<String> visited) {
+        String switchVar = resolveExpressionWithParams(ss.getExpression(), paramValues);
+        if (switchVar == null) return null;
+
+        String switchType = null;
+        if (switchVar.contains(".")) {
+            switchType = switchVar.substring(0, switchVar.lastIndexOf('.'));
+        }
+
+        boolean matchingCase = false;
+        for (Object stmtObj : ss.statements()) {
+            if (stmtObj instanceof org.eclipse.jdt.core.dom.SwitchCase sc) {
+                matchingCase = false;
+                if (sc.isDefault()) {
+                    matchingCase = true;
+                } else {
+                    for (Object exprObj : sc.expressions()) {
+                        String caseVal = resolveExpressionWithParams((Expression) exprObj, paramValues);
+                        // Bare SimpleName case label (e.g. "case PAY"): use identifier as fallback
+                        if (caseVal == null && exprObj instanceof org.eclipse.jdt.core.dom.SimpleName caseSn) {
+                            caseVal = caseSn.getIdentifier();
+                            if (switchType != null) {
+                                caseVal = switchType + "." + caseVal;
+                            }
+                        }
+                        if (caseVal != null) {
+                            if (switchVar.contains(".") && caseVal.contains(".")) {
+                                if (switchVar.equals(caseVal)) {
+                                    matchingCase = true;
+                                    break;
+                                }
+                            } else if (switchVar.endsWith(caseVal)) {
+                                matchingCase = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            } else if (matchingCase) {
+                if (stmtObj instanceof org.eclipse.jdt.core.dom.ReturnStatement rs) {
+                    return resolveInternal(rs.getExpression(), context, visited);
+                } else if (stmtObj instanceof org.eclipse.jdt.core.dom.YieldStatement ys) {
+                    return resolveInternal(ys.getExpression(), context, visited);
+                } else if (stmtObj instanceof org.eclipse.jdt.core.dom.ExpressionStatement es) {
+                    return resolveInternal(es.getExpression(), context, visited);
+                }
+            }
+        }
+        return null;
+    }
+
+    private String evaluateSwitchExpression(org.eclipse.jdt.core.dom.SwitchExpression se, java.util.Map<String, String> paramValues, CodebaseContext context, Set<String> visited) {
+        String switchVar = resolveExpressionWithParams(se.getExpression(), paramValues);
+        if (switchVar == null) return null;
+
+        String switchType = null;
+        if (switchVar.contains(".")) {
+            switchType = switchVar.substring(0, switchVar.lastIndexOf('.'));
+        }
+
+        boolean matchingCase = false;
+        for (Object stmtObj : se.statements()) {
+            if (stmtObj instanceof org.eclipse.jdt.core.dom.SwitchCase sc) {
+                matchingCase = false;
+                if (sc.isDefault()) {
+                    matchingCase = true;
+                } else {
+                    for (Object exprObj : sc.expressions()) {
+                        String caseVal = resolveExpressionWithParams((Expression) exprObj, paramValues);
+                        // Bare SimpleName case label (e.g. "case PAY"): use identifier as fallback
+                        if (caseVal == null && exprObj instanceof org.eclipse.jdt.core.dom.SimpleName caseSn) {
+                            caseVal = caseSn.getIdentifier();
+                            if (switchType != null) {
+                                caseVal = switchType + "." + caseVal;
+                            }
+                        }
+                        if (caseVal != null) {
+                            if (switchVar.contains(".") && caseVal.contains(".")) {
+                                if (switchVar.equals(caseVal)) {
+                                    matchingCase = true;
+                                    break;
+                                }
+                            } else if (switchVar.endsWith(caseVal)) {
+                                matchingCase = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            } else if (matchingCase) {
+                if (stmtObj instanceof org.eclipse.jdt.core.dom.ExpressionStatement es) {
+                    return resolveInternal(es.getExpression(), context, visited);
+                } else if (stmtObj instanceof org.eclipse.jdt.core.dom.YieldStatement ys) {
+                    return resolveInternal(ys.getExpression(), context, visited);
+                } else if (stmtObj instanceof org.eclipse.jdt.core.dom.ReturnStatement rs) {
+                    return resolveInternal(rs.getExpression(), context, visited);
+                }
+            }
+        }
+        return null;
+    }
+
+    private String resolveExpressionWithParams(Expression expr, java.util.Map<String, String> paramValues) {
+        if (expr instanceof SimpleName sn) {
+            String name = sn.getIdentifier();
+            if (paramValues.containsKey(name)) return paramValues.get(name);
+            return null;
+        } else if (expr instanceof FieldAccess fa) {
+            String name = "this." + fa.getName().getIdentifier();
+            if (paramValues.containsKey(name)) return paramValues.get(name);
+            return null;
+        } else if (expr instanceof QualifiedName qn) {
+            return qn.getName().getIdentifier();
+        } else if (expr instanceof org.eclipse.jdt.core.dom.StringLiteral sl) {
+            return sl.getLiteralValue();
+        }
+        return null;
+    }
+
     private String resolveInfix(InfixExpression expr, CodebaseContext context, Set<String> visited) {
         if (expr.getOperator() != InfixExpression.Operator.PLUS) return null;
 
@@ -121,6 +445,32 @@ public class ConstantResolver {
     }
 
     private String resolveManual(SimpleName sn, CodebaseContext context, Set<String> visited) {
+        MethodDeclaration enclosingMethod = findEnclosingMethod(sn);
+        if (enclosingMethod != null) {
+            for (Object paramObj : enclosingMethod.parameters()) {
+                if (paramObj instanceof SingleVariableDeclaration svd) {
+                    if (svd.getName().getIdentifier().equals(sn.getIdentifier())) {
+                        return null;
+                    }
+                }
+            }
+            if (enclosingMethod.getBody() != null) {
+                boolean[] isLocal = {false};
+                enclosingMethod.getBody().accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(VariableDeclarationFragment node) {
+                        if (node.getName().getIdentifier().equals(sn.getIdentifier())) {
+                            isLocal[0] = true;
+                        }
+                        return super.visit(node);
+                    }
+                });
+                if (isLocal[0]) {
+                    return null;
+                }
+            }
+        }
+
         TypeDeclaration td = findEnclosingType(sn);
         if (td != null) {
             String fqn = context.getFqn(td);
@@ -180,6 +530,28 @@ public class ConstantResolver {
                     }
                 }
             }
+            
+            // Check constructors for assignments
+            for (MethodDeclaration md : td.getMethods()) {
+                if (md.isConstructor() && md.getBody() != null) {
+                    for (Object stmtObj : md.getBody().statements()) {
+                        if (stmtObj instanceof ExpressionStatement es) {
+                            if (es.getExpression() instanceof Assignment assignment) {
+                                Expression lhs = assignment.getLeftHandSide();
+                                boolean matches = false;
+                                if (lhs instanceof SimpleName snLhs && snLhs.getIdentifier().equals(fieldName)) {
+                                    matches = true;
+                                } else if (lhs instanceof FieldAccess fa && fa.getName().getIdentifier().equals(fieldName) && fa.getExpression() instanceof ThisExpression) {
+                                    matches = true;
+                                }
+                                if (matches) {
+                                    return resolveInternal(assignment.getRightHandSide(), context, visited);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         } finally {
             visited.remove(fieldId);
         }
@@ -225,4 +597,49 @@ public class ConstantResolver {
         }
         return (TypeDeclaration) parent;
     }
+
+    private MethodDeclaration findEnclosingMethod(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null) {
+            if (parent instanceof MethodDeclaration md) {
+                return md;
+            }
+            parent = parent.getParent();
+        }
+        return null;
+    }
+
+    private String resolveLocalType(SimpleName sn) {
+        String varName = sn.getIdentifier();
+        MethodDeclaration enclosingMethod = findEnclosingMethod(sn);
+        if (enclosingMethod != null && enclosingMethod.getBody() != null) {
+            String[] typeName = new String[1];
+            enclosingMethod.getBody().accept(new ASTVisitor() {
+                @Override
+                public boolean visit(VariableDeclarationStatement node) {
+                    for (Object fragObj : node.fragments()) {
+                        VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                        if (frag.getName().getIdentifier().equals(varName)) {
+                            typeName[0] = node.getType().toString();
+                        }
+                    }
+                    return super.visit(node);
+                }
+            });
+            if (typeName[0] != null) return typeName[0];
+        }
+        
+        TypeDeclaration enclosingType = findEnclosingType(sn);
+        if (enclosingType != null) {
+            for (FieldDeclaration field : enclosingType.getFields()) {
+                for (Object fragObj : field.fragments()) {
+                    VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                    if (frag.getName().getIdentifier().equals(varName)) {
+                        return field.getType().toString();
+                    }
+                }
+            }
+        }
+        return null;
+    }
 }

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/resolver/PolymorphicEventResolver.java

@@ -0,0 +1,22 @@
+package click.kamil.springstatemachineexporter.analysis.resolver;
+
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+
+import java.util.List;
+
+public interface PolymorphicEventResolver {
+    
+    /**
+     * Attempts to resolve a dynamically passed event variable into a set of 
+     * concrete polymorphic event names.
+     * 
+     * @param triggerPoint The original trigger point to resolve.
+     * @param resolvedValue The current String expression (e.g., "event.getType()" or "event")
+     * @param path The call path trace leading up to this variable.
+     * @param context The codebase context for deep type resolution.
+     * @return The updated TriggerPoint with polymorphic events set, or the original if unable to resolve.
+     */
+    TriggerPoint resolvePolymorphicEvents(TriggerPoint triggerPoint, String resolvedValue, List<String> path, CodebaseContext context);
+    
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/service/GenericEventDetector.java

@@ -265,8 +265,26 @@ public class GenericEventDetector {
                 return getSimpleNameString(right);
             }
         } else if (expr instanceof MethodInvocation mi) {
-            if ("equals".equals(mi.getName().getIdentifier()) && !mi.arguments().isEmpty()) {
-                return getSimpleNameString((Expression) mi.arguments().get(0));
+            String methodName = mi.getName().getIdentifier();
+            if (("equals".equals(methodName) || "equalsIgnoreCase".equals(methodName)) && !mi.arguments().isEmpty()) {
+                Expression receiver = mi.getExpression();
+                Expression arg = (Expression) mi.arguments().get(0);
+                
+                // If receiver is null (e.g., implicit this), fall back to arg
+                if (receiver == null) {
+                    return getSimpleNameString(arg);
+                }
+                
+                // Prioritize the one that looks like a constant (QualifiedName or StringLiteral)
+                if (receiver instanceof QualifiedName || receiver instanceof StringLiteral || receiver instanceof FieldAccess) {
+                    return getSimpleNameString(receiver);
+                }
+                if (arg instanceof QualifiedName || arg instanceof StringLiteral || arg instanceof FieldAccess) {
+                    return getSimpleNameString(arg);
+                }
+                
+                // Fallback to receiver
+                return getSimpleNameString(receiver);
             }
         }
         return null;
@@ -325,6 +343,10 @@ public class GenericEventDetector {
             }
         }
 
+        if (expr instanceof ClassInstanceCreation cic) {
+            return cic.getType().toString();
+        }
+
         if (!(expr instanceof MethodInvocation mi)) return null;
 
         // Trace back chain: MessageBuilder.withPayload(event).setHeader(...).build()

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/service/JdtCallGraphEngine.java

@@ -0,0 +1,353 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.CallEdge;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.jdt.core.dom.*;
+
+import java.util.*;
+
+import click.kamil.springstatemachineexporter.analysis.spring.InjectionPointAnalyzer;
+
+@Slf4j
+public class JdtCallGraphEngine extends AbstractCallGraphEngine {
+    private final InjectionPointAnalyzer injectionAnalyzer;
+    private String currentMethodFqn;
+    private Map<String, List<CallEdge>> graph;
+
+    public JdtCallGraphEngine(CodebaseContext context, InjectionPointAnalyzer injectionAnalyzer) {
+        super(context);
+        this.injectionAnalyzer = injectionAnalyzer;
+    }
+
+    protected Map<String, List<CallEdge>> buildCallGraph() {
+        graph = new HashMap<>();
+        for (CompilationUnit cu : context.getCompilationUnits()) {
+            cu.accept(new ASTVisitor() {
+
+                @Override
+                public boolean visit(MethodInvocation node) {
+                    MethodDeclaration md = findEnclosingMethod(node);
+                    if (md != null) {
+                        TypeDeclaration td = findEnclosingType(md);
+                        if (td != null) {
+                            String currentMethodFqn = context.getFqn(td) + "." + md.getName().getIdentifier();
+                            List<String> calledMethods = resolveCalledMethodsPolymorphic(node);
+                            List<String> args = resolveArguments(node.arguments());
+                            for (String calledMethod : calledMethods) {
+                                graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(new CallEdge(calledMethod, args));
+                            }
+                            for (Object argObj : node.arguments()) {
+                                if (argObj instanceof ExpressionMethodReference emr) {
+                                    String typeName = emr.getExpression().toString();
+                                    if ("this".equals(typeName) || "super".equals(typeName)) {
+                                        TypeDeclaration td2 = findEnclosingType(node);
+                                        if (td2 != null) {
+                                            String refMethod = resolveMethodInType(td2, emr.getName().getIdentifier());
+                                            if (refMethod != null) {
+                                                List<String> implicitArgs = new ArrayList<>();
+                                                if (click.kamil.springstatemachineexporter.ast.common.AstUtils.isFunctionalCollectionMethod(node)) {
+                                                    implicitArgs.add(node.getExpression().toString());
+                                                } else {
+                                                    implicitArgs.addAll(args);
+                                                }
+                                                graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(new CallEdge(refMethod, implicitArgs));
+                                            }
+                                        }
+                                    } else {
+                                        String fallbackTypeFqn = null;
+                                        ITypeBinding binding = emr.getExpression().resolveTypeBinding();
+                                        if (binding != null) {
+                                            fallbackTypeFqn = binding.getQualifiedName();
+                                        } else if (emr.getExpression() instanceof SimpleName sn) {
+                                            fallbackTypeFqn = resolveReceiverTypeFallback(sn);
+                                        }
+                                        if (fallbackTypeFqn != null) {
+                                            String calledMethod = fallbackTypeFqn + "." + emr.getName().getIdentifier();
+                                            List<String> implicitArgs = new ArrayList<>();
+                                            if (click.kamil.springstatemachineexporter.ast.common.AstUtils.isFunctionalCollectionMethod(node)) {
+                                                implicitArgs.add(node.getExpression().toString());
+                                            } else {
+                                                implicitArgs.addAll(args);
+                                            }
+                                            graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(new CallEdge(calledMethod, implicitArgs));
+                                            
+                                            List<String> impls = context.getImplementations(fallbackTypeFqn);
+                                            for (String impl : impls) {
+                                                graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(new CallEdge(impl + "." + emr.getName().getIdentifier(), args));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    return super.visit(node);
+                }
+
+                @Override
+                public boolean visit(SuperMethodInvocation node) {
+                    MethodDeclaration md = findEnclosingMethod(node);
+                    if (md != null) {
+                        TypeDeclaration tdOuter = findEnclosingType(md);
+                        if (tdOuter != null) {
+                            String currentMethodFqn = context.getFqn(tdOuter) + "." + md.getName().getIdentifier();
+                            String methodName = node.getName().getIdentifier();
+                            TypeDeclaration td = findEnclosingType(node);
+                            if (td != null) {
+                                String superFqn = context.getSuperclassFqn(td);
+                                if (superFqn != null) {
+                                    TypeDeclaration superTd = context.getTypeDeclaration(superFqn);
+                                    String calledMethod = null;
+                                    if (superTd != null) {
+                                        calledMethod = resolveMethodInType(superTd, methodName);
+                                    }
+                                    if (calledMethod == null) {
+                                        calledMethod = superFqn + "." + methodName;
+                                    }
+                                    List<String> args = resolveArguments(node.arguments());
+                                    graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(new CallEdge(calledMethod, args));
+                                }
+                            }
+                        }
+                    }
+                    return super.visit(node);
+                }
+            });
+        }
+        return graph;
+    }
+
+    @Override
+    protected String resolveArgument(org.eclipse.jdt.core.dom.Expression expr) {
+        // Extract from constructor args (e.g., new CustomMessage(OrderEvent.PROCESS, ...))
+        org.eclipse.jdt.core.dom.Expression unwrappedBuilder = unwrapMessageBuilder(expr);
+        if (unwrappedBuilder != expr) {
+            expr = unwrappedBuilder;
+        }
+
+        // Trace variable to resolve local variable references
+        org.eclipse.jdt.core.dom.Expression tracedExpr = traceVariable(expr);
+        if (tracedExpr instanceof org.eclipse.jdt.core.dom.QualifiedName 
+                || tracedExpr instanceof org.eclipse.jdt.core.dom.ClassInstanceCreation 
+                || tracedExpr instanceof org.eclipse.jdt.core.dom.StringLiteral 
+                || tracedExpr instanceof org.eclipse.jdt.core.dom.NumberLiteral) {
+            expr = tracedExpr; // Only accept trace if it resolves to a pure constant/primitive/constructor
+        }
+
+        // Delegate to base class for lambda, method reference, and constructor unwrapping
+        return super.resolveArgument(expr);
+    }
+
+    private List<String> resolveCalledMethodsPolymorphic(MethodInvocation node) {
+        String baseCalled = resolveCalledMethod(node);
+        if (baseCalled == null) return Collections.emptyList();
+
+        List<String> allResolved = new ArrayList<>();
+        allResolved.add(baseCalled);
+
+        if (baseCalled.contains(".")) {
+            String className = baseCalled.substring(0, baseCalled.lastIndexOf('.'));
+            String methodName = baseCalled.substring(baseCalled.lastIndexOf('.') + 1);
+            
+            List<String> impls = context.getImplementations(className);
+            for (String impl : impls) {
+                allResolved.add(impl + "." + methodName);
+            }
+        }
+
+        return allResolved;
+    }
+
+    protected String resolveCalledMethod(MethodInvocation node) {
+        Expression receiver = node.getExpression();
+        String methodName = node.getName().getIdentifier();
+
+        if (receiver == null) {
+            TypeDeclaration td = findEnclosingType(node);
+            if (td != null) {
+                return resolveMethodInType(td, methodName);
+            }
+            return null;
+        }
+
+        if (injectionAnalyzer != null) {
+            IBinding nameBinding = null;
+            if (receiver instanceof SimpleName sn) {
+                nameBinding = sn.resolveBinding();
+            } else if (receiver instanceof FieldAccess fa) {
+                nameBinding = fa.resolveFieldBinding();
+            }
+            if (nameBinding instanceof IVariableBinding varBinding) {
+                System.out.println("CALLGRAPH RESOLVING BEAN FOR BINDING: " + varBinding.getName() + " calling " + methodName);
+                String concreteFqn = injectionAnalyzer.resolveInjectedBeanFqn(varBinding);
+                if (concreteFqn != null) {
+                    System.out.println("  -> RESOLVED CONCRETE FQN: " + concreteFqn);
+                    return concreteFqn + "." + methodName;
+                } else {
+                    System.out.println("  -> RESOLVE FAILED, RETURNED NULL");
+                }
+            } else {
+                System.out.println("CALLGRAPH NAME BINDING IS NOT VARIABLE: " + nameBinding + " calling " + methodName);
+            }
+        }
+
+        ITypeBinding binding = receiver.resolveTypeBinding();
+        if (binding != null) {
+            String typeName = null;
+            try {
+                if (binding.getErasure() != null) {
+                    typeName = binding.getErasure().getQualifiedName();
+                    if (typeName == null || typeName.isEmpty()) {
+                        typeName = binding.getErasure().getName();
+                    }
+                }
+            } catch (Exception e) {
+                // Ignore JDT internal exceptions
+            }
+
+            if (typeName == null || typeName.isEmpty()) {
+                typeName = binding.getQualifiedName();
+                if (typeName == null || typeName.isEmpty()) {
+                    typeName = binding.getName();
+                }
+                if (typeName != null && typeName.contains("<")) {
+                    typeName = typeName.replaceAll("<.*>", "");
+                }
+            }
+
+            if (typeName != null && !typeName.isEmpty()) {
+                return typeName + "." + methodName;
+            }
+        }
+
+        if (receiver instanceof ThisExpression) {
+            TypeDeclaration td = findEnclosingType(node);
+            if (td != null) {
+                return context.getFqn(td) + "." + methodName;
+            }
+        }
+
+        if (receiver instanceof SimpleName sn) {
+            String fallbackTypeFqn = resolveReceiverTypeFallback(sn);
+            if (fallbackTypeFqn != null) {
+                return fallbackTypeFqn + "." + methodName;
+            }
+            String receiverName = sn.getIdentifier();
+            return receiverName + "." + methodName; 
+        }
+
+        return null;
+    }
+
+    private String resolveReceiverTypeFallback(SimpleName receiverNameNode) {
+        String varName = receiverNameNode.getIdentifier();
+        
+        // 1. Check local variables in enclosing method
+        MethodDeclaration enclosingMethod = findEnclosingMethod(receiverNameNode);
+        if (enclosingMethod != null) {
+            // Check parameters
+            for (Object paramObj : enclosingMethod.parameters()) {
+                SingleVariableDeclaration svd = (SingleVariableDeclaration) paramObj;
+                if (svd.getName().getIdentifier().equals(varName)) {
+                    return resolveTypeToFqn(svd.getType(), receiverNameNode);
+                }
+            }
+            // Check method body (local variables)
+            if (enclosingMethod.getBody() != null) {
+                Type[] foundType = new Type[1];
+                enclosingMethod.getBody().accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(VariableDeclarationStatement node) {
+                        for (Object fragObj : node.fragments()) {
+                            VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                            if (frag.getName().getIdentifier().equals(varName)) {
+                                foundType[0] = node.getType();
+                            }
+                        }
+                        return super.visit(node);
+                    }
+                });
+                if (foundType[0] != null) {
+                    return resolveTypeToFqn(foundType[0], receiverNameNode);
+                }
+            }
+        }
+
+        // 2. Check fields in enclosing class
+        TypeDeclaration enclosingType = findEnclosingType(receiverNameNode);
+        if (enclosingType != null) {
+            for (FieldDeclaration field : enclosingType.getFields()) {
+                for (Object fragObj : field.fragments()) {
+                    VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                    if (frag.getName().getIdentifier().equals(varName)) {
+                        return resolveTypeToFqn(field.getType(), receiverNameNode);
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private String resolveTypeToFqn(Type type, ASTNode contextNode) {
+        if (type == null) return null;
+        String simpleName;
+        if (type.isSimpleType()) {
+            simpleName = ((SimpleType) type).getName().getFullyQualifiedName();
+        } else if (type.isParameterizedType()) {
+            return resolveTypeToFqn(((ParameterizedType) type).getType(), contextNode);
+        } else {
+            simpleName = type.toString();
+        }
+
+        CompilationUnit cu = (CompilationUnit) contextNode.getRoot();
+        TypeDeclaration td = context.getTypeDeclaration(simpleName, cu);
+        if (td != null) {
+            return context.getFqn(td);
+        }
+        
+        // Fallback to import matching if CodebaseContext doesn't know it (e.g., external library)
+        for (Object impObj : cu.imports()) {
+            ImportDeclaration imp = (ImportDeclaration) impObj;
+            String impName = imp.getName().getFullyQualifiedName();
+            if (impName.endsWith("." + simpleName)) {
+                return impName;
+            }
+        }
+
+        return simpleName;
+    }
+
+    private String resolveMethodInType(TypeDeclaration td, String methodName) {
+        MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+        if (md != null) {
+            TypeDeclaration declaringTd = findEnclosingType(md);
+            return context.getFqn(declaringTd) + "." + methodName;
+        }
+        return null;
+    }
+
+    private Expression unwrapMessageBuilder(Expression expr) {
+        if (expr instanceof MethodInvocation mi) {
+            MethodInvocation current = mi;
+            while (current != null) {
+                String name = current.getName().getIdentifier();
+                if (("withPayload".equals(name) || "just".equals(name)) && !current.arguments().isEmpty()) {
+                    return (Expression) current.arguments().get(0);
+                }
+                Expression receiver = current.getExpression();
+                if (receiver instanceof MethodInvocation nextMi) {
+                    current = nextMi;
+                } else {
+                    current = null;
+                }
+            }
+        }
+        return expr;
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/service/JdtIntelligenceProvider.java

@@ -4,6 +4,10 @@ import click.kamil.springstatemachineexporter.analysis.model.CallChain;
 import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
 import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
 import click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver;
+import click.kamil.springstatemachineexporter.analysis.spring.InjectionPointAnalyzer;
+import click.kamil.springstatemachineexporter.analysis.spring.SpringBeanRegistry;
+import click.kamil.springstatemachineexporter.analysis.spring.SpringContextScanner;
+import click.kamil.springstatemachineexporter.analysis.spring.SpringDependencyResolver;
 import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.jdt.core.dom.CompilationUnit;
@@ -32,7 +36,17 @@ public class JdtIntelligenceProvider implements CodebaseIntelligenceProvider {
         this.eventDetector = new GenericEventDetector(context, constantResolver, context.getLibraryHints());
         this.mvcDetector = new SpringMvcDetector(context, constantResolver);
         this.messagingDetector = new MessagingDetector(context);
-        this.callGraphEngine = new HeuristicCallGraphEngine(context);
+        
+        SpringBeanRegistry registry = new SpringBeanRegistry();
+        SpringContextScanner scanner = new SpringContextScanner(registry);
+        for (CompilationUnit cu : context.getCompilationUnits()) {
+            cu.accept(scanner);
+        }
+        SpringDependencyResolver dependencyResolver = new SpringDependencyResolver(registry);
+        InjectionPointAnalyzer injectionAnalyzer = new InjectionPointAnalyzer(dependencyResolver);
+        
+        this.callGraphEngine = new JdtCallGraphEngine(context, injectionAnalyzer);
+        
         this.lifecycleDetector = new LifecycleDetector(context);
         this.interceptorDetector = new InterceptorDetector(context);
         this.componentDetector = new SpringComponentDetector(context);

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/spring/InjectionPointAnalyzer.java

@@ -0,0 +1,93 @@
+package click.kamil.springstatemachineexporter.analysis.spring;
+
+import org.eclipse.jdt.core.dom.IAnnotationBinding;
+import org.eclipse.jdt.core.dom.IMemberValuePairBinding;
+import org.eclipse.jdt.core.dom.IVariableBinding;
+
+import java.util.List;
+
+public class InjectionPointAnalyzer {
+    
+    private final SpringDependencyResolver resolver;
+
+    public InjectionPointAnalyzer(SpringDependencyResolver resolver) {
+        this.resolver = resolver;
+    }
+
+    /**
+     * Resolves the Spring bean injected into the given variable.
+     * 
+     * @param variableBinding The binding of the field or parameter being injected.
+     * @return The FQN of the resolved concrete bean class, or null if unresolved.
+     */
+    public String resolveInjectedBeanFqn(IVariableBinding variableBinding) {
+        if (variableBinding == null || variableBinding.getType() == null) {
+            return null;
+        }
+
+        String requiredTypeFqn = variableBinding.getType().getQualifiedName();
+        String injectionName = variableBinding.getName();
+        String qualifier = extractQualifier(variableBinding);
+
+        List<SpringBean> resolvedBeans = resolver.resolve(requiredTypeFqn, qualifier, injectionName);
+        
+        if (resolvedBeans != null && resolvedBeans.size() == 1) {
+            return resolvedBeans.get(0).getTypeFqn();
+        }
+
+        return null;
+    }
+
+    private String extractQualifier(IVariableBinding binding) {
+        String qualifier = getQualifierValue(binding.getAnnotations());
+        if (qualifier != null) {
+            return qualifier;
+        }
+
+        if (binding.isField()) {
+            org.eclipse.jdt.core.dom.ITypeBinding declaringClass = binding.getDeclaringClass();
+            if (declaringClass != null) {
+                for (org.eclipse.jdt.core.dom.IMethodBinding method : declaringClass.getDeclaredMethods()) {
+                    boolean isAutowiredMethod = false;
+                    for (IAnnotationBinding ann : method.getAnnotations()) {
+                        if (ann.getAnnotationType() != null && "org.springframework.beans.factory.annotation.Autowired".equals(ann.getAnnotationType().getQualifiedName())) {
+                            isAutowiredMethod = true;
+                            break;
+                        }
+                    }
+
+                    if (method.isConstructor() || isAutowiredMethod) {
+                        for (int i = 0; i < method.getParameterTypes().length; i++) {
+                            org.eclipse.jdt.core.dom.ITypeBinding paramType = method.getParameterTypes()[i];
+                            try {
+                                IAnnotationBinding[] paramAnns = method.getParameterAnnotations(i);
+                                String paramQual = getQualifierValue(paramAnns);
+                                if (paramQual != null && paramType.getErasure().isEqualTo(binding.getType().getErasure())) {
+                                    // For setters, verify it roughly matches the field name or just rely on type.
+                                    // We will rely on type equality for now as a heuristic.
+                                    return paramQual;
+                                }
+                            } catch (Exception e) {
+                                // Ignore
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    private String getQualifierValue(IAnnotationBinding[] annotations) {
+        for (IAnnotationBinding ann : annotations) {
+            if (ann.getAnnotationType() != null && "org.springframework.beans.factory.annotation.Qualifier".equals(ann.getAnnotationType().getQualifiedName())) {
+                for (IMemberValuePairBinding pair : ann.getDeclaredMemberValuePairs()) {
+                    if ("value".equals(pair.getName()) && pair.getValue() instanceof String) {
+                        return (String) pair.getValue();
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/spring/SpringBean.java

@@ -0,0 +1,27 @@
+package click.kamil.springstatemachineexporter.analysis.spring;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class SpringBean {
+    private String typeFqn;
+    
+    @Builder.Default
+    private Set<String> assignableTypes = new HashSet<>();
+    
+    @Builder.Default
+    private Set<String> beanNames = new HashSet<>();
+    
+    @Builder.Default
+    private Set<String> qualifiers = new HashSet<>();
+    
+    private boolean isPrimary;
+    private Integer order;
+    private String declaringClassFqn;
+    private String factoryMethodName;
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/spring/SpringBeanRegistry.java

@@ -0,0 +1,17 @@
+package click.kamil.springstatemachineexporter.analysis.spring;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SpringBeanRegistry {
+    private final List<SpringBean> beans = new ArrayList<>();
+
+    public void addBean(SpringBean bean) {
+        beans.add(bean);
+    }
+
+    public List<SpringBean> getBeans() {
+        return Collections.unmodifiableList(beans);
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/spring/SpringContextScanner.java

@@ -0,0 +1,235 @@
+package click.kamil.springstatemachineexporter.analysis.spring;
+
+import org.eclipse.jdt.core.dom.*;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class SpringContextScanner extends ASTVisitor {
+    private final SpringBeanRegistry registry;
+
+    public SpringContextScanner(SpringBeanRegistry registry) {
+        this.registry = registry;
+    }
+
+    @Override
+    public boolean visit(TypeDeclaration node) {
+        ITypeBinding typeBinding = node.resolveBinding();
+        if (typeBinding == null) return true;
+
+        if (isSpringComponent(typeBinding)) {
+            SpringBean bean = SpringBean.builder()
+                    .typeFqn(typeBinding.getQualifiedName())
+                    .assignableTypes(getAssignableTypes(typeBinding))
+                    .isPrimary(hasAnnotation(typeBinding, "org.springframework.context.annotation.Primary"))
+                    .qualifiers(extractQualifiers(typeBinding))
+                    .order(extractOrder(typeBinding))
+                    .declaringClassFqn(typeBinding.getQualifiedName())
+                    .build();
+
+            // Default bean name is uncapitalized simple name
+            String defaultName = Character.toLowerCase(node.getName().getIdentifier().charAt(0)) + node.getName().getIdentifier().substring(1);
+            
+            // Check if @Component or @Service specifies a name (e.g., @Service("myService"))
+            String explicitName = extractStereotypeValue(typeBinding);
+            if (explicitName != null && !explicitName.isEmpty()) {
+                bean.getBeanNames().add(explicitName);
+            } else {
+                bean.getBeanNames().add(defaultName);
+            }
+
+            registry.addBean(bean);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean visit(MethodDeclaration node) {
+        IMethodBinding methodBinding = node.resolveBinding();
+        if (methodBinding == null) return true;
+
+        if (hasAnnotation(methodBinding, "org.springframework.context.annotation.Bean")) {
+            ITypeBinding returnType = methodBinding.getReturnType();
+            if (returnType != null) {
+                Set<String> assignables = getAssignableTypes(returnType);
+                String[] concreteType = new String[] { returnType.getQualifiedName() };
+                
+                if (node.getBody() != null) {
+                    node.getBody().accept(new ASTVisitor() {
+                        @Override
+                        public boolean visit(ReturnStatement ret) {
+                            if (ret.getExpression() != null) {
+                                ITypeBinding exprType = ret.getExpression().resolveTypeBinding();
+                                if (exprType != null && exprType.isClass()) {
+                                    concreteType[0] = exprType.getQualifiedName();
+                                    assignables.addAll(getAssignableTypes(exprType));
+                                }
+                            }
+                            return super.visit(ret);
+                        }
+                    });
+                }
+
+                SpringBean bean = SpringBean.builder()
+                        .typeFqn(concreteType[0])
+                        .assignableTypes(assignables)
+                        .isPrimary(hasAnnotation(methodBinding, "org.springframework.context.annotation.Primary"))
+                        .qualifiers(extractQualifiers(methodBinding))
+                        .order(extractOrder(methodBinding))
+                        .declaringClassFqn(methodBinding.getDeclaringClass().getQualifiedName())
+                        .factoryMethodName(node.getName().getIdentifier())
+                        .build();
+
+                // Default bean name is method name
+                String defaultName = node.getName().getIdentifier();
+                
+                // Check if @Bean specifies a name (e.g., @Bean("myBean"))
+                String explicitName = extractBeanName(methodBinding);
+                if (explicitName != null && !explicitName.isEmpty()) {
+                    bean.getBeanNames().add(explicitName);
+                } else {
+                    bean.getBeanNames().add(defaultName);
+                }
+
+                registry.addBean(bean);
+            }
+        }
+        return true;
+    }
+
+    private boolean isSpringComponent(ITypeBinding binding) {
+        return hasMetaAnnotation(binding, "org.springframework.stereotype.Component") ||
+               hasMetaAnnotation(binding, "org.springframework.web.bind.annotation.RestController");
+    }
+
+    private boolean hasMetaAnnotation(ITypeBinding binding, String targetFqn) {
+        return checkMetaAnnotation(binding.getAnnotations(), targetFqn, new HashSet<>());
+    }
+    
+    private boolean checkMetaAnnotation(IAnnotationBinding[] annotations, String targetFqn, Set<String> visited) {
+        for (IAnnotationBinding ann : annotations) {
+            ITypeBinding annType = ann.getAnnotationType();
+            if (annType != null) {
+                String fqn = annType.getQualifiedName();
+                if (fqn.equals(targetFqn)) return true;
+                
+                // Avoid circular meta-annotations (e.g. Documented -> Documented)
+                if (visited.add(fqn)) {
+                    if (checkMetaAnnotation(annType.getAnnotations(), targetFqn, visited)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean hasAnnotation(IBinding binding, String annotationFqn) {
+        IAnnotationBinding[] annotations = binding.getAnnotations();
+        for (IAnnotationBinding ann : annotations) {
+            if (ann.getAnnotationType() != null && annotationFqn.equals(ann.getAnnotationType().getQualifiedName())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private Set<String> getAssignableTypes(ITypeBinding binding) {
+        Set<String> types = new HashSet<>();
+        collectAssignableTypes(binding, types);
+        return types;
+    }
+
+    private void collectAssignableTypes(ITypeBinding binding, Set<String> types) {
+        if (binding == null) return;
+        
+        String qName = binding.getQualifiedName();
+        if (qName != null && !qName.isEmpty()) {
+            types.add(qName);
+        }
+        
+        ITypeBinding erasure = binding.getErasure();
+        if (erasure != null) {
+            String erasureName = erasure.getQualifiedName();
+            if (erasureName != null && !erasureName.isEmpty()) {
+                types.add(erasureName);
+            }
+        }
+
+        collectAssignableTypes(binding.getSuperclass(), types);
+        if (binding.getInterfaces() != null) {
+            for (ITypeBinding iface : binding.getInterfaces()) {
+                collectAssignableTypes(iface, types);
+            }
+        }
+    }
+
+    private Set<String> extractQualifiers(IBinding binding) {
+        Set<String> qualifiers = new HashSet<>();
+        for (IAnnotationBinding ann : binding.getAnnotations()) {
+            if (ann.getAnnotationType() != null && "org.springframework.beans.factory.annotation.Qualifier".equals(ann.getAnnotationType().getQualifiedName())) {
+                for (IMemberValuePairBinding pair : ann.getDeclaredMemberValuePairs()) {
+                    if ("value".equals(pair.getName()) && pair.getValue() instanceof String) {
+                        qualifiers.add((String) pair.getValue());
+                    }
+                }
+            }
+        }
+        return qualifiers;
+    }
+
+    private Integer extractOrder(IBinding binding) {
+        for (IAnnotationBinding ann : binding.getAnnotations()) {
+            if (ann.getAnnotationType() != null && "org.springframework.core.annotation.Order".equals(ann.getAnnotationType().getQualifiedName())) {
+                for (IMemberValuePairBinding pair : ann.getDeclaredMemberValuePairs()) {
+                    if ("value".equals(pair.getName())) {
+                        Object val = pair.getValue();
+                        if (val instanceof Integer) {
+                            return (Integer) val;
+                        } else if (val instanceof IVariableBinding) {
+                            Object constantValue = ((IVariableBinding) val).getConstantValue();
+                            if (constantValue instanceof Integer) {
+                                return (Integer) constantValue;
+                            }
+                        }
+                    }
+                }
+                return Integer.MAX_VALUE; // Spring's default for @Order()
+            }
+        }
+        return null;
+    }
+
+    private String extractStereotypeValue(ITypeBinding binding) {
+        for (IAnnotationBinding ann : binding.getAnnotations()) {
+            // Check if annotation itself is meta-annotated with @Component
+            if (checkMetaAnnotation(new IAnnotationBinding[]{ann}, "org.springframework.stereotype.Component", new HashSet<>()) ||
+                "org.springframework.stereotype.Component".equals(ann.getAnnotationType().getQualifiedName())) {
+                for (IMemberValuePairBinding pair : ann.getDeclaredMemberValuePairs()) {
+                    if ("value".equals(pair.getName()) && pair.getValue() instanceof String) {
+                        return (String) pair.getValue();
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    private String extractBeanName(IMethodBinding binding) {
+        for (IAnnotationBinding ann : binding.getAnnotations()) {
+            if ("org.springframework.context.annotation.Bean".equals(ann.getAnnotationType().getQualifiedName())) {
+                for (IMemberValuePairBinding pair : ann.getDeclaredMemberValuePairs()) {
+                    if (("value".equals(pair.getName()) || "name".equals(pair.getName())) && pair.getValue() instanceof String) {
+                        return (String) pair.getValue();
+                    } else if (("value".equals(pair.getName()) || "name".equals(pair.getName())) && pair.getValue() instanceof Object[]) {
+                        Object[] vals = (Object[]) pair.getValue();
+                        if (vals.length > 0 && vals[0] instanceof String) {
+                            return (String) vals[0];
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/spring/SpringDependencyResolver.java

@@ -0,0 +1,87 @@
+package click.kamil.springstatemachineexporter.analysis.spring;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class SpringDependencyResolver {
+    private final SpringBeanRegistry registry;
+
+    public SpringDependencyResolver(SpringBeanRegistry registry) {
+        this.registry = registry;
+    }
+
+    /**
+     * Resolves the exact SpringBean that would be injected for a given injection point.
+     *
+     * @param requiredTypeFqn The exact FQN of the type requested at the injection point.
+     * @param qualifier       The value of the @Qualifier annotation on the injection point (if any).
+     * @param injectionName   The name of the field or parameter being injected (used as fallback).
+     * @return A list of resolved beans. Usually 1. If 0, unresolved. If > 1, ambiguous.
+     */
+    public List<SpringBean> resolve(String requiredTypeFqn, String qualifier, String injectionName) {
+        if (requiredTypeFqn == null) return new ArrayList<>();
+
+        // 1. Filter by Type (Exact FQN or Assignable Type)
+        System.out.println("RESOLVING " + requiredTypeFqn + " qual=" + qualifier + " injectionName=" + injectionName);
+        List<SpringBean> candidates = registry.getBeans().stream()
+                .filter(bean -> requiredTypeFqn.equals(bean.getTypeFqn()) || bean.getAssignableTypes().contains(requiredTypeFqn))
+                .collect(Collectors.toList());
+
+        System.out.println("CANDIDATES AFTER TYPE: " + candidates.stream().map(c -> c.getTypeFqn() + " (primary=" + c.isPrimary() + " names=" + c.getBeanNames() + " qual=" + c.getQualifiers() + ")").collect(Collectors.toList()));
+        if (candidates.isEmpty() || candidates.size() == 1) {
+            System.out.println("RETURNING: " + candidates.size());
+        return candidates;
+        }
+
+        // 2. Filter by Qualifier (if provided)
+        if (qualifier != null && !qualifier.isEmpty()) {
+            List<SpringBean> qualifiedCandidates = candidates.stream()
+                    .filter(bean -> bean.getQualifiers().contains(qualifier) || bean.getBeanNames().contains(qualifier))
+                    .collect(Collectors.toList());
+            if (qualifiedCandidates.size() == 1) {
+                return qualifiedCandidates;
+            } else if (!qualifiedCandidates.isEmpty()) {
+                candidates = qualifiedCandidates;
+            }
+        }
+
+        // 3. Filter by @Primary
+        List<SpringBean> primaryCandidates = candidates.stream()
+                .filter(SpringBean::isPrimary)
+                .collect(Collectors.toList());
+        if (primaryCandidates.size() == 1) {
+            return primaryCandidates;
+        }
+
+        // 4. Fallback to Injection Name (field name or parameter name)
+        if (injectionName != null && !injectionName.isEmpty()) {
+            List<SpringBean> namedCandidates = candidates.stream()
+                    .filter(bean -> bean.getBeanNames().contains(injectionName))
+                    .collect(Collectors.toList());
+            if (namedCandidates.size() == 1) {
+                return namedCandidates;
+            }
+        }
+
+        // 5. Fallback to @Order (lowest order wins)
+        Integer minOrder = candidates.stream()
+                .map(SpringBean::getOrder)
+                .filter(o -> o != null)
+                .min(Integer::compareTo)
+                .orElse(null);
+
+        if (minOrder != null) {
+            List<SpringBean> orderedCandidates = candidates.stream()
+                    .filter(bean -> bean.getOrder() != null && bean.getOrder().equals(minOrder))
+                    .collect(Collectors.toList());
+            if (!orderedCandidates.isEmpty()) {
+                candidates = orderedCandidates;
+            }
+        }
+
+        // Return whatever candidates remain (could be ambiguous)
+        System.out.println("RETURNING: " + candidates.size());
+        return candidates;
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/ast/app/AstTransitionParser.java

@@ -292,6 +292,15 @@ public class AstTransitionParser {
                 // Try same file
                 ASTNode declNode = cu.findDeclaringNode(binding.getKey());
                 if (declNode instanceof MethodDeclaration md) {
+                    if (md.getBody() != null && md.getBody().statements().size() == 1) {
+                        Object stmt = md.getBody().statements().get(0);
+                        if (stmt instanceof org.eclipse.jdt.core.dom.ReturnStatement rs) {
+                            Expression retExpr = rs.getExpression();
+                            if (isLambdaOrAnonymous(retExpr)) {
+                                return retExpr.toString();
+                            }
+                        }
+                    }
                     return md.toString();
                 }
 

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/ast/common/AstUtils.java

@@ -36,4 +36,62 @@ public final class AstUtils {
             return type.toString(); // fallback
         }
     }
+
+    public static boolean isFunctionalCollectionMethod(org.eclipse.jdt.core.dom.MethodInvocation node) {
+        if (node.getExpression() == null) {
+            return false;
+        }
+
+        org.eclipse.jdt.core.dom.ITypeBinding typeBinding = node.getExpression().resolveTypeBinding();
+        if (typeBinding != null) {
+            if (isCollectionOrStreamType(typeBinding)) {
+                return true;
+            }
+            return false;
+        }
+        
+        String methodName = node.getName().getIdentifier();
+        if (methodName.equals("forEach") || methodName.equals("map") || 
+            methodName.equals("filter") || methodName.equals("flatMap") || 
+            methodName.equals("anyMatch") || methodName.equals("allMatch") || 
+            methodName.equals("noneMatch") || methodName.equals("reduce") ||
+            methodName.equals("collect") || methodName.equals("removeIf") ||
+            methodName.equals("ifPresent") || methodName.equals("ifPresentOrElse") ||
+            methodName.equals("compute") || methodName.equals("computeIfAbsent") ||
+            methodName.equals("computeIfPresent") || methodName.equals("replaceAll") ||
+            methodName.equals("merge") || methodName.equals("peek") ||
+            methodName.equals("doOnNext") || methodName.equals("doOnSuccess") ||
+            methodName.equals("doOnError") || methodName.equals("concatMap") ||
+            methodName.equals("switchMap")) {
+            return true;
+        }
+        
+        return false; 
+    }
+
+    private static boolean isCollectionOrStreamType(org.eclipse.jdt.core.dom.ITypeBinding typeBinding) {
+        String fqn = typeBinding.getErasure().getQualifiedName();
+        if (fqn.startsWith("java.util.stream.") || 
+            fqn.equals("java.lang.Iterable") || 
+            fqn.equals("java.util.Collection") || 
+            fqn.equals("java.util.List") || 
+            fqn.equals("java.util.Set") || 
+            fqn.equals("java.util.Map") || 
+            fqn.equals("java.util.Iterator") || 
+            fqn.equals("java.util.Optional") ||
+            fqn.equals("reactor.core.publisher.Flux") ||
+            fqn.equals("reactor.core.publisher.Mono")) {
+            return true;
+        }
+        
+        for (org.eclipse.jdt.core.dom.ITypeBinding intf : typeBinding.getInterfaces()) {
+            if (isCollectionOrStreamType(intf)) return true;
+        }
+        
+        if (typeBinding.getSuperclass() != null) {
+            return isCollectionOrStreamType(typeBinding.getSuperclass());
+        }
+        
+        return false;
+    }
 }

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/ast/common/CodebaseContext.java

@@ -65,7 +65,7 @@ public class CodebaseContext {
         return Collections.unmodifiableList(libraryHints);
     }
 
-    private final Set<String> ignorePatterns = new HashSet<>(Set.of("**/test/**", "**/build/**", "**/node_modules/**", "**/out/**"));
+    private final Set<String> ignorePatterns = new HashSet<>(Set.of("**/test/**", "**/build/classes/**", "**/build/libs/**", "**/build/tmp/**", "**/build/reports/**", "**/build/test-results/**", "**/node_modules/**", "**/out/**"));
     private String[] classpath = new String[0];
     private String[] sourcepath = new String[0];
     private boolean resolveBindings = false;
@@ -191,6 +191,8 @@ public class CodebaseContext {
                     indexType(td, packageName, javaFile);
                 } else if (type instanceof EnumDeclaration ed) {
                     indexEnum(ed, packageName, javaFile);
+                } else if (type instanceof org.eclipse.jdt.core.dom.RecordDeclaration rd) {
+                    indexRecord(rd, packageName, javaFile);
                 }
             }
         }
@@ -235,9 +237,37 @@ public class CodebaseContext {
         }
     }
 
+    private void indexRecord(org.eclipse.jdt.core.dom.RecordDeclaration rd, String parentFqn, Path javaFile) {
+        String simpleName = rd.getName().getIdentifier();
+        String fqn = parentFqn.isEmpty() ? simpleName : parentFqn + "." + simpleName;
+        
+        // Treat as a class since it is a type
+        classes.put(fqn, (CompilationUnit) rd.getRoot());
+        classPaths.put(fqn, javaFile);
+
+        if (simpleNameToFqn.containsKey(simpleName)) {
+            String existingFqn = simpleNameToFqn.get(simpleName);
+            if (!existingFqn.equals(fqn)) {
+                ambiguousSimpleNames.add(simpleName);
+            }
+        } else {
+            simpleNameToFqn.put(simpleName, fqn);
+        }
+
+        // Recursively index nested types
+        for (Object type : rd.bodyDeclarations()) {
+            if (type instanceof TypeDeclaration nestedTd) {
+                indexType(nestedTd, fqn, javaFile);
+            } else if (type instanceof org.eclipse.jdt.core.dom.RecordDeclaration nestedRd) {
+                indexRecord(nestedRd, fqn, javaFile);
+            }
+        }
+    }
+
     public List<String> getImplementations(String interfaceName) {
         Set<String> allImpls = new HashSet<>();
         collectImplementations(interfaceName, allImpls, new HashSet<>());
+        System.out.println("GET IMPLEMENTATIONS FOR: " + interfaceName + " -> " + allImpls);
         return new ArrayList<>(allImpls);
     }
 
@@ -542,15 +572,103 @@ public class CodebaseContext {
         return null;
     }
 
-    public String getFqn(TypeDeclaration td) {
-        StringBuilder sb = new StringBuilder(td.getName().getIdentifier());
-        ASTNode current = td.getParent();
-        while (current instanceof TypeDeclaration parent) {
+    public AbstractTypeDeclaration getAbstractTypeDeclaration(String name) {
+        // Try exact FQN match first
+        CompilationUnit cu = classes.get(name);
+        if (cu != null)
+            return findAbstractTypeInCu(cu, name);
+
+        // If it's a simple name, check if it's ambiguous
+        if (ambiguousSimpleNames.contains(name)) {
+            return null;
+        }
+
+        // If not ambiguous, return the one we found during scan
+        String fqn = simpleNameToFqn.get(name);
+        if (fqn != null) {
+            cu = classes.get(fqn);
+            if (cu != null)
+                return findAbstractTypeInCu(cu, fqn);
+        }
+
+        return null;
+    }
+
+    public AbstractTypeDeclaration getAbstractTypeDeclaration(String name, CompilationUnit contextCu) {
+        if (name == null || name.isEmpty())
+            return null;
+
+        // 1. Check if it's already an FQN
+        if (classes.containsKey(name))
+            return getAbstractTypeDeclaration(name);
+
+        // 2. Check imports in contextCu
+        if (contextCu != null) {
+            for (Object impObj : contextCu.imports()) {
+                ImportDeclaration imp = (ImportDeclaration) impObj;
+                String impName = imp.getName().getFullyQualifiedName();
+                if (!imp.isStatic() && !imp.isOnDemand()) {
+                    if (impName.endsWith("." + name))
+                        return getAbstractTypeDeclaration(impName);
+                }
+            }
+
+            // 3. Check same package
+            String packageName = contextCu.getPackage() != null ? contextCu.getPackage().getName().getFullyQualifiedName() : "";
+            String localFqn = packageName.isEmpty() ? name : packageName + "." + name;
+            if (classes.containsKey(localFqn))
+                return getAbstractTypeDeclaration(localFqn);
+
+            // 4. Check on-demand imports (star imports)
+            for (Object impObj : contextCu.imports()) {
+                ImportDeclaration imp = (ImportDeclaration) impObj;
+                if (imp.isOnDemand()) {
+                    String starFqn = imp.getName().getFullyQualifiedName() + "." + name;
+                    if (classes.containsKey(starFqn))
+                        return getAbstractTypeDeclaration(starFqn);
+                }
+            }
+
+            // 5. Fallback to java.lang (common)
+            String langFqn = "java.lang." + name;
+            if (classes.containsKey(langFqn))
+                return getAbstractTypeDeclaration(langFqn);
+        }
+
+        // 6. Last resort: global simple name match
+        return getAbstractTypeDeclaration(name);
+    }
+
+    private AbstractTypeDeclaration findAbstractTypeInCu(CompilationUnit cu, String fqn) {
+        for (Object type : cu.types()) {
+            if (type instanceof AbstractTypeDeclaration atd) {
+                AbstractTypeDeclaration found = findNestedAbstractType(atd, fqn);
+                if (found != null) return found;
+            }
+        }
+        return null;
+    }
+
+    private AbstractTypeDeclaration findNestedAbstractType(AbstractTypeDeclaration atd, String targetFqn) {
+        if (getFqn(atd).equals(targetFqn)) return atd;
+        if (atd instanceof TypeDeclaration td) {
+            for (TypeDeclaration nested : td.getTypes()) {
+                AbstractTypeDeclaration found = findNestedAbstractType(nested, targetFqn);
+                if (found != null) return found;
+            }
+        }
+        return null;
+    }
+
+    public String getFqn(AbstractTypeDeclaration atd) {
+        StringBuilder sb = new StringBuilder(atd.getName().getIdentifier());
+        ASTNode current = atd.getParent();
+        while (current instanceof AbstractTypeDeclaration parent) {
             sb.insert(0, parent.getName().getIdentifier() + ".");
             current = parent.getParent();
         }
 
-        CompilationUnit cu = (CompilationUnit) td.getRoot();
+        CompilationUnit cu = (CompilationUnit) atd.getRoot();
         String packageName = cu.getPackage() != null ? cu.getPackage().getName().getFullyQualifiedName() : "";
         String fqn = sb.toString();
         return packageName.isEmpty() ? fqn : packageName + "." + fqn;

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/service/ExportService.java

@@ -45,6 +45,7 @@ public class ExportService {
                 new EntryPointEnricher(),
                 new PropertyEnricher(),
                 new CallChainEnricher(),
+                new click.kamil.springstatemachineexporter.analysis.enricher.path.ForwardPathEstimationEnricher(),
                 new click.kamil.springstatemachineexporter.analysis.enricher.TransitionLinkerEnricher()
         )));
     }

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/RegressionTest.java

@@ -143,6 +143,12 @@ public class RegressionTest {
                         root.resolve("state_machines/complex_multi_module_sm"),
                         Path.of("src/test/resources/golden/StateMachineConfig"),
                         "StateMachineConfig"
+                ),
+                new TestScenario(
+                        "Polymorphic Events Sample",
+                        root.resolve("state_machines/polymorphic_events_sample"),
+                        Path.of("src/test/resources/golden/PolymorphicStateMachineConfiguration"),
+                        "PolymorphicStateMachineConfiguration"
                 )
         );
     }
@@ -155,7 +161,7 @@ public class RegressionTest {
         if (scenario.inputPath() == null) System.out.println("inputPath is NULL");
         if (tempDir == null) System.out.println("tempDir is NULL");
         
-        exportService.runExporter(scenario.inputPath(), tempDir, List.of("puml", "dot", "scxml", "json"), true, scenario.activeProfiles());
+        exportService.runExporter(scenario.inputPath(), tempDir, List.of("puml", "dot", "scxml", "json"), true, scenario.activeProfiles(), null, null, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, true);
 
         // Find the generated directory (it might be named with FQN)
         List<Path> generatedDirs;

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/enricher/matching/HeuristicEventMatchingEngineTest.java

@@ -0,0 +1,78 @@
+package click.kamil.springstatemachineexporter.analysis.enricher.matching;
+
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.model.Event;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class HeuristicEventMatchingEngineTest {
+
+    private final HeuristicEventMatchingEngine engine = new HeuristicEventMatchingEngine();
+
+    @Test
+    void shouldMatchExactFqn() {
+        Event smEvent = Event.of("PAY", "com.example.OrderEvents.PAY");
+        TriggerPoint triggerPoint = TriggerPoint.builder().event("com.example.OrderEvents.PAY").build();
+
+        assertThat(engine.matches(smEvent, triggerPoint)).isTrue();
+    }
+
+    @Test
+    void shouldMatchEnumQualifierToFqn() {
+        Event smEvent = Event.of("PAY", "com.example.OrderEvents.PAY");
+        TriggerPoint triggerPoint = TriggerPoint.builder().event("OrderEvents.PAY").build();
+
+        assertThat(engine.matches(smEvent, triggerPoint)).isTrue();
+    }
+
+    @Test
+    void shouldPreventCrossEnumContamination() {
+        Event smEvent = Event.of("PAY", "com.example.InvoiceEvents.PAY");
+        TriggerPoint triggerPoint = TriggerPoint.builder().event("OrderEvents.PAY").build();
+
+        assertThat(engine.matches(smEvent, triggerPoint)).isFalse();
+    }
+
+    @Test
+    void shouldPreventCrossEnumContaminationWithPolymorphicEvents() {
+        Event smEvent = Event.of("PAY", "com.example.InvoiceEvents.PAY");
+        TriggerPoint triggerPoint = TriggerPoint.builder().event("getType()").polymorphicEvents(List.of("OrderEvents.PAY")).build();
+
+        assertThat(engine.matches(smEvent, triggerPoint)).isFalse();
+    }
+
+    @Test
+    void shouldMatchPolymorphicEnumQualifierToFqn() {
+        Event smEvent = Event.of("PAY", "com.example.OrderEvents.PAY");
+        TriggerPoint triggerPoint = TriggerPoint.builder().event("getType()").polymorphicEvents(List.of("OrderEvents.PAY")).build();
+
+        assertThat(engine.matches(smEvent, triggerPoint)).isTrue();
+    }
+
+    @Test
+    void shouldMatchRawStringToFqn() {
+        Event smEvent = Event.of("PAY", "com.example.OrderEvents.PAY");
+        TriggerPoint triggerPoint = TriggerPoint.builder().event("PAY").build();
+
+        assertThat(engine.matches(smEvent, triggerPoint)).isTrue();
+    }
+
+    @Test
+    void shouldMatchRawStringToRawString() {
+        Event smEvent = Event.of("PAY", "PAY");
+        TriggerPoint triggerPoint = TriggerPoint.builder().event("PAY").build();
+
+        assertThat(engine.matches(smEvent, triggerPoint)).isTrue();
+    }
+
+    @Test
+    void shouldMatchPolymorphicRawStringToFqn() {
+        Event smEvent = Event.of("PAY", "com.example.OrderEvents.PAY");
+        TriggerPoint triggerPoint = TriggerPoint.builder().event("getType()").polymorphicEvents(List.of("PAY")).build();
+
+        assertThat(engine.matches(smEvent, triggerPoint)).isTrue();
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/resolver/ConstantResolverTest.java

@@ -152,4 +152,334 @@ public class ConstantResolverTest {
         String result = resolver.resolve(returnExpr, context);
         assertThat(result).isEqualTo("${app.path}");
     }
+
+    @Test
+    void testConstructorAssignmentAndFieldAccess(@TempDir Path tempDir) throws IOException {
+        Path dir = tempDir.resolve("com/example");
+        Files.createDirectories(dir);
+        Files.writeString(dir.resolve("EventDto.java"),
+            "package com.example;\n" +
+            "public class EventDto {\n" +
+            "    private String eventType;\n" +
+            "    public EventDto() {\n" +
+            "        this.eventType = \"PAYMENT_SUCCESS\";\n" +
+            "    }\n" +
+            "    public String getEventType() {\n" +
+            "        return this.eventType;\n" +
+            "    }\n" +
+            "}");
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        TypeDeclaration td = context.getTypeDeclaration("com.example.EventDto");
+        MethodDeclaration method = td.getMethods()[1]; // getEventType
+        ReturnStatement rs = (ReturnStatement) method.getBody().statements().get(0);
+        Expression returnExpr = rs.getExpression(); // this.eventType
+
+        ConstantResolver resolver = new ConstantResolver();
+        String result = resolver.resolve(returnExpr, context);
+
+        assertThat(result).isEqualTo("PAYMENT_SUCCESS");
+    }
+
+    @Test
+    void testMethodEvaluationWithNestedBlocksAndVars(@TempDir Path tempDir) throws IOException {
+        Path dir = tempDir.resolve("com/example");
+        Files.createDirectories(dir);
+        Files.writeString(dir.resolve("Logic.java"),
+            "package com.example;\n" +
+            "public class Logic {\n" +
+            "    public String process(String event) {\n" +
+            "        String myVar = event;\n" +
+            "        if (myVar != null) {\n" +
+            "            return myVar;\n" +
+            "        }\n" +
+            "        return \"DEFAULT\";\n" +
+            "    }\n" +
+            "}");
+
+        Files.writeString(dir.resolve("Caller.java"),
+            "package com.example;\n" +
+            "public class Caller {\n" +
+            "    public void call() {\n" +
+            "        Logic logic = new Logic();\n" +
+            "        String result = logic.process(\"MY_EVENT\");\n" +
+            "    }\n" +
+            "}");
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        TypeDeclaration callerTd = context.getTypeDeclaration("com.example.Caller");
+        MethodDeclaration callMethod = callerTd.getMethods()[0]; // call()
+        
+        VariableDeclarationStatement vds = (VariableDeclarationStatement) callMethod.getBody().statements().get(1);
+        VariableDeclarationFragment fragment = (VariableDeclarationFragment) vds.fragments().get(0);
+        MethodInvocation mi = (MethodInvocation) fragment.getInitializer(); // logic.process("MY_EVENT")
+
+        ConstantResolver resolver = new ConstantResolver();
+        String result = resolver.resolve(mi, context);
+
+        assertThat(result).isEqualTo("MY_EVENT");
+    }
+
+    @Test
+    void testMethodShadowingReturnsParameter(@TempDir Path tempDir) throws IOException {
+        Path dir = tempDir.resolve("com/example");
+        Files.createDirectories(dir);
+        Files.writeString(dir.resolve("Logic.java"),
+            "package com.example;\n" +
+            "public class Logic {\n" +
+            "    public String a = \"OLD_FIELD\";\n" +
+            "    public String process(String a) {\n" + // shadowing
+            "        this.a = \"NEW_FIELD\";\n" +
+            "        return a;\n" + // should return the parameter
+            "    }\n" +
+            "}");
+
+        Files.writeString(dir.resolve("Caller.java"),
+            "package com.example;\n" +
+            "public class Caller {\n" +
+            "    public void call() {\n" +
+            "        Logic logic = new Logic();\n" +
+            "        String result = logic.process(\"PARAM_VALUE\");\n" +
+            "    }\n" +
+            "}");
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        TypeDeclaration callerTd = context.getTypeDeclaration("com.example.Caller");
+        MethodDeclaration callMethod = callerTd.getMethods()[0]; // call()
+        
+        VariableDeclarationStatement vds = (VariableDeclarationStatement) callMethod.getBody().statements().get(1);
+        VariableDeclarationFragment fragment = (VariableDeclarationFragment) vds.fragments().get(0);
+        MethodInvocation mi = (MethodInvocation) fragment.getInitializer(); // logic.process(...)
+
+        ConstantResolver resolver = new ConstantResolver();
+        String result = resolver.resolve(mi, context);
+
+        assertThat(result).isEqualTo("PARAM_VALUE");
+    }
+
+    @Test
+    void testMethodShadowingReturnsField(@TempDir Path tempDir) throws IOException {
+        Path dir = tempDir.resolve("com/example");
+        Files.createDirectories(dir);
+        Files.writeString(dir.resolve("Logic.java"),
+            "package com.example;\n" +
+            "public class Logic {\n" +
+            "    public String a = \"OLD_FIELD\";\n" +
+            "    public String process(String a) {\n" + // shadowing
+            "        this.a = \"NEW_FIELD_VALUE\";\n" +
+            "        return this.a;\n" + // should return the field
+            "    }\n" +
+            "}");
+
+        Files.writeString(dir.resolve("Caller.java"),
+            "package com.example;\n" +
+            "public class Caller {\n" +
+            "    public void call() {\n" +
+            "        Logic logic = new Logic();\n" +
+            "        String result = logic.process(\"PARAM_VALUE\");\n" +
+            "    }\n" +
+            "}");
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        TypeDeclaration callerTd = context.getTypeDeclaration("com.example.Caller");
+        MethodDeclaration callMethod = callerTd.getMethods()[0]; // call()
+        
+        VariableDeclarationStatement vds = (VariableDeclarationStatement) callMethod.getBody().statements().get(1);
+        VariableDeclarationFragment fragment = (VariableDeclarationFragment) vds.fragments().get(0);
+        MethodInvocation mi = (MethodInvocation) fragment.getInitializer(); // logic.process(...)
+
+        ConstantResolver resolver = new ConstantResolver();
+        String result = resolver.resolve(mi, context);
+
+        assertThat(result).isEqualTo("NEW_FIELD_VALUE");
+    }
+
+    @Test
+    void testMethodImplicitFieldAssignment(@TempDir Path tempDir) throws IOException {
+        Path dir = tempDir.resolve("com/example");
+        Files.createDirectories(dir);
+        Files.writeString(dir.resolve("Logic.java"),
+            "package com.example;\n" +
+            "public class Logic {\n" +
+            "    public String a = \"OLD_FIELD\";\n" +
+            "    public String process(String p) {\n" +
+            "        a = p;\n" + // implicit field assignment
+            "        return this.a;\n" +
+            "    }\n" +
+            "}");
+
+        Files.writeString(dir.resolve("Caller.java"),
+            "package com.example;\n" +
+            "public class Caller {\n" +
+            "    public void call() {\n" +
+            "        Logic logic = new Logic();\n" +
+            "        String result = logic.process(\"MY_EVENT\");\n" +
+            "    }\n" +
+            "}");
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        TypeDeclaration callerTd = context.getTypeDeclaration("com.example.Caller");
+        MethodDeclaration callMethod = callerTd.getMethods()[0]; // call()
+        
+        VariableDeclarationStatement vds = (VariableDeclarationStatement) callMethod.getBody().statements().get(1);
+        VariableDeclarationFragment fragment = (VariableDeclarationFragment) vds.fragments().get(0);
+        MethodInvocation mi = (MethodInvocation) fragment.getInitializer(); // logic.process(...)
+
+        ConstantResolver resolver = new ConstantResolver();
+        String result = resolver.resolve(mi, context);
+
+        assertThat(result).isEqualTo("MY_EVENT");
+    }
+
+    @Test
+    void testZeroArgMethodEvaluation(@TempDir Path tempDir) throws IOException {
+        Path dir = tempDir.resolve("com/example");
+        Files.createDirectories(dir);
+        Files.writeString(dir.resolve("Logic.java"),
+            "package com.example;\n" +
+            "public class Logic {\n" +
+            "    public String a = \"MY_CONSTANT\";\n" +
+            "    public String getEvent() {\n" +
+            "        return this.a;\n" +
+            "    }\n" +
+            "}");
+
+        Files.writeString(dir.resolve("Caller.java"),
+            "package com.example;\n" +
+            "public class Caller {\n" +
+            "    public void call() {\n" +
+            "        Logic logic = new Logic();\n" +
+            "        String result = logic.getEvent();\n" +
+            "    }\n" +
+            "}");
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        TypeDeclaration callerTd = context.getTypeDeclaration("com.example.Caller");
+        MethodDeclaration callMethod = callerTd.getMethods()[0]; // call()
+        
+        VariableDeclarationStatement vds = (VariableDeclarationStatement) callMethod.getBody().statements().get(1);
+        VariableDeclarationFragment fragment = (VariableDeclarationFragment) vds.fragments().get(0);
+        MethodInvocation mi = (MethodInvocation) fragment.getInitializer(); // logic.getEvent()
+
+        ConstantResolver resolver = new ConstantResolver();
+        String result = resolver.resolve(mi, context);
+
+        assertThat(result).isEqualTo("MY_CONSTANT");
+    }
+
+    /**
+     * When a switch method is called with a <em>known</em> constant argument, {@code evaluateMethodOutput}
+     * should evaluate the switch and return only the matching branch.
+     *
+     * <p>Regression guard: before the {@code SwitchStatement.visit} fix, the ASTVisitor would also descend
+     * into child {@code ReturnStatement} nodes after the switch was already handled, potentially overwriting
+     * a correct result with a wrong one.
+     */
+    @Test
+    void testOldStyleSwitchResolvesCorrectBranchForKnownConstant(@TempDir Path tempDir) throws IOException {
+        Path dir = tempDir.resolve("com/example");
+        Files.createDirectories(dir);
+        Files.writeString(dir.resolve("Classifier.java"),
+            "package com.example;\n" +
+            "public class Classifier {\n" +
+            "    public OrderEvents classify(String q) {\n" +
+            "        switch (q) {\n" +
+            "            case \"a\": return OrderEvents.A8;\n" +
+            "            case \"b\": return OrderEvents.B2;\n" +
+            "            default:  return OrderEvents.DEF;\n" +
+            "        }\n" +
+            "    }\n" +
+            "}\n" +
+            "enum OrderEvents { A8, B2, DEF }");
+        Files.writeString(dir.resolve("Caller.java"),
+            "package com.example;\n" +
+            "public class Caller {\n" +
+            "    public void call() {\n" +
+            "        Classifier c = new Classifier();\n" +
+            "        OrderEvents r = c.classify(\"a\");\n" + // known constant → should match case "a"
+            "    }\n" +
+            "}");
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        TypeDeclaration callerTd = context.getTypeDeclaration("com.example.Caller");
+        MethodDeclaration callMethod = callerTd.getMethods()[0];
+        VariableDeclarationStatement vds = (VariableDeclarationStatement) callMethod.getBody().statements().get(1);
+        VariableDeclarationFragment fragment = (VariableDeclarationFragment) vds.fragments().get(0);
+        MethodInvocation mi = (MethodInvocation) fragment.getInitializer(); // c.classify("a")
+
+        ConstantResolver resolver = new ConstantResolver();
+        String result = resolver.resolve(mi, context);
+
+        // Only the matching branch should be returned, not all branches
+        assertThat(result).isEqualTo("OrderEvents.A8");
+    }
+
+    /**
+     * When a switch method is called with a <em>runtime</em> variable that cannot be statically resolved,
+     * {@code evaluateMethodOutput} must return {@code null} so the resolver falls back to the return-type
+     * enum set (covering all branches).
+     *
+     * <p>Regression: before the fix, {@code SwitchStatement.visit} returned {@code super.visit(ss)} (true),
+     * causing child {@code ReturnStatement} nodes inside the switch to fire. The first return — e.g.
+     * {@code return OrderEvents.A8} — was captured as if it were the only possible result, silently
+     * dropping the other branches. After the fix the visitor returns {@code false}, preventing child
+     * traversal, so the resolver correctly falls back to the full ENUM_SET.
+     */
+    @Test
+    void testOldStyleSwitchWithUnknownVariableReturnsFallbackEnumSet(@TempDir Path tempDir) throws IOException {
+        Path dir = tempDir.resolve("com/example");
+        Files.createDirectories(dir);
+        Files.writeString(dir.resolve("Classifier.java"),
+            "package com.example;\n" +
+            "public class Classifier {\n" +
+            "    public OrderEvents classify(String q) {\n" +
+            "        switch (q) {\n" +
+            "            case \"a\": return OrderEvents.A8;\n" +
+            "            case \"b\": return OrderEvents.B2;\n" +
+            "            default:  return OrderEvents.DEF;\n" +
+            "        }\n" +
+            "    }\n" +
+            "}\n" +
+            "enum OrderEvents { A8, B2, DEF }");
+        Files.writeString(dir.resolve("Caller.java"),
+            "package com.example;\n" +
+            "public class Caller {\n" +
+            "    public void call(String x) {\n" + // x is a runtime parameter — not a constant
+            "        Classifier c = new Classifier();\n" +
+            "        OrderEvents r = c.classify(x);\n" +
+            "    }\n" +
+            "}");
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        TypeDeclaration callerTd = context.getTypeDeclaration("com.example.Caller");
+        MethodDeclaration callMethod = callerTd.getMethods()[0];
+        VariableDeclarationStatement vds = (VariableDeclarationStatement) callMethod.getBody().statements().get(1);
+        VariableDeclarationFragment fragment = (VariableDeclarationFragment) vds.fragments().get(0);
+        MethodInvocation mi = (MethodInvocation) fragment.getInitializer(); // c.classify(x)
+
+        ConstantResolver resolver = new ConstantResolver();
+        String result = resolver.resolve(mi, context);
+
+        // Must cover ALL branches via ENUM_SET — not just the first one ("A8")
+        assertThat(result).startsWith("ENUM_SET:");
+        assertThat(result).contains("OrderEvents.A8");
+        assertThat(result).contains("OrderEvents.B2");
+        assertThat(result).contains("OrderEvents.DEF");
+    }
 }

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/AnonymousClassTests.java

@@ -0,0 +1,61 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AnonymousClassTests {
+
+    @TempDir
+    Path tempDir;
+
+    @Test
+    void shouldResolveEventFromAnonymousClass() throws Exception {
+        String source = """
+            package com.example;
+            public class AnonymousService {
+                private EventService service;
+                
+                public void process() {
+                    MyEvent event = new MyEvent() {
+                        @Override
+                        public String getEvent() {
+                            return "ANON_EVENT";
+                        }
+                    };
+                    service.trigger(event.getEvent());
+                }
+            }
+            class EventService {
+                public void trigger(String ev) {}
+            }
+            class MyEvent {
+                public String getEvent() { return "BASE_EVENT"; }
+            }
+            """;
+            
+        Files.writeString(tempDir.resolve("AnonymousService.java"), source);
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine engine = new HeuristicCallGraphEngine(context);
+        
+        TriggerPoint trigger = TriggerPoint.builder()
+            .className("com.example.EventService")
+            .methodName("trigger")
+            .sourceFile("AnonymousService.java")
+            .sourceModule("com.example")
+            .event("event.getEvent()")
+            .lineNumber(12)
+            .build();
+            
+        TriggerPoint result = engine.resolveTriggerPointParameters(trigger, List.of("com.example.AnonymousService.process", "com.example.EventService.trigger"), java.util.Collections.emptyMap());
+        
+        assertThat(result.getPolymorphicEvents()).contains("ANON_EVENT");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/BuilderLocalVariableTest.java

@@ -0,0 +1,69 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class BuilderLocalVariableTest {
+
+    @Test
+    void shouldTraceLocalVariableInBuilderPattern(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent() {
+                        OrderEvents e = OrderEvents.PAY;
+                        RichOrderEvent event = new RichOrderEvent();
+                        event.setType(e);
+                        service.updateOrderState(event.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class RichOrderEvent {
+                    private OrderEvents type;
+                    public void setType(OrderEvents type) { this.type = type; }
+                    public OrderEvents getType() { return type; }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        System.out.println("POLY EVENTS FOUND: " + chain.getTriggerPoint().getPolymorphicEvents());
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .containsExactlyInAnyOrder("OrderEvents.PAY");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/CollectionIndexingTests.java

@@ -0,0 +1,54 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class CollectionIndexingTests {
+
+    @TempDir
+    Path tempDir;
+
+    @Test
+    void shouldResolveEventFromArrayAccess() throws Exception {
+        String source = """
+            package com.example;
+            public class ArrayService {
+                private EventService service;
+                
+                public void process() {
+                    String[] events = new String[] {"EVENT_1", "EVENT_2"};
+                    service.trigger(events[0]);
+                }
+            }
+            class EventService {
+                public void trigger(String ev) {}
+            }
+            """;
+            
+        Files.writeString(tempDir.resolve("ArrayService.java"), source);
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine engine = new HeuristicCallGraphEngine(context);
+        
+        TriggerPoint trigger = TriggerPoint.builder()
+            .className("com.example.EventService")
+            .methodName("trigger")
+            .sourceFile("ArrayService.java")
+            .sourceModule("com.example")
+            .event("events[0]")
+            .lineNumber(7)
+            .build();
+            
+        TriggerPoint result = engine.resolveTriggerPointParameters(trigger, List.of("com.example.ArrayService.process", "com.example.EventService.trigger"), java.util.Collections.emptyMap());
+        
+        // When using array indexing, we should ideally extract the indexed element or at least all elements in the array
+        assertThat(result.getPolymorphicEvents()).contains("EVENT_1");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/ConstructorInvocationTest.java

@@ -0,0 +1,412 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ConstructorInvocationTest {
+
+    @Test
+    void shouldNotBlindlyAddAllConstructorArguments(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(RichOrderEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class RichOrderEvent {
+                    private OrderEvents type;
+                    private String irrelevantInfo;
+                    
+                    public RichOrderEvent() {
+                        this(OrderEvents.PAY, "DEFAULT_INFO");
+                    }
+                    
+                    public RichOrderEvent(OrderEvents type, String info) {
+                        this.type = type;
+                        this.irrelevantInfo = info;
+                    }
+                    
+                    public OrderEvents getType() { return type; }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .contains("OrderEvents.PAY")
+            .doesNotContain("DEFAULT_INFO");
+    }
+
+
+    @Test
+    void shouldHandleOverloadedConstructorsGracefully(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(RichOrderEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class RichOrderEvent {
+                    private OrderEvents type;
+                    private String irrelevantInfo;
+                    private int count;
+                    
+                    public RichOrderEvent() {
+                        this(OrderEvents.PAY, "DEFAULT_INFO");
+                    }
+                    
+                    // Overloaded constructor 1
+                    public RichOrderEvent(OrderEvents type, String info) {
+                        this.type = type;
+                        this.irrelevantInfo = info;
+                    }
+                    
+                    // Overloaded constructor 2 (same number of arguments!)
+                    public RichOrderEvent(String info, int count) {
+                        this.irrelevantInfo = info;
+                        this.count = count;
+                        // type is not set here
+                    }
+                    
+                    public OrderEvents getType() { return type; }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .contains("OrderEvents.PAY")
+            .doesNotContain("DEFAULT_INFO")
+            .doesNotContain("count");
+    }
+
+
+    @Test
+    void shouldHandleChainedConstructorDelegationGracefully(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(RichOrderEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class BaseEvent {
+                    protected OrderEvents type;
+                    public BaseEvent(OrderEvents type) {
+                        this.type = type;
+                    }
+                }
+                
+                class RichOrderEvent extends BaseEvent {
+                    public RichOrderEvent() {
+                        this(OrderEvents.PAY);
+                    }
+                    
+                    public RichOrderEvent(OrderEvents type) {
+                        this(type, "DEFAULT_INFO");
+                    }
+                    
+                    public RichOrderEvent(OrderEvents type, String info) {
+                        super(type);
+                    }
+                    
+                    public OrderEvents getType() { return type; }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .contains("OrderEvents.PAY")
+            .doesNotContain("DEFAULT_INFO");
+    }
+
+    @Test
+    void shouldHandleFieldAccessGracefully(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(RichOrderEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class RichOrderEvent {
+                    private OrderEvents type;
+                    
+                    public RichOrderEvent() {
+                        this(OrderEvents.PAY);
+                    }
+                    
+                    public RichOrderEvent(OrderEvents type) {
+                        this.type = type;
+                    }
+                    
+                    public OrderEvents getType() { 
+                        return this.type; // Specifically testing FieldAccess
+                    }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .contains("OrderEvents.PAY");
+    }
+    @Test
+    void shouldTraceThroughWrappedConstructorArguments(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                import java.util.Objects;
+                
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(RichOrderEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class RichOrderEvent {
+                    private OrderEvents type;
+                    
+                    public RichOrderEvent() {
+                        this(Objects.requireNonNull(OrderEvents.PAY));
+                    }
+                    
+                    public RichOrderEvent(OrderEvents type) {
+                        this((OrderEvents) type, "DEFAULT_INFO");
+                    }
+                    
+                    public RichOrderEvent(OrderEvents type, String info) {
+                        this.type = Objects.requireNonNull(type);
+                    }
+                    
+                    public OrderEvents getType() { return type; }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .contains("OrderEvents.PAY");
+    }
+
+    @Test
+    void shouldTraceThroughComplexOverloadedConstructors(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(EnterpriseEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class EnterpriseEvent {
+                    private OrderEvents type;
+                    private String info;
+                    
+                    public EnterpriseEvent() {
+                        this(OrderEvents.PAY);
+                    }
+                    
+                    // Matches by parameter count but wrong type!
+                    public EnterpriseEvent(String info) {
+                        this.info = info;
+                    }
+                    
+                    public EnterpriseEvent(OrderEvents type) {
+                        this("info", type);
+                    }
+                    
+                    // Target of previous constructor
+                    public EnterpriseEvent(String info, OrderEvents type) {
+                        this(type, info, null);
+                    }
+                    
+                    // Final destination
+                    public EnterpriseEvent(OrderEvents type, String info, Object extra) {
+                        this.type = type;
+                        this.info = info;
+                    }
+                    
+                    public OrderEvents getType() { return type; }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .contains("OrderEvents.PAY");
+    }
+}
+

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/ConstructorLocalVariableTest.java

@@ -0,0 +1,72 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ConstructorLocalVariableTest {
+
+    @Test
+    void shouldTraceLocalVariableInConstructor(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(RichOrderEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class RichOrderEvent {
+                    private OrderEvents type;
+                    
+                    public RichOrderEvent() {
+                        OrderEvents e = OrderEvents.PAY;
+                        this.type = e;
+                    }
+                    
+                    public OrderEvents getType() { 
+                        return type; 
+                    }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .containsExactlyInAnyOrder("OrderEvents.PAY");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/GenericEventDetectorTest.java

@@ -89,7 +89,8 @@ public class GenericEventDetectorTest {
             "import org.springframework.statemachine.StateMachine;\n" +
             "public class MyService {\n" +
             "    private StateMachine<String, String> stateMachine;\n" +
-            "    public MyEnum getEvent() { return MyEnum.STATE_A; }\n" + // Pretend it returns the enum
+            "    public MyEnum getEvent() { return someExternalCall(); }\n" +
+            "    public MyEnum someExternalCall() { return null; }\n" +
             "    public void trigger() {\n" +
             "        stateMachine.sendEvent(this.getEvent());\n" +
             "    }\n" +

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/HeuristicCallGraphEngineExtendedTest.java

@@ -0,0 +1,315 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@Tag("heuristic_guess_paths_and_scrape_regex_replace_with_data_flow_analysis")
+class HeuristicCallGraphEngineExtendedTest {
+    /**
+     * Diagnostic: Generics, inherited processing, multi-enum constructor args,
+     * and internal constructor mapping via a switch method.
+     * <p>
+     * Pattern:
+     * 1. Abstract base class AbstractEventClass<T> holds the payload and transitionType.
+     * 2. Abstract base class also contains the method that actually fires the state machine.
+     * 3. MyEventClass<T> constructor takes multiple enums (InputEnum1, InputEnum2).
+     * 4. MyEventClass assigns: this.transitionType = computeTransitionType(InputEnum2).
+     * 5. computeTransitionType uses a switch to map InputEnum2 to TransitionEnum.
+     * <p>
+     * Root cause targeted: The engine must not eagerly grab InputEnum1.IGNORE or
+     * InputEnum2.SOURCE_B. It must evaluate the internal computeTransitionType()
+     * method during instantiation to resolve the final TransitionEnum.STATE_Y.
+     */
+    @Test
+    void shouldResolveTransitionEnumThroughGenericsAndInternalConstructorSwitchComputation() throws IOException {
+        String source = """
+                package com.example;
+                
+                public class SystemController {
+                    private StateMachine machine;
+                
+                    public void processIncomingPayload(String rawData) {
+                        // Creates concrete class with multiple enums and a generic payload.
+                        // Engine MUST NOT stop at IGNORE or SOURCE_B.
+                        MyEventClass<String> event = new MyEventClass<>(
+                            rawData, 
+                            InputEnum1.IGNORE, 
+                            InputEnum2.SOURCE_B
+                        );
+                
+                        // Calls the inherited method that actually processes the event
+                        event.fireEvent(machine);
+                    }
+                }
+                
+                abstract class AbstractEventClass<T> {
+                    protected T payload;
+                    protected TransitionEnum transitionType;
+                
+                    public AbstractEventClass(T payload) {
+                        this.payload = payload;
+                    }
+                
+                    // The method to actually process events
+                    public void fireEvent(StateMachine machine) {
+                        machine.fire(this.getTransitionType());
+                    }
+                
+                    public TransitionEnum getTransitionType() {
+                        return this.transitionType;
+                    }
+                }
+                
+                class MyEventClass<T> extends AbstractEventClass<T> {
+                    private InputEnum1 routingFlag;
+                
+                    public MyEventClass(T payload, InputEnum1 flag, InputEnum2 source) {
+                        super(payload);
+                        this.routingFlag = flag;
+                
+                        // The trap: Assignment via an internal method evaluation
+                        this.transitionType = computeTransitionType(source);
+                    }
+                
+                    private TransitionEnum computeTransitionType(InputEnum2 source) {
+                        return switch (source) {
+                            case SOURCE_A -> TransitionEnum.STATE_X;
+                            case SOURCE_B -> TransitionEnum.STATE_Y; // Expected resolution
+                            case SOURCE_C -> TransitionEnum.STATE_Z;
+                        };
+                    }
+                }
+                
+                class StateMachine {
+                    public void fire(TransitionEnum event) {}
+                }
+                
+                enum InputEnum1 { IGNORE, PROCESS_ASYNC }
+                enum InputEnum2 { SOURCE_A, SOURCE_B, SOURCE_C }
+                enum TransitionEnum { STATE_X, STATE_Y, STATE_Z }
+                """;
+
+        java.nio.file.Path tempDir = java.nio.file.Files.createTempDirectory("callgraph_test_generics_computation");
+        java.nio.file.Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine engine = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.SystemController")
+                .methodName("processIncomingPayload")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.StateMachine")
+                .methodName("fire")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+
+        System.out.println("GENERICS & COMPUTATION polymorphicEvents: " +
+                chains.get(0).getTriggerPoint().getPolymorphicEvents());
+
+        // The assertion to prove the bug is fixed.
+        // If the engine returns InputEnum2.SOURCE_B or InputEnum1.IGNORE, it fails.
+        // It MUST evaluate computeTransitionType() and return TransitionEnum.STATE_Y.
+        assertThat(chains.get(0).getTriggerPoint().getPolymorphicEvents())
+                .containsExactlyInAnyOrder("TransitionEnum.STATE_Y");
+    }
+    /**
+     * Diagnostic: Enum tracked through an overridden method and a super() call.
+     *
+     * Pattern:
+     * 1. EntryPoint calls an overridden method on a subclass (CustomHandler.handleEvent)
+     * with an initial enum (ActionType.BEGIN_CHECKOUT).
+     * 2. The subclass intercepts the call, does some localized logic, and delegates
+     * back to the parent using super.handleEvent(ActionType).
+     * 3. The parent class (BaseHandler) takes that enum, transforms it via a switch
+     * statement to a TransitionEnum, and fires the state machine.
+     *
+     * Root cause targeted: The engine must successfully resolve the `super` keyword
+     * to the parent class's AST node, maintain the argument mapping across the inheritance
+     * boundary, and evaluate the switch to get the final TransitionEnum. It must not
+     * get stuck in a recursive loop or eagerly return ActionType.BEGIN_CHECKOUT.
+     */
+    @Test
+    void shouldResolveMappedEnumAcrossOverriddenMethodAndSuperDelegation() throws IOException {
+        String source = """
+                package com.example;
+
+                public class ApiEndpoint {
+                    private CustomHandler handler;
+
+                    public void triggerCheckout() {
+                        // Entry point passes the initial enum
+                        handler.handleEvent(ActionType.BEGIN_CHECKOUT);
+                    }
+                }
+
+                abstract class BaseHandler {
+                    protected StateMachine machine;
+
+                    // The method that gets overridden, but ultimately does the work
+                    public void handleEvent(ActionType action) {
+                        TransitionEnum transition = switch (action) {
+                            case BEGIN_CHECKOUT -> TransitionEnum.CHECKOUT_STARTED; // Expected
+                            case ABORT_CHECKOUT -> TransitionEnum.CHECKOUT_CANCELLED;
+                        };
+                        machine.fire(transition);
+                    }
+                }
+
+                class CustomHandler extends BaseHandler {
+                    
+                    @Override
+                    public void handleEvent(ActionType action) {
+                        // Custom logic before delegation (simulated)
+                        if (action == null) return;
+                        
+                        // The trap: The engine must follow 'super' to BaseHandler
+                        // and carry the 'action' argument with it.
+                        super.handleEvent(action);
+                    }
+                }
+
+                class StateMachine {
+                    public void fire(TransitionEnum event) {}
+                }
+
+                enum ActionType { BEGIN_CHECKOUT, ABORT_CHECKOUT }
+                enum TransitionEnum { CHECKOUT_STARTED, CHECKOUT_CANCELLED }
+                """;
+
+        java.nio.file.Path tempDir = java.nio.file.Files.createTempDirectory("callgraph_test_super_override");
+        java.nio.file.Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine engine = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.ApiEndpoint")
+                .methodName("triggerCheckout")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.StateMachine")
+                .methodName("fire")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+
+        System.out.println("SUPER DELEGATION polymorphicEvents: " +
+                chains.get(0).getTriggerPoint().getPolymorphicEvents());
+
+        // The assertion to prove the bug is fixed.
+        // It MUST NOT contain "ActionType.BEGIN_CHECKOUT".
+        // It MUST successfully trace through super.handleEvent() and resolve the switch.
+        assertThat(chains.get(0).getTriggerPoint().getPolymorphicEvents())
+                .containsExactlyInAnyOrder("TransitionEnum.CHECKOUT_STARTED");
+    }
+
+    @Test
+    void shouldResolveCorrectEnumWhenNamesCollide() throws IOException {
+        String source = """
+                package com.example;
+
+                public class OrderService {
+                    private StateMachine machine;
+
+                    public void processOrder() {
+                        // We use OrderEvent.PROCESS
+                        machine.fire(OrderEvent.PROCESS);
+                    }
+                }
+
+                public class InventoryService {
+                    private StateMachine machine;
+
+                    public void updateInventory() {
+                        // We use InternalEvent.PROCESS which has same simple name
+                        machine.fireInternal(InternalEvent.PROCESS);
+                    }
+
+                    public void wrongProcess() {
+                        // This calls fire(OrderEvent) but with InternalEvent.PROCESS
+                        // It should be REJECTED by type-aware heuristic matching if it matches fire(OrderEvent)
+                        machine.fire(InternalEvent.PROCESS);
+                    }
+                }
+
+                class StateMachine {
+                    // Two overloaded methods or methods in different classes (simulated by names)
+                    public void fire(OrderEvent event) {}
+                    public void fireInternal(InternalEvent event) {}
+                }
+
+                enum OrderEvent { PROCESS, CANCEL }
+                enum InternalEvent { PROCESS, AUDIT }
+                """;
+
+        java.nio.file.Path tempDir = java.nio.file.Files.createTempDirectory("callgraph_test_collision");
+        java.nio.file.Files.writeString(tempDir.resolve("CollisionConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine engine = new HeuristicCallGraphEngine(context);
+
+        // Scenario 1: Trace OrderService.processOrder
+        EntryPoint entryPoint1 = EntryPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("processOrder")
+                .build();
+
+        TriggerPoint trigger1 = TriggerPoint.builder()
+                .className("com.example.StateMachine")
+                .methodName("fire")
+                .event("event")
+                .build();
+
+        List<CallChain> chains1 = engine.findChains(List.of(entryPoint1), List.of(trigger1));
+
+        assertThat(chains1).hasSize(1);
+        assertThat(chains1.get(0).getTriggerPoint().getPolymorphicEvents())
+                .containsExactly("OrderEvent.PROCESS")
+                .doesNotContain("InternalEvent.PROCESS");
+
+        // Scenario 2: Trace InventoryService.updateInventory
+        EntryPoint entryPoint2 = EntryPoint.builder()
+                .className("com.example.InventoryService")
+                .methodName("updateInventory")
+                .build();
+
+        TriggerPoint trigger2 = TriggerPoint.builder()
+                .className("com.example.StateMachine")
+                .methodName("fireInternal")
+                .event("event")
+                .build();
+
+        List<CallChain> chains2 = engine.findChains(List.of(entryPoint2), List.of(trigger2));
+
+        assertThat(chains2).hasSize(1);
+        assertThat(chains2.get(0).getTriggerPoint().getPolymorphicEvents())
+                .containsExactly("InternalEvent.PROCESS")
+                .doesNotContain("OrderEvent.PROCESS");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/JdtCallGraphEngineIntegrationTest.java

@@ -0,0 +1,285 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.analysis.spring.InjectionPointAnalyzer;
+import click.kamil.springstatemachineexporter.analysis.spring.SpringBeanRegistry;
+import click.kamil.springstatemachineexporter.analysis.spring.SpringContextScanner;
+import click.kamil.springstatemachineexporter.analysis.spring.SpringDependencyResolver;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import click.kamil.springstatemachineexporter.analysis.service.DynamicClasspathResolver;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class JdtCallGraphEngineIntegrationTest {
+
+    private CodebaseContext context;
+    private SpringBeanRegistry registry;
+    private JdtCallGraphEngine engine;
+
+    @BeforeEach
+    void setUp() throws IOException {
+        Path projectRoot = Path.of("../state_machines/extended_analysis_sample").toAbsolutePath().normalize();
+        
+        context = new CodebaseContext();
+        context.setProjectRoot(projectRoot);
+        context.setSourcepath(List.of(projectRoot.resolve("src/main/java").toString()));
+        
+        DynamicClasspathResolver resolver = new DynamicClasspathResolver();
+        List<String> cp = resolver.resolveClasspath(projectRoot);
+        if (!cp.isEmpty()) {
+            context.setClasspath(cp);
+        }
+        context.setResolveBindings(true);
+        
+        context.scan(Set.of(projectRoot), Collections.emptySet());
+        
+        registry = new SpringBeanRegistry();
+        SpringContextScanner scanner = new SpringContextScanner(registry);
+        
+        for (var cu : context.getCompilationUnits()) {
+            cu.accept(scanner);
+        }
+
+        SpringDependencyResolver dependencyResolver = new SpringDependencyResolver(registry);
+        InjectionPointAnalyzer injectionAnalyzer = new InjectionPointAnalyzer(dependencyResolver);
+        
+        engine = new JdtCallGraphEngine(context, injectionAnalyzer);
+    }
+
+    @Test
+    void shouldResolvePrimaryBeanInjection() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.web.QuirkController")
+                .methodName("testPrimary")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.PrimaryQuirkService")
+                .methodName("doQuirk")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain())
+                .containsExactly(
+                        "click.kamil.examples.statemachine.extended.web.QuirkController.testPrimary",
+                        "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService.doQuirk"
+                );
+    }
+
+    @Test
+    void shouldResolveQualifierBeanInjection() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.web.QuirkController")
+                .methodName("testQualifier")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.QualifierQuirkService")
+                .methodName("doQuirk")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain())
+                .containsExactly(
+                        "click.kamil.examples.statemachine.extended.web.QuirkController.testQualifier",
+                        "click.kamil.examples.statemachine.extended.service.QualifierQuirkService.doQuirk"
+                );
+    }
+
+    @Test
+    void shouldResolveNamedBeanInjection() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.web.QuirkController")
+                .methodName("testNamed")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.NamedQuirkService")
+                .methodName("doQuirk")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain())
+                .containsExactly(
+                        "click.kamil.examples.statemachine.extended.web.QuirkController.testNamed",
+                        "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk"
+                );
+    }
+
+    @Test
+    void shouldResolveFallbackBeanInjection() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.web.QuirkController")
+                .methodName("testFallback")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.PrimaryQuirkService")
+                .methodName("doQuirk")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain())
+                .containsExactly(
+                        "click.kamil.examples.statemachine.extended.web.QuirkController.testFallback",
+                        "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService.doQuirk"
+                );
+    }
+
+    @Test
+    void shouldResolveBeanParameterInjection() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.config.BeanParameterTestConfig")
+                .methodName("myBeanParamTester")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.NamedQuirkService")
+                .methodName("doQuirk")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain())
+                .containsExactly(
+                        "click.kamil.examples.statemachine.extended.config.BeanParameterTestConfig.myBeanParamTester",
+                        "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk"
+                );
+    }
+
+    @Test
+    void shouldResolveOrderedBeanInjection() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.web.OrderedTestController")
+                .methodName("testOrder")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.HighPriorityOrderedService")
+                .methodName("doAction")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain())
+                .containsExactly(
+                        "click.kamil.examples.statemachine.extended.web.OrderedTestController.testOrder",
+                        "click.kamil.examples.statemachine.extended.service.HighPriorityOrderedService.doAction"
+                );
+    }
+
+    @Test
+    void shouldResolveFieldInjection() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.web.FieldInjectionController")
+                .methodName("testField")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.NamedQuirkService")
+                .methodName("doQuirk")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain()).contains(
+                "click.kamil.examples.statemachine.extended.web.FieldInjectionController.testField",
+                "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk"
+        );
+    }
+
+    @Test
+    void shouldResolveSetterInjection() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.web.SetterInjectionController")
+                .methodName("testSetter")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.NamedQuirkService")
+                .methodName("doQuirk")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain()).contains(
+                "click.kamil.examples.statemachine.extended.web.SetterInjectionController.testSetter",
+                "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk"
+        );
+    }
+
+    @Test
+    void shouldResolveAbstractInheritedBean() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.config.AbstractBaseConfig")
+                .methodName("inheritedBeanTester")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.NamedQuirkService")
+                .methodName("doQuirk")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain()).contains(
+                "click.kamil.examples.statemachine.extended.config.AbstractBaseConfig.inheritedBeanTester",
+                "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk"
+        );
+    }
+
+    @Test
+    void shouldResolveAmbiguousListFallback() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.web.ListInjectionController")
+                .methodName("testList")
+                .build();
+        TriggerPoint tp1 = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.AmbiguousA")
+                .methodName("doAmbig")
+                .build();
+        TriggerPoint tp2 = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.AmbiguousB")
+                .methodName("doAmbig")
+                .build();
+
+        List<CallChain> chains1 = engine.findChains(List.of(ep), List.of(tp1));
+        List<CallChain> chains2 = engine.findChains(List.of(ep), List.of(tp2));
+        
+        assertThat(chains1).isNotEmpty();
+        assertThat(chains1.get(0).getMethodChain()).contains(
+                "click.kamil.examples.statemachine.extended.web.ListInjectionController.testList",
+                "click.kamil.examples.statemachine.extended.service.AmbiguousA.doAmbig"
+        );
+        
+        assertThat(chains2).isNotEmpty();
+        assertThat(chains2.get(0).getMethodChain()).contains(
+                "click.kamil.examples.statemachine.extended.web.ListInjectionController.testList",
+                "click.kamil.examples.statemachine.extended.service.AmbiguousB.doAmbig"
+        );
+    }
+
+    @Test
+    void shouldResolveConcreteReturnType() {
+        EntryPoint ep = EntryPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.web.ConcreteReturnTypeController")
+                .methodName("testConcrete")
+                .build();
+        TriggerPoint tp = TriggerPoint.builder()
+                .className("click.kamil.examples.statemachine.extended.service.QualifierQuirkService")
+                .methodName("doQuirk")
+                .build();
+
+        List<CallChain> chains = engine.findChains(List.of(ep), List.of(tp));
+        System.out.println("CHAINS FOUND: " + chains.size()); assertThat(chains).hasSize(1);
+        assertThat(chains.get(0).getMethodChain()).contains(
+                "click.kamil.examples.statemachine.extended.web.ConcreteReturnTypeController.testConcrete",
+                "click.kamil.examples.statemachine.extended.service.QualifierQuirkService.doQuirk"
+        );
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/LocalVariableTest.java

@@ -0,0 +1,122 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LocalVariableTest {
+
+    @Test
+    void shouldTraceLocalVariableInGetter(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(RichOrderEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class RichOrderEvent {
+                    public OrderEvents getType() { 
+                        OrderEvents e = OrderEvents.PAY;
+                        return e; 
+                    }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .contains("OrderEvents.PAY")
+            .doesNotContain("e"); // Should not blindly add the variable name
+    }
+
+    @Test
+    void shouldTraceMultipleAssignments(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(RichOrderEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class RichOrderEvent {
+                    public OrderEvents getType() { 
+                        OrderEvents e = null;
+                        if (System.currentTimeMillis() % 2 == 0) {
+                            e = OrderEvents.PAY;
+                        } else {
+                            e = OrderEvents.CANCEL;
+                        }
+                        return e; 
+                    }
+                }
+                
+                enum OrderEvents { PAY, CANCEL }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .containsExactlyInAnyOrder("OrderEvents.PAY", "OrderEvents.CANCEL");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/ReturnStatementTest.java

@@ -0,0 +1,66 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ReturnStatementTest {
+
+    @Test
+    void shouldHandleAssignmentInReturn(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(RichOrderEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class RichOrderEvent {
+                    private OrderEvents type;
+                    public OrderEvents getType() { 
+                        return this.type = OrderEvents.PAY; 
+                    }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .containsExactlyInAnyOrder("OrderEvents.PAY");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/StreamApiTests.java

@@ -0,0 +1,66 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StreamApiTests {
+
+    @TempDir
+    Path tempDir;
+
+    @Test
+    void shouldHandleStreamApiChains() throws Exception {
+        String source = """
+            package com.example;
+            import java.util.List;
+            
+            public class StreamService {
+                private EventService service;
+                
+                public void process(List<MyEvent> events) {
+                    events.stream()
+                        .filter(e -> e.isValid())
+                        .map(e -> e.toEvent())
+                        .forEach(t -> service.trigger(t.getEvent()));
+                }
+            }
+            class EventService {
+                public void trigger(String ev) {}
+            }
+            class MyEvent {
+                public boolean isValid() { return true; }
+                public OrderEvent toEvent() { return new OrderEvent(); }
+            }
+            class OrderEvent {
+                public String getEvent() { return "STREAM_EVENT"; }
+            }
+            """;
+            
+        Files.writeString(tempDir.resolve("StreamService.java"), source);
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine engine = new HeuristicCallGraphEngine(context);
+        
+        TriggerPoint trigger = TriggerPoint.builder()
+            .className("com.example.EventService")
+            .methodName("trigger")
+            .sourceFile("StreamService.java")
+            .sourceModule("com.example")
+            .event("t.getEvent()")
+            .lineNumber(11)
+            .build();
+            
+        TriggerPoint result = engine.resolveTriggerPointParameters(trigger, List.of("com.example.StreamService.process", "com.example.EventService.trigger"), java.util.Collections.emptyMap());
+        System.out.println("TEST RESULT: " + result);
+        System.out.println("POLY EVENTS: " + result.getPolymorphicEvents());
+        
+        assertThat(result.getPolymorphicEvents()).isNotNull().containsExactlyInAnyOrder("STREAM_EVENT");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/service/SuperMethodInvocationTest.java

@@ -0,0 +1,71 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SuperMethodInvocationTest {
+
+    @Test
+    void shouldHandleSuperMethodInvocation(@TempDir Path tempDir) throws IOException {
+        String source = """
+                package com.example;
+                public class OrderController {
+                    private OrderService service;
+                    public void processOrderEvent(DerivedEvent domainEvent) {
+                        service.updateOrderState(domainEvent.getType());
+                    }
+                }
+                
+                class OrderService {
+                    public void updateOrderState(OrderEvents event) {}
+                }
+                
+                class BaseEvent {
+                    public OrderEvents getType() {
+                        return OrderEvents.PAY;
+                    }
+                }
+                
+                class DerivedEvent extends BaseEvent {
+                    public OrderEvents getType() { 
+                        return super.getType(); 
+                    }
+                }
+                
+                enum OrderEvents { PAY }
+                """;
+        Files.writeString(tempDir.resolve("OrderConfig.java"), source);
+
+        CodebaseContext context = new CodebaseContext();
+        context.scan(tempDir);
+
+        HeuristicCallGraphEngine builder = new HeuristicCallGraphEngine(context);
+
+        EntryPoint entryPoint = EntryPoint.builder()
+                .className("com.example.OrderController")
+                .methodName("processOrderEvent")
+                .build();
+
+        TriggerPoint trigger = TriggerPoint.builder()
+                .className("com.example.OrderService")
+                .methodName("updateOrderState")
+                .event("event")
+                .build();
+
+        List<CallChain> chains = builder.findChains(List.of(entryPoint), List.of(trigger));
+
+        assertThat(chains).hasSize(1);
+        CallChain chain = chains.get(0);
+        assertThat(chain.getTriggerPoint().getPolymorphicEvents())
+            .contains("OrderEvents.PAY");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/spring/SpringContextScannerIntegrationTest.java

@@ -0,0 +1,89 @@
+package click.kamil.springstatemachineexporter.analysis.spring;
+
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import click.kamil.springstatemachineexporter.analysis.service.DynamicClasspathResolver;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SpringContextScannerIntegrationTest {
+
+    private CodebaseContext context;
+    private SpringBeanRegistry registry;
+
+    @BeforeEach
+    void setUp() throws IOException {
+        Path projectRoot = Path.of("../state_machines/extended_analysis_sample").toAbsolutePath().normalize();
+        
+        context = new CodebaseContext();
+        context.setProjectRoot(projectRoot);
+        context.setSourcepath(List.of(projectRoot.resolve("src/main/java").toString()));
+        
+        DynamicClasspathResolver resolver = new DynamicClasspathResolver();
+        List<String> cp = resolver.resolveClasspath(projectRoot);
+        if (!cp.isEmpty()) {
+            context.setClasspath(cp);
+        }
+        context.setResolveBindings(true);
+        
+        context.scan(Set.of(projectRoot), Collections.emptySet());
+        
+        registry = new SpringBeanRegistry();
+        SpringContextScanner scanner = new SpringContextScanner(registry);
+        
+        for (var cu : context.getCompilationUnits()) {
+            cu.accept(scanner);
+        }
+    }
+
+    @Test
+    void shouldFindStereotypeBeans() {
+        List<SpringBean> beans = registry.getBeans();
+        
+        // PrimaryQuirkService
+        assertThat(beans).anySatisfy(bean -> {
+            assertThat(bean.getTypeFqn()).isEqualTo("click.kamil.examples.statemachine.extended.service.PrimaryQuirkService");
+            assertThat(bean.isPrimary()).isTrue();
+            assertThat(bean.getAssignableTypes()).contains("click.kamil.examples.statemachine.extended.service.QuirkService");
+            assertThat(bean.getBeanNames()).contains("primaryQuirkService");
+        });
+        
+        // QualifierQuirkService
+        assertThat(beans).anySatisfy(bean -> {
+            assertThat(bean.getTypeFqn()).isEqualTo("click.kamil.examples.statemachine.extended.service.QualifierQuirkService");
+            assertThat(bean.isPrimary()).isFalse();
+            assertThat(bean.getBeanNames()).contains("qualifierQuirkService");
+        });
+        
+        // NamedQuirkService (should have explicit name via @Service("customName"))
+        assertThat(beans).anySatisfy(bean -> {
+            assertThat(bean.getTypeFqn()).isEqualTo("click.kamil.examples.statemachine.extended.service.NamedQuirkService");
+            assertThat(bean.getBeanNames()).contains("customName");
+        });
+
+        // PaymentController (should be detected via @RestController)
+        assertThat(beans).anySatisfy(bean -> {
+            assertThat(bean.getTypeFqn()).isEqualTo("click.kamil.examples.statemachine.extended.web.PaymentController");
+        });
+    }
+
+    @Test
+    void shouldFindMethodBeans() {
+        List<SpringBean> beans = registry.getBeans();
+        
+        // Beans created via @Bean
+        assertThat(beans).anySatisfy(bean -> {
+            assertThat(bean.getTypeFqn()).isEqualTo("java.lang.String");
+            assertThat(bean.getFactoryMethodName()).isEqualTo("myStringBean");
+            assertThat(bean.getBeanNames()).contains("customMockBean");
+            assertThat(bean.getDeclaringClassFqn()).isEqualTo("click.kamil.examples.statemachine.extended.config.MockBeanConfig");
+        });
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/analysis/spring/SpringDependencyResolverTest.java

@@ -0,0 +1,220 @@
+package click.kamil.springstatemachineexporter.analysis.spring;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SpringDependencyResolverTest {
+
+    private SpringBeanRegistry registry;
+    private SpringDependencyResolver resolver;
+
+    @BeforeEach
+    void setUp() {
+        registry = new SpringBeanRegistry();
+        resolver = new SpringDependencyResolver(registry);
+    }
+
+    @Test
+    void shouldResolveSingleMatchByType() {
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.PaymentServiceImpl")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .build());
+
+        List<SpringBean> resolved = resolver.resolve("com.example.PaymentService", null, "paymentService");
+
+        assertThat(resolved).hasSize(1);
+        assertThat(resolved.get(0).getTypeFqn()).isEqualTo("com.example.PaymentServiceImpl");
+    }
+
+    @Test
+    void shouldResolveByPrimaryWhenMultipleImplementationsExist() {
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.NormalService")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .isPrimary(false)
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.PrimaryService")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .isPrimary(true)
+                .build());
+
+        List<SpringBean> resolved = resolver.resolve("com.example.PaymentService", null, "paymentService");
+
+        assertThat(resolved).hasSize(1);
+        assertThat(resolved.get(0).getTypeFqn()).isEqualTo("com.example.PrimaryService");
+    }
+
+    @Test
+    void shouldResolveByQualifierWhenMultipleImplementationsExist() {
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceA")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .qualifiers(Set.of("serviceA"))
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceB")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .qualifiers(Set.of("serviceB"))
+                .build());
+
+        List<SpringBean> resolved = resolver.resolve("com.example.PaymentService", "serviceB", "paymentService");
+
+        assertThat(resolved).hasSize(1);
+        assertThat(resolved.get(0).getTypeFqn()).isEqualTo("com.example.ServiceB");
+    }
+
+    @Test
+    void shouldResolveByInjectionNameFallback() {
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceA")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .beanNames(Set.of("serviceA"))
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceB")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .beanNames(Set.of("specialService"))
+                .build());
+
+        // Qualifier is null, Primary is false. Should match by variable name "specialService"
+        List<SpringBean> resolved = resolver.resolve("com.example.PaymentService", null, "specialService");
+
+        assertThat(resolved).hasSize(1);
+        assertThat(resolved.get(0).getTypeFqn()).isEqualTo("com.example.ServiceB");
+    }
+
+    @Test
+    void shouldResolveByOrderWhenOtherFiltersTie() {
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.LowestOrderService")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .order(Integer.MAX_VALUE) // Lowest precedence
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.HighestOrderService")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .order(Integer.MIN_VALUE) // Highest precedence
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.MiddleOrderService")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .order(0)
+                .build());
+
+        List<SpringBean> resolved = resolver.resolve("com.example.PaymentService", null, "someUnknownName");
+
+        assertThat(resolved).hasSize(1);
+        assertThat(resolved.get(0).getTypeFqn()).isEqualTo("com.example.HighestOrderService");
+    }
+
+    @Test
+    void shouldResolveByOrderWithCustomValues() {
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceA")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .order(400) 
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceB")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .order(100) 
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceC")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .order(2147483647 + 400) // This wraps around in Java due to overflow, but let's test a very large valid value
+                .build());
+
+        List<SpringBean> resolved = resolver.resolve("com.example.PaymentService", null, "someUnknownName");
+
+        assertThat(resolved).hasSize(1);
+        assertThat(resolved.get(0).getTypeFqn()).isEqualTo("com.example.ServiceC");
+    }
+
+    @Test
+    void primaryShouldOverrideOrder() {
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.PrimaryButLowestOrder")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .isPrimary(true)
+                .order(Integer.MAX_VALUE)
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.NotPrimaryButHighestOrder")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .isPrimary(false)
+                .order(Integer.MIN_VALUE)
+                .build());
+
+        List<SpringBean> resolved = resolver.resolve("com.example.PaymentService", null, "someUnknownName");
+
+        assertThat(resolved).hasSize(1);
+        assertThat(resolved.get(0).getTypeFqn()).isEqualTo("com.example.PrimaryButLowestOrder");
+    }
+
+    @Test
+    void qualifierShouldOverridePrimaryAndOrder() {
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.PrimaryService")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .isPrimary(true)
+                .order(Integer.MIN_VALUE)
+                .qualifiers(Set.of("primary"))
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.QualifiedService")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .isPrimary(false)
+                .order(Integer.MAX_VALUE)
+                .qualifiers(Set.of("targetQualifier"))
+                .build());
+
+        List<SpringBean> resolved = resolver.resolve("com.example.PaymentService", "targetQualifier", "someUnknownName");
+
+        assertThat(resolved).hasSize(1);
+        assertThat(resolved.get(0).getTypeFqn()).isEqualTo("com.example.QualifiedService");
+    }
+
+    @Test
+    void shouldReturnMultipleWhenOrderIsTied() {
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceA")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .order(10)
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceB")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .order(10)
+                .build());
+
+        registry.addBean(SpringBean.builder()
+                .typeFqn("com.example.ServiceC")
+                .assignableTypes(Set.of("com.example.PaymentService"))
+                .order(20)
+                .build());
+
+        List<SpringBean> resolved = resolver.resolve("com.example.PaymentService", null, "someUnknownName");
+
+        assertThat(resolved).hasSize(2);
+        assertThat(resolved.stream().map(SpringBean::getTypeFqn))
+                .containsExactlyInAnyOrder("com.example.ServiceA", "com.example.ServiceB");
+    }
+}

state_machine_exporter/src/test/java/click/kamil/springstatemachineexporter/ast/app/AstTransitionParserTest.java

@@ -261,6 +261,56 @@ class AstTransitionParserTest {
                 .contains("System.out.println(\"Hello\")");
     }
 
+    @Test
+    void shouldExtractInternalLogicForSameFileMethodReturningLambda() {
+        String source = """
+                import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
+                import org.springframework.statemachine.guard.Guard;
+                public class TestClass {
+                    public void configure(StateMachineTransitionConfigurer<String, String> transitions) throws Exception {
+                        transitions
+                            .withExternal()
+                            .source("S1")
+                            .target("S2")
+                            .guard(guardVarEquals("test"));
+                    }
+                    
+                    protected Guard<String, String> guardVarEquals(String expected) {
+                        return context -> {
+                            return expected.equals(context.getMessage());
+                        };
+                    }
+                }
+                """;
+        MethodDeclaration method = createMethodDeclarationWithBindings(source);
+
+        List<Transition> transitions = AstTransitionParser.parseTransitions(method, context);
+
+        assertThat(transitions).hasSize(1);
+        assertThat(transitions.getFirst().getGuard().internalLogic())
+                .contains("return expected.equals(context.getMessage());")
+                .doesNotContain("protected Guard<String, String> guardVarEquals");
+    }
+
+    private MethodDeclaration createMethodDeclarationWithBindings(String source) {
+        ASTParser parser = ASTParser.newParser(AST.getJLSLatest());
+        parser.setKind(ASTParser.K_COMPILATION_UNIT);
+        parser.setResolveBindings(true);
+        parser.setBindingsRecovery(true);
+        parser.setEnvironment(new String[0], new String[0], null, true);
+        parser.setUnitName("TestClass.java");
+        parser.setSource(source.toCharArray());
+        CompilationUnit cu = (CompilationUnit) parser.createAST(null);
+        if (cu.types().isEmpty()) {
+            return null;
+        }
+        TypeDeclaration typeDecl = (TypeDeclaration) cu.types().getFirst();
+        MethodDeclaration[] methods = typeDecl.getMethods();
+        if (methods.length > 0) {
+            return methods[0];
+        }
+        return null;
+    }
     private MethodDeclaration createMethodDeclaration(String source) {
         ASTParser parser = ASTParser.newParser(AST.getJLSLatest());
         parser.setKind(ASTParser.K_COMPILATION_UNIT);

state_machine_exporter/src/test/resources/golden/EnterpriseStateMachineConfig/EnterpriseStateMachineConfig.json

@@ -192,7 +192,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 16,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "PLACE_ORDER" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -227,7 +227,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 21,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "CANCEL_ORDER" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -288,7 +288,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 18,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "PAY_ORDER" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {

state_machine_exporter/src/test/resources/golden/ExtendedStateMachineConfig/ExtendedStateMachineConfig.json

@@ -21,10 +21,30 @@
       "lineNumber" : 16,
       "polymorphicEvents" : null
     }, {
-      "event" : "EXTERNAL_TRIGGER",
-      "className" : "click.kamil.examples.statemachine.extended.service.OrderService",
-      "methodName" : "processSubmit",
-      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/OrderService.java",
+      "event" : "FALLBACK_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.FallbackQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/FallbackQuirkService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 17,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "PROFILED_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.ProfiledQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/ProfiledQuirkService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 19,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "PRIMARY_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PrimaryQuirkService.java",
       "sourceModule" : null,
       "stateMachineId" : null,
       "sourceState" : null,
@@ -60,6 +80,56 @@
       "sourceState" : null,
       "lineNumber" : 29,
       "polymorphicEvents" : null
+    }, {
+      "event" : "QUALIFIER_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.QualifierQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/QualifierQuirkService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 17,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "NAMED_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.NamedQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/NamedQuirkService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 17,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "AUTHORIZE",
+      "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+      "methodName" : "processPayment",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PaymentServiceImpl.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 22,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "CAPTURE",
+      "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+      "methodName" : "capturePayment",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PaymentServiceImpl.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 35,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "[LIFECYCLE:RESTORE]",
+      "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+      "methodName" : "capturePayment",
+      "sourceFile" : null,
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 28,
+      "polymorphicEvents" : null
     }, {
       "event" : "REACTIVE_EVENT",
       "className" : "click.kamil.examples.statemachine.extended.service.ReactiveOrderService",
@@ -144,39 +214,137 @@
         "interceptorType" : "Spring MVC Interceptor"
       },
       "parameters" : [ ]
-    } ],
-    "callChains" : [ {
-      "entryPoint" : {
-        "type" : "REST",
-        "name" : "POST /api/orders/submit",
-        "className" : "click.kamil.examples.statemachine.extended.web.OrderController",
-        "methodName" : "submitOrder",
-        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/OrderController.java",
-        "metadata" : {
-          "path" : "/api/orders/submit",
-          "verb" : "POST"
-        },
-        "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-setter",
+      "className" : "click.kamil.examples.statemachine.extended.web.SetterInjectionController",
+      "methodName" : "testSetter",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/SetterInjectionController.java",
+      "metadata" : {
+        "path" : "/test-setter",
+        "verb" : "GET"
       },
-      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.OrderController.submitOrder", "click.kamil.examples.statemachine.extended.service.OrderService.processSubmit" ],
-      "triggerPoint" : {
-        "event" : "EXTERNAL_TRIGGER",
-        "className" : "click.kamil.examples.statemachine.extended.service.OrderService",
-        "methodName" : "processSubmit",
-        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/OrderService.java",
-        "sourceModule" : null,
-        "stateMachineId" : null,
-        "sourceState" : null,
-        "lineNumber" : 19,
-        "polymorphicEvents" : null
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /api/quirk/primary",
+      "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+      "methodName" : "testPrimary",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+      "metadata" : {
+        "path" : "/api/quirk/primary",
+        "verb" : "POST"
       },
-      "contextMachineId" : null,
-      "matchedTransitions" : [ {
-        "sourceState" : "START",
-        "targetState" : "PROCESSING",
-        "event" : "EXTERNAL_TRIGGER"
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /api/quirk/named",
+      "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+      "methodName" : "testNamed",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+      "metadata" : {
+        "path" : "/api/quirk/named",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /api/quirk/qualifier",
+      "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+      "methodName" : "testQualifier",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+      "metadata" : {
+        "path" : "/api/quirk/qualifier",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /api/quirk/fallback",
+      "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+      "methodName" : "testFallback",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+      "metadata" : {
+        "path" : "/api/quirk/fallback",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-order",
+      "className" : "click.kamil.examples.statemachine.extended.web.OrderedTestController",
+      "methodName" : "testOrder",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/OrderedTestController.java",
+      "metadata" : {
+        "path" : "/test-order",
+        "verb" : "GET"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-concrete",
+      "className" : "click.kamil.examples.statemachine.extended.web.ConcreteReturnTypeController",
+      "methodName" : "testConcrete",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/ConcreteReturnTypeController.java",
+      "metadata" : {
+        "path" : "/test-concrete",
+        "verb" : "GET"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-field",
+      "className" : "click.kamil.examples.statemachine.extended.web.FieldInjectionController",
+      "methodName" : "testField",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/FieldInjectionController.java",
+      "metadata" : {
+        "path" : "/test-field",
+        "verb" : "GET"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-list",
+      "className" : "click.kamil.examples.statemachine.extended.web.ListInjectionController",
+      "methodName" : "testList",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/ListInjectionController.java",
+      "metadata" : {
+        "path" : "/test-list",
+        "verb" : "GET"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /api/base/{id}",
+      "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+      "methodName" : "processBaseEndpoint",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+      "metadata" : {
+        "path" : "/api/base/{id}",
+        "verb" : "GET"
+      },
+      "parameters" : [ {
+        "name" : "id",
+        "type" : "String",
+        "annotations" : [ "PathVariable" ]
       } ]
     }, {
+      "type" : "REST",
+      "name" : "POST /api/payment/{id}/capture",
+      "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+      "methodName" : "capturePaymentEndpoint",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+      "metadata" : {
+        "path" : "/api/payment/{id}/capture",
+        "verb" : "POST"
+      },
+      "parameters" : [ {
+        "name" : "id",
+        "type" : "String",
+        "annotations" : [ "PathVariable" ]
+      } ]
+    } ],
+    "callChains" : [ {
       "entryPoint" : {
         "type" : "REST",
         "name" : "POST /api/orders/submit",
@@ -199,7 +367,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 20,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "SUBMIT_EVENT" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -230,7 +398,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 25,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "CANCEL_EVENT" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -327,7 +495,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 18,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "REACTIVE_EVENT" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -365,6 +533,288 @@
         "targetState" : "START",
         "event" : "AUDIT_EVENT"
       } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "GET /test-setter",
+        "className" : "click.kamil.examples.statemachine.extended.web.SetterInjectionController",
+        "methodName" : "testSetter",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/SetterInjectionController.java",
+        "metadata" : {
+          "path" : "/test-setter",
+          "verb" : "GET"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.SetterInjectionController.testSetter", "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "NAMED_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.NamedQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/NamedQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "NAMED_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/quirk/primary",
+        "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+        "methodName" : "testPrimary",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+        "metadata" : {
+          "path" : "/api/quirk/primary",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.QuirkController.testPrimary", "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "PRIMARY_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PrimaryQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 19,
+        "polymorphicEvents" : [ "PRIMARY_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/quirk/named",
+        "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+        "methodName" : "testNamed",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+        "metadata" : {
+          "path" : "/api/quirk/named",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.QuirkController.testNamed", "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "NAMED_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.NamedQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/NamedQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "NAMED_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/quirk/qualifier",
+        "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+        "methodName" : "testQualifier",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+        "metadata" : {
+          "path" : "/api/quirk/qualifier",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.QuirkController.testQualifier", "click.kamil.examples.statemachine.extended.service.QualifierQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "QUALIFIER_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.QualifierQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/QualifierQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "QUALIFIER_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/quirk/fallback",
+        "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+        "methodName" : "testFallback",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+        "metadata" : {
+          "path" : "/api/quirk/fallback",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.QuirkController.testFallback", "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "PRIMARY_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PrimaryQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 19,
+        "polymorphicEvents" : [ "PRIMARY_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "GET /test-concrete",
+        "className" : "click.kamil.examples.statemachine.extended.web.ConcreteReturnTypeController",
+        "methodName" : "testConcrete",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/ConcreteReturnTypeController.java",
+        "metadata" : {
+          "path" : "/test-concrete",
+          "verb" : "GET"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.ConcreteReturnTypeController.testConcrete", "click.kamil.examples.statemachine.extended.service.QualifierQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "QUALIFIER_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.QualifierQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/QualifierQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "QUALIFIER_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "GET /test-field",
+        "className" : "click.kamil.examples.statemachine.extended.web.FieldInjectionController",
+        "methodName" : "testField",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/FieldInjectionController.java",
+        "metadata" : {
+          "path" : "/test-field",
+          "verb" : "GET"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.FieldInjectionController.testField", "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "NAMED_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.NamedQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/NamedQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "NAMED_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "GET /api/base/{id}",
+        "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+        "methodName" : "processBaseEndpoint",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+        "metadata" : {
+          "path" : "/api/base/{id}",
+          "verb" : "GET"
+        },
+        "parameters" : [ {
+          "name" : "id",
+          "type" : "String",
+          "annotations" : [ "PathVariable" ]
+        } ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.PaymentController.processBaseEndpoint", "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl.processPayment" ],
+      "triggerPoint" : {
+        "event" : "AUTHORIZE",
+        "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+        "methodName" : "processPayment",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PaymentServiceImpl.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 22,
+        "polymorphicEvents" : null
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/payment/{id}/capture",
+        "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+        "methodName" : "capturePaymentEndpoint",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+        "metadata" : {
+          "path" : "/api/payment/{id}/capture",
+          "verb" : "POST"
+        },
+        "parameters" : [ {
+          "name" : "id",
+          "type" : "String",
+          "annotations" : [ "PathVariable" ]
+        } ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.PaymentController.capturePaymentEndpoint", "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl.capturePayment" ],
+      "triggerPoint" : {
+        "event" : "CAPTURE",
+        "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+        "methodName" : "capturePayment",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PaymentServiceImpl.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 35,
+        "polymorphicEvents" : null
+      },
+      "contextMachineId" : "paymentId",
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/payment/{id}/capture",
+        "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+        "methodName" : "capturePaymentEndpoint",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+        "metadata" : {
+          "path" : "/api/payment/{id}/capture",
+          "verb" : "POST"
+        },
+        "parameters" : [ {
+          "name" : "id",
+          "type" : "String",
+          "annotations" : [ "PathVariable" ]
+        } ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.PaymentController.capturePaymentEndpoint", "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl.capturePayment" ],
+      "triggerPoint" : {
+        "event" : "[LIFECYCLE:RESTORE]",
+        "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+        "methodName" : "capturePayment",
+        "sourceFile" : null,
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 28,
+        "polymorphicEvents" : null
+      },
+      "contextMachineId" : "paymentId",
+      "matchedTransitions" : null
     } ],
     "properties" : {
       "default" : {

state_machine_exporter/src/test/resources/golden/ExtendedStateMachineConfig_PROD/ExtendedStateMachineConfig.json

@@ -21,10 +21,30 @@
       "lineNumber" : 16,
       "polymorphicEvents" : null
     }, {
-      "event" : "EXTERNAL_TRIGGER",
-      "className" : "click.kamil.examples.statemachine.extended.service.OrderService",
-      "methodName" : "processSubmit",
-      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/OrderService.java",
+      "event" : "FALLBACK_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.FallbackQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/FallbackQuirkService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 17,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "PROFILED_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.ProfiledQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/ProfiledQuirkService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 19,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "PRIMARY_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PrimaryQuirkService.java",
       "sourceModule" : null,
       "stateMachineId" : null,
       "sourceState" : null,
@@ -60,6 +80,56 @@
       "sourceState" : null,
       "lineNumber" : 29,
       "polymorphicEvents" : null
+    }, {
+      "event" : "QUALIFIER_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.QualifierQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/QualifierQuirkService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 17,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "NAMED_EVENT",
+      "className" : "click.kamil.examples.statemachine.extended.service.NamedQuirkService",
+      "methodName" : "doQuirk",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/NamedQuirkService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 17,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "AUTHORIZE",
+      "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+      "methodName" : "processPayment",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PaymentServiceImpl.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 22,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "CAPTURE",
+      "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+      "methodName" : "capturePayment",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PaymentServiceImpl.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 35,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "[LIFECYCLE:RESTORE]",
+      "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+      "methodName" : "capturePayment",
+      "sourceFile" : null,
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 28,
+      "polymorphicEvents" : null
     }, {
       "event" : "REACTIVE_EVENT",
       "className" : "click.kamil.examples.statemachine.extended.service.ReactiveOrderService",
@@ -144,39 +214,137 @@
         "interceptorType" : "Spring MVC Interceptor"
       },
       "parameters" : [ ]
-    } ],
-    "callChains" : [ {
-      "entryPoint" : {
-        "type" : "REST",
-        "name" : "POST /api/orders/submit",
-        "className" : "click.kamil.examples.statemachine.extended.web.OrderController",
-        "methodName" : "submitOrder",
-        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/OrderController.java",
-        "metadata" : {
-          "path" : "/api/orders/submit",
-          "verb" : "POST"
-        },
-        "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-setter",
+      "className" : "click.kamil.examples.statemachine.extended.web.SetterInjectionController",
+      "methodName" : "testSetter",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/SetterInjectionController.java",
+      "metadata" : {
+        "path" : "/test-setter",
+        "verb" : "GET"
       },
-      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.OrderController.submitOrder", "click.kamil.examples.statemachine.extended.service.OrderService.processSubmit" ],
-      "triggerPoint" : {
-        "event" : "EXTERNAL_TRIGGER",
-        "className" : "click.kamil.examples.statemachine.extended.service.OrderService",
-        "methodName" : "processSubmit",
-        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/OrderService.java",
-        "sourceModule" : null,
-        "stateMachineId" : null,
-        "sourceState" : null,
-        "lineNumber" : 19,
-        "polymorphicEvents" : null
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /api/quirk/primary",
+      "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+      "methodName" : "testPrimary",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+      "metadata" : {
+        "path" : "/api/quirk/primary",
+        "verb" : "POST"
       },
-      "contextMachineId" : null,
-      "matchedTransitions" : [ {
-        "sourceState" : "START",
-        "targetState" : "PROCESSING",
-        "event" : "EXTERNAL_TRIGGER"
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /api/quirk/named",
+      "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+      "methodName" : "testNamed",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+      "metadata" : {
+        "path" : "/api/quirk/named",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /api/quirk/qualifier",
+      "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+      "methodName" : "testQualifier",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+      "metadata" : {
+        "path" : "/api/quirk/qualifier",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /api/quirk/fallback",
+      "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+      "methodName" : "testFallback",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+      "metadata" : {
+        "path" : "/api/quirk/fallback",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-order",
+      "className" : "click.kamil.examples.statemachine.extended.web.OrderedTestController",
+      "methodName" : "testOrder",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/OrderedTestController.java",
+      "metadata" : {
+        "path" : "/test-order",
+        "verb" : "GET"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-concrete",
+      "className" : "click.kamil.examples.statemachine.extended.web.ConcreteReturnTypeController",
+      "methodName" : "testConcrete",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/ConcreteReturnTypeController.java",
+      "metadata" : {
+        "path" : "/test-concrete",
+        "verb" : "GET"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-field",
+      "className" : "click.kamil.examples.statemachine.extended.web.FieldInjectionController",
+      "methodName" : "testField",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/FieldInjectionController.java",
+      "metadata" : {
+        "path" : "/test-field",
+        "verb" : "GET"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /test-list",
+      "className" : "click.kamil.examples.statemachine.extended.web.ListInjectionController",
+      "methodName" : "testList",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/ListInjectionController.java",
+      "metadata" : {
+        "path" : "/test-list",
+        "verb" : "GET"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "GET /api/base/{id}",
+      "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+      "methodName" : "processBaseEndpoint",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+      "metadata" : {
+        "path" : "/api/base/{id}",
+        "verb" : "GET"
+      },
+      "parameters" : [ {
+        "name" : "id",
+        "type" : "String",
+        "annotations" : [ "PathVariable" ]
       } ]
     }, {
+      "type" : "REST",
+      "name" : "POST /api/payment/{id}/capture",
+      "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+      "methodName" : "capturePaymentEndpoint",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+      "metadata" : {
+        "path" : "/api/payment/{id}/capture",
+        "verb" : "POST"
+      },
+      "parameters" : [ {
+        "name" : "id",
+        "type" : "String",
+        "annotations" : [ "PathVariable" ]
+      } ]
+    } ],
+    "callChains" : [ {
       "entryPoint" : {
         "type" : "REST",
         "name" : "POST /api/orders/submit",
@@ -199,7 +367,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 20,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "SUBMIT_EVENT" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -230,7 +398,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 25,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "CANCEL_EVENT" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -327,7 +495,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 18,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "REACTIVE_EVENT" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -365,6 +533,288 @@
         "targetState" : "START",
         "event" : "AUDIT_EVENT"
       } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "GET /test-setter",
+        "className" : "click.kamil.examples.statemachine.extended.web.SetterInjectionController",
+        "methodName" : "testSetter",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/SetterInjectionController.java",
+        "metadata" : {
+          "path" : "/test-setter",
+          "verb" : "GET"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.SetterInjectionController.testSetter", "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "NAMED_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.NamedQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/NamedQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "NAMED_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/quirk/primary",
+        "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+        "methodName" : "testPrimary",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+        "metadata" : {
+          "path" : "/api/quirk/primary",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.QuirkController.testPrimary", "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "PRIMARY_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PrimaryQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 19,
+        "polymorphicEvents" : [ "PRIMARY_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/quirk/named",
+        "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+        "methodName" : "testNamed",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+        "metadata" : {
+          "path" : "/api/quirk/named",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.QuirkController.testNamed", "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "NAMED_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.NamedQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/NamedQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "NAMED_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/quirk/qualifier",
+        "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+        "methodName" : "testQualifier",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+        "metadata" : {
+          "path" : "/api/quirk/qualifier",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.QuirkController.testQualifier", "click.kamil.examples.statemachine.extended.service.QualifierQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "QUALIFIER_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.QualifierQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/QualifierQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "QUALIFIER_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/quirk/fallback",
+        "className" : "click.kamil.examples.statemachine.extended.web.QuirkController",
+        "methodName" : "testFallback",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java",
+        "metadata" : {
+          "path" : "/api/quirk/fallback",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.QuirkController.testFallback", "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "PRIMARY_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.PrimaryQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PrimaryQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 19,
+        "polymorphicEvents" : [ "PRIMARY_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "GET /test-concrete",
+        "className" : "click.kamil.examples.statemachine.extended.web.ConcreteReturnTypeController",
+        "methodName" : "testConcrete",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/ConcreteReturnTypeController.java",
+        "metadata" : {
+          "path" : "/test-concrete",
+          "verb" : "GET"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.ConcreteReturnTypeController.testConcrete", "click.kamil.examples.statemachine.extended.service.QualifierQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "QUALIFIER_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.QualifierQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/QualifierQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "QUALIFIER_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "GET /test-field",
+        "className" : "click.kamil.examples.statemachine.extended.web.FieldInjectionController",
+        "methodName" : "testField",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/FieldInjectionController.java",
+        "metadata" : {
+          "path" : "/test-field",
+          "verb" : "GET"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.FieldInjectionController.testField", "click.kamil.examples.statemachine.extended.service.NamedQuirkService.doQuirk" ],
+      "triggerPoint" : {
+        "event" : "NAMED_EVENT",
+        "className" : "click.kamil.examples.statemachine.extended.service.NamedQuirkService",
+        "methodName" : "doQuirk",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/NamedQuirkService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "NAMED_EVENT" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "GET /api/base/{id}",
+        "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+        "methodName" : "processBaseEndpoint",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+        "metadata" : {
+          "path" : "/api/base/{id}",
+          "verb" : "GET"
+        },
+        "parameters" : [ {
+          "name" : "id",
+          "type" : "String",
+          "annotations" : [ "PathVariable" ]
+        } ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.PaymentController.processBaseEndpoint", "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl.processPayment" ],
+      "triggerPoint" : {
+        "event" : "AUTHORIZE",
+        "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+        "methodName" : "processPayment",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PaymentServiceImpl.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 22,
+        "polymorphicEvents" : null
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/payment/{id}/capture",
+        "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+        "methodName" : "capturePaymentEndpoint",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+        "metadata" : {
+          "path" : "/api/payment/{id}/capture",
+          "verb" : "POST"
+        },
+        "parameters" : [ {
+          "name" : "id",
+          "type" : "String",
+          "annotations" : [ "PathVariable" ]
+        } ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.PaymentController.capturePaymentEndpoint", "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl.capturePayment" ],
+      "triggerPoint" : {
+        "event" : "CAPTURE",
+        "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+        "methodName" : "capturePayment",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/service/PaymentServiceImpl.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 35,
+        "polymorphicEvents" : null
+      },
+      "contextMachineId" : "paymentId",
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /api/payment/{id}/capture",
+        "className" : "click.kamil.examples.statemachine.extended.web.PaymentController",
+        "methodName" : "capturePaymentEndpoint",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java",
+        "metadata" : {
+          "path" : "/api/payment/{id}/capture",
+          "verb" : "POST"
+        },
+        "parameters" : [ {
+          "name" : "id",
+          "type" : "String",
+          "annotations" : [ "PathVariable" ]
+        } ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.extended.web.PaymentController.capturePaymentEndpoint", "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl.capturePayment" ],
+      "triggerPoint" : {
+        "event" : "[LIFECYCLE:RESTORE]",
+        "className" : "click.kamil.examples.statemachine.extended.service.PaymentServiceImpl",
+        "methodName" : "capturePayment",
+        "sourceFile" : null,
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 28,
+        "polymorphicEvents" : null
+      },
+      "contextMachineId" : "paymentId",
+      "matchedTransitions" : null
     } ],
     "properties" : {
       "default" : {

state_machine_exporter/src/test/resources/golden/InheritanceStateMachineConfig/InheritanceStateMachineConfig.json

@@ -57,7 +57,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 15,
-        "polymorphicEvents" : null
+        "polymorphicEvents" : [ "INHERITED_SUBMIT" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {

state_machine_exporter/src/test/resources/golden/PolymorphicStateMachineConfiguration/PolymorphicStateMachineConfiguration.dot

@@ -0,0 +1,15 @@
+digraph statemachine {
+  rankdir=LR;
+  node [shape=rounded, style=filled, fillcolor=white, fontname="Arial"];
+  edge [fontname="Arial", fontsize=10];
+
+  _start [shape=circle, label="", fillcolor=black, width=0.1];
+  _start -> SUBMITTED;
+  CANCELED [fillcolor=lightgray];
+  FULFILLED [fillcolor=lightgray];
+  SUBMITTED -> PAID [label="OrderEvents.PAY", style="solid", color="black"];
+  PAID -> FULFILLED [label="OrderEvents.FULFILL", style="solid", color="black"];
+  SUBMITTED -> CANCELED [label="OrderEvents.CANCEL", style="solid", color="black"];
+  PAID -> CANCELED [label="OrderEvents.ABCD", style="solid", color="black"];
+}
+

state_machine_exporter/src/test/resources/golden/PolymorphicStateMachineConfiguration/PolymorphicStateMachineConfiguration.json

@@ -0,0 +1,627 @@
+{
+  "metadata" : {
+    "triggers" : [ {
+      "event" : "event",
+      "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+      "methodName" : "processEvent",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 13,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "payload",
+      "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+      "methodName" : "processPayloadEvent",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 17,
+      "polymorphicEvents" : null
+    }, {
+      "event" : "event",
+      "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+      "methodName" : "processCustomEvent",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+      "sourceModule" : null,
+      "stateMachineId" : null,
+      "sourceState" : null,
+      "lineNumber" : 21,
+      "polymorphicEvents" : null
+    } ],
+    "entryPoints" : [ {
+      "type" : "REST",
+      "name" : "POST /pay",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "pay",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/pay",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /fulfill",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "fulfill",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/fulfill",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /cancel",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "cancel",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/cancel",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /payload-pay",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "payloadPay",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/payload-pay",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /pay-variable",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "payVariable",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/pay-variable",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /pay-cast",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "payCast",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/pay-cast",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /pay-ternary",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "payTernary",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/pay-ternary",
+        "verb" : "POST"
+      },
+      "parameters" : [ {
+        "name" : "isPay",
+        "type" : "boolean",
+        "annotations" : [ ]
+      } ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /pay-list",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "payList",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/pay-list",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /pay-builder-static",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "payBuilderStatic",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/pay-builder-static",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /pay-builder-instance",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "payBuilderInstance",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/pay-builder-instance",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /abcd",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "abcd",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/abcd",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    }, {
+      "type" : "REST",
+      "name" : "POST /mystery",
+      "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+      "methodName" : "mystery",
+      "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+      "metadata" : {
+        "path" : "/mystery",
+        "verb" : "POST"
+      },
+      "parameters" : [ ]
+    } ],
+    "callChains" : [ {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /pay",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "pay",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/pay",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.pay", "click.kamil.examples.statemachine.polymorphic.OrderService.processEvent" ],
+      "triggerPoint" : {
+        "event" : "new PayEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 13,
+        "polymorphicEvents" : [ "OrderEvents.PAY" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.SUBMITTED",
+        "targetState" : "OrderStates.PAID",
+        "event" : "OrderEvents.PAY"
+      } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /fulfill",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "fulfill",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/fulfill",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.fulfill", "click.kamil.examples.statemachine.polymorphic.OrderService.processEvent" ],
+      "triggerPoint" : {
+        "event" : "new FulfillEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 13,
+        "polymorphicEvents" : [ "OrderEvents.FULFILL" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.PAID",
+        "targetState" : "OrderStates.FULFILLED",
+        "event" : "OrderEvents.FULFILL"
+      } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /cancel",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "cancel",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/cancel",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.cancel", "click.kamil.examples.statemachine.polymorphic.OrderService.processEvent" ],
+      "triggerPoint" : {
+        "event" : "new CancelEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 13,
+        "polymorphicEvents" : [ "OrderEvents.CANCEL" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.SUBMITTED",
+        "targetState" : "OrderStates.CANCELED",
+        "event" : "OrderEvents.CANCEL"
+      } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /payload-pay",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "payloadPay",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/payload-pay",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.payloadPay", "click.kamil.examples.statemachine.polymorphic.OrderService.processPayloadEvent" ],
+      "triggerPoint" : {
+        "event" : "new PayEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processPayloadEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 17,
+        "polymorphicEvents" : [ "OrderEvents.PAY" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.SUBMITTED",
+        "targetState" : "OrderStates.PAID",
+        "event" : "OrderEvents.PAY"
+      } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /pay-variable",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "payVariable",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/pay-variable",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.payVariable", "click.kamil.examples.statemachine.polymorphic.OrderService.processEvent" ],
+      "triggerPoint" : {
+        "event" : "new PayEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 13,
+        "polymorphicEvents" : [ "OrderEvents.PAY" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.SUBMITTED",
+        "targetState" : "OrderStates.PAID",
+        "event" : "OrderEvents.PAY"
+      } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /pay-cast",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "payCast",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/pay-cast",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.payCast", "click.kamil.examples.statemachine.polymorphic.OrderService.processEvent" ],
+      "triggerPoint" : {
+        "event" : "(BaseEvent)new PayEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 13,
+        "polymorphicEvents" : [ "OrderEvents.PAY" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.SUBMITTED",
+        "targetState" : "OrderStates.PAID",
+        "event" : "OrderEvents.PAY"
+      } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /pay-ternary",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "payTernary",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/pay-ternary",
+          "verb" : "POST"
+        },
+        "parameters" : [ {
+          "name" : "isPay",
+          "type" : "boolean",
+          "annotations" : [ ]
+        } ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.payTernary", "click.kamil.examples.statemachine.polymorphic.OrderService.processEvent" ],
+      "triggerPoint" : {
+        "event" : "isPay ? new PayEvent() : new CancelEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 13,
+        "polymorphicEvents" : [ "OrderEvents.PAY", "OrderEvents.CANCEL" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.SUBMITTED",
+        "targetState" : "OrderStates.PAID",
+        "event" : "OrderEvents.PAY"
+      }, {
+        "sourceState" : "OrderStates.SUBMITTED",
+        "targetState" : "OrderStates.CANCELED",
+        "event" : "OrderEvents.CANCEL"
+      } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /pay-list",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "payList",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/pay-list",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.payList", "click.kamil.examples.statemachine.polymorphic.OrderService.processEvent" ],
+      "triggerPoint" : {
+        "event" : "new PayEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 13,
+        "polymorphicEvents" : [ "OrderEvents.PAY" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.SUBMITTED",
+        "targetState" : "OrderStates.PAID",
+        "event" : "OrderEvents.PAY"
+      } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /pay-builder-static",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "payBuilderStatic",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/pay-builder-static",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.payBuilderStatic", "click.kamil.examples.statemachine.polymorphic.OrderService.processEvent" ],
+      "triggerPoint" : {
+        "event" : "EventBuilder.buildEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 13,
+        "polymorphicEvents" : [ ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /pay-builder-instance",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "payBuilderInstance",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/pay-builder-instance",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.payBuilderInstance", "click.kamil.examples.statemachine.polymorphic.OrderService.processEvent" ],
+      "triggerPoint" : {
+        "event" : "new EventBuilder().buildInstanceEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 13,
+        "polymorphicEvents" : [ ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : null
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /abcd",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "abcd",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/abcd",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.abcd", "click.kamil.examples.statemachine.polymorphic.OrderService.processCustomEvent" ],
+      "triggerPoint" : {
+        "event" : "new AbcdEvent()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processCustomEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 21,
+        "polymorphicEvents" : [ "OrderEvents.ABCD" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.PAID",
+        "targetState" : "OrderStates.CANCELED",
+        "event" : "OrderEvents.ABCD"
+      } ]
+    }, {
+      "entryPoint" : {
+        "type" : "REST",
+        "name" : "POST /mystery",
+        "className" : "click.kamil.examples.statemachine.polymorphic.PolymorphicController",
+        "methodName" : "mystery",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java",
+        "metadata" : {
+          "path" : "/mystery",
+          "verb" : "POST"
+        },
+        "parameters" : [ ]
+      },
+      "methodChain" : [ "click.kamil.examples.statemachine.polymorphic.PolymorphicController.mystery", "click.kamil.examples.statemachine.polymorphic.OrderService.processCustomEvent" ],
+      "triggerPoint" : {
+        "event" : "new MysteryPayload()",
+        "className" : "click.kamil.examples.statemachine.polymorphic.OrderService",
+        "methodName" : "processCustomEvent",
+        "sourceFile" : "src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java",
+        "sourceModule" : null,
+        "stateMachineId" : null,
+        "sourceState" : null,
+        "lineNumber" : 21,
+        "polymorphicEvents" : [ "OrderEvents.ABCD", "OrderEvents.PAY" ]
+      },
+      "contextMachineId" : null,
+      "matchedTransitions" : [ {
+        "sourceState" : "OrderStates.SUBMITTED",
+        "targetState" : "OrderStates.PAID",
+        "event" : "OrderEvents.PAY"
+      }, {
+        "sourceState" : "OrderStates.PAID",
+        "targetState" : "OrderStates.CANCELED",
+        "event" : "OrderEvents.ABCD"
+      } ]
+    } ],
+    "properties" : {
+      "default" : {
+        "spring.application.name" : "statemachinedemo"
+      }
+    }
+  },
+  "name" : "click.kamil.examples.statemachine.polymorphic.PolymorphicStateMachineConfiguration",
+  "renderChoicesAsDiamonds" : true,
+  "startStates" : [ "OrderStates.SUBMITTED" ],
+  "transitions" : [ {
+    "type" : "EXTERNAL",
+    "sourceStates" : [ {
+      "rawName" : "OrderStates.SUBMITTED",
+      "fullIdentifier" : "OrderStates.SUBMITTED"
+    } ],
+    "targetStates" : [ {
+      "rawName" : "OrderStates.PAID",
+      "fullIdentifier" : "OrderStates.PAID"
+    } ],
+    "event" : {
+      "rawName" : "OrderEvents.PAY",
+      "fullIdentifier" : "OrderEvents.PAY"
+    },
+    "guard" : null,
+    "actions" : [ ],
+    "order" : null
+  }, {
+    "type" : "EXTERNAL",
+    "sourceStates" : [ {
+      "rawName" : "OrderStates.PAID",
+      "fullIdentifier" : "OrderStates.PAID"
+    } ],
+    "targetStates" : [ {
+      "rawName" : "OrderStates.FULFILLED",
+      "fullIdentifier" : "OrderStates.FULFILLED"
+    } ],
+    "event" : {
+      "rawName" : "OrderEvents.FULFILL",
+      "fullIdentifier" : "OrderEvents.FULFILL"
+    },
+    "guard" : null,
+    "actions" : [ ],
+    "order" : null
+  }, {
+    "type" : "EXTERNAL",
+    "sourceStates" : [ {
+      "rawName" : "OrderStates.SUBMITTED",
+      "fullIdentifier" : "OrderStates.SUBMITTED"
+    } ],
+    "targetStates" : [ {
+      "rawName" : "OrderStates.CANCELED",
+      "fullIdentifier" : "OrderStates.CANCELED"
+    } ],
+    "event" : {
+      "rawName" : "OrderEvents.CANCEL",
+      "fullIdentifier" : "OrderEvents.CANCEL"
+    },
+    "guard" : null,
+    "actions" : [ ],
+    "order" : null
+  }, {
+    "type" : "EXTERNAL",
+    "sourceStates" : [ {
+      "rawName" : "OrderStates.PAID",
+      "fullIdentifier" : "OrderStates.PAID"
+    } ],
+    "targetStates" : [ {
+      "rawName" : "OrderStates.CANCELED",
+      "fullIdentifier" : "OrderStates.CANCELED"
+    } ],
+    "event" : {
+      "rawName" : "OrderEvents.ABCD",
+      "fullIdentifier" : "OrderEvents.ABCD"
+    },
+    "guard" : null,
+    "actions" : [ ],
+    "order" : null
+  } ],
+  "endStates" : [ "OrderStates.CANCELED", "OrderStates.FULFILLED" ]
+}

state_machine_exporter/src/test/resources/golden/PolymorphicStateMachineConfiguration/PolymorphicStateMachineConfiguration.puml

@@ -0,0 +1,35 @@
+@startuml
+!pragma layout smetana
+set separator none
+hide empty description
+hide stereotype
+skinparam state {
+  BackgroundColor white
+  BorderColor #94a3b8
+  BorderThickness 1
+  FontName Inter
+  FontSize 9
+  FontStyle bold
+  RoundCorner 20
+  Padding 1
+}
+skinparam shadowing false
+skinparam ArrowFontName JetBrains Mono
+skinparam ArrowFontSize 8
+skinparam ArrowColor #cbd5e1
+skinparam ArrowThickness 1
+skinparam dpi 110
+skinparam svgLinkTarget _self
+
+[*] --> OrderStates.SUBMITTED
+
+
+OrderStates.SUBMITTED -[#1E90FF,bold]-> OrderStates.PAID <<external>> : OrderEvents.PAY
+OrderStates.PAID -[#1E90FF,bold]-> OrderStates.FULFILLED <<external>> : OrderEvents.FULFILL
+OrderStates.SUBMITTED -[#1E90FF,bold]-> OrderStates.CANCELED <<external>> : OrderEvents.CANCEL
+OrderStates.PAID -[#1E90FF,bold]-> OrderStates.CANCELED <<external>> : OrderEvents.ABCD
+
+OrderStates.CANCELED --> [*]
+OrderStates.FULFILLED --> [*]
+@enduml
+

state_machine_exporter/src/test/resources/golden/PolymorphicStateMachineConfiguration/PolymorphicStateMachineConfiguration.scxml.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<scxml xmlns="http://www.w3.org/2005/07/scxml" version="1.0" initial="SUBMITTED">
+  <state id="SUBMITTED">
+    <transition target="PAID" event="OrderEvents.PAY"/>
+    <transition target="CANCELED" event="OrderEvents.CANCEL"/>
+  </state>
+  <state id="PAID">
+    <transition target="FULFILLED" event="OrderEvents.FULFILL"/>
+    <transition target="CANCELED" event="OrderEvents.ABCD"/>
+  </state>
+  <state id="FULFILLED">
+  </state>
+  <state id="CANCELED">
+  </state>
+</scxml>
+

state_machine_exporter/src/test/resources/golden/StateMachineConfig/StateMachineConfig.json

@@ -144,7 +144,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 25,
-        "polymorphicEvents" : [ ]
+        "polymorphicEvents" : [ "OrderEvent.PROCESS" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -175,7 +175,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 25,
-        "polymorphicEvents" : [ ]
+        "polymorphicEvents" : [ "OrderEvent.COMPLETE" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -206,7 +206,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 25,
-        "polymorphicEvents" : [ ]
+        "polymorphicEvents" : [ "OrderEvent.CANCEL" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -241,7 +241,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 25,
-        "polymorphicEvents" : [ ]
+        "polymorphicEvents" : [ "OrderEvent.COMPLETE" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -276,7 +276,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 78,
-        "polymorphicEvents" : [ ]
+        "polymorphicEvents" : [ "OrderEvent.PROCESS" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -311,7 +311,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 25,
-        "polymorphicEvents" : [ ]
+        "polymorphicEvents" : [ "OrderEvent.PROCESS" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {
@@ -346,7 +346,7 @@
         "stateMachineId" : null,
         "sourceState" : null,
         "lineNumber" : 50,
-        "polymorphicEvents" : [ ]
+        "polymorphicEvents" : [ "OrderEvent.CANCEL" ]
       },
       "contextMachineId" : null,
       "matchedTransitions" : [ {

state_machines/enterprise_order_system/src/main/resources/hints.json

@@ -1,6 +0,0 @@
-[
-  {
-    "methodFqn": "ExternalTaxService.calculateTax",
-    "event": "FINALIZE"
-  }
-]

state_machines/extended_analysis_sample/.gitignore

@@ -1,6 +1,37 @@
+HELP.md
+.gradle
 build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
 out/
-.gradle/
-.idea/
-*.class
-*.log
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/config/AbstractBaseConfig.java

@@ -0,0 +1,14 @@
+package click.kamil.examples.statemachine.extended.config;
+
+import click.kamil.examples.statemachine.extended.service.QuirkService;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Bean;
+
+public abstract class AbstractBaseConfig {
+
+    @Bean
+    public String inheritedBeanTester(@Qualifier("customName") QuirkService someService) {
+        someService.doQuirk();
+        return "inherited";
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/config/BeanParameterTestConfig.java

@@ -0,0 +1,17 @@
+package click.kamil.examples.statemachine.extended.config;
+
+import click.kamil.examples.statemachine.extended.service.QuirkService;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class BeanParameterTestConfig extends AbstractBaseConfig {
+
+    @Bean
+    public String myBeanParamTester(@Qualifier("customName") QuirkService someService) {
+        // We will use this method as an entry point in the test
+        someService.doQuirk();
+        return "tested";
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/config/ConcreteReturnTypeConfig.java

@@ -0,0 +1,15 @@
+package click.kamil.examples.statemachine.extended.config;
+
+import click.kamil.examples.statemachine.extended.service.QuirkService;
+import click.kamil.examples.statemachine.extended.service.QualifierQuirkService;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ConcreteReturnTypeConfig {
+
+    @Bean
+    public QuirkService hiddenConcreteService() {
+        return new QualifierQuirkService(); // It returns an interface, but the concrete type is QualifierQuirkService
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/config/MockBeanConfig.java

@@ -0,0 +1,13 @@
+package click.kamil.examples.statemachine.extended.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class MockBeanConfig {
+
+    @Bean(name = {"customMockBean", "aliasMockBean"})
+    public String myStringBean() {
+        return "Hello World";
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/config/PaymentStateMachineConfig.java

@@ -0,0 +1,58 @@
+package click.kamil.examples.statemachine.extended.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.statemachine.config.EnableStateMachine;
+import org.springframework.statemachine.config.StateMachineConfigurerAdapter;
+import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
+import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
+
+@Configuration
+@EnableStateMachine(name = "paymentStateMachine")
+public class PaymentStateMachineConfig extends StateMachineConfigurerAdapter<String, String> {
+
+    @Override
+    public void configure(StateMachineStateConfigurer<String, String> states) throws Exception {
+        states
+            .withStates()
+                .initial("NEW")
+                .state("AUTHORIZED")
+                .state("CAPTURED")
+                .state("DECLINED")
+                .state("QUIRK1")
+                .state("QUIRK2")
+                .state("QUIRK3")
+                .state("QUIRK4");
+    }
+
+    @Override
+    public void configure(StateMachineTransitionConfigurer<String, String> transitions) throws Exception {
+        transitions
+            .withExternal()
+                .source("NEW").target("AUTHORIZED")
+                .event("AUTHORIZE")
+            .and()
+            .withExternal()
+                .source("AUTHORIZED").target("CAPTURED")
+                .event("CAPTURE")
+            .and()
+            .withExternal()
+                .source("NEW").target("DECLINED")
+                .event("DECLINE")
+            .and()
+            .withExternal()
+                .source("NEW").target("QUIRK1")
+                .event("PRIMARY_EVENT")
+            .and()
+            .withExternal()
+                .source("NEW").target("QUIRK2")
+                .event("NAMED_EVENT")
+            .and()
+            .withExternal()
+                .source("NEW").target("QUIRK3")
+                .event("QUALIFIER_EVENT")
+            .and()
+            .withExternal()
+                .source("NEW").target("QUIRK4")
+                .event("FALLBACK_EVENT");
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/AmbiguousA.java

@@ -0,0 +1,9 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.stereotype.Service;
+
+@Service
+public class AmbiguousA implements AmbiguousService {
+    @Override
+    public void doAmbig() {}
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/AmbiguousB.java

@@ -0,0 +1,9 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.stereotype.Service;
+
+@Service
+public class AmbiguousB implements AmbiguousService {
+    @Override
+    public void doAmbig() {}
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/AmbiguousService.java

@@ -0,0 +1,5 @@
+package click.kamil.examples.statemachine.extended.service;
+
+public interface AmbiguousService {
+    void doAmbig();
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/FallbackQuirkService.java

@@ -0,0 +1,19 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.statemachine.StateMachine;
+import org.springframework.stereotype.Service;
+
+@Service
+public class FallbackQuirkService implements QuirkService {
+
+    @Autowired
+    @Qualifier("paymentStateMachine")
+    private StateMachine<String, String> stateMachine;
+
+    @Override
+    public void doQuirk() {
+        stateMachine.sendEvent("FALLBACK_EVENT");
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/HighPriorityOrderedService.java

@@ -0,0 +1,12 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Service;
+
+@Service
+@Order(Ordered.HIGHEST_PRECEDENCE)
+public class HighPriorityOrderedService implements OrderedService {
+    @Override
+    public void doAction() {}
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/LowPriorityOrderedService.java

@@ -0,0 +1,11 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Service;
+
+@Service
+@Order(10)
+public class LowPriorityOrderedService implements OrderedService {
+    @Override
+    public void doAction() {}
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/NamedQuirkService.java

@@ -0,0 +1,19 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.statemachine.StateMachine;
+import org.springframework.stereotype.Service;
+
+@Service("customName")
+public class NamedQuirkService implements QuirkService {
+
+    @Autowired
+    @Qualifier("paymentStateMachine")
+    private StateMachine<String, String> stateMachine;
+
+    @Override
+    public void doQuirk() {
+        stateMachine.sendEvent("NAMED_EVENT");
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/OrderedService.java

@@ -0,0 +1,5 @@
+package click.kamil.examples.statemachine.extended.service;
+
+public interface OrderedService {
+    void doAction();
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/PaymentService.java

@@ -0,0 +1,6 @@
+package click.kamil.examples.statemachine.extended.service;
+
+public interface PaymentService {
+    void processPayment(String paymentId);
+    void capturePayment(String paymentId);
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/PaymentServiceImpl.java

@@ -0,0 +1,37 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.statemachine.StateMachine;
+import org.springframework.statemachine.persist.StateMachinePersister;
+import org.springframework.stereotype.Service;
+
+@Service
+public class PaymentServiceImpl implements PaymentService {
+
+    @Autowired
+    @Qualifier("paymentStateMachine")
+    private StateMachine<String, String> stateMachine;
+
+    @Autowired
+    private StateMachinePersister<String, String, String> persister;
+
+    @Override
+    public void processPayment(String paymentId) {
+        // Send a trigger mapped strictly to PaymentStateMachineConfig
+        stateMachine.sendEvent("AUTHORIZE");
+    }
+
+    @Override
+    public void capturePayment(String paymentId) {
+        try {
+            persister.restore(stateMachine, paymentId);
+        } catch (Exception e) {}
+        
+        org.springframework.messaging.Message<String> msg = org.springframework.messaging.support.MessageBuilder
+            .withPayload("CAPTURE")
+            .setHeader("paymentId", paymentId)
+            .build();
+        stateMachine.sendEvent(msg);
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/PrimaryQuirkService.java

@@ -0,0 +1,21 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Primary;
+import org.springframework.statemachine.StateMachine;
+import org.springframework.stereotype.Service;
+
+@Service
+@Primary
+public class PrimaryQuirkService implements QuirkService {
+
+    @Autowired
+    @Qualifier("paymentStateMachine")
+    private StateMachine<String, String> stateMachine;
+
+    @Override
+    public void doQuirk() {
+        stateMachine.sendEvent("PRIMARY_EVENT");
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/ProfiledQuirkService.java

@@ -0,0 +1,21 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Profile;
+import org.springframework.statemachine.StateMachine;
+import org.springframework.stereotype.Service;
+
+@Service
+@Profile("nonexistent")
+public class ProfiledQuirkService implements QuirkService {
+
+    @Autowired
+    @Qualifier("paymentStateMachine")
+    private StateMachine<String, String> stateMachine;
+
+    @Override
+    public void doQuirk() {
+        stateMachine.sendEvent("PROFILED_EVENT");
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/QualifierQuirkService.java

@@ -0,0 +1,19 @@
+package click.kamil.examples.statemachine.extended.service;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.statemachine.StateMachine;
+import org.springframework.stereotype.Service;
+
+@Service
+public class QualifierQuirkService implements QuirkService {
+
+    @Autowired
+    @Qualifier("paymentStateMachine")
+    private StateMachine<String, String> stateMachine;
+
+    @Override
+    public void doQuirk() {
+        stateMachine.sendEvent("QUALIFIER_EVENT");
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/service/QuirkService.java

@@ -0,0 +1,5 @@
+package click.kamil.examples.statemachine.extended.service;
+
+public interface QuirkService {
+    void doQuirk();
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/web/BaseController.java

@@ -0,0 +1,10 @@
+package click.kamil.examples.statemachine.extended.web;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+
+public interface BaseController {
+
+    @GetMapping("/api/base/{id}")
+    String processBaseEndpoint(@PathVariable String id);
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/web/ConcreteReturnTypeController.java

@@ -0,0 +1,21 @@
+package click.kamil.examples.statemachine.extended.web;
+
+import click.kamil.examples.statemachine.extended.service.QuirkService;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class ConcreteReturnTypeController {
+
+    private final QuirkService hiddenConcreteService;
+
+    public ConcreteReturnTypeController(@Qualifier("hiddenConcreteService") QuirkService hiddenConcreteService) {
+        this.hiddenConcreteService = hiddenConcreteService;
+    }
+
+    @GetMapping("/test-concrete")
+    public void testConcrete() {
+        hiddenConcreteService.doQuirk();
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/web/FieldInjectionController.java

@@ -0,0 +1,20 @@
+package click.kamil.examples.statemachine.extended.web;
+
+import click.kamil.examples.statemachine.extended.service.QuirkService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class FieldInjectionController {
+
+    @Autowired
+    @Qualifier("customName")
+    private QuirkService myFieldService;
+
+    @GetMapping("/test-field")
+    public void testField() {
+        myFieldService.doQuirk();
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/web/ListInjectionController.java

@@ -0,0 +1,24 @@
+package click.kamil.examples.statemachine.extended.web;
+
+import click.kamil.examples.statemachine.extended.service.AmbiguousService;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RestController
+public class ListInjectionController {
+
+    private final List<AmbiguousService> services;
+
+    public ListInjectionController(List<AmbiguousService> services) {
+        this.services = services;
+    }
+
+    @GetMapping("/test-list")
+    public void testList() {
+        for (AmbiguousService s : services) {
+            s.doAmbig();
+        }
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/web/OrderedTestController.java

@@ -0,0 +1,22 @@
+package click.kamil.examples.statemachine.extended.web;
+
+import click.kamil.examples.statemachine.extended.service.OrderedService;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class OrderedTestController {
+
+    private final OrderedService service;
+
+    // The name "service" does not match HighPriorityOrderedService or LowPriorityOrderedService
+    // So the Fallback by name will fail, and it will fall back to @Order
+    public OrderedTestController(OrderedService service) {
+        this.service = service;
+    }
+
+    @GetMapping("/test-order")
+    public void testOrder() {
+        service.doAction();
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/web/PaymentController.java

@@ -0,0 +1,28 @@
+package click.kamil.examples.statemachine.extended.web;
+
+import click.kamil.examples.statemachine.extended.service.PaymentService;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.PathVariable;
+
+@RestController
+public class PaymentController implements BaseController {
+
+    private final PaymentService paymentService;
+
+    public PaymentController(PaymentService paymentService) {
+        this.paymentService = paymentService;
+    }
+
+    @Override
+    public String processBaseEndpoint(@PathVariable String id) {
+        paymentService.processPayment(id);
+        return "Started Base Payment: " + id;
+    }
+
+    @PostMapping("/api/payment/{id}/capture")
+    public String capturePaymentEndpoint(@PathVariable String id) {
+        paymentService.capturePayment(id);
+        return "Captured: " + id;
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/web/QuirkController.java

@@ -0,0 +1,45 @@
+package click.kamil.examples.statemachine.extended.web;
+
+import click.kamil.examples.statemachine.extended.service.QuirkService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class QuirkController {
+
+    @Autowired
+    private QuirkService quirkService; // Should resolve to PrimaryQuirkService
+
+    @Autowired
+    @Qualifier("customName")
+    private QuirkService someService; // Should resolve to NamedQuirkService
+
+    @Autowired
+    @Qualifier("qualifierQuirkService")
+    private QuirkService anotherService; // Should resolve to QualifierQuirkService
+
+    @Autowired
+    private QuirkService fallbackQuirkService; // Should resolve to FallbackQuirkService
+
+    @PostMapping("/api/quirk/primary")
+    public void testPrimary() {
+        quirkService.doQuirk();
+    }
+
+    @PostMapping("/api/quirk/named")
+    public void testNamed() {
+        someService.doQuirk();
+    }
+
+    @PostMapping("/api/quirk/qualifier")
+    public void testQualifier() {
+        anotherService.doQuirk();
+    }
+
+    @PostMapping("/api/quirk/fallback")
+    public void testFallback() {
+        fallbackQuirkService.doQuirk();
+    }
+}

state_machines/extended_analysis_sample/src/main/java/click/kamil/examples/statemachine/extended/web/SetterInjectionController.java

@@ -0,0 +1,23 @@
+package click.kamil.examples.statemachine.extended.web;
+
+import click.kamil.examples.statemachine.extended.service.QuirkService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class SetterInjectionController {
+
+    private QuirkService setterService;
+
+    @Autowired
+    public void setSetterService(@Qualifier("customName") QuirkService setterService) {
+        this.setterService = setterService;
+    }
+
+    @GetMapping("/test-setter")
+    public void testSetter() {
+        setterService.doQuirk();
+    }
+}

state_machines/extended_analysis_sample/src/main/resources/hints.json

@@ -1,6 +0,0 @@
-[
-  {
-    "methodFqn": "ExternalNotificationService.sendExternalNotification",
-    "event": "EXTERNAL_TRIGGER"
-  }
-]

state_machines/polymorphic_events_sample/.gitignore

@@ -0,0 +1,37 @@
+HELP.md
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/

state_machines/polymorphic_events_sample/build.gradle

@@ -0,0 +1,45 @@
+plugins {
+	id 'java'
+	id 'org.springframework.boot' version '3.5.3'
+	id 'io.spring.dependency-management' version '1.1.7'
+}
+
+group = 'click.kamil'
+version = '0.0.1-SNAPSHOT'
+
+java {
+	toolchain {
+		languageVersion = JavaLanguageVersion.of(21)
+	}
+}
+
+repositories {
+	mavenCentral()
+}
+
+configurations {
+	compileOnly {
+		extendsFrom annotationProcessor
+	}
+}
+
+repositories {
+	mavenCentral()
+}
+
+dependencies {
+	implementation 'org.springframework.boot:spring-boot-starter'
+	implementation 'org.springframework.statemachine:spring-statemachine-starter:3.2.0'
+
+	compileOnly 'org.projectlombok:lombok'
+	annotationProcessor 'org.projectlombok:lombok'
+	testImplementation 'org.springframework.boot:spring-boot-starter-test'
+	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+}
+
+tasks.named('test') {
+	useJUnitPlatform()
+}
+
+bootJar { enabled = false }
+jar { enabled = true }

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/AbcdEvent.java

@@ -0,0 +1,8 @@
+package click.kamil.examples.statemachine.polymorphic;
+
+public class AbcdEvent implements CustomCodeEventInterface {
+    @Override
+    public OrderEvents resolveEventCode() {
+        return OrderEvents.ABCD;
+    }
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/BaseEvent.java

@@ -0,0 +1,2 @@
+package click.kamil.examples.statemachine.polymorphic;
+public interface BaseEvent { OrderEvents getType(); }

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/CancelEvent.java

@@ -0,0 +1,4 @@
+package click.kamil.examples.statemachine.polymorphic;
+public class CancelEvent implements BaseEvent {
+    @Override public OrderEvents getType() { return OrderEvents.CANCEL; }
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/CustomCodeEventInterface.java

@@ -0,0 +1,5 @@
+package click.kamil.examples.statemachine.polymorphic;
+
+public interface CustomCodeEventInterface {
+    OrderEvents resolveEventCode();
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/EventBuilder.java

@@ -0,0 +1,11 @@
+package click.kamil.examples.statemachine.polymorphic;
+
+public class EventBuilder {
+    public static BaseEvent buildEvent() {
+        return new FulfillEvent();
+    }
+    
+    public BaseEvent buildInstanceEvent() {
+        return new CancelEvent();
+    }
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/FulfillEvent.java

@@ -0,0 +1,4 @@
+package click.kamil.examples.statemachine.polymorphic;
+public class FulfillEvent implements BaseEvent {
+    @Override public OrderEvents getType() { return OrderEvents.FULFILL; }
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/MysteryPayload.java

@@ -0,0 +1,9 @@
+package click.kamil.examples.statemachine.polymorphic;
+
+public class MysteryPayload implements CustomCodeEventInterface {
+    @Override
+    public OrderEvents resolveEventCode() {
+        int a = (int) (Math.random() * 10);
+        return a > 5 ? OrderEvents.ABCD : OrderEvents.PAY;
+    }
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/OrderEvents.java

@@ -0,0 +1,2 @@
+package click.kamil.examples.statemachine.polymorphic;
+public enum OrderEvents { FULFILL, PAY, CANCEL, ABCD, NOPE, IGNORE }

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/OrderService.java

@@ -0,0 +1,23 @@
+package click.kamil.examples.statemachine.polymorphic;
+import org.springframework.statemachine.StateMachine;
+import org.springframework.stereotype.Service;
+import org.springframework.messaging.support.MessageBuilder;
+
+@Service
+public class OrderService {
+    private final StateMachine<OrderStates, OrderEvents> sm;
+
+    public OrderService(StateMachine<OrderStates, OrderEvents> sm) { this.sm = sm; }
+
+    public void processEvent(BaseEvent event) {
+        sm.sendEvent(event.getType());
+    }
+    
+    public void processPayloadEvent(Object payload) {
+        sm.sendEvent(MessageBuilder.withPayload(payload).build());
+    }
+
+    public void processCustomEvent(CustomCodeEventInterface event) {
+        sm.sendEvent(event.resolveEventCode());
+    }
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/OrderStates.java

@@ -0,0 +1,2 @@
+package click.kamil.examples.statemachine.polymorphic;
+public enum OrderStates { SUBMITTED, PAID, FULFILLED, CANCELED, PAID1, PAID2, PAID3, INVALID, HAPPEN, SKIPPED, NEVER }

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/PayEvent.java

@@ -0,0 +1,4 @@
+package click.kamil.examples.statemachine.polymorphic;
+public class PayEvent implements BaseEvent {
+    @Override public OrderEvents getType() { return OrderEvents.PAY; }
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicController.java

@@ -0,0 +1,79 @@
+package click.kamil.examples.statemachine.polymorphic;
+
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class PolymorphicController {
+
+    private final OrderService orderService;
+
+    public PolymorphicController(OrderService orderService) {
+        this.orderService = orderService;
+    }
+
+    @PostMapping("/pay")
+    public void pay() {
+        orderService.processEvent(new PayEvent());
+    }
+
+    @PostMapping("/fulfill")
+    public void fulfill() {
+        orderService.processEvent(new FulfillEvent());
+    }
+
+    @PostMapping("/cancel")
+    public void cancel() {
+        orderService.processEvent(new CancelEvent());
+    }
+
+    @PostMapping("/payload-pay")
+    public void payloadPay() {
+        orderService.processPayloadEvent(new PayEvent());
+    }
+
+    @PostMapping("/pay-variable")
+    public void payVariable() {
+        PayEvent event = new PayEvent();
+        orderService.processEvent(event);
+    }
+
+    @PostMapping("/pay-cast")
+    public void payCast() {
+        orderService.processEvent((BaseEvent) new PayEvent());
+    }
+
+    @PostMapping("/pay-ternary")
+    public void payTernary(boolean isPay) {
+        orderService.processEvent(isPay ? new PayEvent() : new CancelEvent());
+    }
+
+    @PostMapping("/pay-list")
+    public void payList() {
+        java.util.List<BaseEvent> events = java.util.Arrays.asList(new PayEvent(), new FulfillEvent());
+        for (BaseEvent event : events) {
+            orderService.processEvent(event);
+        }
+    }
+
+    @PostMapping("/pay-builder-static")
+    public void payBuilderStatic() {
+        orderService.processEvent(EventBuilder.buildEvent());
+    }
+
+    @PostMapping("/pay-builder-instance")
+    public void payBuilderInstance() {
+        EventBuilder builder = new EventBuilder();
+        orderService.processEvent(builder.buildInstanceEvent());
+    }
+
+    @PostMapping("/abcd")
+    public void abcd() {
+        orderService.processCustomEvent(new AbcdEvent());
+    }
+
+    @PostMapping("/mystery")
+    public void mystery() {
+        orderService.processCustomEvent(new MysteryPayload());
+    }
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/PolymorphicStateMachineConfiguration.java

@@ -0,0 +1,23 @@
+package click.kamil.examples.statemachine.polymorphic;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.statemachine.config.EnableStateMachine;
+import org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter;
+import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
+import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
+
+@Configuration
+@EnableStateMachine
+public class PolymorphicStateMachineConfiguration extends EnumStateMachineConfigurerAdapter<OrderStates, OrderEvents> {
+    @Override
+    public void configure(StateMachineStateConfigurer<OrderStates, OrderEvents> states) throws Exception {
+        states.withStates().initial(OrderStates.SUBMITTED).state(OrderStates.PAID).state(OrderStates.FULFILLED).state(OrderStates.CANCELED);
+    }
+    @Override
+    public void configure(StateMachineTransitionConfigurer<OrderStates, OrderEvents> transitions) throws Exception {
+        transitions
+            .withExternal().source(OrderStates.SUBMITTED).target(OrderStates.PAID).event(OrderEvents.PAY).and()
+            .withExternal().source(OrderStates.PAID).target(OrderStates.FULFILLED).event(OrderEvents.FULFILL).and()
+            .withExternal().source(OrderStates.SUBMITTED).target(OrderStates.CANCELED).event(OrderEvents.CANCEL).and()
+            .withExternal().source(OrderStates.PAID).target(OrderStates.CANCELED).event(OrderEvents.ABCD);
+    }
+}

state_machines/polymorphic_events_sample/src/main/java/click/kamil/examples/statemachine/polymorphic/app/StateMachineApplication.java

@@ -0,0 +1,7 @@
+package click.kamil.examples.statemachine.polymorphic.app;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+@SpringBootApplication
+public class StateMachineApplication {
+    public static void main(String[] args) { SpringApplication.run(StateMachineApplication.class, args); }
+}

state_machines/polymorphic_events_sample/src/main/resources/application.properties

@@ -0,0 +1 @@
+spring.application.name=statemachinedemo