kotlin

InspectGolden.java

@@ -0,0 +1,22 @@
+import java.nio.file.*;
+import java.util.*;
+import click.kamil.springstatemachineexporter.service.ExportService;
+import click.kamil.springstatemachineexporter.exporter.*;
+import click.kamil.springstatemachineexporter.analysis.service.EnrichmentService;
+
+public class InspectGolden {
+    public static void main(String[] args) throws Exception {
+        Path inputDir = Path.of("state_machines/complex_state_machine");
+        Path tempDir = Files.createTempDirectory("golden-update-");
+        
+        List<StateMachineExporter> exporters = List.of(new PlantUml(), new Dot(), new Scxml(), new JsonExporter());
+        EnrichmentService enrichmentService = new EnrichmentService(Collections.emptyList());
+        ExportService exportService = new ExportService(exporters, enrichmentService);
+        
+        exportService.runExporter(inputDir, tempDir, null, true);
+        
+        try (var stream = Files.list(tempDir)) {
+            stream.forEach(System.out::println);
+        }
+    }
+}

README.md

@@ -1,34 +1,38 @@
+# Spring State Machine Explorer
 
-```shell
-brew install graphviz
+Static analysis tool to extract and visualize Spring State Machines with deep code traceability.
+
+## Core Modules
+- **`state_machine_exporter`**: Java AST analyzer. Scans source code, resolves local Maven/Gradle dependencies, and extracts logic (Lambdas, Actions, Guards) into JSON/PUML.
+- **`state_machine_exporter_html`**: Generates an interactive HTML portal with SVG diagrams and rich tooltips.
+
+## Usage
+
+### 1. Extract Metadata (JSON)
+```bash
+./gradlew :state_machine_exporter:run --args="-i ./my-project -o ./out -f json"
 ```
 
-```shell
-dot -Tpng statemachine.dot -o statemachine.png
+### 2. Generate Interactive Portal (HTML)
+```bash
+./gradlew :state_machine_exporter_html:run --args="-i ./my-project -o ./out_html"
+```
+*Supports `--profiles prod` to resolve Spring property placeholders.*
+
+## Business Flows
+Define sequence of events in `src/main/resources/flows.json`:
+```json
+[
+  {
+    "name": "Order Success",
+    "description": "Happy path for order placement",
+    "steps": ["PAY", "CHECK_AVAILABILITY->PENDING", "SHIP"]
+  }
+]
 ```
 
-
-```shell
-brew install plantuml
-```
-```shell
-plantuml statemachine.puml
-plantuml -tsvg statemachine.puml
-```
-Possible formats
-```shell
-    -teps               To generate images using EPS format
-    -thtml              To generate HTML file for class diagram
-    -tlatex:nopreamble  To generate images using LaTeX/Tikz format without preamble
-    -tlatex             To generate images using LaTeX/Tikz format
-    -tpdf               To generate images using PDF format
-    -tpng               To generate images using PNG format (default)
-    -tscxml             To generate SCXML file for state diagram
-    -tsvg               To generate images using SVG format
-    -ttxt               To generate images with ASCII art
-    -tutxt              To generate images with ASCII art using Unicode characters
-    -tvdx               To generate images using VDX format
-    -txmi               To generate XMI file for class diagram
-```
-
-plantuml statemachine.scxml
+## JSON Structure
+- `metadata.entryPoints`: REST, WebFlux, and JMS entry points.
+- `metadata.callChains`: Trace from API call to machine trigger (`sendEvent`).
+- `transitions.actions[].internalLogic`: Extracted source code/lambdas.
+- `metadata.properties`: Dictionary of all detected Spring profiles.

TODO.md

@@ -1,6 +1,5 @@
 1.extract from all possible formats (ask chatgpt)
 
-[DONE] json
 [TODO] xml, maybe yaml
 
 2. [PLAN] Support external dependencies (JARs/compiled classes):

TestHeuristic.java

@@ -0,0 +1,17 @@
+import java.util.*;
+
+public class TestHeuristic {
+    public static void main(String[] args) {
+        System.out.println(isFullyQualifiedMethod("TransformerImpl.transform"));
+        System.out.println(isFullyQualifiedMethod("Transformer.transform"));
+    }
+    
+    private static boolean isFullyQualifiedMethod(String methodFqn) {
+        if (methodFqn == null || !methodFqn.contains(".")) return false;
+        int lastDot = methodFqn.lastIndexOf('.');
+        String classPart = methodFqn.substring(0, lastDot);
+        if (classPart.contains(".")) return true;
+        if (!classPart.isEmpty() && Character.isUpperCase(classPart.charAt(0))) return true;
+        return false;
+    }
+}

lombok.config

@@ -0,0 +1,3 @@
+lombok.anyConstructor.addConstructorProperties = true
+lombok.jacksonized.flagUsage = ALLOW
+config.stopBubbling = true

run_golden.gradle

@@ -0,0 +1,5 @@
+task runGolden(type: JavaExec) {
+    mainClass = "click.kamil.springstatemachineexporter.GoldenUpdater"
+    classpath = sourceSets.test.runtimeClasspath
+    workingDir = rootProject.projectDir
+}

settings.gradle

@@ -2,6 +2,7 @@ rootProject.name = 'state machine exporter'
 
 include ':file_combine'
 include ':state_machine_exporter'
+include ':state_machine_exporter_html'
 include ':state_machine_exporter_spring_based'
 include ':state_machines:complex_state_machine'
 include ':state_machines:dynamic_state_machine'
@@ -12,3 +13,12 @@ include ':state_machines:inheritance_extra_functions_state_machine'
 include ':state_machines:inheritance_extra_functions2_state_machine'
 include ':state_machines:inheritance_extra_functions3_state_machine'
 include ':state_machines:simple_state_machine'
+include ':state_machines:extended_analysis_sample'
+include ':state_machines:inheritance_sample'
+include ':state_machines:ultimate_ecosystem_sm'
+include ':state_machines:enterprise_order_system'
+include ':state_machines:multi_module_sample:api-module'
+include ':state_machines:multi_module_sample:core-module'
+include ':state_machines:state_machine_enterprise'
+include 'state_machine_exporter_kotlin'
+include ':state_machines:kotlin_simple_state_machine'

state_machine_exporter/build.gradle

@@ -32,10 +32,14 @@ dependencies {
 	// deps for parsing java AST
 	implementation 'org.eclipse.jdt:org.eclipse.jdt.core:3.36.0'
 
+	// Kotlin plugin integration via ServiceLoader
+	runtimeOnly project(':state_machine_exporter_kotlin')
+
 	// Jackson for JSON support
 	implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1'
 	implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.17.1'
 	implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.17.1'
+	implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.17.1'
 
 	compileOnly 'org.projectlombok:lombok:1.18.46'
 	annotationProcessor 'org.projectlombok:lombok:1.18.46'
@@ -45,8 +49,17 @@ dependencies {
 	testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:6.1.0'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher:6.1.0'
 	testImplementation 'org.assertj:assertj-core:3.27.7'
+
+	implementation 'net.sourceforge.plantuml:plantuml:1.2024.3'
 }
 
 tasks.named('test') {
 	useJUnitPlatform()
+	systemProperty "updateGolden", System.getProperty("updateGolden")
+}
+
+task runGolden(type: JavaExec) {
+    mainClass = "click.kamil.springstatemachineexporter.GoldenUpdater"
+    classpath = sourceSets.test.runtimeClasspath
+    workingDir = rootProject.projectDir
 }

state_machine_exporter/flow_renderer_plan/html_generator_architecture.md

@@ -1,101 +0,0 @@
-# Interactive HTML Generator: Architecture & Flow Definition Format
-
-Following the success of the interactive SVG PoC, this document outlines the proposed architecture for adding an **HTML Generator** to the State Machine Exporter, allowing users to define and visualize specific business flows dynamically.
-
-## 1. The Flow Definition Format (JSON & JSON Schema)
-
-To make the interactive HTML generator useful and intuitive, users need a way to define their business flows externally. Rather than reinventing the wheel, we looked at industry standards for defining graph paths, workflows, and execution traces:
-*   **Workflow Definitions:** Tools like *Amazon States Language (ASL)*, *SCXML*, and *XState* are highly structured but define the *entire* machine's logic. They are too heavy for simply defining a "path" through an existing machine.
-*   **Trace Formats:** *OpenTelemetry (OTel)* uses "Spans" to represent individual steps forming a "Trace". This is closer to what we want (a history of states).
-*   **Graph Formats:** The *JSON Graph Format (JGF)* standardizes graph nodes and edges representation but is geared towards raw data modeling rather than human-readable business flows.
-
-**Conclusion on Format:** We will use a lightweight custom JSON format inspired by execution traces. It is designed to be highly readable for humans defining business flows, relying simply on ordered arrays of State names.
-
-### JSON Schema for IDE Autocomplete
-To make the format truly intuitive and prevent typos, we will publish a **JSON Schema** (`flow-schema.json`). 
-By referencing this schema, developers writing `flows.json` in IDEs like VS Code or IntelliJ will get **instant autocomplete, hover tooltips, and real-time validation** for fields like `id`, `title`, and `color`.
-*   *Future Enhancement:* The Java exporter could dynamically generate a project-specific JSON Schema on the fly that hardcodes the allowed `enum` values for the `path` array (e.g., restricted exactly to `"SUBMITTED"`, `"PAID"`, etc.), providing perfect autocomplete for state names!
-
-### Proposed Schema (`flows.json`)
-
-```json
-{
-  "$schema": "./flow-schema.json",
-  "stateMachine": "click.kamil.examples.statemachine.simple.SimpleEnumStateMachineConfiguration",
-  "flows": [
-    {
-      "id": "flow-happy-path",
-      "title": "Happy Path (Success)",
-      "description": "The standard flow for a successful order: Submitted -> Paid -> Fulfilled.",
-      "color": "#32CD32", 
-      "path": [
-        ".start.",
-        "SUBMITTED",
-        "PAID",
-        "FULFILLED",
-        ".end."
-      ]
-    },
-    {
-      "id": "flow-cancel-post-pay",
-      "title": "Cancel Post-Payment",
-      "description": "Order is canceled after payment.",
-      "color": "#FF6347",
-      "path": [
-        ".start.",
-        "SUBMITTED",
-        "PAID",
-        "CANCELED",
-        ".end."
-      ]
-    }
-  ]
-}
-```
-
-### Format Details:
-*   **`$schema`**: Points to the JSON schema for IDE tooling.
-*   **`stateMachine`**: Links these flows to a specific state machine configuration in the codebase.
-*   **`id`**: A unique identifier for the flow (used for DOM elements).
-*   **`title` & `description`**: Rendered in the HTML sidebar for the user.
-*   **`color` (Optional)**: Allows overriding the default highlight color (e.g., green for success, red for errors).
-*   **`path`**: An ordered array of **State Names** (acting like an OpenTelemetry trace). 
-    *   *Note on Edges:* The user only needs to define the *states* they pass through. The generator will automatically calculate the edges (transitions) between these states to highlight the lines. Special tokens like `.start.` and `.end.` map to the initial and terminal pseudo-states.
-
-## 2. Robust Error Handling & Input Validation
-
-Before generating the HTML, the exporter **must validate** that the provided `flows.json` is logically sound against the actual codebase AST. If a user defines a flow that isn't physically possible in the state machine, the tool must fail fast with highly descriptive errors.
-
-### Validation Rules & Error Handling Strategy:
-1.  **Schema Validation (Syntax):** 
-    *   *Check:* Is the JSON structurally correct (required fields present, correct types)?
-    *   *Error:* "Invalid format in flows.json: 'title' is required for flow 'flow-cancel-post-pay'."
-2.  **State Existence (Dangling Pointers):**
-    *   *Check:* Every state listed in the `path` array must exist in the parsed `StateMachineModel`.
-    *   *Error:* "Validation Error in 'Happy Path': State 'FULLFILLED' does not exist in StateMachine 'SimpleEnum'. Did you mean 'FULFILLED'?" (implementing a Levenshtein distance check for typos would be excellent here).
-3.  **Transition Validity (Impossible Paths):** 
-    *   *Check:* For every adjacent pair in the `path` array (e.g., `["SUBMITTED", "PAID"]`), the validator must check the `StateMachineModel.getTransitions()` to ensure a valid transition exists where `source == "SUBMITTED"` and `target == "PAID"`.
-    *   *Error:* "Validation Error in 'Happy Path': No transition exists from 'PAID' to 'SUBMITTED'. Please check your state machine configuration."
-4.  **Ambiguous Transitions (Multiple Edges):** 
-    *   *Check:* If multiple transitions exist between the same two states (e.g., two different events trigger a move from A -> B).
-    *   *Handling:* By default, highlight *all* edges between A and B to represent the general path.
-    *   *Future Enhancement:* Expand the JSON format to allow specifying the exact `event` name in the path array (e.g., `["SUBMITTED", {"state": "PAID", "event": "PAY_CREDIT_CARD"}]`) to disambiguate.
-
-## 3. HTML Generation Strategy
-
-The HTML Exporter will be a new class implementing the `StateMachineExporter` interface (or a specialized decorator around the `PlantUml` exporter).
-
-### Steps for Generation:
-1.  **Generate PlantUML SVG:** First, use the existing PlantUML engine to generate the raw SVG string in memory (using the modern CSS `<style>` approach we finalized).
-2.  **Parse `flows.json`:** Load the user-provided flow definitions.
-3.  **Validate Flows:** Run the "Flow Validator" against the AST `StateMachineModel`.
-4.  **Calculate Edges:** For each valid flow, convert the `path` array (States) into an `edges` array (Transitions) so the Javascript knows exactly which SVG arrows to highlight.
-5.  **Inject Template:** Load a base HTML template (similar to `interactive_poc2.html`).
-6.  **Data Binding:** 
-    *   Inject the raw `<svg>` string directly into the template (avoiding CORS issues).
-    *   Inject the validated flow data into a `<script>` tag as a JSON object, or directly render the sidebar HTML elements with `data-*` attributes.
-7.  **Output:** Write the final standalone `.html` file to the output directory.
-
-## 4. Advantages of this Architecture
-*   **Standalone Output:** The resulting HTML file is 100% self-contained. No server, no external CSS/JS, and no CORS issues. It can be directly emailed, attached to Jira tickets, or hosted on GitHub Pages.
-*   **CI/CD Integration:** Because validation is strictly tied to the AST, if a developer refactors the Java State Machine and breaks a documented "Flow", the CI pipeline will fail, ensuring interactive documentation never goes out of date.

state_machine_exporter/flow_renderer_plan/interactive_flow_highlighting_research.md

@@ -1,66 +0,0 @@
-# Thought Experiment: Interactive SVG Flow Highlighting
-
-## Overview
-The goal of this thought experiment is to explore the feasibility and usefulness of animating or interactively highlighting specific "flows" (paths composed of states and transitions) within a generated state machine diagram. For example, hovering over a label like "Successful Payment Flow" would highlight the `SUBMITTED -> PAID -> FULFILLED` path, dimming the rest of the diagram.
-
-## Usefulness
-This feature would be **highly useful** and would significantly elevate the value of the State Machine Exporter:
-1. **Comprehension of Complex Machines:** In large diagrams (like `ComplexStateMachineConfig`), a static image becomes a "spaghetti" of crossing lines. Interactive highlighting allows developers to visually isolate a single business transaction (e.g., "Cancellation Flow", "Refund Flow") without losing the context of the whole machine.
-2. **Documentation & Onboarding:** It turns a static architectural diagram into an interactive documentation tool, making it much easier for new team members to trace how an entity moves through its lifecycle.
-3. **Debugging:** By defining flows based on logged events, a developer could "replay" a sequence of events and see exactly what path the state machine took.
-
-## Feasibility
-This is **entirely feasible** using the tools currently available in the project.
-
-### The Technical Reality of PlantUML SVGs
-When PlantUML generates an SVG (`plantuml -tsvg`), it embeds highly predictable metadata into the DOM structure:
-- **States (Nodes):** PlantUML creates `<g>` elements for states. They typically have an `id` matching the state name (e.g., `id="FULFILLED"`) or prefixed with entity (e.g., `id="entity_SUBMITTED"`).
-- **Transitions (Links):** PlantUML creates `<g>` elements for arrows with predictable IDs and data attributes. For example: `<g class="link" data-entity-1="SUBMITTED" data-entity-2="PAID" id="link_SUBMITTED_PAID">`.
-
-Because these identifiers match the semantic names of the states in the Java/JSON model, mapping a logical "Flow" to visual SVG elements is straightforward.
-
-## Proposed Technical Approach
-
-To realize this, we would build a lightweight **Interactive HTML Exporter** (or augment the JSON exporter to generate a companion HTML file).
-
-### 1. Data Structure (The "Flow" Definition)
-We need a way to define flows. This could be passed via configuration or inferred from the model. A flow is essentially an array of IDs:
-```json
-{
-  "name": "Successful Payment",
-  "elements": ["SUBMITTED", "link_SUBMITTED_PAID", "PAID", "link_PAID_FULFILLED", "FULFILLED"]
-}
-```
-
-### 2. HTML/JS Wrapper
-Instead of just outputting an `.svg` or `.png`, the exporter would output an `.html` file that contains:
-1. **The inline SVG code** (generated via PlantUML).
-2. **A Sidebar UI** containing a list of defined flows.
-3. **Vanilla JavaScript** to handle the interactivity.
-
-### 3. The JavaScript Logic (Proof of Concept)
-The JS logic is remarkably simple. It listens for `mouseenter` events on the flow list:
-1. **Dim Everything:** Add a class to the root SVG wrapper (e.g., `.flow-active`) that sets `opacity: 0.2` on all `<g>` tags.
-2. **Highlight Flow:** Iterate through the `elements` array of the active flow. Find the SVG elements by their `id` (e.g., `document.getElementById('link_SUBMITTED_PAID')`) and add a `.highlighted` class.
-3. **CSS Magic:** 
-```css
-.diagram-container.flow-active svg g.highlighted {
-  opacity: 1 !important;
-}
-.diagram-container.flow-active svg g.highlighted path {
-  stroke: red !important;
-  stroke-width: 3px !important;
-}
-```
-
-## Limitations & Challenges
-
-While feasible, there are a few edge cases to handle:
-
-1. **Multiple Transitions Between Same States:** If there are two distinct transitions from `A` to `B` (e.g., triggered by different events), PlantUML might generate IDs like `link_A_B` and `link_A_B_1`. The JS logic would need to rely on the event stereotypes we added recently (e.g., `<<e_PAY>>`) to distinguish them. We could parse the SVG text nodes to find the event label, or rely on the custom CSS classes if PlantUML supports passing them through to SVG (currently, PlantUML inlines styles rather than keeping CSS classes for transitions).
-2. **Layout Shifts:** We must rely purely on CSS styling (colors, opacities, stroke widths). We cannot animate the *position* or layout of the arrows because PlantUML hardcodes the exact SVG path coordinates.
-3. **Standalone vs. Hosted:** Generating a single `.html` file is easy and portable. However, if this is meant to be embedded in a documentation site (like Confluence or Backstage), injecting custom JS/CSS along with raw SVG can sometimes run into sanitization or iframe limitations.
-4. **Maintenance:** Any changes to how PlantUML generates its internal SVG IDs in future versions would break the JS highlighting logic.
-
-## Conclusion
-The idea is brilliant. It transforms the output from a static image into an interactive, exploratory tool. Since the `StateMachineModel` is already cleanly exported as JSON, a standalone frontend script could easily marry that JSON data with the PlantUML SVG output to create dynamic, highlightable documentation flows without requiring heavy backend changes.

state_machine_exporter/flow_renderer_plan/interactive_poc.html

@@ -1,90 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<style>
-  body { font-family: sans-serif; display: flex; }
-  #sidebar { width: 300px; padding: 20px; background: #f4f4f4; }
-  #diagram { flex-grow: 1; padding: 20px; }
-  
-  .flow-btn { padding: 10px; margin-bottom: 5px; cursor: pointer; background: #ddd; border: 1px solid #ccc; border-radius: 4px;}
-  .flow-btn:hover { background: #bdf; }
-
-  /* Dim everything by default when a flow is active */
-  .diagram-container.flow-active svg g {
-    opacity: 0.2;
-    transition: opacity 0.3s;
-  }
-  
-  /* Highlight active elements */
-  .diagram-container.flow-active svg g.highlighted {
-    opacity: 1 !important;
-  }
-  
-  /* Make highlighted paths thicker/red */
-  .diagram-container.flow-active svg g.highlighted path, 
-  .diagram-container.flow-active svg g.highlighted polygon {
-    stroke: red !important;
-    stroke-width: 3px !important;
-  }
-  
-  .diagram-container.flow-active svg g.highlighted rect,
-  .diagram-container.flow-active svg g.highlighted ellipse {
-    stroke: red !important;
-    stroke-width: 3px !important;
-  }
-</style>
-</head>
-<body>
-
-<div id="sidebar">
-  <h3>Flows</h3>
-  <div class="flow-btn" data-flow='["SUBMITTED", "link_SUBMITTED_PAID", "PAID", "link_PAID_FULFILLED", "FULFILLED"]'>Flow: Successful Payment</div>
-  <div class="flow-btn" data-flow='["SUBMITTED", "link_SUBMITTED_CANCELED", "CANCELED"]'>Flow: Cancel Before Pay</div>
-</div>
-
-<div id="diagram" class="diagram-container">
-  <!-- SVG will be injected here -->
-</div>
-
-<script>
-  // Load SVG
-  fetch('SimpleEnumStateMachineConfiguration.svg')
-    .then(r => r.text())
-    .then(svg => {
-       document.getElementById('diagram').innerHTML = svg;
-       setupInteractivity();
-    });
-
-  function setupInteractivity() {
-    const container = document.getElementById('diagram');
-    
-    document.querySelectorAll('.flow-btn').forEach(btn => {
-      btn.addEventListener('mouseenter', (e) => {
-        container.classList.add('flow-active');
-        const flowIds = JSON.parse(e.target.getAttribute('data-flow'));
-        
-        flowIds.forEach(id => {
-          // PlantUML sometimes prepends entity_
-          let el = document.getElementById(id) || document.getElementById('entity_' + id);
-          if(el) {
-             el.classList.add('highlighted');
-          } else {
-             // For links, fallback to data-attributes if id parsing fails
-             if (id.startsWith('link_')) {
-                 const parts = id.split('_');
-                 let link = document.querySelector(`g[data-entity-1="${parts[1]}"][data-entity-2="${parts[2]}"]`);
-                 if (link) link.classList.add('highlighted');
-             }
-          }
-        });
-      });
-
-      btn.addEventListener('mouseleave', () => {
-        container.classList.remove('flow-active');
-        document.querySelectorAll('.highlighted').forEach(el => el.classList.remove('highlighted'));
-      });
-    });
-  }
-</script>
-</body>
-</html>

state_machine_exporter/out_simple/click.kamil.examples.statemachine.simple.SimpleEnumStateMachineConfiguration/click.kamil.examples.statemachine.simple.SimpleEnumStateMachineConfiguration.dot

@@ -1,29 +0,0 @@
-digraph statemachine {
-  rankdir=LR;
-  node [shape=rounded, style=filled, fillcolor=white, fontname="Arial"];
-  edge [fontname="Arial", fontsize=10];
-
-  SUBMITTED_choice [shape=diamond, label="", fillcolor="blue", width=0.2, height=0.2];
-  SUBMITTED -> SUBMITTED_choice [style=dotted, color="blue"];
-  PAID_choice [shape=diamond, label="", fillcolor="green", width=0.2, height=0.2];
-  PAID -> PAID_choice [style=dotted, color="green"];
-  _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.CANCEL", style="solid", color="black"];
-  SUBMITTED -> SUBMITTED [label="OrderEvents.ABCD", style="solid", color="black"];
-  SUBMITTED_choice -> PAID2 [label="[λ] (order=0)", style="solid", color="blue"];
-  SUBMITTED_choice -> PAID3 [label="(order=1)", style="solid", color="blue"];
-  PAID_choice -> PAID1 [label="[λ] (order=0)", style="solid", color="green"];
-  PAID_choice -> PAID2 [label="[guard1] (order=1)", style="solid", color="green"];
-  PAID_choice -> HAPPEN [label="[λ] (order=2)", style="solid", color="green"];
-  PAID_choice -> PAID3 [label="(order=3)", style="solid", color="green"];
-  PAID2 -> CANCELED [style="solid", color="black"];
-  PAID3 -> CANCELED [style="solid", color="black"];
-  PAID1 -> PAID1 [label="OrderEvents.ABCD / λ, action2", style="solid", color="black"];
-}
-

state_machine_exporter/out_simple/click.kamil.examples.statemachine.simple.SimpleEnumStateMachineConfiguration/click.kamil.examples.statemachine.simple.SimpleEnumStateMachineConfiguration.scxml.xml

@@ -1,46 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<scxml xmlns="http://www.w3.org/2005/07/scxml" version="1.0" initial="SUBMITTED">
-  <state id="PAID1">
-    <transition target="PAID1" event="OrderEvents.ABCD"/>
-  </state>
-  <state id="SUBMITTED">
-    <transition target="PAID" event="OrderEvents.PAY"/>
-    <transition target="CANCELED" event="OrderEvents.CANCEL" cond="λ"/>
-    <transition target="SUBMITTED" event="OrderEvents.ABCD"/>
-    <transition target="PAID2" cond="λ">
-      <!-- order=0 -->
-    </transition>
-    <transition target="PAID3">
-      <!-- order=1 -->
-    </transition>
-  </state>
-  <state id="PAID">
-    <transition target="FULFILLED" event="OrderEvents.FULFILL"/>
-    <transition target="CANCELED" event="OrderEvents.CANCEL"/>
-    <transition target="PAID1" cond="λ">
-      <!-- order=0 -->
-    </transition>
-    <transition target="PAID2" cond="guard1">
-      <!-- order=1 -->
-    </transition>
-    <transition target="HAPPEN" cond="λ">
-      <!-- order=2 -->
-    </transition>
-    <transition target="PAID3">
-      <!-- order=3 -->
-    </transition>
-  </state>
-  <state id="CANCELED">
-  </state>
-  <state id="FULFILLED">
-  </state>
-  <state id="PAID3">
-    <transition target="CANCELED"/>
-  </state>
-  <state id="HAPPEN">
-  </state>
-  <state id="PAID2">
-    <transition target="CANCELED"/>
-  </state>
-</scxml>
-

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/Main.java

@@ -1,5 +1,6 @@
 package click.kamil.springstatemachineexporter;
 
+import click.kamil.springstatemachineexporter.analysis.service.EnrichmentService;
 import click.kamil.springstatemachineexporter.exporter.Dot;
 import click.kamil.springstatemachineexporter.exporter.JsonExporter;
 import click.kamil.springstatemachineexporter.exporter.PlantUml;
@@ -8,10 +9,19 @@ import click.kamil.springstatemachineexporter.command.ExporterCommand;
 import click.kamil.springstatemachineexporter.service.ExportService;
 import picocli.CommandLine;
 
+import java.util.Collections;
 import java.util.List;
 
 public class Main {
     public static void main(String[] args) {
+        // Enable diagnostic mode early before SLF4J initializes
+        for (String arg : args) {
+            if ("--debug".equals(arg)) {
+                System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "debug");
+                break;
+            }
+        }
+
         // Manual DI / Wiring
         var exporters = List.of(new PlantUml(), new Dot(), new Scxml(), new JsonExporter());
         var exportService = new ExportService(exporters);

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/AnalysisEnricher.java

@@ -0,0 +1,9 @@
+package click.kamil.springstatemachineexporter.analysis.enricher;
+
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+import click.kamil.springstatemachineexporter.analysis.service.CodebaseIntelligenceProvider;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+
+public interface AnalysisEnricher {
+    void enrich(AnalysisResult result, CodebaseContext context, CodebaseIntelligenceProvider intelligence);
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/CallChainEnricher.java

@@ -0,0 +1,28 @@
+package click.kamil.springstatemachineexporter.analysis.enricher;
+
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.CodebaseMetadata;
+import click.kamil.springstatemachineexporter.analysis.service.CodebaseIntelligenceProvider;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+
+@Slf4j
+public class CallChainEnricher implements AnalysisEnricher {
+
+    @Override
+    public void enrich(AnalysisResult result, CodebaseContext context, CodebaseIntelligenceProvider intelligence) {
+        log.info("Enriching {} with call chains", result.getName());
+        
+        List<CallChain> chains = intelligence.findCallChains(
+                result.getMetadata().getEntryPoints(),
+                result.getMetadata().getTriggers()
+        );
+        
+        result.addMetadata(CodebaseMetadata.builder()
+                .callChains(chains)
+                .build());
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/EntryPointEnricher.java

@@ -0,0 +1,25 @@
+package click.kamil.springstatemachineexporter.analysis.enricher;
+
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+import click.kamil.springstatemachineexporter.analysis.model.CodebaseMetadata;
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.service.CodebaseIntelligenceProvider;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+
+@Slf4j
+public class EntryPointEnricher implements AnalysisEnricher {
+
+    @Override
+    public void enrich(AnalysisResult result, CodebaseContext context, CodebaseIntelligenceProvider intelligence) {
+        log.info("Enriching {} with entry points", result.getName());
+        
+        List<EntryPoint> entryPoints = intelligence.findEntryPoints();
+        
+        result.addMetadata(CodebaseMetadata.builder()
+                .entryPoints(entryPoints)
+                .build());
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/PropertyEnricher.java

@@ -0,0 +1,24 @@
+package click.kamil.springstatemachineexporter.analysis.enricher;
+
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+import click.kamil.springstatemachineexporter.analysis.model.CodebaseMetadata;
+import click.kamil.springstatemachineexporter.analysis.service.CodebaseIntelligenceProvider;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.Map;
+
+@Slf4j
+public class PropertyEnricher implements AnalysisEnricher {
+
+    @Override
+    public void enrich(AnalysisResult result, CodebaseContext context, CodebaseIntelligenceProvider intelligence) {
+        log.info("Enriching {} with properties", result.getName());
+        
+        Map<String, Map<String, String>> properties = intelligence.resolveProperties();
+        
+        result.addMetadata(CodebaseMetadata.builder()
+                .properties(properties)
+                .build());
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/TransitionLinkerEnricher.java

@@ -0,0 +1,256 @@
+package click.kamil.springstatemachineexporter.analysis.enricher;
+
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.analysis.model.CodebaseMetadata;
+import click.kamil.springstatemachineexporter.analysis.model.MatchedTransition;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.analysis.service.CodebaseIntelligenceProvider;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import click.kamil.springstatemachineexporter.model.State;
+import click.kamil.springstatemachineexporter.model.Transition;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import click.kamil.springstatemachineexporter.analysis.enricher.routing.HeuristicBeanResolutionEngine;
+import click.kamil.springstatemachineexporter.analysis.enricher.routing.BeanResolutionEngine;
+import click.kamil.springstatemachineexporter.analysis.enricher.matching.EventMatchingEngine;
+import click.kamil.springstatemachineexporter.analysis.enricher.matching.StrictFqnMatchingEngine;
+
+public class TransitionLinkerEnricher implements AnalysisEnricher {
+
+    private final BeanResolutionEngine routingEngine = new HeuristicBeanResolutionEngine();
+    private final EventMatchingEngine matchingEngine = new StrictFqnMatchingEngine();
+
+    @Override
+    public void enrich(AnalysisResult result, CodebaseContext context, CodebaseIntelligenceProvider intelligence) {
+        if (result.getMetadata() == null || result.getMetadata().getCallChains() == null) {
+            return;
+        }
+
+        List<CallChain> updatedChains = new ArrayList<>();
+        List<Transition> stateMachineTransitions = result.getTransitions();
+
+        for (CallChain chain : result.getMetadata().getCallChains()) {
+            TriggerPoint tp = chain.getTriggerPoint();
+            if (tp == null || tp.getEvent() == null) {
+                updatedChains.add(chain);
+                continue;
+            }
+
+            String triggerEvent = simplify(tp.getEvent());
+            String triggerSource = tp.getSourceState() != null ? simplify(tp.getSourceState()) : null;
+
+            List<MatchedTransition> matched = new ArrayList<>();
+
+            for (Transition t : stateMachineTransitions) {
+                if (t.getEvent() != null && matchingEngine.matches(t.getEvent(), tp)) {
+                    String smEventRaw = t.getEvent().fullIdentifier() != null ? t.getEvent().fullIdentifier() : t.getEvent().rawName();
+                    // Event matches
+                    for (State smSourceState : t.getSourceStates()) {
+                            String smSourceRaw = smSourceState.fullIdentifier() != null ? smSourceState.fullIdentifier() : smSourceState.rawName();
+                            String smSource = simplify(smSourceRaw);
+                            if (triggerSource == null || triggerSource.equals(smSource)) {
+                                if (t.getTargetStates() == null || t.getTargetStates().isEmpty()) {
+                                    MatchedTransition mt = MatchedTransition.builder()
+                                            .sourceState(smSourceRaw)
+                                            .targetState(smSourceRaw)
+                                            .event(smEventRaw)
+                                            .build();
+                                    if (isRoutedToCorrectMachine(chain, result.getName(), context)
+                                            && isConstraintCompatible(tp.getConstraint(), result.getName())) {
+                                        matched.add(mt);
+                                    }
+                                } else {
+                                    for (State smTargetState : t.getTargetStates()) {
+                                        String targetRaw = smTargetState.fullIdentifier() != null ? smTargetState.fullIdentifier() : smTargetState.rawName();
+                                        MatchedTransition mt = MatchedTransition.builder()
+                                                .sourceState(smSourceRaw)
+                                                .targetState(targetRaw)
+                                                .event(smEventRaw)
+                                                .build();
+                                        if (isRoutedToCorrectMachine(chain, result.getName(), context)
+                                                && isConstraintCompatible(tp.getConstraint(), result.getName())) {
+                                            matched.add(mt);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+            if (!matched.isEmpty()) {
+                CallChain newChain = chain.toBuilder().matchedTransitions(matched).build();
+                updatedChains.add(newChain);
+            } else {
+                updatedChains.add(chain);
+            }
+        }
+
+        // Update the metadata with the new call chains
+        CodebaseMetadata updatedMetadata = CodebaseMetadata.builder()
+                .triggers(result.getMetadata().getTriggers())
+                .entryPoints(result.getMetadata().getEntryPoints())
+                .callChains(updatedChains)
+                .properties(result.getMetadata().getProperties())
+                .build();
+
+        result.setMetadata(updatedMetadata);
+    }
+
+    
+    private boolean isRoutedToCorrectMachine(CallChain chain, String currentMachineName, CodebaseContext context) {
+        return routingEngine.isRoutedToCorrectMachine(chain, currentMachineName, context);
+    }
+
+    private boolean isConstraintCompatible(String constraint, String machineName) {
+        if (constraint == null || machineName == null) return true;
+        
+        String cleanMachine = machineName.substring(machineName.lastIndexOf('.') + 1).toUpperCase();
+        if (cleanMachine.endsWith("STATEMACHINECONFIGURATION")) {
+            cleanMachine = cleanMachine.substring(0, cleanMachine.length() - "STATEMACHINECONFIGURATION".length());
+        }
+        if (cleanMachine.endsWith("STATEMACHINE")) {
+            cleanMachine = cleanMachine.substring(0, cleanMachine.length() - "STATEMACHINE".length());
+        }
+        if (cleanMachine.endsWith("CONFIG")) {
+            cleanMachine = cleanMachine.substring(0, cleanMachine.length() - "CONFIG".length());
+        }
+        
+        String expr = constraint;
+        java.util.regex.Pattern p = java.util.regex.Pattern.compile("[\"']([a-zA-Z0-9_-]+)[\"']");
+        java.util.regex.Matcher matcher = p.matcher(constraint);
+        java.util.Set<String> literals = new java.util.HashSet<>();
+        while (matcher.find()) {
+            literals.add(matcher.group(1));
+        }
+        
+        for (String m : literals) {
+            boolean isCurrent = m.equalsIgnoreCase(cleanMachine);
+            String replacement = isCurrent ? "true" : "false";
+            
+            String regex1 = "(?i)[\"']?" + m + "[\"']?\\s*\\.\\s*(equalsIgnoreCase|equals)\\s*\\([^)]*\\)";
+            String regex2 = "(?i)[a-zA-Z0-9._]+\\s*\\.\\s*(equalsIgnoreCase|equals)\\s*\\(\\s*[\"']?" + m + "[\"']?\\s*\\)";
+            String regex3 = "(?i)[a-zA-Z0-9._]+\\s*==\\s*[\"']?" + m + "[\"']?";
+            String regex4 = "(?i)[a-zA-Z0-9._]+\\s*!=\\s*[\"']?" + m + "[\"']?";
+            
+            expr = expr.replaceAll(regex1, replacement);
+            expr = expr.replaceAll(regex2, replacement);
+            expr = expr.replaceAll(regex3, replacement);
+            expr = expr.replaceAll(regex4, isCurrent ? "false" : "true");
+        }
+        
+        try {
+            return BooleanEvaluator.evaluate(expr);
+        } catch (Exception e) {
+            return !expr.contains("false");
+        }
+    }
+
+    private static class BooleanEvaluator {
+        public static boolean evaluate(String expr) {
+            expr = expr.replaceAll("\\s+", "");
+            return parseExpr(expr);
+        }
+
+        private static boolean parseExpr(String s) {
+            if (s.isEmpty()) return true;
+            
+            int parenDepth = 0;
+            for (int i = s.length() - 1; i >= 0; i--) {
+                char c = s.charAt(i);
+                if (c == ')') parenDepth++;
+                else if (c == '(') parenDepth--;
+                else if (parenDepth == 0 && i > 0 && s.charAt(i) == '|' && s.charAt(i - 1) == '|') {
+                    return parseExpr(s.substring(0, i - 1)) || parseExpr(s.substring(i + 1));
+                }
+            }
+            
+            parenDepth = 0;
+            for (int i = s.length() - 1; i >= 0; i--) {
+                char c = s.charAt(i);
+                if (c == ')') parenDepth++;
+                else if (c == '(') parenDepth--;
+                else if (parenDepth == 0 && i > 0 && s.charAt(i) == '&' && s.charAt(i - 1) == '&') {
+                    return parseExpr(s.substring(0, i - 1)) && parseExpr(s.substring(i + 1));
+                }
+            }
+
+            if (s.startsWith("!")) {
+                return !parseExpr(s.substring(1));
+            }
+
+            if (s.startsWith("(") && s.endsWith(")")) {
+                return parseExpr(s.substring(1, s.length() - 1));
+            }
+
+            if (s.equalsIgnoreCase("true")) return true;
+            if (s.equalsIgnoreCase("false")) return false;
+            
+            return true;
+        }
+    }
+
+    private final java.util.Map<String, String> simplifyCache = new java.util.HashMap<>();
+    private final java.util.Map<java.util.Map.Entry<String, String>, Boolean> guardedCache = new java.util.HashMap<>();
+    private static final java.util.regex.Pattern SUFFIX_PATTERN = java.util.regex.Pattern.compile("(?i)(.+)(Event|Action|Transition|Command)(s)?$");
+    private static final java.util.regex.Pattern FQN_PATTERN = java.util.regex.Pattern.compile("^.*\\.([A-Z0-9_]+)$");
+
+    private String simplify(String name) {
+        if (name == null) return null;
+        if (simplifyCache.containsKey(name)) return simplifyCache.get(name);
+        
+        // Strip common suffixes
+        String simplified = SUFFIX_PATTERN.matcher(name).replaceAll("$1");
+        if (simplified.isEmpty()) {
+            simplified = name;
+        }
+        // Simplify full identifiers to just the last part (enum name)
+        simplified = FQN_PATTERN.matcher(simplified).replaceAll("$1");
+        
+        simplifyCache.put(name, simplified);
+        return simplified;
+    }
+
+    private boolean isGuardedContains(String smEvent, String triggerEvent) {
+        if (smEvent == null || triggerEvent == null) return false;
+        
+        // Use a strictly immutable pair to guarantee 100% collision-free caching regardless of string content
+        java.util.Map.Entry<String, String> cacheKey = new java.util.AbstractMap.SimpleImmutableEntry<>(smEvent, triggerEvent);
+        if (guardedCache.containsKey(cacheKey)) return guardedCache.get(cacheKey);
+        
+        boolean result = calculateGuardedContains(smEvent, triggerEvent);
+        guardedCache.put(cacheKey, result);
+        return result;
+    }
+
+    private boolean calculateGuardedContains(String smEvent, String triggerEvent) {
+        // Only fire if it looks like a simple identifier (no spaces, no parens)
+        // Prevents unresolved AST nodes (e.g. "event.getPayload()") from accidentally matching "Event"
+        if (smEvent.contains(" ") || smEvent.contains("(") || smEvent.contains(")") ||
+            triggerEvent.contains(" ") || triggerEvent.contains("(") || triggerEvent.contains(")")) {
+            return false;
+        }
+        
+        String shorter = smEvent.length() < triggerEvent.length() ? smEvent : triggerEvent;
+        String longer = smEvent.length() >= triggerEvent.length() ? smEvent : triggerEvent;
+        
+        shorter = shorter.toLowerCase();
+        longer = longer.toLowerCase();
+        
+        if (longer.contains(shorter)) {
+            // Guard: If the matching part is very short (< 4 chars), it must be bounded by word separators
+            // to avoid matching completely unrelated words (e.g., "PAY" matching "PAYMENT" or "E" matching "UPDATE")
+            if (shorter.length() < 4) {
+                return longer.matches(".*(^|_|-)" + java.util.regex.Pattern.quote(shorter) + "(_|-|$).*");
+            }
+            // For longer strings, a straight contains is usually safe enough
+            return true;
+        }
+        return false;
+    }
+
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/TriggerEnricher.java

@@ -0,0 +1,26 @@
+package click.kamil.springstatemachineexporter.analysis.enricher;
+
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+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.List;
+
+@Slf4j
+public class TriggerEnricher implements AnalysisEnricher {
+
+    @Override
+    public void enrich(AnalysisResult result, CodebaseContext context, CodebaseIntelligenceProvider intelligence) {
+        log.info("Enriching {} with triggers", result.getName());
+        
+        List<TriggerPoint> triggers = intelligence.findTriggerPoints();
+        
+        // Initially, we just add all triggers found in the codebase to the metadata.
+        // In later steps of Phase 2, we will filter them by State Machine ID.
+        result.addMetadata(click.kamil.springstatemachineexporter.analysis.model.CodebaseMetadata.builder()
+                .triggers(triggers)
+                .build());
+    }
+}

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

@@ -0,0 +1,11 @@
+package click.kamil.springstatemachineexporter.analysis.enricher.matching;
+
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.model.Event;
+
+public interface EventMatchingEngine {
+    /**
+     * Determines whether the given trigger point is a match for the state machine event.
+     */
+    boolean matches(Event stateMachineEvent, TriggerPoint triggerPoint);
+}

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

@@ -0,0 +1,192 @@
+package click.kamil.springstatemachineexporter.analysis.enricher.matching;
+
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.model.Event;
+import java.util.List;
+
+public class HeuristicEventMatchingEngine implements EventMatchingEngine {
+
+    private final java.util.Map<java.util.Map.Entry<Event, TriggerPoint>, Boolean> matchesCache = new java.util.HashMap<>();
+
+    @Override
+    public boolean matches(Event stateMachineEvent, TriggerPoint triggerPoint) {
+        if (stateMachineEvent == null || triggerPoint == null || triggerPoint.getEvent() == null) {
+            return false;
+        }
+        java.util.Map.Entry<Event, TriggerPoint> cacheKey = new java.util.AbstractMap.SimpleImmutableEntry<>(stateMachineEvent, triggerPoint);
+        if (matchesCache.containsKey(cacheKey)) return matchesCache.get(cacheKey);
+
+        boolean result = calculateMatches(stateMachineEvent, triggerPoint);
+        matchesCache.put(cacheKey, result);
+        return result;
+    }
+
+    private boolean calculateMatches(Event stateMachineEvent, TriggerPoint triggerPoint) {
+
+        String rawTriggerEvent = triggerPoint.getEvent();
+        String smEventRaw = stateMachineEvent.fullIdentifier() != null ? stateMachineEvent.fullIdentifier() : stateMachineEvent.rawName();
+        String smEvent = simplify(smEventRaw);
+
+        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) || pe.endsWith("." + smEventRaw)) {
+                    hasPolyMatch = true;
+                    break;
+                }
+                String classPe = pe.substring(0, pe.lastIndexOf('.'));
+                String classSm = smEventRaw.substring(0, smEventRaw.lastIndexOf('.'));
+                if (classPe.contains(".") && classSm.contains(".")) {
+                    String p1 = classPe.substring(0, classPe.lastIndexOf('.'));
+                    String p2 = classSm.substring(0, classSm.lastIndexOf('.'));
+                    if (!p1.equals(p2) && !p1.startsWith(p2 + ".") && !p2.startsWith(p1 + ".")) {
+                        continue;
+                    }
+                }
+                String simpleClassPe = classPe.contains(".") ? classPe.substring(classPe.lastIndexOf('.') + 1) : classPe;
+                String simpleClassSm = classSm.contains(".") ? classSm.substring(classSm.lastIndexOf('.') + 1) : classSm;
+                if (!simpleClassPe.equals(simpleClassSm)) {
+                    continue;
+                }
+            }
+
+            String simplePe = pe;
+            if (pe.contains(".")) {
+                simplePe = pe.substring(pe.lastIndexOf('.') + 1);
+            }
+            String simplifiedPe = simplify(simplePe);
+
+            if (simplePe.equals(smEventRaw) || simplePe.equals(smEvent) || 
+                simplePe.equalsIgnoreCase(smEvent) || simplifiedPe.equalsIgnoreCase(smEvent) ||
+                isGuardedContains(smEvent, simplifiedPe)) {
+                hasPolyMatch = true;
+                break;
+            }
+        }
+
+        if (hasPolyMatch) return true;
+        if (polyEvents.isEmpty() && isWildcard) {
+            String eventTypeFqn = triggerPoint.getEventTypeFqn();
+            if (eventTypeFqn != null && smEventRaw.contains(".")) {
+                String smEventClass = smEventRaw.substring(0, smEventRaw.lastIndexOf('.'));
+                if (smEventClass.equals(eventTypeFqn)) {
+                    return true;
+                }
+                String simpleEventType = eventTypeFqn.contains(".") ? eventTypeFqn.substring(eventTypeFqn.lastIndexOf('.') + 1) : eventTypeFqn;
+                String simpleSmClass = smEventClass.contains(".") ? smEventClass.substring(smEventClass.lastIndexOf('.') + 1) : smEventClass;
+                if (simpleEventType.equalsIgnoreCase(simpleSmClass)) {
+                    return true;
+                }
+                return false;
+            }
+            return true;
+        }
+
+        if (rawTriggerEvent.contains(".") && smEventRaw.contains(".")) {
+            if (smEventRaw.equals(rawTriggerEvent) || smEventRaw.endsWith("." + rawTriggerEvent) || rawTriggerEvent.endsWith("." + smEventRaw)) {
+                return true;
+            }
+            String classTrig = rawTriggerEvent.substring(0, rawTriggerEvent.lastIndexOf('.'));
+            String classSm = smEventRaw.substring(0, smEventRaw.lastIndexOf('.'));
+            if (classTrig.contains(".") && classSm.contains(".")) {
+                String p1 = classTrig.substring(0, classTrig.lastIndexOf('.'));
+                String p2 = classSm.substring(0, classSm.lastIndexOf('.'));
+                if (!p1.equals(p2) && !p1.startsWith(p2 + ".") && !p2.startsWith(p1 + ".")) {
+                    return false;
+                }
+            }
+            String simpleClassTrig = classTrig.contains(".") ? classTrig.substring(classTrig.lastIndexOf('.') + 1) : classTrig;
+            String simpleClassSm = classSm.contains(".") ? classSm.substring(classSm.lastIndexOf('.') + 1) : classSm;
+            if (!simpleClassTrig.equals(simpleClassSm)) {
+                return false;
+            }
+        }
+
+        String triggerEvent = simplify(rawTriggerEvent);
+        if (smEvent.equalsIgnoreCase(triggerEvent)) {
+            return true;
+        }
+        return isGuardedContains(smEvent, triggerEvent);
+    }
+
+    private final java.util.Map<String, String> simplifyCache = new java.util.HashMap<>();
+    private final java.util.Map<java.util.Map.Entry<String, String>, Boolean> guardedCache = new java.util.HashMap<>();
+    private static final java.util.regex.Pattern SUFFIX_PATTERN = java.util.regex.Pattern.compile("(?i)(.+)(Event|Action|Transition|Command)(s)?$");
+    private static final java.util.regex.Pattern FQN_PATTERN = java.util.regex.Pattern.compile("^.*\\.([A-Z0-9_]+)$");
+
+    private boolean isGuardedContains(String smEvent, String triggerEvent) {
+        if (smEvent == null || triggerEvent == null) return false;
+        
+        java.util.Map.Entry<String, String> cacheKey = new java.util.AbstractMap.SimpleImmutableEntry<>(smEvent, triggerEvent);
+        if (guardedCache.containsKey(cacheKey)) return guardedCache.get(cacheKey);
+        
+        boolean result = calculateGuardedContains(smEvent, triggerEvent);
+        guardedCache.put(cacheKey, result);
+        return result;
+    }
+
+    private boolean calculateGuardedContains(String smEvent, String triggerEvent) {
+        // Only fire if it looks like a simple identifier (no spaces, no parens)
+        // Prevents unresolved AST nodes (e.g. "event.getPayload()") from accidentally matching "Event"
+        if (smEvent.contains(" ") || smEvent.contains("(") || smEvent.contains(")") ||
+            triggerEvent.contains(" ") || triggerEvent.contains("(") || triggerEvent.contains(")")) {
+            return false;
+        }
+        
+        String smLower = smEvent.toLowerCase();
+        String triggerLower = triggerEvent.toLowerCase();
+        
+        if (smLower.equals(triggerLower)) {
+            return true;
+        }
+        
+        // Match if one contains the other as a whole word/segment.
+        // We quote the patterns to avoid regex syntax injection issues.
+        String pattern1 = "\\b" + java.util.regex.Pattern.quote(smLower) + "\\b";
+        String pattern2 = "\\b" + java.util.regex.Pattern.quote(triggerLower) + "\\b";
+        
+        // Treat underscores and hyphens as word boundary separators
+        String smNormalized = smLower.replace('_', ' ').replace('-', ' ');
+        String triggerNormalized = triggerLower.replace('_', ' ').replace('-', ' ');
+        
+        return smNormalized.matches(".*" + pattern2 + ".*") || triggerNormalized.matches(".*" + pattern1 + ".*");
+    }
+
+    private boolean isWildcardVariable(String eventStr) {
+        if (eventStr == null) return false;
+        
+        if (eventStr.equals("event") || eventStr.equals("e") || 
+            eventStr.equals("msg") || eventStr.equals("message") || 
+            eventStr.equals("payload")) {
+            return true;
+        }
+        
+        if (eventStr.contains(".valueOf(") || eventStr.contains("valueOf (")) {
+            return true;
+        }
+
+        if (eventStr.contains(" ? ") && eventStr.contains(" : ")) {
+            return true;
+        }
+        
+        return false;
+    }
+
+    private String simplify(String name) {
+        if (name == null) return null;
+        if (simplifyCache.containsKey(name)) return simplifyCache.get(name);
+        
+        String simplified = SUFFIX_PATTERN.matcher(name).replaceAll("$1");
+        if (simplified.isEmpty()) {
+            simplified = name;
+        }
+        simplified = FQN_PATTERN.matcher(simplified).replaceAll("$1");
+        
+        simplifyCache.put(name, simplified);
+        return simplified;
+    }
+}

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

@@ -0,0 +1,150 @@
+package click.kamil.springstatemachineexporter.analysis.enricher.matching;
+
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.model.Event;
+import java.util.List;
+
+public class StrictFqnMatchingEngine implements EventMatchingEngine {
+
+    @Override
+    public boolean matches(Event stateMachineEvent, TriggerPoint triggerPoint) {
+        if (stateMachineEvent == null || triggerPoint == null || triggerPoint.getEvent() == null) {
+            return false;
+        }
+
+        if (triggerPoint.isExternal()) {
+            return true;
+        }
+
+        String smEventRaw = stateMachineEvent.fullIdentifier() != null ? stateMachineEvent.fullIdentifier() : stateMachineEvent.rawName();
+        String rawTriggerEvent = triggerPoint.getEvent();
+
+        if (rawTriggerEvent != null && rawTriggerEvent.startsWith("<SYMBOLIC: ") && rawTriggerEvent.endsWith(".*>")) {
+            String targetType = rawTriggerEvent.substring(11, rawTriggerEvent.length() - 3);
+            if (smEventRaw.startsWith(targetType + ".")) {
+                return true;
+            }
+            if (smEventRaw.contains(".")) {
+                String smType = smEventRaw.substring(0, smEventRaw.lastIndexOf('.'));
+                if (smType.endsWith("." + targetType) || smType.equals(targetType)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        List<String> polyEvents = triggerPoint.getPolymorphicEvents() != null ? triggerPoint.getPolymorphicEvents() : java.util.Collections.emptyList();
+        
+        for (String pe : polyEvents) {
+            if (matchEventNames(pe, smEventRaw, triggerPoint.getEventTypeFqn())) {
+                return true;
+            }
+            if (pe.startsWith("<SYMBOLIC: ") && pe.endsWith(".*>")) {
+                String targetType = pe.substring(11, pe.length() - 3);
+                if (smEventRaw.startsWith(targetType + ".")) {
+                    return true;
+                }
+                if (smEventRaw.contains(".")) {
+                    String smType = smEventRaw.substring(0, smEventRaw.lastIndexOf('.'));
+                    if (smType.endsWith("." + targetType) || smType.equals(targetType)) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        if (rawTriggerEvent != null && rawTriggerEvent.contains(".valueOf(")) {
+            String enumClass = rawTriggerEvent.substring(0, rawTriggerEvent.indexOf(".valueOf("));
+            if (enumClass.contains(" ")) {
+                enumClass = enumClass.substring(enumClass.lastIndexOf(" ") + 1);
+            }
+            String smClass = smEventRaw.contains(".") ? smEventRaw.substring(0, smEventRaw.lastIndexOf('.')) : smEventRaw;
+            if (enumClass.equals(smClass) || enumClass.endsWith("." + smClass) || smClass.endsWith("." + enumClass)) {
+                return true;
+            }
+            return false;
+        }
+
+        if (polyEvents.isEmpty() && isDynamicVariable(rawTriggerEvent)) {
+            if (triggerPoint.getEventTypeFqn() != null) {
+                if (smEventRaw.startsWith(triggerPoint.getEventTypeFqn() + ".")) {
+                    return true;
+                }
+                if (isStringTypeOrPrimitive(triggerPoint.getEventTypeFqn()) && !smEventRaw.contains(".")) {
+                    return true;
+                }
+                return false;
+            }
+            return true;
+        }
+
+        return matchEventNames(rawTriggerEvent, smEventRaw, triggerPoint.getEventTypeFqn());
+    }
+
+    private boolean matchEventNames(String triggerEvent, String smEvent, String eventTypeFqn) {
+        if (triggerEvent == null || smEvent == null) return false;
+        if (triggerEvent.equals(smEvent)) return true;
+
+        String tConst = triggerEvent.contains(".") ? triggerEvent.substring(triggerEvent.lastIndexOf('.') + 1) : triggerEvent;
+        String smConst = smEvent.contains(".") ? smEvent.substring(smEvent.lastIndexOf('.') + 1) : smEvent;
+
+        if (!tConst.equals(smConst)) return false;
+
+        // Prevent matching string/primitive triggers to enum transitions
+        if (isStringTypeOrPrimitive(eventTypeFqn) && smEvent.contains(".")) {
+            return false;
+        }
+
+        // Prevent matching enum triggers to string transitions
+        if (!smEvent.contains(".") && triggerEvent.contains(".")) {
+            return false;
+        }
+
+        if (eventTypeFqn != null && eventTypeFqn.contains(".") && smEvent.contains(".")) {
+            String fullTriggerFqn = eventTypeFqn + "." + tConst;
+            return fullTriggerFqn.equals(smEvent);
+        }
+
+        if (triggerEvent.contains(".") && smEvent.contains(".")) {
+            String tClass = triggerEvent.substring(0, triggerEvent.lastIndexOf('.'));
+            String smClass = smEvent.substring(0, smEvent.lastIndexOf('.'));
+            String tClassSimple = tClass.contains(".") ? tClass.substring(tClass.lastIndexOf('.') + 1) : tClass;
+            String smClassSimple = smClass.contains(".") ? smClass.substring(smClass.lastIndexOf('.') + 1) : smClass;
+            return tClassSimple.equals(smClassSimple);
+        }
+
+        return true;
+    }
+
+    private boolean isStringTypeOrPrimitive(String typeFqn) {
+        if (typeFqn == null) return false;
+        return typeFqn.equals("String") || typeFqn.equals("java.lang.String") ||
+               typeFqn.equals("int") || typeFqn.equals("long") || typeFqn.equals("char");
+    }
+
+    private boolean isDynamicVariable(String eventStr) {
+        if (eventStr == null || eventStr.isEmpty()) return false;
+        
+        if (eventStr.contains(" ? ") && eventStr.contains(" : ")) {
+            return true;
+        }
+        
+        if (eventStr.endsWith("()")) {
+            return true;
+        }
+        
+        if (eventStr.contains(".")) {
+            String firstPart = eventStr.substring(0, eventStr.indexOf('.'));
+            if (!firstPart.isEmpty() && Character.isLowerCase(firstPart.charAt(0))) {
+                return true; 
+            }
+            return false;
+        }
+
+        if (Character.isLowerCase(eventStr.charAt(0))) {
+            return true; 
+        }
+
+        return false;
+    }
+}

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,132 @@
+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();
+                        
+                        if (caller != null) {
+                            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/enricher/routing/BeanResolutionEngine.java

@@ -0,0 +1,9 @@
+package click.kamil.springstatemachineexporter.analysis.enricher.routing;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+
+public interface BeanResolutionEngine {
+    boolean isRoutedToCorrectMachine(CallChain chain, String currentMachineName, CodebaseContext context);
+}
+

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/enricher/routing/HeuristicBeanResolutionEngine.java

@@ -0,0 +1,380 @@
+package click.kamil.springstatemachineexporter.analysis.enricher.routing;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallChain;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class HeuristicBeanResolutionEngine implements BeanResolutionEngine {
+
+    @Override
+    public boolean isRoutedToCorrectMachine(CallChain chain, String currentMachineName, CodebaseContext context) {
+        // Precise FQN Type argument match
+        if (chain.getTriggerPoint() != null && context != null && currentMachineName != null) {
+            String triggerEventFqn = chain.getTriggerPoint().getEventTypeFqn();
+            String triggerStateFqn = chain.getTriggerPoint().getStateTypeFqn();
+            if (triggerEventFqn != null || triggerStateFqn != null) {
+                String[] machineTypes = getStateMachineTypeArguments(currentMachineName, context);
+                String machineStateFqn = machineTypes[0];
+                String machineEventFqn = machineTypes[1];
+                
+                if (triggerEventFqn != null && machineEventFqn != null) {
+                    if (eraseGenerics(triggerEventFqn).equals(eraseGenerics(machineEventFqn))) {
+                        return true; // Match!
+                    }
+                    if (isTypeMismatched(triggerEventFqn, machineEventFqn)) {
+                        return false; // Mismatch!
+                    }
+                }
+                if (triggerStateFqn != null && machineStateFqn != null) {
+                    if (eraseGenerics(triggerStateFqn).equals(eraseGenerics(machineStateFqn))) {
+                        return true; // Match!
+                    }
+                    if (isTypeMismatched(triggerStateFqn, machineStateFqn)) {
+                        return false; // Mismatch!
+                    }
+                }
+            }
+        }
+
+        String targetVar = chain.getContextMachineId();
+        if (targetVar == null && chain.getTriggerPoint() != null) {
+            targetVar = chain.getTriggerPoint().getStateMachineId();
+        }
+        
+        String simplifiedMachineName = currentMachineName != null ? currentMachineName.substring(currentMachineName.lastIndexOf('.') + 1).toLowerCase() : "";
+        
+        if (targetVar != null && !targetVar.isEmpty()) {
+            targetVar = targetVar.toLowerCase();
+            if (targetVar.endsWith("statemachine")) {
+                String prefix = targetVar.substring(0, targetVar.length() - "statemachine".length());
+                if (!prefix.isEmpty()) {
+                    if (simplifiedMachineName.contains(prefix)) {
+                        return true; // Explicit positive match
+                    } else {
+                        return false; // Explicit negative match
+                    }
+                }
+            } else if (simplifiedMachineName.contains(targetVar)) {
+                 return true;
+            }
+        }
+
+        if (chain.getMethodChain() != null && !chain.getMethodChain().isEmpty() && currentMachineName != null) {
+            String smPackage = getPackageName(currentMachineName);
+            String smSimple = getSimpleClassName(currentMachineName);
+            String smPrefix = getFirstCamelCaseWord(smSimple);
+            
+            boolean hasPositiveMatch = false;
+            boolean hasStrongMismatch = false;
+
+            if (chain.getTriggerPoint() != null && chain.getTriggerPoint().getClassName() != null) {
+                String chainClass = chain.getTriggerPoint().getClassName();
+                String chainPackage = getPackageName(chainClass);
+                String chainSimple = getSimpleClassName(chainClass);
+                String chainPrefix = getFirstCamelCaseWord(chainSimple);
+                
+                if (smPrefix != null && chainPrefix != null && smPrefix.equals(chainPrefix)) {
+                    hasPositiveMatch = true;
+                }
+                
+                if (isDomainMatch(smPackage, chainPackage, smPrefix, chainPrefix)) {
+                    hasPositiveMatch = true;
+                }
+            }
+
+            for (String method : chain.getMethodChain()) {
+                String chainClass = getClassNameOnly(method);
+                String chainPackage = getPackageName(chainClass);
+                String chainSimple = getSimpleClassName(chainClass);
+                String chainPrefix = getFirstCamelCaseWord(chainSimple);
+                
+                if (smPrefix != null && chainPrefix != null && smPrefix.equals(chainPrefix)) {
+                    hasPositiveMatch = true;
+                }
+                
+                if (isDomainMatch(smPackage, chainPackage, smPrefix, chainPrefix)) {
+                    hasPositiveMatch = true;
+                }
+                
+                if (isDomainMismatch(smPackage, chainPackage, smPrefix, chainPrefix, smSimple, chainSimple)) {
+                    hasStrongMismatch = true;
+                }
+            }
+            
+            if (hasPositiveMatch) {
+                return true;
+            }
+            if (hasStrongMismatch) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean isDomainMatch(String smPackage, String chainPackage, String smPrefix, String chainPrefix) {
+        if (smPackage == null || chainPackage == null || smPackage.isEmpty() || chainPackage.isEmpty()) return false;
+        
+        if (smPackage.startsWith(chainPackage) || chainPackage.startsWith(smPackage)) {
+            return true;
+        }
+        
+        // Find deepest common package root
+        String[] p1 = smPackage.split("\\.");
+        String[] p2 = chainPackage.split("\\.");
+        int matchIdx = -1;
+        for (int i = 0; i < Math.min(p1.length, p2.length); i++) {
+            if (p1[i].equals(p2[i])) {
+                matchIdx = i;
+            } else {
+                break;
+            }
+        }
+        
+        // If the state machine's prefix is part of the shared common package, 
+        // then the state machine represents the parent domain of the caller.
+        if (smPrefix != null && matchIdx >= 0) {
+            String lowerPrefix = smPrefix.toLowerCase();
+            for (int i = 0; i <= matchIdx; i++) {
+                if (p1[i].toLowerCase().contains(lowerPrefix) || lowerPrefix.contains(p1[i].toLowerCase())) {
+                    return true;
+                }
+            }
+        }
+        
+        return false;
+    }
+    
+    private boolean isDomainMismatch(String smPackage, String chainPackage, String smPrefix, String chainPrefix, String smSimple, String chainSimple) {
+        if (smPackage == null || chainPackage == null || smPackage.isEmpty() || chainPackage.isEmpty()) return false;
+        if (smPrefix == null || chainPrefix == null) return false;
+
+        String smLower = smPrefix.toLowerCase();
+        String chainLower = chainPrefix.toLowerCase();
+
+        // Ignore generic/technical class prefixes
+        if (smLower.equals("state") || smLower.equals("statemachine") || smLower.equals("config") || smLower.equals("configuration") || smLower.equals("adapter") ||
+            smLower.equals("enterprise") || smLower.equals("app") || smLower.equals("global") || smLower.equals("core") || smLower.equals("project") || smLower.equals("main") || smLower.equals("base") || smLower.equals("common") || smLower.equals("shared") ||
+            chainLower.equals("state") || chainLower.equals("statemachine") || chainLower.equals("config") || chainLower.equals("configuration") || chainLower.equals("adapter") ||
+            chainLower.equals("enterprise") || chainLower.equals("app") || chainLower.equals("global") || chainLower.equals("core") || chainLower.equals("project") || chainLower.equals("main") || chainLower.equals("base") || chainLower.equals("common") || chainLower.equals("shared")) {
+            return false;
+        }
+
+        // If class prefixes diverge, check if they are from different domains
+        if (!smLower.equals(chainLower)) {
+            // If one prefix is present as a domain/feature segment in the other package, they are related
+            if (chainPackage.toLowerCase().contains(smLower) || smPackage.toLowerCase().contains(chainLower)) {
+                return false;
+            }
+
+            // Otherwise, if they diverge under a shared project package root, it is a mismatch
+            String[] p1 = smPackage.split("\\.");
+            String[] p2 = chainPackage.split("\\.");
+            int matchIdx = -1;
+            for (int i = 0; i < Math.min(p1.length, p2.length); i++) {
+                if (p1[i].equals(p2[i])) {
+                    matchIdx = i;
+                } else {
+                    break;
+                }
+            }
+            if (matchIdx >= 1) {
+                // If they diverge under a shared root, check if the divergence is only on generic package layers
+                boolean onlyGenericDivergence = true;
+                Set<String> genericLayers = Set.of(
+                    "config", "configuration", "service", "services", "impl", "api", "web", 
+                    "controller", "controllers", "messaging", "listener", "listeners", 
+                    "repository", "repositories", "db", "model", "models", "domain", 
+                    "constants", "utils", "helper", "helpers", "event", "events", 
+                    "state", "states", "transition", "transitions"
+                );
+                for (int i = matchIdx + 1; i < p1.length; i++) {
+                    if (!genericLayers.contains(p1[i].toLowerCase())) {
+                        onlyGenericDivergence = false;
+                        break;
+                    }
+                }
+                if (onlyGenericDivergence) {
+                    for (int i = matchIdx + 1; i < p2.length; i++) {
+                        if (!genericLayers.contains(p2[i].toLowerCase())) {
+                            onlyGenericDivergence = false;
+                            break;
+                        }
+                    }
+                }
+                
+                if (!onlyGenericDivergence) {
+                    return true; // Mismatch under a shared root
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private Set<String> extractDomainTerms(String pkg, String prefix) {
+        Set<String> terms = new HashSet<>();
+        if (pkg != null && !pkg.isEmpty()) {
+            String[] segments = pkg.split("\\.");
+            // Take segments from index 2 onwards if length > 2
+            int start = segments.length > 2 ? 2 : 0;
+            for (int i = start; i < segments.length; i++) {
+                terms.add(segments[i].toLowerCase());
+            }
+        }
+        if (prefix != null && !prefix.isEmpty()) {
+            terms.add(prefix.toLowerCase());
+        }
+        return terms;
+    }
+
+    private String getPackageName(String fqn) {
+        if (fqn == null || !fqn.contains(".")) return "";
+        return fqn.substring(0, fqn.lastIndexOf('.'));
+    }
+
+    private String getSimpleClassName(String fqn) {
+        if (fqn == null) return "";
+        if (!fqn.contains(".")) return fqn;
+        return fqn.substring(fqn.lastIndexOf('.') + 1);
+    }
+
+    private String getClassNameOnly(String methodFqn) {
+        if (methodFqn == null) return "";
+        String clean = methodFqn;
+        if (clean.contains("(")) {
+            clean = clean.substring(0, clean.indexOf('('));
+        }
+        if (clean.contains(".")) {
+            clean = clean.substring(0, clean.lastIndexOf('.'));
+        }
+        return clean;
+    }
+
+    private String getFirstCamelCaseWord(String simpleName) {
+        if (simpleName == null || simpleName.isEmpty()) return null;
+        String[] words = simpleName.split("(?<!^)(?=[A-Z])");
+        if (words.length > 0) {
+            return words[0];
+        }
+        return null;
+    }
+
+    private String[] getStateMachineTypeArguments(String machineName, CodebaseContext context) {
+        org.eclipse.jdt.core.dom.TypeDeclaration td = context.getTypeDeclaration(machineName);
+        if (td != null) {
+            org.eclipse.jdt.core.dom.Type superclass = td.getSuperclassType();
+            Set<String> visited = new HashSet<>();
+            visited.add(machineName);
+            return findTypeArgumentsRecursively(superclass, context, (org.eclipse.jdt.core.dom.CompilationUnit) td.getRoot(), visited);
+        }
+        return new String[]{null, null};
+    }
+
+    private String[] findTypeArgumentsRecursively(org.eclipse.jdt.core.dom.Type type, CodebaseContext context, org.eclipse.jdt.core.dom.CompilationUnit cu, Set<String> visited) {
+        if (type == null) return new String[]{null, null};
+
+        if (type instanceof org.eclipse.jdt.core.dom.ParameterizedType pt) {
+            String rawTypeName = pt.getType().toString();
+            if (rawTypeName.equals("StateMachineConfigurerAdapter") || rawTypeName.equals("EnumStateMachineConfigurerAdapter") ||
+                rawTypeName.endsWith(".StateMachineConfigurerAdapter") || rawTypeName.endsWith(".EnumStateMachineConfigurerAdapter")) {
+                java.util.List<?> typeArgs = pt.typeArguments();
+                if (typeArgs.size() >= 2) {
+                    String stateType = resolveTypeToFqn((org.eclipse.jdt.core.dom.Type) typeArgs.get(0), cu, context);
+                    String eventType = resolveTypeToFqn((org.eclipse.jdt.core.dom.Type) typeArgs.get(1), cu, context);
+                    return new String[]{stateType, eventType};
+                }
+            }
+            
+            // Recurse into the raw type declaration's superclass
+            org.eclipse.jdt.core.dom.AbstractTypeDeclaration td = context.getAbstractTypeDeclaration(rawTypeName, cu);
+            if (td != null) {
+                String fqn = context.getFqn(td);
+                if (visited.add(fqn)) {
+                    org.eclipse.jdt.core.dom.Type superclass = (td instanceof org.eclipse.jdt.core.dom.TypeDeclaration) ? ((org.eclipse.jdt.core.dom.TypeDeclaration) td).getSuperclassType() : null;
+                    String[] res = findTypeArgumentsRecursively(superclass, context, (org.eclipse.jdt.core.dom.CompilationUnit) td.getRoot(), visited);
+                    if (res[0] != null || res[1] != null) return res;
+                }
+            }
+        } else {
+            // It's a simple type (e.g. MyBaseConfig)
+            String simpleName = type.toString();
+            org.eclipse.jdt.core.dom.AbstractTypeDeclaration td = context.getAbstractTypeDeclaration(simpleName, cu);
+            if (td != null) {
+                String fqn = context.getFqn(td);
+                if (visited.add(fqn)) {
+                    org.eclipse.jdt.core.dom.Type superclass = (td instanceof org.eclipse.jdt.core.dom.TypeDeclaration) ? ((org.eclipse.jdt.core.dom.TypeDeclaration) td).getSuperclassType() : null;
+                    String[] res = findTypeArgumentsRecursively(superclass, context, (org.eclipse.jdt.core.dom.CompilationUnit) td.getRoot(), visited);
+                    if (res[0] != null || res[1] != null) return res;
+                }
+            }
+        }
+
+        return new String[]{null, null};
+    }
+
+    private String eraseGenerics(String type) {
+        if (type == null) return null;
+        int idx = type.indexOf('<');
+        if (idx != -1) {
+            return type.substring(0, idx);
+        }
+        return type;
+    }
+
+    private String resolveTypeToFqn(org.eclipse.jdt.core.dom.Type type, org.eclipse.jdt.core.dom.CompilationUnit cu, CodebaseContext context) {
+        if (type == null) return null;
+        String simpleName;
+        if (type.isSimpleType()) {
+            simpleName = ((org.eclipse.jdt.core.dom.SimpleType) type).getName().getFullyQualifiedName();
+        } else if (type.isParameterizedType()) {
+            return resolveTypeToFqn(((org.eclipse.jdt.core.dom.ParameterizedType) type).getType(), cu, context);
+        } else {
+            simpleName = type.toString();
+        }
+
+        if (simpleName.contains("<")) {
+            simpleName = simpleName.substring(0, simpleName.indexOf('<'));
+        }
+
+        org.eclipse.jdt.core.dom.AbstractTypeDeclaration td = context.getAbstractTypeDeclaration(simpleName, cu);
+        if (td != null) {
+            return context.getFqn(td);
+        }
+        
+        for (Object impObj : cu.imports()) {
+            org.eclipse.jdt.core.dom.ImportDeclaration imp = (org.eclipse.jdt.core.dom.ImportDeclaration) impObj;
+            String impName = imp.getName().getFullyQualifiedName();
+            if (impName.endsWith("." + simpleName)) {
+                return impName;
+            }
+        }
+
+        String packageName = cu.getPackage() != null ? cu.getPackage().getName().getFullyQualifiedName() : "";
+        if (!packageName.isEmpty()) {
+            org.eclipse.jdt.core.dom.AbstractTypeDeclaration localTd = context.getAbstractTypeDeclaration(packageName + "." + simpleName);
+            if (localTd != null) return context.getFqn(localTd);
+        }
+
+        return simpleName;
+    }
+
+    private boolean isTypeMismatched(String type1, String type2) {
+        if (type1 == null || type2 == null) return false;
+        type1 = eraseGenerics(type1);
+        type2 = eraseGenerics(type2);
+        if (type1.length() == 1 || type2.length() == 1) return false;
+        if (type1.equals("java.lang.String") || type1.equals("String") || type1.equals("java.lang.Object") || type1.equals("Object")) return false;
+        if (type2.equals("java.lang.String") || type2.equals("String") || type2.equals("java.lang.Object") || type2.equals("Object")) return false;
+        return !type1.equals(type2);
+    }
+
+    private boolean isSingleStateMachine(CodebaseContext context) {
+        if (context == null) return false;
+        int count = 0;
+        count += context.findEntryPointClasses(java.util.List.of("EnableStateMachineFactory", "EnableStateMachine")).size();
+        count += context.findBeanMethodsReturning(java.util.Set.of("StateMachine", "StateMachineFactory", "StateMachineModelFactory")).size();
+        return count <= 1;
+    }
+}

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

@@ -0,0 +1,123 @@
+package click.kamil.springstatemachineexporter.analysis.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder;
+import click.kamil.springstatemachineexporter.model.Transition;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.jackson.Jacksonized;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@Getter
+@Setter
+@Builder(toBuilder = true)
+@Jacksonized
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class AnalysisResult {
+    private String name;
+    @Builder.Default
+    private Set<click.kamil.springstatemachineexporter.model.State> states = java.util.Collections.emptySet();
+    private List<Transition> transitions;
+    private Set<String> startStates;
+    private Set<String> endStates;
+    private boolean renderChoicesAsDiamonds;
+
+    @Builder.Default
+    private List<BusinessFlow> flows = java.util.Collections.emptyList();
+
+    @Builder.Default
+    private CodebaseMetadata metadata = CodebaseMetadata.empty();
+
+    public void applyResolution(Map<String, String> properties) {
+        var resolver = new click.kamil.springstatemachineexporter.analysis.resolver.PropertyResolver();
+        
+        // 1. Resolve start/end states strings
+        if (startStates != null) {
+            this.startStates = startStates.stream()
+                    .map(s -> resolver.resolveValue(s, properties))
+                    .collect(java.util.stream.Collectors.toSet());
+        }
+        if (endStates != null) {
+            this.endStates = endStates.stream()
+                    .map(s -> resolver.resolveValue(s, properties))
+                    .collect(java.util.stream.Collectors.toSet());
+        }
+
+        // 2. Resolve states (State record is immutable, so recreate)
+        if (states != null) {
+            this.states = states.stream()
+                    .map(s -> click.kamil.springstatemachineexporter.model.State.of(s.rawName(), resolver.resolveValue(s.fullIdentifier(), properties)))
+                    .collect(java.util.stream.Collectors.toSet());
+        }
+
+        // 3. Resolve transitions
+        if (transitions != null) {
+            for (var t : transitions) {
+                if (t.getEvent() != null) {
+                    t.setEvent(click.kamil.springstatemachineexporter.model.Event.of(t.getEvent().rawName(), resolver.resolveValue(t.getEvent().fullIdentifier(), properties)));
+                }
+                // Resolve states within transitions
+                t.setSourceStates(t.getSourceStates().stream()
+                        .map(s -> click.kamil.springstatemachineexporter.model.State.of(s.rawName(), resolver.resolveValue(s.fullIdentifier(), properties)))
+                        .collect(java.util.stream.Collectors.toList()));
+                t.setTargetStates(t.getTargetStates().stream()
+                        .map(s -> click.kamil.springstatemachineexporter.model.State.of(s.rawName(), resolver.resolveValue(s.fullIdentifier(), properties)))
+                        .collect(java.util.stream.Collectors.toList()));
+            }
+        }
+
+        // 4. Resolve metadata (triggers, entry points)
+        if (metadata != null) {
+            if (metadata.getTriggers() != null) {
+                for (var trigger : metadata.getTriggers()) {
+                    if (trigger.getEvent() != null) {
+                        trigger.setEvent(resolver.resolveValue(trigger.getEvent(), properties));
+                    }
+                }
+            }
+            if (metadata.getEntryPoints() != null) {
+                for (var ep : metadata.getEntryPoints()) {
+                    if (ep.getName() != null) {
+                        ep.setName(resolver.resolveValue(ep.getName(), properties));
+                    }
+                    if (ep.getMetadata() != null) {
+                        Map<String, String> resolvedMeta = new java.util.HashMap<>();
+                        for (var entry : ep.getMetadata().entrySet()) {
+                            resolvedMeta.put(entry.getKey(), resolver.resolveValue(entry.getValue(), properties));
+                        }
+                        ep.setMetadata(resolvedMeta);
+                    }
+                }
+            }
+        }
+    }
+
+    public void addMetadata(CodebaseMetadata newMetadata) {
+        if (newMetadata == null) return;
+        
+        List<TriggerPoint> combinedTriggers = new java.util.ArrayList<>(this.metadata.getTriggers());
+        if (newMetadata.getTriggers() != null) combinedTriggers.addAll(newMetadata.getTriggers());
+
+        List<EntryPoint> combinedEntryPoints = new java.util.ArrayList<>(this.metadata.getEntryPoints());
+        if (newMetadata.getEntryPoints() != null) combinedEntryPoints.addAll(newMetadata.getEntryPoints());
+
+        List<CallChain> combinedCallChains = new java.util.ArrayList<>(this.metadata.getCallChains());
+        if (newMetadata.getCallChains() != null) combinedCallChains.addAll(newMetadata.getCallChains());
+
+        java.util.Map<String, java.util.Map<String, String>> combinedProperties = new java.util.HashMap<>(this.metadata.getProperties());
+        if (newMetadata.getProperties() != null) combinedProperties.putAll(newMetadata.getProperties());
+
+        this.metadata = CodebaseMetadata.builder()
+                .triggers(Collections.unmodifiableList(combinedTriggers))
+                .entryPoints(Collections.unmodifiableList(combinedEntryPoints))
+                .callChains(Collections.unmodifiableList(combinedCallChains))
+                .properties(Collections.unmodifiableMap(combinedProperties))
+                .build();
+    }
+}

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

@@ -0,0 +1,18 @@
+package click.kamil.springstatemachineexporter.analysis.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Builder;
+import lombok.Data;
+import lombok.extern.jackson.Jacksonized;
+
+import java.util.List;
+
+@Data
+@Builder
+@Jacksonized
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class BusinessFlow {
+    private final String name;
+    private final String description;
+    private final List<String> steps; // List of Event names in order
+}

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

@@ -0,0 +1,20 @@
+package click.kamil.springstatemachineexporter.analysis.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Builder;
+import lombok.Data;
+import lombok.extern.jackson.Jacksonized;
+
+import java.util.List;
+
+@Data
+@Builder(toBuilder = true)
+@Jacksonized
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class CallChain {
+    private final EntryPoint entryPoint;
+    private final List<String> methodChain; // e.g., ["Controller.submit", "Service.process", "Service.send"]
+    private final TriggerPoint triggerPoint;
+    private final String contextMachineId;
+    private final List<MatchedTransition> matchedTransitions;
+}

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

@@ -0,0 +1,25 @@
+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 String targetMethod;
+    private List<String> arguments;
+    private String receiver;
+    private String constraint;
+
+    public CallEdge(String targetMethod, List<String> arguments) {
+        this(targetMethod, arguments, null, null);
+    }
+
+    public CallEdge(String targetMethod, List<String> arguments, String receiver) {
+        this(targetMethod, arguments, receiver, null);
+    }
+}

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

@@ -0,0 +1,30 @@
+package click.kamil.springstatemachineexporter.analysis.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.extern.jackson.Jacksonized;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+@Getter
+@Builder(toBuilder = true)
+@Jacksonized
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class CodebaseMetadata {
+    @Builder.Default
+    private final List<TriggerPoint> triggers = Collections.emptyList();
+    @Builder.Default
+    private final List<EntryPoint> entryPoints = Collections.emptyList();
+    @Builder.Default
+    private final List<CallChain> callChains = Collections.emptyList();
+    @Builder.Default
+    private final Map<String, Map<String, String>> properties = Collections.emptyMap();
+
+    public static CodebaseMetadata empty() {
+        return CodebaseMetadata.builder().build();
+    }
+}

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

@@ -0,0 +1,36 @@
+package click.kamil.springstatemachineexporter.analysis.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Builder;
+import lombok.Data;
+import lombok.extern.jackson.Jacksonized;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+@Builder
+@Jacksonized
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class EntryPoint {
+    public enum Type { REST, KAFKA, RABBIT, JMS, SQS, SNS, CUSTOM }
+
+    @Data
+    @Builder
+    @Jacksonized
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public static class Parameter {
+        private final String name;
+        private final String type;
+        private final List<String> annotations;
+    }
+
+    private final Type type;
+    private String name; // e.g., "POST /orders" or "Kafka Topic: orders"
+    private final String className;
+    private final String methodName;
+    private final String sourceFile;
+    private Map<String, String> metadata; // e.g., path, topic, exchange
+    @Builder.Default
+    private final List<Parameter> parameters = java.util.Collections.emptyList();
+}

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

@@ -0,0 +1,19 @@
+package click.kamil.springstatemachineexporter.analysis.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Builder;
+import lombok.Data;
+import lombok.extern.jackson.Jacksonized;
+
+import java.util.List;
+
+@Data
+@Builder
+@Jacksonized
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class LibraryHint {
+    private final String methodFqn; // e.g., "com.thirdparty.Workflow.send"
+    private final String event;     // The event it triggers (static)
+    private final Integer eventArgumentIndex; // e.g., 0 to extract from the 0th argument
+    private final String eventArgumentMethod; // e.g., "getType" to extract from argument method call
+}

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

@@ -0,0 +1,16 @@
+package click.kamil.springstatemachineexporter.analysis.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Builder;
+import lombok.Data;
+import lombok.extern.jackson.Jacksonized;
+
+@Data
+@Builder
+@Jacksonized
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class MatchedTransition {
+    private final String sourceState;
+    private final String targetState;
+    private final String event;
+}

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

@@ -0,0 +1,130 @@
+package click.kamil.springstatemachineexporter.analysis.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Builder;
+import lombok.Data;
+import lombok.extern.jackson.Jacksonized;
+
+import java.util.Map;
+
+@Data
+@Builder(toBuilder = true)
+@Jacksonized
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class TriggerPoint {
+    private String event;
+    private final String className;
+    private final String methodName;
+    private final String sourceFile;
+    private final String sourceModule;
+    private final String stateMachineId; // Optional: to link to a specific SM instance
+    private final String sourceState;    // Optional: if we can determine the expected current state
+    private final int lineNumber;
+    @com.fasterxml.jackson.annotation.JsonIgnore
+    private final String stateTypeFqn;  // Type of State (e.g. OrderStates FQN)
+    @com.fasterxml.jackson.annotation.JsonIgnore
+    private final String eventTypeFqn;  // Type of Event (e.g. OrderEvents FQN)
+    private final java.util.List<String> polymorphicEvents; // NEW: stores concrete events resolved via deep polymorphism
+    private final boolean external;
+    private final String constraint;
+    private final boolean ambiguous;
+
+    public TriggerPoint(
+            String event,
+            String className,
+            String methodName,
+            String sourceFile,
+            String sourceModule,
+            String stateMachineId,
+            String sourceState,
+            int lineNumber,
+            String stateTypeFqn,
+            String eventTypeFqn,
+            java.util.List<String> polymorphicEvents,
+            boolean external,
+            String constraint,
+            boolean ambiguous) {
+        this.className = className;
+        this.methodName = methodName;
+        this.sourceFile = sourceFile;
+        this.sourceModule = sourceModule;
+        this.stateMachineId = stateMachineId;
+        this.sourceState = sourceState;
+        this.lineNumber = lineNumber;
+        this.stateTypeFqn = stateTypeFqn;
+        this.eventTypeFqn = eventTypeFqn;
+        this.event = qualifyEvent(event, eventTypeFqn);
+        if (polymorphicEvents != null) {
+            this.polymorphicEvents = polymorphicEvents.stream()
+                    .map(pe -> qualifyEvent(pe, eventTypeFqn))
+                    .collect(java.util.stream.Collectors.toList());
+        } else {
+            this.polymorphicEvents = null;
+        }
+        this.external = external;
+        this.constraint = constraint;
+        this.ambiguous = ambiguous;
+    }
+
+    private static String qualifyEvent(String e, String eventTypeFqn) {
+        if (e == null || eventTypeFqn == null || e.isEmpty()) {
+            return e;
+        }
+        if (e.startsWith("<SYMBOLIC: ")) {
+            return e;
+        }
+        if (isWildcardVariable(e)) {
+            return e;
+        }
+        if (Character.isLowerCase(e.charAt(0))) {
+            return e;
+        }
+        if (!isEnumConstantCandidate(e)) {
+            return e;
+        }
+
+        String simpleEventType = eventTypeFqn.contains(".") ? eventTypeFqn.substring(eventTypeFqn.lastIndexOf('.') + 1) : eventTypeFqn;
+
+        if (e.contains(".")) {
+            String qualifier = e.substring(0, e.lastIndexOf('.'));
+            String lastSegment = e.substring(e.lastIndexOf('.') + 1);
+            String simpleQualifier = qualifier.contains(".") ? qualifier.substring(qualifier.lastIndexOf('.') + 1) : qualifier;
+
+            if (simpleQualifier.equals(simpleEventType)) {
+                return simpleEventType + "." + lastSegment;
+            }
+            return e;
+        }
+        if (eventTypeFqn.startsWith("java.lang.") || eventTypeFqn.equals("String") || eventTypeFqn.equals("int") || eventTypeFqn.equals("long") || eventTypeFqn.equals("char")) {
+            return e;
+        }
+        return simpleEventType + "." + e;
+    }
+
+    private static boolean isEnumConstantCandidate(String eventStr) {
+        if (eventStr == null) return false;
+        if (eventStr.startsWith("<SYMBOLIC: ")) {
+            return false;
+        }
+        if (eventStr.contains(" ") || eventStr.contains("(") || eventStr.contains(")") || eventStr.contains("?")) {
+            return false;
+        }
+        return true;
+    }
+
+    private static boolean isWildcardVariable(String eventStr) {
+        if (eventStr == null) return false;
+        if (eventStr.equals("event") || eventStr.equals("e") || 
+            eventStr.equals("msg") || eventStr.equals("message") || 
+            eventStr.equals("payload")) {
+            return true;
+        }
+        if (eventStr.contains(".valueOf(") || eventStr.contains("valueOf (")) {
+            return true;
+        }
+        if (eventStr.contains(" ? ") && eventStr.contains(" : ")) {
+            return true;
+        }
+        return false;
+    }
+}

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/resolver/PropertyResolver.java

@@ -0,0 +1,136 @@
+package click.kamil.springstatemachineexporter.analysis.resolver;
+
+import lombok.extern.slf4j.Slf4j;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.stream.Stream;
+
+
+@Slf4j
+public class PropertyResolver {
+
+    private final List<String> activeProfiles = new ArrayList<>();
+
+    public void setActiveProfiles(List<String> profiles) {
+        this.activeProfiles.clear();
+        if (profiles != null) {
+            this.activeProfiles.addAll(profiles);
+        }
+    }
+
+    public Map<String, String> resolveProperties(Path rootDir) {
+        Map<String, String> allProperties = new HashMap<>();
+        
+        // 1. Load base properties
+        loadMatching(rootDir, "application.properties", allProperties);
+        loadMatching(rootDir, "application.yml", allProperties);
+        loadMatching(rootDir, "application.yaml", allProperties);
+
+        // 2. Load profile-specific properties (overriding base)
+        for (String profile : activeProfiles) {
+            loadMatching(rootDir, "application-" + profile + ".properties", allProperties);
+            loadMatching(rootDir, "application-" + profile + ".yml", allProperties);
+            loadMatching(rootDir, "application-" + profile + ".yaml", allProperties);
+        }
+        
+        return allProperties;
+    }
+
+    public Map<String, Map<String, String>> resolveAllProperties(Set<Path> rootDirs) {
+        Map<String, Map<String, String>> profiles = new HashMap<>();
+        
+        for (Path rootDir : rootDirs) {
+            // 1. Load default profile
+            Map<String, String> defaultProps = profiles.computeIfAbsent("default", k -> new HashMap<>());
+            loadMatching(rootDir, "application.properties", defaultProps);
+            loadMatching(rootDir, "application.yml", defaultProps);
+            loadMatching(rootDir, "application.yaml", defaultProps);
+
+            // 2. Discover and load all other profiles
+            try (Stream<Path> paths = Files.walk(rootDir)) {
+                paths.filter(Files::isRegularFile)
+                     .filter(p -> {
+                         String name = p.getFileName().toString();
+                         return name.startsWith("application-") && 
+                                (name.endsWith(".properties") || name.endsWith(".yml") || name.endsWith(".yaml"));
+                     })
+                     .forEach(p -> {
+                         String name = p.getFileName().toString();
+                         String profile = name.substring("application-".length(), name.lastIndexOf('.'));
+                         Map<String, String> loaded = p.toString().endsWith(".properties") ? loadProperties(p) : loadYaml(p);
+                         profiles.computeIfAbsent(profile, k -> new HashMap<>()).putAll(loaded);
+                     });
+            } catch (IOException e) {
+                log.error("Failed to scan for profiles in {}", rootDir, e);
+            }
+        }
+        
+        return profiles;
+    }
+
+    private void loadMatching(Path rootDir, String fileName, Map<String, String> target) {
+        try (Stream<Path> paths = Files.walk(rootDir)) {
+            paths.filter(p -> Files.isRegularFile(p))
+                 .filter(p -> p.getFileName().toString().equals(fileName))
+                 .forEach(p -> {
+                     if (p.toString().endsWith(".properties")) {
+                         target.putAll(loadProperties(p));
+                     } else {
+                         target.putAll(loadYaml(p));
+                     }
+                 });
+        } catch (IOException e) {
+            log.error("Failed to scan for {} in {}", fileName, rootDir, e);
+        }
+    }
+
+    private Map<String, String> loadProperties(Path path) {
+        Map<String, String> props = new HashMap<>();
+        Properties p = new Properties();
+        try (InputStream is = Files.newInputStream(path)) {
+            p.load(is);
+            p.forEach((k, v) -> props.put(k.toString(), v.toString()));
+        } catch (IOException e) {
+            log.warn("Failed to load properties from {}", path);
+        }
+        return props;
+    }
+
+    private Map<String, String> loadYaml(Path path) {
+        Map<String, String> props = new HashMap<>();
+        try {
+            com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper(new com.fasterxml.jackson.dataformat.yaml.YAMLFactory());
+            Map<String, Object> map = mapper.readValue(path.toFile(), new com.fasterxml.jackson.core.type.TypeReference<Map<String, Object>>() {});
+            flattenYaml("", map, props);
+        } catch (IOException e) {
+            log.warn("Failed to load YAML from {}", path);
+        }
+        return props;
+    }
+
+    @SuppressWarnings("unchecked")
+    private void flattenYaml(String prefix, Map<String, Object> map, Map<String, String> result) {
+        if (map == null) return;
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            String key = prefix.isEmpty() ? entry.getKey() : prefix + "." + entry.getKey();
+            Object value = entry.getValue();
+            if (value instanceof Map) {
+                flattenYaml(key, (Map<String, Object>) value, result);
+            } else if (value != null) {
+                result.put(key, value.toString());
+            }
+        }
+    }
+
+    public String resolveValue(String placeholder, Map<String, String> properties) {
+        return click.kamil.springstatemachineexporter.analysis.util.PlaceholderResolver.resolve(placeholder, properties);
+    }
+}

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

@@ -0,0 +1,226 @@
+package click.kamil.springstatemachineexporter.analysis.resolver;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Slf4j
+public class SiblingDependencyResolver {
+
+    private static final Pattern GRADLE_PROJECT_DEP = Pattern.compile("project\\(['\"]:(.*?)['\"]\\)");
+    private static final Pattern MAVEN_DEPENDENCY = Pattern.compile("<dependency>\\s*<groupId>(.*?)</groupId>\\s*<artifactId>(.*?)</artifactId>\\s*<version>(.*?)</version>", Pattern.DOTALL);
+
+    public Set<Path> resolveSiblings(Path projectDir) {
+        Set<Path> allSiblings = new HashSet<>();
+        Queue<Path> queue = new LinkedList<>();
+        queue.add(projectDir);
+        
+        while (!queue.isEmpty()) {
+            Path current = queue.poll();
+            Set<Path> currentSiblings = new HashSet<>();
+            try {
+                currentSiblings.addAll(resolveGradleSiblings(current));
+                currentSiblings.addAll(resolveMavenSiblings(current));
+            } catch (Exception e) {
+                log.warn("Error resolving sibling dependencies for {}", current, e);
+            }
+            
+            for (Path sibling : currentSiblings) {
+                if (!allSiblings.contains(sibling) && !sibling.equals(projectDir)) {
+                    allSiblings.add(sibling);
+                    queue.add(sibling);
+                }
+            }
+        }
+        return allSiblings;
+    }
+
+    private Set<Path> resolveGradleSiblings(Path projectDir) throws IOException {
+        Set<Path> siblings = new HashSet<>();
+        Path buildGradle = projectDir.resolve("build.gradle");
+        if (!Files.exists(buildGradle)) {
+            buildGradle = projectDir.resolve("build.gradle.kts");
+        }
+
+        if (Files.exists(buildGradle)) {
+            log.info("Found build.gradle at {}", buildGradle);
+            String content = Files.readString(buildGradle);
+            Matcher matcher = GRADLE_PROJECT_DEP.matcher(content);
+            Set<String> gradlePaths = new HashSet<>();
+            while (matcher.find()) {
+                gradlePaths.add(matcher.group(1));
+            }
+            log.info("Found project dependencies: {}", gradlePaths);
+
+            if (!gradlePaths.isEmpty()) {
+                Path rootDir = findGradleRoot(projectDir);
+                log.info("Resolved Gradle root to: {}", rootDir);
+                if (rootDir != null) {
+                    for (String gradlePath : gradlePaths) {
+                        String relativePath = gradlePath.replace(':', '/');
+                        Path resolvedSibling = rootDir.resolve(relativePath).normalize();
+
+                        // Check for explicit projectDir mapping in settings.gradle or settings.gradle.kts
+                        Path settingsFile = rootDir.resolve("settings.gradle");
+                        if (!Files.exists(settingsFile)) {
+                            settingsFile = rootDir.resolve("settings.gradle.kts");
+                        }
+                        if (Files.exists(settingsFile)) {
+                            String settingsContent = Files.readString(settingsFile);
+                            String regex = "project\\(['\"]:" + gradlePath + "['\"]\\)\\.projectDir\\s*=\\s*(?:file\\(['\"](.*?)['\"]\\)|new File\\(.*?,\\s*['\"](.*?)['\"]\\))";
+                            Matcher settingsMatcher = Pattern.compile(regex).matcher(settingsContent);
+                            if (settingsMatcher.find()) {
+                                String customPath = settingsMatcher.group(1) != null ? settingsMatcher.group(1) : settingsMatcher.group(2);
+                                resolvedSibling = rootDir.resolve(customPath).normalize();
+                                log.info("Found custom projectDir in settings for {}: {}", gradlePath, resolvedSibling);
+                            }
+                        }
+
+                        if (Files.exists(resolvedSibling)) {
+                            log.info("Discovered local Gradle sibling dependency: {}", resolvedSibling);
+                            siblings.add(resolvedSibling);
+                        }
+                    }
+                }
+            }
+        }
+        return siblings;
+    }
+
+    private Path findGradleRoot(Path start) {
+        Path current = start.toAbsolutePath();
+        Path lastSettingsDir = null;
+        while (current != null) {
+            if (Files.exists(current.resolve("settings.gradle")) || Files.exists(current.resolve("settings.gradle.kts"))) {
+                lastSettingsDir = current;
+            }
+            if (Files.exists(current.resolve(".git"))) {
+                return lastSettingsDir != null ? lastSettingsDir : current;
+            }
+            current = current.getParent();
+        }
+        return lastSettingsDir;
+    }
+
+    private Set<Path> resolveMavenSiblings(Path projectDir) throws IOException {
+        Set<Path> siblings = new HashSet<>();
+        Path pom = projectDir.resolve("pom.xml");
+        if (Files.exists(pom)) {
+            log.info("Found pom.xml at {}", pom);
+            String content = Files.readString(pom);
+            
+            Set<String> targetArtifacts = new HashSet<>();
+            Matcher matcher = Pattern.compile("<artifactId>(.*?)</artifactId>").matcher(content);
+            // We want artifacts from the <dependencies> section
+            int depsStart = content.indexOf("<dependencies>");
+            int depsEnd = content.indexOf("</dependencies>");
+            if (depsStart != -1 && depsEnd > depsStart) {
+                String depsContent = content.substring(depsStart, depsEnd);
+                Matcher depMatcher = Pattern.compile("<artifactId>(.*?)</artifactId>").matcher(depsContent);
+                while (depMatcher.find()) {
+                    targetArtifacts.add(depMatcher.group(1));
+                }
+            }
+            log.info("Found maven target artifacts: {}", targetArtifacts);
+
+            if (!targetArtifacts.isEmpty()) {
+                Path rootDir = findMavenRoot(projectDir);
+                log.info("Resolved Maven root to: {}", rootDir);
+                if (rootDir != null) {
+                    try (Stream<Path> paths = Files.walk(rootDir)) {
+                        List<Path> allPoms = paths.filter(p -> p.getFileName().toString().equals("pom.xml"))
+                             .filter(p -> !p.toString().contains("/target/"))
+                             .collect(Collectors.toList());
+                        log.info("Scanned {} total pom.xml files under {}", allPoms.size(), rootDir);
+                        
+                         for (Path p : allPoms) {
+                             try {
+                                 String pContent = Files.readString(p);
+                                 String artifactId = extractOwnArtifactId(pContent);
+                                 log.info("Checking artifactId {} in {}", artifactId, p);
+                                 if (artifactId != null && targetArtifacts.contains(artifactId)) {
+                                     Path siblingDir = p.getParent();
+                                     if (!siblingDir.equals(projectDir)) {
+                                        log.info("Discovered local Maven sibling dependency via artifact match: {}", siblingDir);
+                                        siblings.add(siblingDir);
+                                     }
+                                 }
+                             } catch (IOException e) {
+                                 // ignore
+                             }
+                        }
+                    }
+                }
+            }
+
+            // Also directly add aggregator <module> directories declared in this pom
+            Matcher moduleMatcher = Pattern.compile("<module>(.*?)</module>").matcher(content);
+            while (moduleMatcher.find()) {
+                String moduleName = moduleMatcher.group(1).trim();
+                Path moduleDir = projectDir.resolve(moduleName).normalize();
+                if (Files.exists(moduleDir) && Files.exists(moduleDir.resolve("pom.xml")) && !moduleDir.equals(projectDir)) {
+                    log.info("Discovered local Maven sibling dependency via <module>: {}", moduleDir);
+                    siblings.add(moduleDir);
+                }
+            }
+            
+            // Also add parent dir if it has a pom.xml
+            Path parentDir = projectDir.getParent();
+            
+            // Check for explicit <relativePath> in parent block
+            Matcher parentRelativePathMatcher = Pattern.compile("<parent>.*?<relativePath>(.*?)</relativePath>.*?</parent>", Pattern.DOTALL).matcher(content);
+            if (parentRelativePathMatcher.find()) {
+                String relPathStr = parentRelativePathMatcher.group(1).trim();
+                Path relPath = projectDir.resolve(relPathStr).normalize();
+                if (Files.isRegularFile(relPath) && relPath.getFileName().toString().equals("pom.xml")) {
+                    parentDir = relPath.getParent();
+                } else if (Files.isDirectory(relPath)) {
+                    parentDir = relPath;
+                }
+            }
+            
+            if (parentDir != null && Files.exists(parentDir.resolve("pom.xml")) && !parentDir.equals(projectDir)) {
+                log.info("Discovered local Maven parent sibling: {}", parentDir);
+                siblings.add(parentDir);
+            }
+        }
+        return siblings;
+    }
+
+    private String extractOwnArtifactId(String pomContent) {
+        // Strip <parent> block if it exists
+        String content = pomContent;
+        int parentEnd = pomContent.indexOf("</parent>");
+        if (parentEnd != -1) {
+            content = pomContent.substring(parentEnd);
+        }
+        
+        Matcher matcher = Pattern.compile("<artifactId>(.*?)</artifactId>").matcher(content);
+        if (matcher.find()) {
+            return matcher.group(1);
+        }
+        return null;
+    }
+
+    private Path findMavenRoot(Path start) {
+        Path current = start.toAbsolutePath();
+        Path lastPomDir = null;
+        while (current != null) {
+            if (Files.exists(current.resolve("pom.xml"))) {
+                lastPomDir = current;
+            }
+            if (Files.exists(current.resolve(".git"))) {
+                return lastPomDir != null ? lastPomDir : current;
+            }
+            current = current.getParent();
+        }
+        return lastPomDir;
+    }
+}

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

@@ -0,0 +1,15 @@
+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 java.util.List;
+
+public interface CallGraphEngine {
+    List<CallChain> findChains(List<EntryPoint> entryPoints, List<TriggerPoint> triggers);
+
+    default java.util.Map<String, java.util.List<click.kamil.springstatemachineexporter.analysis.model.CallEdge>> getCallGraph() {
+        return java.util.Collections.emptyMap();
+    }
+}

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

@@ -0,0 +1,276 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallEdge;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.eclipse.jdt.core.dom.TypeDeclaration;
+import lombok.extern.slf4j.Slf4j;
+import java.util.*;
+
+@Slf4j
+public class CallGraphPathFinder {
+    private final CodebaseContext context;
+    private final Map<java.util.Map.Entry<String, String>, Boolean> heuristicCache = new HashMap<>();
+
+    private final Map<java.util.Map.Entry<String, String>, List<List<String>>> memoCache = new HashMap<>();
+    private final Map<java.util.Map.Entry<String, String>, Boolean> unreachableCache = new HashMap<>();
+
+    public CallGraphPathFinder(CodebaseContext context) {
+        this.context = context;
+    }
+
+    public List<String> findPath(String start, String target, Map<String, List<CallEdge>> graph, Set<String> visited) {
+        if (start.equals(target)) return new ArrayList<>(List.of(start));
+        if (!visited.add(start)) {
+            if (log.isDebugEnabled()) {
+                log.debug("Cycle detected in call graph search: {} is already in visited path {}", start, visited);
+            }
+            return null; // Path-scoped cycle detection
+        }
+
+        List<CallEdge> neighbors = graph.get(start);
+        if (neighbors != null) {
+            for (CallEdge edge : neighbors) {
+                String neighbor = edge.getTargetMethod();
+                if (neighbor.equals(target) || isHeuristicMatch(neighbor, target)) {
+                    visited.remove(start);
+                    return new ArrayList<>(List.of(start, target));
+                }
+                List<String> path = findPath(neighbor, target, graph, visited);
+                if (path != null) {
+                    path.add(0, start);
+                    visited.remove(start);
+                    return path;
+                }
+            }
+        }
+        
+        if (log.isDebugEnabled()) {
+            log.debug("Path search dead-end at {} when looking for {}", start, target);
+        }
+        
+        visited.remove(start);
+        return null;
+    }
+
+    public List<List<String>> findAllPaths(String start, String target, Map<String, List<CallEdge>> graph, Set<String> visited) {
+        return findAllPaths(start, target, graph, visited, new boolean[]{false});
+    }
+
+    public List<List<String>> findAllPaths(String start, String target, Map<String, List<CallEdge>> graph, Set<String> visited, boolean[] parentHitCycle) {
+        List<List<String>> result = new ArrayList<>();
+        java.util.Map.Entry<String, String> cacheKey = new java.util.AbstractMap.SimpleImmutableEntry<>(start, target);
+        if (unreachableCache.containsKey(cacheKey)) {
+            return result;
+        }
+        if (memoCache.containsKey(cacheKey)) {
+            List<List<String>> cached = memoCache.get(cacheKey);
+            for (List<String> path : cached) {
+                boolean hasCycle = false;
+                for (String node : path) {
+                    if (visited.contains(node)) {
+                        hasCycle = true;
+                        parentHitCycle[0] = true;
+                        break;
+                    }
+                }
+                if (!hasCycle) {
+                    result.add(new ArrayList<>(path));
+                }
+            }
+            return result;
+        }
+        if (start.equals(target)) {
+            result.add(new ArrayList<>(List.of(start)));
+            return result;
+        }
+        if (!visited.add(start)) {
+            parentHitCycle[0] = true;
+            return result;
+        }
+
+        boolean[] localHitCycle = new boolean[]{false};
+
+        List<CallEdge> neighbors = graph.get(start);
+        if (neighbors != null) {
+            for (CallEdge edge : neighbors) {
+                String neighbor = edge.getTargetMethod();
+                if (neighbor.startsWith("java.") || neighbor.startsWith("javax.") || neighbor.startsWith("jakarta.") || neighbor.startsWith("org.springframework.")) continue;
+                if (neighbor.equals(target) || isHeuristicMatch(neighbor, target)) {
+                    List<String> path = new ArrayList<>(List.of(start, target));
+                    result.add(path);
+                } else {
+                    List<List<String>> subPaths = findAllPaths(neighbor, target, graph, visited, localHitCycle);
+                    for (List<String> subPath : subPaths) {
+                        List<String> path = new ArrayList<>();
+                        path.add(start);
+                        path.addAll(subPath);
+                        result.add(path);
+                    }
+                }
+            }
+        }
+        
+        // Handle inheritance fallback for concrete class methods not in the graph
+        if (result.isEmpty() && start.contains(".")) {
+            String className = start.substring(0, start.lastIndexOf('.'));
+            String methodName = start.substring(start.lastIndexOf('.') + 1);
+            if (className.contains("<")) {
+                className = className.substring(0, className.indexOf('<'));
+            }
+            TypeDeclaration td = context.getTypeDeclaration(className);
+            if (td != null) {
+                String superclass = context.getSuperclassFqn(td);
+                if (superclass != null) {
+                    String superMethod = superclass + "." + methodName;
+                    if (graph.containsKey(superMethod)) {
+                        List<List<String>> superPaths = findAllPaths(superMethod, target, graph, visited, localHitCycle);
+                        for (List<String> superPath : superPaths) {
+                            List<String> path = new ArrayList<>();
+                            path.add(start);
+                            path.addAll(superPath);
+                            result.add(path);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Handle implementation fallback for interfaces/superclasses (interface -> concrete class)
+        if (result.isEmpty() && start.contains(".")) {
+            String className = start.substring(0, start.lastIndexOf('.'));
+            String methodName = start.substring(start.lastIndexOf('.') + 1);
+            if (className.contains("<")) {
+                className = className.substring(0, className.indexOf('<'));
+            }
+            List<String> impls = context.getImplementations(className);
+            if (impls != null) {
+                for (String impl : impls) {
+                    String implMethod = impl + "." + methodName;
+                    if (graph.containsKey(implMethod)) {
+                        List<List<String>> implPaths = findAllPaths(implMethod, target, graph, visited, localHitCycle);
+                        for (List<String> implPath : implPaths) {
+                            List<String> path = new ArrayList<>();
+                            path.add(start);
+                            path.addAll(implPath);
+                            result.add(path);
+                        }
+                    }
+                }
+            }
+        }
+        visited.remove(start);
+        
+        if (localHitCycle[0]) {
+            parentHitCycle[0] = true;
+        } else if (result.isEmpty()) {
+            unreachableCache.put(cacheKey, true);
+        } else {
+            List<List<String>> toCache = new ArrayList<>();
+            for (List<String> path : result) {
+                toCache.add(new ArrayList<>(path));
+            }
+            memoCache.put(cacheKey, toCache);
+        }
+        
+        return result;
+    }
+
+    public String extractContextMachineId(List<String> path, Map<String, List<CallEdge>> callGraph) {
+        for (String node : path) {
+            List<CallEdge> edges = callGraph.get(node);
+            if (edges != null) {
+                for (CallEdge edge : edges) {
+                    String target = edge.getTargetMethod();
+                    if (target != null && (target.contains(".restore") || target.contains(".read"))) {
+                        if (edge.getArguments().size() >= 2) {
+                            return edge.getArguments().get(1); // The contextObj / machineId
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    public boolean isHeuristicMatch(String neighbor, String target) {
+        if (neighbor == null || target == null) return false;
+        if (neighbor.equals(target)) return true;
+
+        java.util.Map.Entry<String, String> cacheKey = new java.util.AbstractMap.SimpleImmutableEntry<>(neighbor, target);
+        Boolean cached = heuristicCache.get(cacheKey);
+        if (cached != null) return cached;
+
+        boolean result = calculateHeuristicMatch(neighbor, target);
+        heuristicCache.put(cacheKey, result);
+        return result;
+    }
+
+    private boolean calculateHeuristicMatch(String neighbor, String target) {
+        if (neighbor.equals(target)) return true;
+
+        if (isFullyQualifiedMethod(neighbor) && isFullyQualifiedMethod(target)) {
+            int lastDotNeighbor = neighbor.lastIndexOf('.');
+            int lastDotTarget = target.lastIndexOf('.');
+            if (lastDotNeighbor < 0 || lastDotTarget < 0) return false;
+            
+            String methodNeighbor = neighbor.substring(lastDotNeighbor + 1);
+            String methodTarget = target.substring(lastDotTarget + 1);
+            
+            if (!methodNeighbor.equals(methodTarget)) {
+                return false;
+            }
+            
+            String classNeighbor = neighbor.substring(0, lastDotNeighbor);
+            String classTarget = target.substring(0, lastDotTarget);
+            
+            if (classNeighbor.equals(classTarget)) return true;
+            
+            String simpleClassNeighbor = classNeighbor.contains(".") ? classNeighbor.substring(classNeighbor.lastIndexOf('.') + 1) : classNeighbor;
+            String simpleClassTarget = classTarget.contains(".") ? classTarget.substring(classTarget.lastIndexOf('.') + 1) : classTarget;
+            
+            if (simpleClassNeighbor.equals(simpleClassTarget)) return true;
+            
+            List<String> impls = context.getImplementations(classTarget);
+            if (impls != null) {
+                for (String impl : impls) {
+                    if (impl.equals(classNeighbor) || impl.endsWith("." + classNeighbor)) return true;
+                }
+            }
+            List<String> implsN = context.getImplementations(classNeighbor);
+            if (implsN != null) {
+                for (String impl : implsN) {
+                    if (impl.equals(classTarget) || impl.endsWith("." + classTarget)) return true;
+                }
+            }
+            
+            return false;
+        }
+
+        String simpleTarget = target.contains(".") ? target.substring(target.lastIndexOf('.') + 1) : target;
+        String simpleNeighbor = neighbor.contains(".") ? neighbor.substring(neighbor.lastIndexOf('.') + 1) : neighbor;
+        if (!simpleNeighbor.equals(simpleTarget)) return false;
+        
+        String classNeighbor = neighbor.contains(".") ? neighbor.substring(0, neighbor.lastIndexOf('.')) : null;
+        String classTarget = target.contains(".") ? target.substring(0, target.lastIndexOf('.')) : null;
+        String simpleClassTarget = classTarget != null && classTarget.contains(".") ? classTarget.substring(classTarget.lastIndexOf('.') + 1) : classTarget;
+        String simpleClassNeighbor = classNeighbor != null && classNeighbor.contains(".") ? classNeighbor.substring(classNeighbor.lastIndexOf('.') + 1) : classNeighbor;
+
+        if (simpleClassNeighbor != null && simpleClassTarget != null) {
+            if (simpleClassNeighbor.equalsIgnoreCase(simpleClassTarget)) return true;
+            // e.g. "this" vs "com.example.Machine"
+            if (simpleClassNeighbor.equals("this") || simpleClassNeighbor.equals("super")) return true;
+            return false;
+        }
+        
+        return true;
+    }
+
+    private boolean isFullyQualifiedMethod(String methodFqn) {
+        if (methodFqn == null || !methodFqn.contains(".")) return false;
+        int lastDot = methodFqn.lastIndexOf('.');
+        String classPart = methodFqn.substring(0, lastDot);
+        if (classPart.contains(".")) return true;
+        if (!classPart.isEmpty() && Character.isUpperCase(classPart.charAt(0))) return true;
+        return false;
+    }
+}

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

@@ -0,0 +1,30 @@
+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 java.util.List;
+import java.util.Map;
+
+public interface CodebaseIntelligenceProvider {
+    /**
+     * Discovers all locations where events are triggered.
+     */
+    List<TriggerPoint> findTriggerPoints();
+
+    /**
+     * Discovers all entry points (REST, Kafka, etc.).
+     */
+    List<EntryPoint> findEntryPoints();
+
+    /**
+     * Links Entry Points to Trigger Points.
+     */
+    List<CallChain> findCallChains(List<EntryPoint> entryPoints, List<TriggerPoint> triggers);
+
+    /**
+     * Resolves configuration properties per profile.
+     */
+    Map<String, Map<String, String>> resolveProperties();
+}

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

@@ -0,0 +1,118 @@
+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 java.util.*;
+
+public class CompositeCallGraphEngine implements CallGraphEngine {
+    private final List<CallGraphEngine> engines;
+    private final Map<String, List<CallEdge>> mergedGraph = new HashMap<>();
+
+    public CompositeCallGraphEngine(List<CallGraphEngine> engines) {
+        this.engines = engines;
+        mergeGraphs();
+    }
+
+    private void mergeGraphs() {
+        for (CallGraphEngine engine : engines) {
+            Map<String, List<CallEdge>> graph = engine.getCallGraph();
+            if (graph != null) {
+                for (Map.Entry<String, List<CallEdge>> entry : graph.entrySet()) {
+                    String caller = normalizeCompanionFqn(entry.getKey());
+                    List<CallEdge> edges = mergedGraph.computeIfAbsent(caller, k -> new ArrayList<>());
+                    for (CallEdge edge : entry.getValue()) {
+                        String target = normalizeCompanionFqn(edge.getTargetMethod());
+                        edges.add(new CallEdge(target, edge.getArguments(), edge.getReceiver()));
+                    }
+                }
+            }
+        }
+    }
+
+    private String normalizeCompanionFqn(String fqn) {
+        if (fqn == null) return null;
+        return fqn.replace(".Companion.", ".");
+    }
+
+    @Override
+    public Map<String, List<CallEdge>> getCallGraph() {
+        return mergedGraph;
+    }
+
+    @Override
+    public List<CallChain> findChains(List<EntryPoint> entryPoints, List<TriggerPoint> triggers) {
+        List<CallChain> chains = new ArrayList<>();
+        for (EntryPoint ep : entryPoints) {
+            String startMethod = normalizeCompanionFqn(ep.getClassName() + "." + ep.getMethodName());
+            for (TriggerPoint tp : triggers) {
+                String targetMethod = normalizeCompanionFqn(tp.getClassName() + "." + tp.getMethodName());
+                List<List<String>> paths = findAllPaths(startMethod, targetMethod, new LinkedHashSet<>());
+                for (List<String> path : paths) {
+                    chains.add(CallChain.builder()
+                            .entryPoint(ep)
+                            .methodChain(path)
+                            .triggerPoint(tp)
+                            .build());
+                }
+            }
+        }
+        return chains;
+    }
+
+    private List<List<String>> findAllPaths(String start, String target, Set<String> visited) {
+        List<List<String>> result = new ArrayList<>();
+        if (start.equals(target)) {
+            result.add(new ArrayList<>(List.of(start)));
+            return result;
+        }
+        if (!visited.add(start)) {
+            return result;
+        }
+
+        List<CallEdge> neighbors = mergedGraph.get(start);
+        if (neighbors != null) {
+            for (CallEdge edge : neighbors) {
+                String neighbor = edge.getTargetMethod();
+                if (neighbor.startsWith("java.") || neighbor.startsWith("javax.") || 
+                    neighbor.startsWith("jakarta.") || neighbor.startsWith("org.springframework.")) {
+                    continue;
+                }
+                
+                if (neighbor.equals(target) || isHeuristicMatch(neighbor, target)) {
+                    List<String> path = new ArrayList<>(List.of(start, target));
+                    result.add(path);
+                } else {
+                    List<List<String>> subPaths = findAllPaths(neighbor, target, visited);
+                    for (List<String> subPath : subPaths) {
+                        List<String> path = new ArrayList<>();
+                        path.add(start);
+                        path.addAll(subPath);
+                        result.add(path);
+                    }
+                }
+            }
+        }
+        visited.remove(start);
+        return result;
+    }
+
+    private boolean isHeuristicMatch(String neighbor, String target) {
+        if (neighbor == null || target == null) return false;
+        if (neighbor.equals(target)) return true;
+        if (neighbor.contains(".") && target.contains(".")) {
+            String methodNeighbor = neighbor.substring(neighbor.lastIndexOf('.') + 1);
+            String methodTarget = target.substring(target.lastIndexOf('.') + 1);
+            if (methodNeighbor.equals(methodTarget)) {
+                String classNeighbor = neighbor.substring(0, neighbor.lastIndexOf('.'));
+                String classTarget = target.substring(0, target.lastIndexOf('.'));
+                String simpleClassNeighbor = classNeighbor.contains(".") ? classNeighbor.substring(classNeighbor.lastIndexOf('.') + 1) : classNeighbor;
+                String simpleClassTarget = classTarget.contains(".") ? classTarget.substring(classTarget.lastIndexOf('.') + 1) : classTarget;
+                return simpleClassNeighbor.equalsIgnoreCase(simpleClassTarget);
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,53 @@
+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 java.util.*;
+
+public class CompositeIntelligenceProvider implements CodebaseIntelligenceProvider {
+    private final List<CodebaseIntelligenceProvider> providers;
+    private final List<CallGraphEngine> engines;
+
+    public CompositeIntelligenceProvider(List<CodebaseIntelligenceProvider> providers, List<CallGraphEngine> engines) {
+        this.providers = providers;
+        this.engines = engines;
+    }
+
+    @Override
+    public List<TriggerPoint> findTriggerPoints() {
+        List<TriggerPoint> result = new ArrayList<>();
+        for (CodebaseIntelligenceProvider provider : providers) {
+            result.addAll(provider.findTriggerPoints());
+        }
+        return result;
+    }
+
+    @Override
+    public List<EntryPoint> findEntryPoints() {
+        List<EntryPoint> result = new ArrayList<>();
+        for (CodebaseIntelligenceProvider provider : providers) {
+            result.addAll(provider.findEntryPoints());
+        }
+        return result;
+    }
+
+    @Override
+    public List<CallChain> findCallChains(List<EntryPoint> entryPoints, List<TriggerPoint> triggers) {
+        CompositeCallGraphEngine compositeEngine = new CompositeCallGraphEngine(engines);
+        return compositeEngine.findChains(entryPoints, triggers);
+    }
+
+    @Override
+    public Map<String, Map<String, String>> resolveProperties() {
+        Map<String, Map<String, String>> result = new HashMap<>();
+        for (CodebaseIntelligenceProvider provider : providers) {
+            Map<String, Map<String, String>> props = provider.resolveProperties();
+            if (props != null) {
+                result.putAll(props);
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,420 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.jdt.core.dom.*;
+import java.util.*;
+import java.util.function.Function;
+
+@Slf4j
+public class ConstantExtractor {
+    private final CodebaseContext context;
+    private final ConstantResolver constantResolver;
+    private final Function<MethodInvocation, String> calledMethodResolver;
+    private VariableTracer variableTracer;
+    private ConstructorAnalyzer constructorAnalyzer;
+
+    public ConstantExtractor(CodebaseContext context, ConstantResolver constantResolver, Function<MethodInvocation, String> calledMethodResolver) {
+        this.context = context;
+        this.constantResolver = constantResolver;
+        this.calledMethodResolver = calledMethodResolver;
+    }
+
+    public void setVariableTracer(VariableTracer variableTracer) {
+        this.variableTracer = variableTracer;
+    }
+
+    public void setConstructorAnalyzer(ConstructorAnalyzer constructorAnalyzer) {
+        this.constructorAnalyzer = constructorAnalyzer;
+    }
+
+    public void extractConstantsFromExpression(Expression expr, List<String> constants) {
+        if (constantResolver != null) {
+            String resolved = constantResolver.resolve(expr, context);
+            if (resolved != null) {
+                if (resolved.startsWith("ENUM_SET:")) {
+                    for (String eVal : resolved.substring(9).split(",")) {
+                        String parsed = parseEnumSetElement(eVal);
+                        if (!constants.contains(parsed)) constants.add(parsed);
+                    }
+                } else {
+                    constants.add(resolved);
+                }
+                return;
+            }
+        }
+
+        if (expr instanceof QualifiedName qn) {
+            constants.add(qn.toString());
+        } else if (expr instanceof StringLiteral sl) {
+            constants.add(sl.getLiteralValue());
+        } else if (expr instanceof ConditionalExpression ce) {
+            extractConstantsFromExpression(ce.getThenExpression(), constants);
+            extractConstantsFromExpression(ce.getElseExpression(), constants);
+        } else if (expr instanceof ParenthesizedExpression pe) {
+            extractConstantsFromExpression(pe.getExpression(), constants);
+        } else if (expr instanceof CastExpression ce) {
+            extractConstantsFromExpression(ce.getExpression(), constants);
+        } else if (expr instanceof Assignment assignment) {
+            extractConstantsFromExpression(assignment.getRightHandSide(), constants);
+        } else if (expr instanceof SwitchExpression se) {
+            se.accept(new ASTVisitor() {
+                @Override
+                public boolean visit(YieldStatement ys) {
+                    extractConstantsFromExpression(ys.getExpression(), constants);
+                    return super.visit(ys);
+                }
+                @Override
+                public boolean visit(ExpressionStatement es) {
+                    extractConstantsFromExpression(es.getExpression(), constants);
+                    return super.visit(es);
+                }
+                @Override
+                public boolean visit(ReturnStatement rs) {
+                    extractConstantsFromExpression(rs.getExpression(), constants);
+                    return super.visit(rs);
+                }
+            });
+        } else if (expr instanceof ArrayAccess aa) {
+            extractConstantsFromExpression(aa.getArray(), constants);
+        } else if (expr instanceof ArrayCreation ac && ac.getInitializer() != null) {
+            for (Object expObj : ac.getInitializer().expressions()) {
+                extractConstantsFromArgument((Expression) expObj, constants);
+            }
+        } else if (expr instanceof ArrayInitializer ai) {
+            for (Object expObj : ai.expressions()) {
+                extractConstantsFromArgument((Expression) expObj, constants);
+            }
+        } else if (expr instanceof MethodInvocation mi) {
+            String methodName = mi.getName().getIdentifier();
+            
+            log.trace("Processing mi: {}", mi);
+            if (methodName.equals("get") || methodName.equals("getOrDefault")) {
+                if (mi.getExpression() != null) {
+                    if (variableTracer != null) {
+                        List<Expression> traced = variableTracer.traceVariableAll(mi.getExpression());
+                        for (Expression t : traced) {
+                            extractConstantsFromExpression(t, constants);
+                        }
+                    } else {
+                        extractConstantsFromExpression(mi.getExpression(), constants);
+                    }
+                }
+                return;
+            }
+            if (methodName.equals("of") || methodName.equals("ofEntries") || methodName.equals("asList") || methodName.equals("entry") ||
+                methodName.equals("just") || methodName.equals("withPayload") || methodName.equals("success")) {
+                for (Object argObj : mi.arguments()) {
+                    extractConstantsFromExpression((Expression) argObj, constants);
+                }
+                return;
+            }
+            
+            if ((methodName.startsWith("get") || methodName.equals("type") || methodName.equals("event")) && mi.getExpression() instanceof SimpleName sn) {
+                String varName = sn.getIdentifier();
+                String propName = methodName.startsWith("get") ? methodName.substring(3) : methodName;
+                
+                Block block = findEnclosingBlock(mi);
+                if (block != null) {
+                    for (Object stmtObj : block.statements()) {
+                        if (stmtObj == mi.getParent() || stmtObj == mi) break;
+                        if (stmtObj instanceof ExpressionStatement es) {
+                            if (es.getExpression() instanceof MethodInvocation setterMi) {
+                                if (setterMi.getName().getIdentifier().equalsIgnoreCase("set" + propName) || setterMi.getName().getIdentifier().equalsIgnoreCase(propName)) {
+                                    if (setterMi.getExpression() instanceof SimpleName setterSn && setterSn.getIdentifier().equals(varName)) {
+                                        if (!setterMi.arguments().isEmpty()) {
+                                            extractConstantsFromExpression((Expression) setterMi.arguments().get(0), constants);
+                                            return;
+                                        }
+                                    }
+                                }
+                            } else if (es.getExpression() instanceof Assignment assignment) {
+                                if (assignment.getLeftHandSide() instanceof FieldAccess fa) {
+                                    if (fa.getExpression() instanceof SimpleName faSn && faSn.getIdentifier().equals(varName)) {
+                                        if (fa.getName().getIdentifier().equalsIgnoreCase(propName)) {
+                                            extractConstantsFromExpression(assignment.getRightHandSide(), constants);
+                                            return;
+                                        }
+                                    }
+                                } else if (assignment.getLeftHandSide() instanceof QualifiedName qqn) {
+                                    if (qqn.getQualifier().getFullyQualifiedName().equals(varName)) {
+                                        if (qqn.getName().getIdentifier().equalsIgnoreCase(propName)) {
+                                            extractConstantsFromExpression(assignment.getRightHandSide(), constants);
+                                            return;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            
+            List<Expression> receivers = new ArrayList<>();
+            if (mi.getExpression() != null) {
+                if (mi.getExpression() instanceof ClassInstanceCreation) {
+                    receivers.add(mi.getExpression());
+                } else if (variableTracer != null) {
+                    receivers.addAll(variableTracer.traceVariableAll(mi.getExpression()));
+                }
+            }
+            
+            for (Expression receiverExpr : receivers) {
+                if (receiverExpr instanceof ClassInstanceCreation cic) {
+                    if (cic.getAnonymousClassDeclaration() != null) {
+                        for (Object declObj : cic.getAnonymousClassDeclaration().bodyDeclarations()) {
+                            if (declObj instanceof MethodDeclaration mdecl) {
+                                if (mdecl.getName().getIdentifier().equals(methodName) && mdecl.getBody() != null) {
+                                    mdecl.getBody().accept(new ASTVisitor() {
+                                        @Override
+                                        public boolean visit(ReturnStatement rs) {
+                                            if (rs.getExpression() != null) {
+                                                extractConstantsFromExpression(rs.getExpression(), constants);
+                                            }
+                                            return super.visit(rs);
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                    } else if (constructorAnalyzer != null) {
+                        boolean handledByLombok = false;
+                        if (methodName.startsWith("get") && methodName.length() > 3) {
+                            String typeName = click.kamil.springstatemachineexporter.ast.common.AstUtils.extractSimpleTypeName(cic.getType());
+                            TypeDeclaration typeDecl = context.getTypeDeclaration(typeName);
+                            if (typeDecl != null) {
+                                String fieldName = Character.toLowerCase(methodName.charAt(3)) + methodName.substring(4);
+                                int fieldIndex = constructorAnalyzer.findConstructorArgumentIndexForLombokField(typeDecl, fieldName);
+                                if (fieldIndex >= 0 && fieldIndex < cic.arguments().size()) {
+                                    extractConstantsFromArgument((Expression) cic.arguments().get(fieldIndex), constants);
+                                    handledByLombok = true;
+                                }
+                            }
+                        }
+                        if (!handledByLombok && methodName != null && !methodName.isEmpty()) {
+                            List<String> narrowed = constructorAnalyzer.resolveInlineInstantiationGetterResult(
+                                    cic, methodName, context, new HashSet<>());
+                            if (narrowed.isEmpty()) {
+                                String typeName = click.kamil.springstatemachineexporter.ast.common.AstUtils.extractSimpleTypeName(cic.getType());
+                                CompilationUnit contextCu = expr.getRoot() instanceof CompilationUnit ? (CompilationUnit) expr.getRoot() : null;
+                                TypeDeclaration typeDecl = contextCu != null ? context.getTypeDeclaration(typeName, contextCu) : context.getTypeDeclaration(typeName);
+                                if (typeDecl == null) typeDecl = context.getTypeDeclaration(typeName);
+                                if (typeDecl != null) {
+                                    narrowed = resolveMethodReturnConstant(context.getFqn(typeDecl), methodName, 0, new HashSet<>(), contextCu);
+                                }
+                            }
+                            if (narrowed != null && !narrowed.isEmpty()) {
+                                constants.addAll(narrowed);
+                            }
+                        }
+                    }
+                }
+            }
+            
+            Expression currentMi = mi;
+            while (currentMi instanceof MethodInvocation chainMi) {
+                String chainName = chainMi.getName().getIdentifier();
+                if (chainName.equals("setHeader") && chainMi.arguments().size() == 2) {
+                    extractConstantsFromExpression((Expression) chainMi.arguments().get(1), constants);
+                } else if ((chainName.equalsIgnoreCase("event") || chainName.equalsIgnoreCase("type") || chainName.equalsIgnoreCase("eventType")) && chainMi.arguments().size() == 1) {
+                    extractConstantsFromExpression((Expression) chainMi.arguments().get(0), constants);
+                }
+                currentMi = chainMi.getExpression();
+            }
+            
+            TypeDeclaration td = findEnclosingType(mi);
+            if (td != null && (mi.getExpression() == null || mi.getExpression() instanceof ThisExpression)) {
+                List<String> values = resolveMethodReturnConstant(context.getFqn(td), methodName, 0, new HashSet<>(), null);
+                if (values != null) constants.addAll(values);
+            }
+        }
+    }
+
+    public void extractConstantsFromArgument(Expression argObj, List<String> constants) {
+        if (argObj instanceof ClassInstanceCreation innerCic) {
+            String typeName = click.kamil.springstatemachineexporter.ast.common.AstUtils.extractSimpleTypeName(innerCic.getType());
+            if ("String".equals(typeName)) {
+                extractConstantsFromExpression(argObj, constants);
+            }
+        } else {
+            extractConstantsFromExpression(argObj, constants);
+        }
+    }
+
+    public List<String> resolveClassConstantReturns(String className, CodebaseContext context, CompilationUnit contextCu) {
+        if (className != null && className.contains(".")) {
+            String prefix = className.substring(0, className.lastIndexOf('.'));
+            String suffix = className.substring(className.lastIndexOf('.') + 1);
+            TypeDeclaration prefixTd = contextCu != null ? context.getTypeDeclaration(prefix, contextCu) : context.getTypeDeclaration(prefix);
+            if (prefixTd == null) prefixTd = context.getTypeDeclaration(prefix);
+            boolean isKnownType = prefixTd != null || context.getEnumValues(prefix) != null;
+            if (isKnownType) {
+                String simplePrefix = prefix.contains(".") ? prefix.substring(prefix.lastIndexOf('.') + 1) : prefix;
+                return Collections.singletonList(simplePrefix + "." + suffix);
+            }
+        }
+
+        TypeDeclaration td = contextCu != null ? context.getTypeDeclaration(className, contextCu) : context.getTypeDeclaration(className);
+        if (td == null) td = context.getTypeDeclaration(className);
+        if (td == null) return null;
+        
+        final List<String> resolvedConstants = new ArrayList<>();
+        for (MethodDeclaration md : td.getMethods()) {
+            if (md.getBody() != null) {
+                md.getBody().accept(new ASTVisitor() {
+                    public boolean visit(ReturnStatement node) {
+                        if (variableTracer != null) {
+                            List<Expression> tracedReturns = variableTracer.traceVariableAll(node.getExpression());
+                            for (Expression tracedRet : tracedReturns) {
+                                extractConstantsFromExpression(tracedRet, resolvedConstants);
+                            }
+                        }
+                        return super.visit(node);
+                    }
+                });
+            }
+            if (!resolvedConstants.isEmpty()) {
+                return resolvedConstants;
+            }
+        }
+        return null;
+    }
+
+    public List<String> resolveMethodReturnConstant(String className, String methodName, int depth, Set<String> visited, CompilationUnit contextCu) {
+        log.debug("ConstantExtractor.resolveMethodReturnConstant CALLED: className={}, methodName={}", className, methodName);
+        log.debug("Entering resolveMethodReturnConstant with className={}, methodName={}, depth={}", className, methodName, depth);
+        if (depth > 20) {
+            log.debug("Exiting resolveMethodReturnConstant early (depth limit) for {}.{}", className, methodName);
+            return Collections.emptyList();
+        }
+        String fqn = className + "." + methodName;
+        if (!visited.add(fqn)) {
+            log.debug("Exiting resolveMethodReturnConstant early (cycle detected) for fqn={}", fqn);
+            return Collections.emptyList();
+        }
+
+        List<String> constants = new ArrayList<>();
+        TypeDeclaration tempTd = contextCu != null ? context.getTypeDeclaration(className, contextCu) : null;
+        if (tempTd == null) {
+            tempTd = context.getTypeDeclaration(className);
+        }
+        final TypeDeclaration td = tempTd;
+        if (td != null) {
+            MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+            if (md != null && md.getBody() != null) {
+                md.getBody().accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(ReturnStatement node) {
+                        Expression retExpr = node.getExpression();
+                        if (retExpr != null) {
+                            boolean handled = false;
+                            if (retExpr instanceof MethodInvocation mi && calledMethodResolver != null) {
+                                String called = calledMethodResolver.apply(mi);
+                                if (called != null && called.contains(".")) {
+                                    if (visited.contains(called)) {
+                                        handled = true;
+                                    } else {
+                                        String cName = called.substring(0, called.lastIndexOf('.'));
+                                        String mName = called.substring(called.lastIndexOf('.') + 1);
+                                        
+                                        TypeDeclaration targetTd = contextCu != null ? context.getTypeDeclaration(cName, contextCu) : context.getTypeDeclaration(cName);
+                                        if (targetTd == null) targetTd = context.getTypeDeclaration(cName);
+                                        
+                                        if (targetTd != null && context.findMethodDeclaration(targetTd, mName, true) != null) {
+                                            List<String> delegationResult = resolveMethodReturnConstant(cName, mName, depth + 1, visited, contextCu);
+                                            constants.addAll(delegationResult);
+                                            handled = true;
+                                        }
+                                    }
+                                }
+                            } else if (retExpr instanceof SuperMethodInvocation smi) {
+                                String superFqn = context.getSuperclassFqn(td);
+                                if (superFqn != null) {
+                                    String called = superFqn + "." + smi.getName().getIdentifier();
+                                    if (visited.contains(called)) {
+                                        handled = true;
+                                    } else {
+                                        String cName = superFqn;
+                                        String mName = smi.getName().getIdentifier();
+                                        TypeDeclaration targetTd = contextCu != null ? context.getTypeDeclaration(cName, contextCu) : context.getTypeDeclaration(cName);
+                                        if (targetTd == null) targetTd = context.getTypeDeclaration(cName);
+                                        
+                                        if (targetTd != null && context.findMethodDeclaration(targetTd, mName, true) != null) {
+                                            List<String> delegationResult = resolveMethodReturnConstant(cName, mName, depth + 1, visited, contextCu);
+                                            constants.addAll(delegationResult);
+                                            handled = true;
+                                        }
+                                    }
+                                }
+                            }
+                            if (!handled && variableTracer != null && constructorAnalyzer != null) {
+                                List<Expression> tracedRetExprs = variableTracer.traceVariableAll(retExpr);
+                                if (tracedRetExprs.isEmpty() && retExpr != null) {
+                                    tracedRetExprs = List.of(retExpr);
+                                }
+                                for (Expression tracedRetExpr : tracedRetExprs) {
+                                    extractConstantsFromExpression(tracedRetExpr, constants);
+                                    String val = constantResolver.resolve(tracedRetExpr, context);
+                                    if (val != null) {
+                                        if (val.startsWith("ENUM_SET:")) {
+                                            for (String eVal : val.substring(9).split(",")) {
+                                                String parsed = parseEnumSetElement(eVal);
+                                                if (!constants.contains(parsed)) constants.add(parsed);
+                                            }
+                                        } else {
+                                            if (!constants.contains(val)) constants.add(val);
+                                        }
+                                    } else if (tracedRetExpr instanceof SimpleName sn) {
+                                        List<String> consts = constructorAnalyzer.traceFieldInConstructors(td, sn.getIdentifier(), context, visited);
+                                        if (!consts.isEmpty()) {
+                                            constants.addAll(consts);
+                                        }
+                                    } else if (tracedRetExpr instanceof FieldAccess fa) {
+                                        List<String> consts = constructorAnalyzer.traceFieldInConstructors(td, fa.getName().getIdentifier(), context, visited);
+                                        if (!consts.isEmpty()) {
+                                            constants.addAll(consts);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        return super.visit(node);
+                    }
+                });
+            } else {
+                List<String> impls = context.getImplementations(className);
+                if (impls != null) {
+                    for (String implName : impls) {
+                        List<String> delegationResult = resolveMethodReturnConstant(implName, methodName, depth + 1, visited, contextCu);
+                        constants.addAll(delegationResult);
+                    }
+                }
+            }
+        }
+        visited.remove(fqn);
+        log.debug("resolveMethodReturnConstant className={} methodName={} returns: {}", className, methodName, constants);
+        log.debug("resolveMethodReturnConstant for class={}, method={} resolved constants: {}", className, methodName, constants);
+        return constants;
+    }
+
+    public String parseEnumSetElement(String eVal) {
+        return eVal.contains(".") ? eVal.substring(eVal.lastIndexOf('.', eVal.lastIndexOf('.') - 1) + 1) : eVal;
+    }
+
+    private Block findEnclosingBlock(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof Block)) {
+            parent = parent.getParent();
+        }
+        return (Block) parent;
+    }
+
+    private TypeDeclaration findEnclosingType(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof TypeDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (TypeDeclaration) parent;
+    }
+}

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

@@ -0,0 +1,793 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.eclipse.jdt.core.dom.*;
+import java.util.*;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class ConstructorAnalyzer {
+    private final CodebaseContext context;
+    private final ConstantResolver constantResolver;
+    private VariableTracer variableTracer;
+    private ConstantExtractor constantExtractor;
+
+    @FunctionalInterface
+    public interface RhsResolver {
+        String resolve(Expression rhs, Map<String, String> paramValues, TypeDeclaration td);
+    }
+
+    public ConstructorAnalyzer(CodebaseContext context, ConstantResolver constantResolver) {
+        this.context = context;
+        this.constantResolver = constantResolver;
+    }
+
+    public void setVariableTracer(VariableTracer variableTracer) {
+        this.variableTracer = variableTracer;
+    }
+
+    public void setConstantExtractor(ConstantExtractor constantExtractor) {
+        this.constantExtractor = constantExtractor;
+    }
+
+    public List<String> traceFieldInConstructors(TypeDeclaration td, String fieldName, CodebaseContext context, Set<String> visited) {
+        if (td == null || fieldName == null) return Collections.emptyList();
+        String fqn = context.getFqn(td);
+        if (fqn == null) return Collections.emptyList();
+
+        String cycleKey = fqn + "#" + fieldName;
+        if (!visited.add(cycleKey)) {
+            return Collections.emptyList();
+        }
+
+        List<String> results = new ArrayList<>();
+        
+        for (FieldDeclaration fd : td.getFields()) {
+            for (Object fragObj : fd.fragments()) {
+                VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                if (frag.getName().getIdentifier().equals(fieldName) && frag.getInitializer() != null) {
+                    Expression right = frag.getInitializer();
+                    if (variableTracer != null && constantExtractor != null) {
+                        List<Expression> tracedRights = variableTracer.traceVariableAll(right);
+                        for (Expression tracedRight : tracedRights) {
+                            if (tracedRight instanceof MethodInvocation mi) {
+                                String calledName = mi.getName().getIdentifier();
+                                String targetClass = context.getFqn(td);
+                                CompilationUnit cu = td.getRoot() instanceof CompilationUnit ? (CompilationUnit) td.getRoot() : null;
+                                if (mi.getExpression() == null) {
+                                    TypeDeclaration targetTd = context.resolveStaticImport(calledName, cu);
+                                    if (targetTd != null) {
+                                        targetClass = context.getFqn(targetTd);
+                                    }
+                                }
+                                results.addAll(constantExtractor.resolveMethodReturnConstant(targetClass, calledName, 0, visited, cu));
+                            } else {
+                                String val = constantResolver.resolve(tracedRight, context);
+                                if (val != null) results.add(val);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        ASTVisitor assignmentVisitor = new ASTVisitor() {
+            @Override
+            public boolean visit(Assignment node) {
+                Expression left = node.getLeftHandSide();
+                if ((left instanceof SimpleName && ((SimpleName) left).getIdentifier().equals(fieldName)) ||
+                    (left instanceof FieldAccess && ((FieldAccess) left).getName().getIdentifier().equals(fieldName))) {
+                    
+                    Expression right = node.getRightHandSide();
+                    if (variableTracer != null && constantExtractor != null) {
+                        List<Expression> tracedRights = variableTracer.traceVariableAll(right);
+                        for (Expression tracedRight : tracedRights) {
+                            if (tracedRight instanceof MethodInvocation mi) {
+                                String calledName = mi.getName().getIdentifier();
+                                String targetClass = context.getFqn(td);
+                                
+                                if (mi.getExpression() != null && mi.resolveMethodBinding() != null && mi.resolveMethodBinding().getDeclaringClass() != null) {
+                                    targetClass = mi.resolveMethodBinding().getDeclaringClass().getQualifiedName();
+                                } else if (mi.getExpression() instanceof SimpleName) {
+                                    String exprName = ((SimpleName) mi.getExpression()).getIdentifier();
+                                    CompilationUnit cu = td.getRoot() instanceof CompilationUnit ? (CompilationUnit) td.getRoot() : null;
+                                    TypeDeclaration targetTd = context.resolveStaticImport(exprName, cu);
+                                    if (targetTd != null) {
+                                        targetClass = context.getFqn(targetTd);
+                                    }
+                                } else if (mi.getExpression() == null) {
+                                    CompilationUnit cu = td.getRoot() instanceof CompilationUnit ? (CompilationUnit) td.getRoot() : null;
+                                    TypeDeclaration targetTd = context.resolveStaticImport(calledName, cu);
+                                    if (targetTd != null) {
+                                        targetClass = context.getFqn(targetTd);
+                                    }
+                                }
+
+                                CompilationUnit cu = td.getRoot() instanceof CompilationUnit ? (CompilationUnit) td.getRoot() : null;
+                                results.addAll(constantExtractor.resolveMethodReturnConstant(targetClass, calledName, 0, visited, cu));
+                            } else {
+                                String val = constantResolver.resolve(tracedRight, context);
+                                if (val != null) results.add(val);
+                            }
+                        }
+                    }
+                }
+                return super.visit(node);
+            }
+            @Override
+            public boolean visit(ConstructorInvocation node) {
+                processConstructorInvocationArgs(node.arguments(), findEnclosingType(node), node, results, fieldName, context, visited);
+                return super.visit(node);
+            }
+            
+            @Override
+            public boolean visit(SuperConstructorInvocation node) {
+                TypeDeclaration enclosingTd = findEnclosingType(node);
+                if (enclosingTd != null) {
+                    String superFqn = context.getSuperclassFqn(enclosingTd);
+                    if (superFqn != null) {
+                        TypeDeclaration superTd = context.getTypeDeclaration(superFqn);
+                        processConstructorInvocationArgs(node.arguments(), superTd, node, results, fieldName, context, visited);
+                    }
+                }
+                return super.visit(node);
+            }
+        };
+
+        for (MethodDeclaration md : td.getMethods()) {
+            if (md.isConstructor() && md.getBody() != null) {
+                md.getBody().accept(assignmentVisitor);
+            }
+        }
+
+        for (Object bodyDecl : td.bodyDeclarations()) {
+            if (bodyDecl instanceof Initializer init && init.getBody() != null) {
+                init.getBody().accept(assignmentVisitor);
+            }
+        }
+
+        if (results.isEmpty()) {
+            // Context-Aware Fallback (Up): Check superclass constructors
+            String superFqn = context.getSuperclassFqn(td);
+            if (superFqn != null && !superFqn.equals("java.lang.Object")) {
+                TypeDeclaration superTd = context.getTypeDeclaration(superFqn);
+                if (superTd != null) {
+                    results.addAll(traceFieldInConstructors(superTd, fieldName, context, visited));
+                }
+            }
+        }
+
+        if (results.isEmpty()) {
+            // Context-Aware Fallback (Down): Check subclasses/implementations
+            List<String> impls = context.getImplementations(fqn);
+            if (impls != null) {
+                for (String implFqn : impls) {
+                    TypeDeclaration implTd = context.getTypeDeclaration(implFqn);
+                    if (implTd != null) {
+                        results.addAll(traceFieldInConstructors(implTd, fieldName, context, visited));
+                    }
+                }
+            }
+        }
+
+        if (results.isEmpty()) {
+            // Global Fallback: Search all parsed classes in the workspace
+            Collection<TypeDeclaration> allTypes = context.getTypeDeclarations();
+            if (allTypes != null) {
+                int matchedCount = 0;
+                for (TypeDeclaration typeDecl : allTypes) {
+                    if (typeDecl == null) continue;
+                    if (context.hasField(typeDecl, fieldName)) {
+                        results.addAll(traceFieldInConstructors(typeDecl, fieldName, context, visited));
+                        matchedCount++;
+                        if (matchedCount >= 10) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        visited.remove(cycleKey);
+        return results;
+    }
+
+    public Map<String, String> buildFieldValuesFromCIC(
+            TypeDeclaration td,
+            ClassInstanceCreation cic,
+            CodebaseContext context,
+            RhsResolver rhsResolver,
+            Map<String, String> initialLocals) {
+
+        String actualTypeName = click.kamil.springstatemachineexporter.ast.common.AstUtils.extractSimpleTypeName(cic.getType());
+        TypeDeclaration actualTd = context.getTypeDeclaration(actualTypeName);
+        if (actualTd == null) {
+            actualTd = td; 
+        }
+
+        Map<String, String> fieldValues = new HashMap<>();
+        Set<String> visitedCtors = new HashSet<>();
+        buildFieldValuesFromCICRecursive(actualTd, cic, context, fieldValues, visitedCtors, rhsResolver, initialLocals);
+        return fieldValues;
+    }
+
+    public Map<String, String> buildFieldValuesFromCIC(
+            TypeDeclaration td,
+            ClassInstanceCreation cic,
+            CodebaseContext context,
+            RhsResolver rhsResolver) {
+        return buildFieldValuesFromCIC(td, cic, context, rhsResolver, null);
+    }
+
+    public Map<String, String> buildFieldValuesFromCIC(
+            TypeDeclaration td,
+            ClassInstanceCreation cic,
+            CodebaseContext context) {
+        return buildFieldValuesFromCIC(td, cic, context, null, null);
+    }
+
+    private void buildFieldValuesFromCICRecursive(
+            TypeDeclaration td,
+            ClassInstanceCreation cic,
+            CodebaseContext context,
+            Map<String, String> fieldValues,
+            Set<String> visitedCtors,
+            RhsResolver rhsResolver,
+            Map<String, String> initialLocals) {
+
+        String tdKey = context.getFqn(td);
+        if (!visitedCtors.add(tdKey)) return;
+
+        IMethodBinding resolvedCtor = cic.resolveConstructorBinding();
+
+        for (MethodDeclaration ctor : td.getMethods()) {
+            if (!ctor.isConstructor() || ctor.getBody() == null) continue;
+            
+            boolean matches = false;
+            if (resolvedCtor != null && ctor.resolveBinding() != null) {
+                matches = resolvedCtor.isEqualTo(ctor.resolveBinding()) || resolvedCtor.getKey().equals(ctor.resolveBinding().getKey());
+            }
+            if (!matches) {
+                matches = ctor.parameters().size() == cic.arguments().size();
+            }
+            if (!matches) continue;
+
+            Map<String, String> paramValues = new HashMap<>();
+            for (int i = 0; i < ctor.parameters().size(); i++) {
+                String pName = ((SingleVariableDeclaration) ctor.parameters().get(i)).getName().getIdentifier();
+                Expression argExpr = (Expression) cic.arguments().get(i);
+                List<String> consts = new ArrayList<>();
+                if (constantExtractor != null) {
+                    constantExtractor.extractConstantsFromArgument(argExpr, consts);
+                }
+                if (!consts.isEmpty()) {
+                    paramValues.put(pName, consts.get(0));
+                } else {
+                    String resolved = null;
+                    if (argExpr instanceof SimpleName sn && initialLocals != null && initialLocals.containsKey(sn.getIdentifier())) {
+                        resolved = initialLocals.get(sn.getIdentifier());
+                    }
+                    if (resolved == null) {
+                        resolved = constantResolver.resolve(argExpr, context);
+                    }
+                    if (resolved != null) paramValues.put(pName, resolved);
+                }
+            }
+            // Evaluate constructor body regardless of whether parameters could be resolved as constants
+
+            java.util.Map<String, String> localVars = new java.util.HashMap<>(paramValues);
+            constantResolver.evaluateMethodBodyWithLocals(ctor, localVars, context, new java.util.HashSet<>());
+            for (java.util.Map.Entry<String, String> entry : localVars.entrySet()) {
+                if (entry.getKey().startsWith("this.")) {
+                    fieldValues.put(entry.getKey(), entry.getValue());
+                    fieldValues.put(entry.getKey().substring(5), entry.getValue());
+                } else if (context.hasField(td, entry.getKey())) {
+                    fieldValues.put(entry.getKey(), entry.getValue());
+                    fieldValues.put("this." + entry.getKey(), entry.getValue());
+                }
+            }
+
+            ctor.getBody().accept(new ASTVisitor() {
+                @Override
+                public boolean visit(SuperConstructorInvocation sci) {
+                    IMethodBinding binding = sci.resolveConstructorBinding();
+                    if (binding != null) {
+                        ITypeBinding declaringClass = binding.getDeclaringClass();
+                        if (declaringClass != null) {
+                            TypeDeclaration superTd = context.getTypeDeclaration(declaringClass.getErasure().getQualifiedName());
+                            if (superTd != null) {
+                                processSuperConstructorArgs(superTd, binding, sci.arguments(), paramValues, context, fieldValues, visitedCtors, rhsResolver);
+                                return super.visit(sci);
+                            }
+                        }
+                    }
+                    String superFqn = context.getSuperclassFqn(td);
+                    if (superFqn != null) {
+                        TypeDeclaration superTd = context.getTypeDeclaration(superFqn);
+                        if (superTd != null) {
+                            processSuperConstructorArgs(superTd, null, sci.arguments(), paramValues, context, fieldValues, visitedCtors, rhsResolver);
+                        }
+                    }
+                    return super.visit(sci);
+                }
+
+                @Override
+                public boolean visit(ConstructorInvocation ci) {
+                    IMethodBinding binding = ci.resolveConstructorBinding();
+                    processSuperConstructorArgs(td, binding, ci.arguments(), paramValues, context, fieldValues, visitedCtors, rhsResolver);
+                    return super.visit(ci);
+                }
+            });
+            break; 
+        }
+    }
+
+    private void processSuperConstructorArgs(
+            TypeDeclaration superTd,
+            IMethodBinding resolvedBinding,
+            List<?> superArgs,
+            Map<String, String> subClassParamValues,
+            CodebaseContext context,
+            Map<String, String> fieldValues,
+            Set<String> visitedCtors,
+            RhsResolver rhsResolver) {
+
+        if (superTd == null) return;
+
+        for (MethodDeclaration superCtor : superTd.getMethods()) {
+            if (!superCtor.isConstructor() || superCtor.getBody() == null) continue;
+            
+            boolean matches = false;
+            if (resolvedBinding != null && superCtor.resolveBinding() != null) {
+                matches = resolvedBinding.isEqualTo(superCtor.resolveBinding()) || resolvedBinding.getKey().equals(superCtor.resolveBinding().getKey());
+            } else {
+                matches = superCtor.parameters().size() == superArgs.size();
+            }
+            if (!matches) continue;
+
+            Map<String, String> superParamValues = new HashMap<>();
+            for (int i = 0; i < superCtor.parameters().size(); i++) {
+                String pName = ((SingleVariableDeclaration) superCtor.parameters().get(i)).getName().getIdentifier();
+                Expression argExpr = (Expression) superArgs.get(i);
+                
+                String resolved = null;
+                if (argExpr instanceof SimpleName sn) {
+                    resolved = subClassParamValues.get(sn.getIdentifier());
+                }
+                if (resolved == null) {
+                    List<String> consts = new ArrayList<>();
+                    if (constantExtractor != null) {
+                        constantExtractor.extractConstantsFromArgument(argExpr, consts);
+                    }
+                    if (!consts.isEmpty()) {
+                        resolved = consts.get(0);
+                    } else {
+                        resolved = constantResolver.resolve(argExpr, context);
+                    }
+                }
+                if (resolved == null && rhsResolver != null) {
+                    TypeDeclaration enclosingTd = findEnclosingType(argExpr);
+                    if (enclosingTd != null) {
+                        resolved = rhsResolver.resolve(argExpr, subClassParamValues, enclosingTd);
+                    }
+                }
+                if (resolved != null) {
+                    superParamValues.put(pName, resolved);
+                }
+            }
+            if (superParamValues.isEmpty()) continue;
+
+            java.util.Map<String, String> localVars = new java.util.HashMap<>(superParamValues);
+            constantResolver.evaluateMethodBodyWithLocals(superCtor, localVars, context, new java.util.HashSet<>());
+            for (java.util.Map.Entry<String, String> entry : localVars.entrySet()) {
+                if (entry.getKey().startsWith("this.")) {
+                    fieldValues.put(entry.getKey(), entry.getValue());
+                    fieldValues.put(entry.getKey().substring(5), entry.getValue());
+                } else if (context.hasField(superTd, entry.getKey())) {
+                    fieldValues.put(entry.getKey(), entry.getValue());
+                    fieldValues.put("this." + entry.getKey(), entry.getValue());
+                }
+            }
+
+            superCtor.getBody().accept(new ASTVisitor() {
+                @Override
+                public boolean visit(SuperConstructorInvocation sci) {
+                    IMethodBinding binding = sci.resolveConstructorBinding();
+                    if (binding != null) {
+                        ITypeBinding declaringClass = binding.getDeclaringClass();
+                        if (declaringClass != null) {
+                            TypeDeclaration nextSuperTd = context.getTypeDeclaration(declaringClass.getErasure().getQualifiedName());
+                            if (nextSuperTd != null) {
+                                processSuperConstructorArgs(nextSuperTd, binding, sci.arguments(), superParamValues, context, fieldValues, visitedCtors, rhsResolver);
+                                return super.visit(sci);
+                            }
+                        }
+                    }
+                    String superFqn = context.getSuperclassFqn(superTd);
+                    if (superFqn != null) {
+                        TypeDeclaration nextSuperTd = context.getTypeDeclaration(superFqn);
+                        if (nextSuperTd != null) {
+                            processSuperConstructorArgs(nextSuperTd, null, sci.arguments(), superParamValues, context, fieldValues, visitedCtors, rhsResolver);
+                        }
+                    }
+                    return super.visit(sci);
+                }
+
+                @Override
+                public boolean visit(ConstructorInvocation ci) {
+                    IMethodBinding binding = ci.resolveConstructorBinding();
+                    processSuperConstructorArgs(superTd, binding, ci.arguments(), superParamValues, context, fieldValues, visitedCtors, rhsResolver);
+                    return super.visit(ci);
+                }
+            });
+            break; 
+        }
+    }
+
+    public String evaluateMethodCallInConstructor(
+            Expression rhs,
+            Map<String, String> paramValues,
+            TypeDeclaration td) {
+
+        if (!(rhs instanceof MethodInvocation mi)) {
+            return null;
+        }
+
+        String methodName = mi.getName().getIdentifier();
+        Expression receiver = mi.getExpression();
+        if (receiver != null && !(receiver instanceof ThisExpression)) {
+            return null;
+        }
+
+        MethodDeclaration method = context.findMethodDeclaration(td, methodName, true);
+        if (method == null) {
+            CompilationUnit cu = td.getRoot() instanceof CompilationUnit ? (CompilationUnit) td.getRoot() : null;
+            TypeDeclaration targetTd = context.resolveStaticImport(methodName, cu);
+            if (targetTd != null) {
+                method = context.findMethodDeclaration(targetTd, methodName, true);
+            }
+        }
+        if (method == null || method.getBody() == null) {
+            return null;
+        }
+
+        Map<String, String> localVars = new HashMap<>(paramValues);
+        return constantResolver.evaluateMethodBodyWithLocals(method, localVars, context, new HashSet<>());
+    }
+
+    public ClassInstanceCreation findReturnedCIC(
+            String className, String methodName, CodebaseContext context) {
+        return findReturnedCIC(className, methodName, context, new HashSet<>(), 0);
+    }
+
+    private ClassInstanceCreation findReturnedCIC(
+            String className, String methodName, CodebaseContext context,
+            Set<String> visited, int depth) {
+        if (depth > 50 || !visited.add(className + "#" + methodName)) {
+            return null;
+        }
+
+        TypeDeclaration td = context.getTypeDeclaration(className);
+        if (td != null) {
+            MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+            if (md != null && md.getBody() != null) {
+                ClassInstanceCreation[] result = {null};
+                md.getBody().accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(ReturnStatement rs) {
+                        if (rs.getExpression() instanceof ClassInstanceCreation cic) {
+                            result[0] = cic;
+                        }
+                        return false;
+                    }
+                });
+                if (result[0] != null) return result[0];
+            }
+        }
+        List<String> impls = context.getImplementations(className);
+        for (String impl : impls) {
+            ClassInstanceCreation cic = findReturnedCIC(impl, methodName, context, visited, depth + 1);
+            if (cic != null) return cic;
+        }
+        return null;
+    }
+
+    public List<String> resolveInlineInstantiationGetterResult(
+            ClassInstanceCreation cic,
+            String getterName,
+            CodebaseContext context,
+            Set<String> visited) {
+
+        String typeName = click.kamil.springstatemachineexporter.ast.common.AstUtils.extractSimpleTypeName(cic.getType());
+        CompilationUnit contextCu = cic.getRoot() instanceof CompilationUnit ? (CompilationUnit) cic.getRoot() : null;
+        AbstractTypeDeclaration atd = contextCu != null ? context.getAbstractTypeDeclaration(typeName, contextCu) : context.getAbstractTypeDeclaration(typeName);
+        if (atd == null) atd = context.getAbstractTypeDeclaration(typeName);
+        if (atd == null) return Collections.emptyList();
+
+        if (atd instanceof RecordDeclaration rd) {
+            int compIdx = -1;
+            List<?> components = rd.recordComponents();
+            for (int i = 0; i < components.size(); i++) {
+                Object compObj = components.get(i);
+                if (compObj != null) {
+                    try {
+                        java.lang.reflect.Method getNameMethod = compObj.getClass().getMethod("getName");
+                        SimpleName nameObj = (SimpleName) getNameMethod.invoke(compObj);
+                        if (nameObj != null && nameObj.getIdentifier().equals(getterName)) {
+                            compIdx = i;
+                            break;
+                        }
+                    } catch (Exception e) {
+                        // ignore reflection errors
+                    }
+                }
+            }
+            if (compIdx >= 0 && compIdx < cic.arguments().size()) {
+                Expression argExpr = (Expression) cic.arguments().get(compIdx);
+                List<String> consts = new ArrayList<>();
+                if (constantExtractor != null) {
+                    constantExtractor.extractConstantsFromArgument(argExpr, consts);
+                }
+                if (!consts.isEmpty()) {
+                    return consts;
+                } else {
+                    String resolved = constantResolver.resolve(argExpr, context);
+                    if (resolved != null) {
+                        return List.of(resolved);
+                    }
+                }
+            }
+            return Collections.emptyList();
+        }
+
+        if (!(atd instanceof TypeDeclaration td)) return Collections.emptyList();
+
+        MethodDeclaration getter = context.findMethodDeclaration(td, getterName, true);
+        if (getter == null || getter.getBody() == null) return Collections.emptyList();
+
+        String getterKey = typeName + "#" + getterName;
+        if (!visited.add(getterKey)) {
+            return Collections.emptyList(); 
+        }
+
+        try {
+            Map<String, String> fieldValues = buildFieldValuesFromCIC(td, cic, context, this::evaluateMethodCallInConstructor);
+            log.debug("RESOLVE_GETTER: td={}, fieldValues={}", context.getFqn(td), fieldValues);
+            if (fieldValues.isEmpty()) return Collections.emptyList();
+
+            String result = constantResolver.evaluateMethodBodyWithLocals(getter, fieldValues, context, visited);
+            log.debug("RESOLVE_GETTER: result={}", result);
+            return result != null ? List.of(result) : Collections.emptyList();
+        } finally {
+            visited.remove(getterKey);
+        }
+    }
+
+    public int findConstructorArgumentIndexForLombokField(TypeDeclaration td, String fieldName) {
+        boolean isAllArgsConstructor = false;
+        boolean isRequiredArgsConstructor = false;
+        boolean isData = false;
+        boolean isValue = false;
+        
+        for (Object modObj : td.modifiers()) {
+            if (modObj instanceof MarkerAnnotation ma) {
+                String name = ma.getTypeName().getFullyQualifiedName();
+                if (name.equals("AllArgsConstructor") || name.equals("lombok.AllArgsConstructor")) isAllArgsConstructor = true;
+                if (name.equals("RequiredArgsConstructor") || name.equals("lombok.RequiredArgsConstructor")) isRequiredArgsConstructor = true;
+                if (name.equals("Data") || name.equals("lombok.Data")) isData = true;
+                if (name.equals("Value") || name.equals("lombok.Value")) isValue = true;
+            } else if (modObj instanceof NormalAnnotation na) {
+                String name = na.getTypeName().getFullyQualifiedName();
+                if (name.equals("AllArgsConstructor") || name.equals("lombok.AllArgsConstructor")) isAllArgsConstructor = true;
+                if (name.equals("RequiredArgsConstructor") || name.equals("lombok.RequiredArgsConstructor")) isRequiredArgsConstructor = true;
+                if (name.equals("Data") || name.equals("lombok.Data")) isData = true;
+                if (name.equals("Value") || name.equals("lombok.Value")) isValue = true;
+            }
+        }
+        
+        if (!isAllArgsConstructor && !isRequiredArgsConstructor && !isData && !isValue) {
+            return -1;
+        }
+        
+        int index = 0;
+        for (FieldDeclaration fd : td.getFields()) {
+            boolean isStatic = false;
+            boolean isFinal = false;
+            boolean hasNonNull = false;
+            for (Object modObj : fd.modifiers()) {
+                if (modObj instanceof Modifier mod) {
+                    if (mod.isStatic()) isStatic = true;
+                    if (mod.isFinal()) isFinal = true;
+                } else if (modObj instanceof MarkerAnnotation ma) {
+                    if (ma.getTypeName().getFullyQualifiedName().endsWith("NonNull")) hasNonNull = true;
+                }
+            }
+            if (isStatic) continue;
+            
+            if (isRequiredArgsConstructor && !isAllArgsConstructor && !isFinal && !hasNonNull) continue;
+            if (isData && !isAllArgsConstructor && !isFinal && !hasNonNull) continue;
+            
+            for (Object fragObj : fd.fragments()) {
+                VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                if (frag.getName().getIdentifier().equals(fieldName)) {
+                    return index;
+                }
+                index++;
+            }
+        }
+        return -1;
+    }
+
+    private void processConstructorInvocationArgs(List<?> arguments, TypeDeclaration targetTd, ASTNode callNode, List<String> results, String fieldName, CodebaseContext context, Set<String> visited) {
+        if (targetTd == null) return;
+        MethodDeclaration callerMd = findEnclosingMethod(callNode);
+        
+        IMethodBinding resolvedBinding = null;
+        if (callNode instanceof ConstructorInvocation ci) {
+            resolvedBinding = ci.resolveConstructorBinding();
+        } else if (callNode instanceof SuperConstructorInvocation sci) {
+            resolvedBinding = sci.resolveConstructorBinding();
+        }
+        
+        for (MethodDeclaration otherMd : targetTd.getMethods()) {
+            boolean matches = false;
+            if (resolvedBinding != null && otherMd.resolveBinding() != null) {
+                matches = resolvedBinding.isEqualTo(otherMd.resolveBinding()) || resolvedBinding.getKey().equals(otherMd.resolveBinding().getKey());
+            } else {
+                matches = otherMd.isConstructor() && otherMd.parameters().size() == arguments.size() && otherMd != callerMd;
+            }
+            
+            if (matches) {
+                int targetIdx = findAssignedParameterIndex(otherMd, fieldName, context, new HashSet<>());
+                if (targetIdx >= 0 && targetIdx < arguments.size()) {
+                    Expression arg = (Expression) arguments.get(targetIdx);
+                    String val = constantResolver.resolve(arg, context);
+                    if (val == null && arg instanceof MethodInvocation mi) {
+                        TypeDeclaration enclosingTd = findEnclosingType(arg);
+                        if (enclosingTd != null) {
+                            val = evaluateMethodCallInConstructor(arg, new HashMap<>(), enclosingTd);
+                        }
+                    }
+                    if (val != null) {
+                        if (val.startsWith("ENUM_SET:")) {
+                            for (String eVal : val.substring(9).split(",")) {
+                                if (constantExtractor != null) {
+                                    results.add(constantExtractor.parseEnumSetElement(eVal));
+                                }
+                            }
+                        } else {
+                            results.add(val);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private int findAssignedParameterIndex(MethodDeclaration constructorMd, String fieldName, CodebaseContext context, Set<MethodDeclaration> visited) {
+        if (constructorMd == null || constructorMd.getBody() == null) return -1;
+        if (!visited.add(constructorMd)) return -1;
+        
+        final int[] foundIdx = {-1};
+        constructorMd.getBody().accept(new ASTVisitor() {
+            @Override
+            public boolean visit(Assignment asn) {
+                Expression left = asn.getLeftHandSide();
+                if ((left instanceof SimpleName sn && sn.getIdentifier().equals(fieldName)) ||
+                    (left instanceof FieldAccess fa && fa.getName().getIdentifier().equals(fieldName)) ||
+                    (left instanceof SuperFieldAccess sfa && sfa.getName().getIdentifier().equals(fieldName))) {
+                    Expression right = asn.getRightHandSide();
+                    String rightName = extractVariableName(right);
+                    if (rightName != null) {
+                        for (int i = 0; i < constructorMd.parameters().size(); i++) {
+                            SingleVariableDeclaration svd = (SingleVariableDeclaration) constructorMd.parameters().get(i);
+                            if (svd.getName().getIdentifier().equals(rightName)) {
+                                foundIdx[0] = i;
+                            }
+                        }
+                    }
+                }
+                return super.visit(asn);
+            }
+            @Override
+            public boolean visit(ConstructorInvocation node) {
+                IMethodBinding resolvedBinding = node.resolveConstructorBinding();
+                TypeDeclaration enclosingTd = findEnclosingType(node);
+                if (enclosingTd != null) {
+                    for (MethodDeclaration otherMd : enclosingTd.getMethods()) {
+                        boolean matches = false;
+                        if (resolvedBinding != null && otherMd.resolveBinding() != null) {
+                            matches = resolvedBinding.isEqualTo(otherMd.resolveBinding()) || resolvedBinding.getKey().equals(otherMd.resolveBinding().getKey());
+                        } else {
+                            matches = otherMd.isConstructor() && otherMd != constructorMd && otherMd.parameters().size() == node.arguments().size();
+                        }
+                        if (matches) {
+                            int targetIdx = findAssignedParameterIndex(otherMd, fieldName, context, visited);
+                            if (targetIdx >= 0 && targetIdx < node.arguments().size()) {
+                                Expression arg = (Expression) node.arguments().get(targetIdx);
+                                String argName = extractVariableName(arg);
+                                if (argName != null) {
+                                    for (int i = 0; i < constructorMd.parameters().size(); i++) {
+                                        SingleVariableDeclaration svd = (SingleVariableDeclaration) constructorMd.parameters().get(i);
+                                        if (svd.getName().getIdentifier().equals(argName)) {
+                                            foundIdx[0] = i;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return super.visit(node);
+            }
+            @Override
+            public boolean visit(SuperConstructorInvocation node) {
+                IMethodBinding resolvedBinding = node.resolveConstructorBinding();
+                TypeDeclaration enclosingTd = findEnclosingType(node);
+                if (enclosingTd != null) {
+                    String superFqn = context.getSuperclassFqn(enclosingTd);
+                    if (superFqn != null) {
+                        TypeDeclaration superTd = context.getTypeDeclaration(superFqn);
+                        if (superTd != null) {
+                            for (MethodDeclaration otherMd : superTd.getMethods()) {
+                                boolean matches = false;
+                                if (resolvedBinding != null && otherMd.resolveBinding() != null) {
+                                    matches = resolvedBinding.isEqualTo(otherMd.resolveBinding()) || resolvedBinding.getKey().equals(otherMd.resolveBinding().getKey());
+                                } else {
+                                    matches = otherMd.isConstructor() && otherMd.parameters().size() == node.arguments().size();
+                                }
+                                if (matches) {
+                                    int targetIdx = findAssignedParameterIndex(otherMd, fieldName, context, visited);
+                                    if (targetIdx >= 0 && targetIdx < node.arguments().size()) {
+                                        Expression arg = (Expression) node.arguments().get(targetIdx);
+                                        String argName = extractVariableName(arg);
+                                        if (argName != null) {
+                                            for (int i = 0; i < constructorMd.parameters().size(); i++) {
+                                                SingleVariableDeclaration svd = (SingleVariableDeclaration) constructorMd.parameters().get(i);
+                                                if (svd.getName().getIdentifier().equals(argName)) {
+                                                    foundIdx[0] = i;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return super.visit(node);
+            }
+        });
+        return foundIdx[0];
+    }
+
+    private String extractVariableName(Expression expr) {
+        if (expr instanceof SimpleName sn) return sn.getIdentifier();
+        if (expr instanceof FieldAccess fa) return fa.getName().getIdentifier();
+        if (expr instanceof SuperFieldAccess sfa) return sfa.getName().getIdentifier();
+        if (expr instanceof CastExpression ce) return extractVariableName(ce.getExpression());
+        if (expr instanceof ParenthesizedExpression pe) return extractVariableName(pe.getExpression());
+        if (expr instanceof MethodInvocation mi && (mi.getName().getIdentifier().equals("requireNonNull") || mi.getName().getIdentifier().equals("notNull"))) {
+            if (!mi.arguments().isEmpty()) return extractVariableName((Expression)mi.arguments().get(0));
+        }
+        return null;
+    }
+
+    private MethodDeclaration findEnclosingMethod(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof MethodDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (MethodDeclaration) parent;
+    }
+
+    private TypeDeclaration findEnclosingType(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof TypeDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (TypeDeclaration) parent;
+    }
+}

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

@@ -0,0 +1,173 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+@Slf4j
+public class DynamicClasspathResolver {
+
+    public List<String> resolveClasspath(Path projectRoot) {
+        log.info("Attempting dynamic classpath resolution for project at {}", projectRoot);
+        if (projectRoot == null || !Files.exists(projectRoot)) {
+            return Collections.emptyList();
+        }
+
+        if (Files.exists(projectRoot.resolve("pom.xml"))) {
+            return resolveMaven(projectRoot);
+        } else if (Files.exists(projectRoot.resolve("build.gradle")) || Files.exists(projectRoot.resolve("build.gradle.kts"))) {
+            return resolveGradle(projectRoot);
+        }
+
+        log.info("No Maven or Gradle configuration found at {}. Proceeding without dynamic classpath.", projectRoot);
+        return Collections.emptyList();
+    }
+
+    protected List<String> resolveMaven(Path projectRoot) {
+        log.info("Maven project detected. Resolving dependencies...");
+        try {
+            String mvnCmd = getCommand(projectRoot, "mvnw", "mvn");
+            if (mvnCmd == null) {
+                log.warn("Maven executable not found.");
+                return Collections.emptyList();
+            }
+
+            ProcessBuilder pb = new ProcessBuilder(
+                    mvnCmd,
+                    "-q",
+                    "dependency:build-classpath",
+                    "-DincludeScope=compile",
+                    "-Dmdep.outputFile=sme_cp.txt"
+            );
+            pb.directory(projectRoot.toFile());
+            
+            runProcess(pb);
+
+            java.util.Set<String> allPaths = new java.util.LinkedHashSet<>();
+            try (java.util.stream.Stream<Path> stream = Files.walk(projectRoot)) {
+                stream.filter(p -> p.getFileName().toString().equals("sme_cp.txt"))
+                      .forEach(cpFile -> {
+                          try {
+                              String cpString = Files.readString(cpFile).trim();
+                              if (!cpString.isEmpty()) {
+                                  allPaths.addAll(Arrays.asList(cpString.split(File.pathSeparator)));
+                              }
+                              Files.deleteIfExists(cpFile);
+                          } catch (IOException e) {
+                              log.warn("Failed to read or delete sme_cp.txt at {}", cpFile, e);
+                          }
+                      });
+            }
+            if (!allPaths.isEmpty()) {
+                return new ArrayList<>(allPaths);
+            }
+        } catch (Exception e) {
+            log.error("Failed to dynamically resolve Maven classpath", e);
+        }
+        return Collections.emptyList();
+    }
+
+    protected List<String> resolveGradle(Path projectRoot) {
+        log.info("Gradle project detected. Resolving dependencies...");
+        Path initScript = null;
+        try {
+            initScript = Files.createTempFile("state_machine_exporter_init", ".gradle");
+            String gradleCmd = getCommand(projectRoot, "gradlew", "gradle");
+            if (gradleCmd == null) {
+                log.warn("Gradle executable not found.");
+                return Collections.emptyList();
+            }
+
+            String scriptContent = """
+                    allprojects {
+                        task smePrintClasspath {
+                            doLast {
+                                def cp = []
+                                if (configurations.findByName("compileClasspath")) {
+                                    cp = configurations.compileClasspath.files
+                                }
+                                println "SME_CLASSPATH_MARKER:" + cp.join(File.pathSeparator)
+                            }
+                        }
+                    }
+                    """;
+            Files.writeString(initScript, scriptContent);
+
+            ProcessBuilder pb = new ProcessBuilder(
+                    gradleCmd,
+                    "-q",
+                    "-I", initScript.toAbsolutePath().toString(),
+                    "smePrintClasspath"
+            );
+            pb.directory(projectRoot.toFile());
+
+            String output = runProcessAndGetOutput(pb);
+            java.util.Set<String> allPaths = new java.util.LinkedHashSet<>();
+            for (String line : output.split("\\r?\\n")) {
+                if (line.startsWith("SME_CLASSPATH_MARKER:")) {
+                    String cpString = line.substring("SME_CLASSPATH_MARKER:".length()).trim();
+                    if (!cpString.isEmpty()) {
+                        allPaths.addAll(Arrays.asList(cpString.split(File.pathSeparator)));
+                    }
+                }
+            }
+            if (!allPaths.isEmpty()) {
+                return new ArrayList<>(allPaths);
+            }
+        } catch (Exception e) {
+            log.error("Failed to dynamically resolve Gradle classpath", e);
+        } finally {
+            if (initScript != null) {
+                try {
+                    Files.deleteIfExists(initScript);
+                } catch (IOException ignored) {}
+            }
+        }
+        return Collections.emptyList();
+    }
+
+    private String getCommand(Path projectRoot, String wrapper, String systemBinary) {
+        Path wrapperUnix = projectRoot.resolve(wrapper);
+        Path wrapperWin = projectRoot.resolve(wrapper + ".bat");
+        
+        boolean isWin = System.getProperty("os.name").toLowerCase().contains("win");
+        
+        if (isWin && Files.exists(wrapperWin)) return wrapperWin.toAbsolutePath().toString();
+        if (!isWin && Files.exists(wrapperUnix)) {
+            // Need absolute path like ./gradlew
+            return wrapperUnix.toAbsolutePath().toString();
+        }
+        
+        return systemBinary;
+    }
+
+    protected void runProcess(ProcessBuilder pb) throws IOException, InterruptedException {
+        pb.redirectErrorStream(true);
+        pb.redirectOutput(ProcessBuilder.Redirect.DISCARD);
+        Process p = pb.start();
+        p.waitFor();
+    }
+
+    protected String runProcessAndGetOutput(ProcessBuilder pb) throws IOException, InterruptedException {
+        pb.redirectErrorStream(true);
+        Process p = pb.start();
+        StringBuilder out = new StringBuilder();
+        try (BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()))) {
+            String line;
+            while ((line = br.readLine()) != null) {
+                out.append(line).append("\n");
+            }
+        }
+        p.waitFor();
+        return out.toString();
+    }
+}

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

@@ -0,0 +1,19 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.enricher.AnalysisEnricher;
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.RequiredArgsConstructor;
+
+import java.util.List;
+
+@RequiredArgsConstructor
+public class EnrichmentService {
+    private final List<AnalysisEnricher> enrichers;
+
+    public void enrich(AnalysisResult result, CodebaseContext context, CodebaseIntelligenceProvider intelligence) {
+        for (AnalysisEnricher enricher : enrichers) {
+            enricher.enrich(result, context, intelligence);
+        }
+    }
+}

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

@@ -0,0 +1,808 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.LibraryHint;
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.jdt.core.dom.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@Slf4j
+@RequiredArgsConstructor
+public class GenericEventDetector {
+    private final CodebaseContext context;
+    private final ConstantResolver constantResolver;
+    private final List<LibraryHint> hints;
+
+    public List<TriggerPoint> detect(CompilationUnit cu) {
+        List<TriggerPoint> triggers = new ArrayList<>();
+        String fileName = "unknown";
+        try {
+            if (cu.getJavaElement() != null) fileName = cu.getJavaElement().getElementName();
+        } catch (Exception e) {}
+        
+        log.debug("Scanning for triggers in {}", fileName);
+        
+        cu.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(MethodInvocation node) {
+                String methodName = node.getName().getIdentifier();
+                
+                if ("sendEvent".equals(methodName) || "sendEvents".equals(methodName) || 
+                    "sendEventCollect".equals(methodName) || "sendEventMono".equals(methodName)) {
+                    processSendEvent(node, cu, triggers);
+                } else {
+                    for (Object argObj : node.arguments()) {
+                        if (argObj instanceof ExpressionMethodReference emr) {
+                            String refMethod = emr.getName().getIdentifier();
+                            if ("sendEvent".equals(refMethod) || "sendEvents".equals(refMethod) || 
+                                "sendEventCollect".equals(refMethod) || "sendEventMono".equals(refMethod)) {
+                                processSendEventMethodReference(node, emr, cu, triggers);
+                            }
+                        }
+                    }
+                }
+                
+                processHints(node, cu, triggers);
+
+                return super.visit(node);
+            }
+        });
+        return triggers;
+    }
+
+    private void processSendEventMethodReference(MethodInvocation node, ExpressionMethodReference emr, CompilationUnit cu, List<TriggerPoint> triggers) {
+        Expression receiver = node.getExpression();
+        String eventValue = extractEventFromReceiver(receiver);
+        if (eventValue == null) {
+            eventValue = receiver != null ? receiver.toString() : null;
+        }
+
+        MethodDeclaration method = findEnclosingMethod(node);
+        TypeDeclaration type = findEnclosingType(node);
+        if (type == null) return;
+
+        String sourceState = extractSourceState(node);
+        String[] smTypes = resolveStateMachineTypeArgumentsForExpression(emr.getExpression(), node);
+
+        boolean external = false;
+        if (receiver != null) {
+            AssignmentDag dag = new AssignmentDag(method);
+            external = dag.isExternal(receiver, new java.util.HashSet<>());
+        }
+
+        if (eventValue != null) {
+            String constraint = click.kamil.springstatemachineexporter.ast.common.AstUtils.findConditionConstraint(node);
+            triggers.add(TriggerPoint.builder()
+                    .event(eventValue)
+                    .sourceState(sourceState)
+                    .className(context.getFqn(type))
+                    .methodName(method != null ? method.getName().getIdentifier() : "initializer")
+                    .sourceFile(context.getRelativePath(context.getFqn(type)))
+                    .lineNumber(cu.getLineNumber(node.getStartPosition()))
+                    .stateTypeFqn(smTypes[0])
+                    .eventTypeFqn(smTypes[1])
+                    .external(external)
+                    .constraint(constraint)
+                    .build());
+        }
+    }
+
+    private String extractEventFromReceiver(Expression receiver) {
+        if (receiver == null) return null;
+        if (receiver instanceof MethodInvocation mi) {
+            String mName = mi.getName().getIdentifier();
+            if (("just".equals(mName) || "withPayload".equals(mName) || "success".equals(mName)) && !mi.arguments().isEmpty()) {
+                Expression arg = (Expression) mi.arguments().get(0);
+                String resolved = constantResolver.resolve(arg, context);
+                return resolved != null ? resolved : arg.toString();
+            }
+            if (mi.getExpression() != null) {
+                return extractEventFromReceiver(mi.getExpression());
+            }
+        }
+        if (receiver instanceof SimpleName sn) {
+            return sn.getIdentifier();
+        }
+        return null;
+    }
+
+    private String[] resolveStateMachineTypeArgumentsForExpression(Expression receiver, MethodInvocation node) {
+        if (receiver == null) return new String[]{null, null};
+
+        ITypeBinding binding = receiver.resolveTypeBinding();
+        if (binding != null) {
+            ITypeBinding smBinding = findStateMachineSupertype(binding, new java.util.HashSet<>());
+            if (smBinding != null) {
+                ITypeBinding[] typeArgs = smBinding.getTypeArguments();
+                if (typeArgs.length >= 2) {
+                    return new String[]{typeArgs[0].getQualifiedName(), typeArgs[1].getQualifiedName()};
+                }
+            }
+        }
+
+        Type declType = findReceiverTypeManually(receiver, node);
+        if (declType instanceof ParameterizedType pt) {
+            List<?> typeArgs = pt.typeArguments();
+            if (typeArgs.size() >= 2) {
+                CompilationUnit compilationUnit = (CompilationUnit) node.getRoot();
+                String stateType = resolveTypeToFqn((Type) typeArgs.get(0), compilationUnit);
+                String eventType = resolveTypeToFqn((Type) typeArgs.get(1), compilationUnit);
+                return new String[]{stateType, eventType};
+            }
+        }
+
+        return new String[]{null, null};
+    }
+
+    private void processSendEvent(MethodInvocation node, CompilationUnit cu, List<TriggerPoint> triggers) {
+        List<TriggerPoint> builtTriggers = buildTriggerPoints(node, cu, null);
+        if (builtTriggers != null) {
+            for (TriggerPoint trigger : builtTriggers) {
+                log.debug("Successfully built trigger point: {}", trigger.getEvent());
+                triggers.add(trigger);
+            }
+        }
+    }
+
+    private void processHints(MethodInvocation node, CompilationUnit cu, List<TriggerPoint> triggers) {
+        if (hints == null || hints.isEmpty()) return;
+
+        String calledMethod = resolveCalledMethodName(node);
+        if (calledMethod == null) return;
+
+        for (LibraryHint hint : hints) {
+            if (calledMethod.equals(hint.getMethodFqn()) || isHintMatch(calledMethod, hint.getMethodFqn())) {
+                String eventToUse = hint.getEvent();
+                if (eventToUse == null && hint.getEventArgumentIndex() != null) {
+                    if (node.arguments().size() > hint.getEventArgumentIndex()) {
+                        Expression argExpr = (Expression) node.arguments().get(hint.getEventArgumentIndex());
+                        eventToUse = argExpr.toString();
+                        if (hint.getEventArgumentMethod() != null && !hint.getEventArgumentMethod().isEmpty()) {
+                            eventToUse = eventToUse + "." + hint.getEventArgumentMethod() + "()";
+                        }
+                    }
+                }
+                
+                List<TriggerPoint> builtTriggers = buildTriggerPoints(node, cu, eventToUse);
+                if (builtTriggers != null) {
+                    for (TriggerPoint trigger : builtTriggers) {
+                        log.debug("Successfully built synthetic trigger point from hint: {}", trigger.getEvent());
+                        triggers.add(trigger);
+                    }
+                }
+            }
+        }
+    }
+
+    private boolean isHintMatch(String called, String hintFqn) {
+        return hintFqn.endsWith("." + called);
+    }
+
+    private String resolveCalledMethodName(MethodInvocation node) {
+        Expression receiver = node.getExpression();
+        String methodName = node.getName().getIdentifier();
+        if (receiver == null) return methodName;
+
+        if (receiver instanceof SimpleName sn) {
+            String name = sn.getIdentifier();
+            // Check if it's a field in the enclosing class
+            TypeDeclaration td = findEnclosingType(node);
+            if (td != null) {
+                for (FieldDeclaration fd : td.getFields()) {
+                    for (Object fragObj : fd.fragments()) {
+                        if (fragObj instanceof VariableDeclarationFragment fragment) {
+                            if (fragment.getName().getIdentifier().equals(name)) {
+                                String typeName = fd.getType().toString();
+                                return typeName + "." + methodName;
+                            }
+                        }
+                    }
+                }
+            }
+            return name + "." + methodName;
+        }
+        
+        return receiver.toString() + "." + methodName;
+    }
+
+    private List<TriggerPoint> buildTriggerPoints(MethodInvocation node, CompilationUnit cu, String forcedEvent) {
+        String eventValue = null;
+        if (forcedEvent != null) {
+            eventValue = context.resolveString(forcedEvent);
+        } else {
+            if (node.arguments().isEmpty()) return Collections.emptyList();
+            Expression eventExpr = (Expression) node.arguments().get(0);
+            
+            // Try MessageBuilder extraction first
+            eventValue = extractEventFromMessageBuilder(eventExpr);
+            
+            if (eventValue != null) {
+                 eventValue = context.resolveString(eventValue);
+            } else {
+                 eventValue = context.resolveExpression(eventExpr);
+            }
+        }
+
+        MethodDeclaration method = findEnclosingMethod(node);
+        TypeDeclaration type = findEnclosingType(node);
+
+        if (type == null) return Collections.emptyList();
+
+        String sourceState = extractSourceState(node);
+        String[] smTypes = resolveStateMachineTypeArguments(node);
+
+        boolean external = false;
+        if (!node.arguments().isEmpty()) {
+            Expression eventExpr = (Expression) node.arguments().get(0);
+            AssignmentDag dag = new AssignmentDag(method);
+            external = dag.isExternal(eventExpr, new java.util.HashSet<>());
+        }
+        
+        String constraint = click.kamil.springstatemachineexporter.ast.common.AstUtils.findConditionConstraint(node);
+        
+        List<TriggerPoint> results = new ArrayList<>();
+        if (eventValue != null && eventValue.startsWith("ENUM_SET:")) {
+            String[] parts = eventValue.substring(9).split(",");
+            for (String part : parts) {
+                if (!part.trim().isEmpty()) {
+                    results.add(TriggerPoint.builder()
+                            .event(part.trim())
+                            .sourceState(sourceState)
+                            .className(context.getFqn(type))
+                            .methodName(method != null ? method.getName().getIdentifier() : "initializer")
+                            .sourceFile(context.getRelativePath(context.getFqn(type)))
+                            .lineNumber(cu.getLineNumber(node.getStartPosition()))
+                            .stateTypeFqn(smTypes[0])
+                            .eventTypeFqn(smTypes[1])
+                            .external(external)
+                            .constraint(constraint)
+                            .build());
+                }
+            }
+        } else {
+            results.add(TriggerPoint.builder()
+                    .event(eventValue)
+                    .sourceState(sourceState)
+                    .className(context.getFqn(type))
+                    .methodName(method != null ? method.getName().getIdentifier() : "initializer")
+                    .sourceFile(context.getRelativePath(context.getFqn(type)))
+                    .lineNumber(cu.getLineNumber(node.getStartPosition()))
+                    .stateTypeFqn(smTypes[0])
+                    .eventTypeFqn(smTypes[1])
+                    .external(external)
+                    .constraint(constraint)
+                    .build());
+        }
+
+        return results;
+    }
+
+    private String extractSourceState(ASTNode node) {
+        ASTNode current = node;
+        while (current != null && !(current instanceof MethodDeclaration)) {
+            ASTNode parent = current.getParent();
+            
+            // 1. Direct parent is IfStatement wrapper (e.g., if (state == X) { sm.sendEvent() })
+            if (parent instanceof IfStatement ifStmt) {
+                // Only consider if our current node is in the 'then' or 'else' part, not the condition
+                if (ifStmt.getExpression() != current) {
+                    Expression expr = ifStmt.getExpression();
+                    String state = extractStateFromExpression(expr);
+                    if (state != null) return state;
+                }
+            }
+
+            // 2. Parent is a Block or SwitchStatement: perform sibling traversal
+            if (parent instanceof Block block) {
+                String state = extractStateFromSiblings(current, block.statements());
+                if (state != null) return state;
+            } else if (parent instanceof SwitchStatement switchStmt) {
+                String state = extractStateFromSiblings(current, switchStmt.statements());
+                if (state != null) return state;
+            }
+
+            current = parent;
+        }
+        return null;
+    }
+
+    private String extractStateFromSiblings(ASTNode currentNode, List<?> statements) {
+        int index = statements.indexOf(currentNode);
+        if (index <= 0) return null; // No previous siblings
+
+        // Walk backwards through siblings
+        for (int i = index - 1; i >= 0; i--) {
+            Object stmtObj = statements.get(i);
+            
+            if (stmtObj instanceof SwitchCase switchCase) {
+                if (!switchCase.expressions().isEmpty()) {
+                    return getSimpleNameString((Expression) switchCase.expressions().get(0));
+                }
+            } else if (stmtObj instanceof IfStatement ifStmt) {
+                // Guard clause detection: check if the 'then' block has a return/throw
+                if (isGuardClause(ifStmt.getThenStatement())) {
+                    Expression expr = ifStmt.getExpression();
+                    // If it's a guard clause, it usually checks `state != EXPECTED`, so the true state *is* EXPECTED
+                    String state = extractStateFromExpression(expr);
+                    if (state != null) return state;
+                }
+            }
+        }
+        return null;
+    }
+
+    private boolean isGuardClause(Statement thenStatement) {
+        if (thenStatement instanceof ReturnStatement || thenStatement instanceof ThrowStatement) {
+            return true;
+        }
+        if (thenStatement instanceof Block block) {
+            for (Object obj : block.statements()) {
+                if (obj instanceof ReturnStatement || obj instanceof ThrowStatement) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private String extractStateFromExpression(Expression expr) {
+        if (expr instanceof InfixExpression infix) {
+            if (infix.getOperator() == InfixExpression.Operator.EQUALS || infix.getOperator() == InfixExpression.Operator.NOT_EQUALS) {
+                Expression left = infix.getLeftOperand();
+                Expression right = infix.getRightOperand();
+                
+                // Ignore null checks entirely
+                if (left instanceof NullLiteral || right instanceof NullLiteral) {
+                    return null;
+                }
+                
+                // Usually one is a method call like getState() or a variable like `state`
+                // and the other is the constant enum like `OrderState.PENDING` or `"PENDING"`
+                
+                // If one is a QualifiedName (enum constant) or StringLiteral, it's likely the state
+                if (left instanceof QualifiedName || left instanceof StringLiteral || left instanceof FieldAccess) {
+                    return getSimpleNameString(left);
+                }
+                if (right instanceof QualifiedName || right instanceof StringLiteral || right instanceof FieldAccess) {
+                    return getSimpleNameString(right);
+                }
+                
+                // Fallback
+                return getSimpleNameString(right);
+            }
+        } else if (expr instanceof MethodInvocation mi) {
+            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;
+    }
+
+    private String getSimpleNameString(Expression expr) {
+        if (expr instanceof QualifiedName qn) {
+            return qn.getName().getIdentifier();
+        } else if (expr instanceof FieldAccess fa) {
+            return fa.getName().getIdentifier();
+        } else if (expr instanceof StringLiteral sl) {
+            return sl.getLiteralValue();
+        }
+        return expr.toString();
+    }
+
+    private String extractEventFromMessageBuilder(Expression expr) {
+        if (expr instanceof CastExpression ce) {
+            return extractEventFromMessageBuilder(ce.getExpression());
+        }
+
+        if (expr instanceof SimpleName sn) {
+            String varName = sn.getIdentifier();
+            MethodDeclaration enclosingMethod = findEnclosingMethod(expr);
+            if (enclosingMethod != null) {
+                // Find variable declaration
+                final Expression[] initializer = new Expression[1];
+                enclosingMethod.accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(VariableDeclarationFragment node) {
+                        if (node.getName().getIdentifier().equals(varName) && node.getInitializer() != null) {
+                            initializer[0] = node.getInitializer();
+                        }
+                        return super.visit(node);
+                    }
+                    @Override
+                    public boolean visit(Assignment node) {
+                        if (node.getLeftHandSide() instanceof SimpleName asn && asn.getIdentifier().equals(varName)) {
+                            initializer[0] = node.getRightHandSide();
+                        }
+                        return super.visit(node);
+                    }
+                });
+                if (initializer[0] != null) {
+                    return extractEventFromMessageBuilder(initializer[0]); // recursive
+                }
+                
+                // If it has NO initializer, it might be a method parameter!
+                for (Object paramObj : enclosingMethod.parameters()) {
+                    if (paramObj instanceof SingleVariableDeclaration svd) {
+                        if (svd.getName().getIdentifier().equals(varName)) {
+                            return varName;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (expr instanceof ClassInstanceCreation cic) {
+            return cic.getType().toString();
+        }
+
+        if (!(expr instanceof MethodInvocation mi)) return null;
+
+        // Trace back chain: MessageBuilder.withPayload(event).setHeader(...).build()
+        MethodInvocation current = mi;
+        while (current != null) {
+            String name = current.getName().getIdentifier();
+            if (("withPayload".equals(name) || "just".equals(name)) && !current.arguments().isEmpty()) {
+                Expression payloadExpr = (Expression) current.arguments().get(0);
+                
+                // If it's Mono.just(msg), where msg is a variable
+                if ("just".equals(name)) {
+                    String extracted = extractEventFromMessageBuilder(payloadExpr);
+                    if (extracted != null) return extracted;
+                }
+                
+                String resolved = constantResolver.resolve(payloadExpr, context);
+                if (resolved != null) return resolved;
+                
+                // If not a constant, it might be a parameter like 'event'
+                if (payloadExpr instanceof CastExpression ce) {
+                    payloadExpr = ce.getExpression();
+                }
+                
+                if (payloadExpr instanceof SimpleName sn) {
+                    String extracted = extractEventFromMessageBuilder(payloadExpr);
+                    if (extracted != null) {
+                        return extracted;
+                    }
+                    return sn.getIdentifier(); // Fall back to returning the parameter name
+                }
+                return payloadExpr.toString();
+            } else if (current.arguments().isEmpty() && current.getExpression() instanceof SimpleName sn) {
+                // If the event is obtained by calling a method on a provider/supplier parameter, 
+                // return the provider's name so CallGraphBuilder can trace the lambda argument
+                String traced = extractEventFromMessageBuilder(sn);
+                return traced != null ? traced : sn.getIdentifier();
+            }
+            
+            Expression receiver = current.getExpression();
+            if (receiver instanceof MethodInvocation nextMi) {
+                current = nextMi;
+            } else {
+                current = null;
+            }
+        }
+        return null;
+    }
+
+    private MethodDeclaration findEnclosingMethod(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof MethodDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (MethodDeclaration) parent;
+    }
+
+    private TypeDeclaration findEnclosingType(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof TypeDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (TypeDeclaration) parent;
+    }
+
+    private String[] resolveStateMachineTypeArguments(MethodInvocation node) {
+        Expression receiver = node.getExpression();
+        
+        // Trace back the receiver if it's a builder chain
+        while (receiver instanceof MethodInvocation mi) {
+            if (mi.getName().getIdentifier().equals("sendEvent")) {
+                receiver = mi.getExpression();
+                break;
+            }
+            receiver = mi.getExpression();
+        }
+        
+        // Also if the node itself is sendEvent, receiver is already correct
+        if (node.getName().getIdentifier().equals("sendEvent")) {
+            receiver = node.getExpression();
+        }
+
+        if (receiver == null) return new String[]{null, null};
+
+        ITypeBinding binding = receiver.resolveTypeBinding();
+        if (binding != null) {
+            ITypeBinding smBinding = findStateMachineSupertype(binding, new java.util.HashSet<>());
+            if (smBinding != null) {
+                ITypeBinding[] typeArgs = smBinding.getTypeArguments();
+                if (typeArgs.length >= 2) {
+                    return new String[]{typeArgs[0].getQualifiedName(), typeArgs[1].getQualifiedName()};
+                }
+            }
+        }
+
+        // Fallback: search enclosing class/method for variable declaration
+        Type declType = findReceiverTypeManually(receiver, node);
+        if (declType instanceof ParameterizedType pt) {
+            List<?> typeArgs = pt.typeArguments();
+            if (typeArgs.size() >= 2) {
+                CompilationUnit cu = (CompilationUnit) node.getRoot();
+                String stateType = resolveTypeToFqn((Type) typeArgs.get(0), cu);
+                String eventType = resolveTypeToFqn((Type) typeArgs.get(1), cu);
+                
+                if (stateType != null && stateType.length() == 1) {
+                    stateType = resolveGenericTypeVariable(stateType, node, cu);
+                }
+                if (eventType != null && eventType.length() == 1) {
+                    eventType = resolveGenericTypeVariable(eventType, node, cu);
+                }
+                
+                return new String[]{stateType, eventType};
+            }
+        }
+        return new String[]{null, null};
+    }
+
+    private String resolveGenericTypeVariable(String typeVarName, ASTNode node, CompilationUnit cu) {
+        TypeDeclaration enclosingClass = findEnclosingType(node);
+        if (enclosingClass == null) return typeVarName;
+        String className = context.getFqn(enclosingClass);
+        if (className == null) return typeVarName;
+
+        List<String> impls = context.getImplementations(className);
+        if (impls == null || impls.isEmpty()) return typeVarName;
+
+        for (String implFqn : impls) {
+            org.eclipse.jdt.core.dom.AbstractTypeDeclaration implNode = context.getAbstractTypeDeclaration(implFqn);
+            if (implNode instanceof TypeDeclaration td) {
+                Type superclassType = td.getSuperclassType();
+                if (superclassType instanceof ParameterizedType pt) {
+                    Type baseType = pt.getType();
+                    String baseName = resolveTypeToFqn(baseType, (CompilationUnit) implNode.getRoot());
+                    if (className.equals(baseName) || className.endsWith("." + baseName)) {
+                        int typeIndex = -1;
+                        List<?> typeParams = enclosingClass.typeParameters();
+                        for (int i = 0; i < typeParams.size(); i++) {
+                            TypeParameter tp = (TypeParameter) typeParams.get(i);
+                            if (tp.getName().getIdentifier().equals(typeVarName)) {
+                                typeIndex = i;
+                                break;
+                            }
+                        }
+                        if (typeIndex >= 0 && typeIndex < pt.typeArguments().size()) {
+                            Type concreteType = (Type) pt.typeArguments().get(typeIndex);
+                            return resolveTypeToFqn(concreteType, (CompilationUnit) implNode.getRoot());
+                        }
+                    }
+                }
+            }
+        }
+        return typeVarName;
+    }
+
+    private ITypeBinding findStateMachineSupertype(ITypeBinding binding, java.util.Set<String> visited) {
+        ITypeBinding current = binding;
+        while (current != null) {
+            String erasureName = current.getErasure().getQualifiedName();
+            if (erasureName != null && !visited.add(erasureName)) {
+                return null;
+            }
+            if ("org.springframework.statemachine.StateMachine".equals(erasureName)) {
+                return current;
+            }
+            for (ITypeBinding iface : current.getInterfaces()) {
+                ITypeBinding res = findStateMachineSupertype(iface, visited);
+                if (res != null) return res;
+            }
+            current = current.getSuperclass();
+        }
+        return null;
+    }
+
+    private Type findReceiverTypeManually(Expression receiver, MethodInvocation node) {
+        if (!(receiver instanceof SimpleName sn)) return null;
+        String varName = sn.getIdentifier();
+
+        MethodDeclaration enclosingMethod = findEnclosingMethod(node);
+        if (enclosingMethod != null) {
+            // Check params
+            for (Object paramObj : enclosingMethod.parameters()) {
+                if (paramObj instanceof SingleVariableDeclaration svd) {
+                    if (svd.getName().getIdentifier().equals(varName)) {
+                        return svd.getType();
+                    }
+                }
+            }
+            // Check local variables
+            if (enclosingMethod.getBody() != null) {
+                Type[] found = new Type[1];
+                enclosingMethod.getBody().accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(VariableDeclarationStatement vds) {
+                        for (Object fragObj : vds.fragments()) {
+                            if (fragObj instanceof VariableDeclarationFragment fragment) {
+                                if (fragment.getName().getIdentifier().equals(varName)) {
+                                    found[0] = vds.getType();
+                                }
+                            }
+                        }
+                        return super.visit(vds);
+                    }
+                });
+                if (found[0] != null) return found[0];
+            }
+        }
+
+        // Check fields
+        TypeDeclaration enclosingType = findEnclosingType(node);
+        if (enclosingType != null) {
+            for (FieldDeclaration fd : enclosingType.getFields()) {
+                for (Object fragObj : fd.fragments()) {
+                    if (fragObj instanceof VariableDeclarationFragment fragment) {
+                        if (fragment.getName().getIdentifier().equals(varName)) {
+                            return fd.getType();
+                        }
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private String resolveTypeToFqn(Type type, CompilationUnit cu) {
+        if (type == null) return null;
+        String simpleName;
+        if (type.isSimpleType()) {
+            simpleName = ((SimpleType) type).getName().getFullyQualifiedName();
+        } else if (type.isParameterizedType()) {
+            return resolveTypeToFqn(((ParameterizedType) type).getType(), cu);
+        } else {
+            simpleName = type.toString();
+        }
+
+        AbstractTypeDeclaration td = context.getAbstractTypeDeclaration(simpleName, cu);
+        if (td != null) {
+            return context.getFqn(td);
+        }
+        
+        // Fallback to import matching
+        for (Object impObj : cu.imports()) {
+            ImportDeclaration imp = (ImportDeclaration) impObj;
+            String impName = imp.getName().getFullyQualifiedName();
+            if (impName.endsWith("." + simpleName)) {
+                return impName;
+            }
+        }
+
+        // Check package name
+        String packageName = cu.getPackage() != null ? cu.getPackage().getName().getFullyQualifiedName() : "";
+        if (!packageName.isEmpty()) {
+            AbstractTypeDeclaration localTd = context.getAbstractTypeDeclaration(packageName + "." + simpleName);
+            if (localTd != null) return context.getFqn(localTd);
+        }
+
+        return simpleName;
+    }
+
+    private static class AssignmentDag {
+        final java.util.Map<String, List<Expression>> assignments = new java.util.HashMap<>();
+        final java.util.Set<SingleVariableDeclaration> parameters = new java.util.HashSet<>();
+
+        AssignmentDag(MethodDeclaration method) {
+            if (method == null) return;
+            for (Object paramObj : method.parameters()) {
+                if (paramObj instanceof SingleVariableDeclaration svd) {
+                    parameters.add(svd);
+                }
+            }
+            if (method.getBody() != null) {
+                method.getBody().accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(VariableDeclarationFragment fragment) {
+                        String varName = fragment.getName().getIdentifier();
+                        if (fragment.getInitializer() != null) {
+                            assignments.computeIfAbsent(varName, k -> new ArrayList<>()).add(fragment.getInitializer());
+                        }
+                        return super.visit(fragment);
+                    }
+
+                    @Override
+                    public boolean visit(Assignment assignment) {
+                        if (assignment.getLeftHandSide() instanceof SimpleName sn) {
+                            String varName = sn.getIdentifier();
+                            assignments.computeIfAbsent(varName, k -> new ArrayList<>()).add(assignment.getRightHandSide());
+                        }
+                        return super.visit(assignment);
+                    }
+                });
+            }
+        }
+
+        boolean isExternal(Expression expr, java.util.Set<String> visited) {
+            if (expr == null) return false;
+            Expression peeled = expr;
+            while (peeled instanceof ParenthesizedExpression pe) {
+                peeled = pe.getExpression();
+            }
+            while (peeled instanceof CastExpression ce) {
+                peeled = ce.getExpression();
+            }
+
+            if (peeled instanceof SimpleName sn) {
+                String varName = sn.getIdentifier();
+                for (SingleVariableDeclaration svd : parameters) {
+                    if (svd.getName().getIdentifier().equals(varName)) {
+                        return isAnnotatedAsExternal(svd);
+                    }
+                }
+                if (assignments.containsKey(varName)) {
+                    if (!visited.add(varName)) {
+                        return false;
+                    }
+                    List<Expression> defs = assignments.get(varName);
+                    for (Expression def : defs) {
+                        if (isExternal(def, visited)) {
+                            return true;
+                        }
+                    }
+                }
+            } else if (peeled instanceof MethodInvocation mi) {
+                if (mi.getExpression() != null && isExternal(mi.getExpression(), visited)) {
+                    return true;
+                }
+                for (Object arg : mi.arguments()) {
+                    if (isExternal((Expression) arg, visited)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        private boolean isAnnotatedAsExternal(SingleVariableDeclaration svd) {
+            for (Object modifier : svd.modifiers()) {
+                if (modifier instanceof Annotation annotation) {
+                    String typeName = annotation.getTypeName().getFullyQualifiedName();
+                    if (typeName.endsWith("PathVariable") || typeName.endsWith("RequestBody") || typeName.endsWith("RequestParam")
+                        || typeName.endsWith("PathParam") || typeName.endsWith("QueryParam")) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,634 @@
+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.*;
+
+@Slf4j
+public class HeuristicCallGraphEngine extends AbstractCallGraphEngine {
+    protected String currentMethodFqn;
+    protected Map<String, List<CallEdge>> graph;
+
+    public HeuristicCallGraphEngine(CodebaseContext context) {
+        super(context);
+    }
+
+    @SuppressWarnings("unchecked")
+    protected Map<String, List<CallEdge>> buildCallGraph() {
+        Map<String, List<CallEdge>> cached = (Map<String, List<CallEdge>>) context.getCache().get("heuristicCallGraph");
+        if (cached != null) {
+            this.graph = cached;
+            return cached;
+        }
+        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());
+                            String constraint = click.kamil.springstatemachineexporter.ast.common.AstUtils.findConditionConstraint(node);
+                            for (String calledMethod : calledMethods) {
+                                String receiver = getReceiverString(node.getExpression());
+                                CallEdge edge = new CallEdge(calledMethod, args, receiver);
+                                edge.setConstraint(resolveConstraint(node, calledMethod, constraint));
+                                graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(edge);
+                            }
+                            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);
+                                                }
+                                                String receiver = getReceiverString(node.getExpression());
+                                                CallEdge edge = new CallEdge(refMethod, implicitArgs, receiver);
+                                                edge.setConstraint(constraint);
+                                                graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(edge);
+                                            }
+                                        }
+                                    } 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);
+                                            }
+                                            String receiver = getReceiverString(node.getExpression());
+                                            CallEdge edge = new CallEdge(calledMethod, implicitArgs, receiver);
+                                            edge.setConstraint(constraint);
+                                            graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(edge);
+                                            
+                                            List<String> impls = context.getImplementations(fallbackTypeFqn);
+                                            for (String impl : impls) {
+                                                CallEdge implEdge = new CallEdge(impl + "." + emr.getName().getIdentifier(), args, receiver);
+                                                implEdge.setConstraint(constraint);
+                                                graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(implEdge);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    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());
+                                    String receiver = "super";
+                                    String constraint = click.kamil.springstatemachineexporter.ast.common.AstUtils.findConditionConstraint(node);
+                                    CallEdge edge = new CallEdge(calledMethod, args, receiver);
+                                    edge.setConstraint(constraint);
+                                    graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(edge);
+                                }
+                            }
+                        }
+                    }
+                    return super.visit(node);
+                }
+            });
+        }
+        context.getCache().put("heuristicCallGraph", graph);
+        return graph;
+    }
+
+    @Override
+    protected String postProcessResolvedArgument(org.eclipse.jdt.core.dom.Expression originalExpr, String resolvedValue) {
+        // Preserve getter calls on 'this' or 'super' for later resolution in trigger parameter tracing
+        // where we can substitute the actual receiver from the call edge
+        boolean isThisOrSuperGetter = (originalExpr instanceof org.eclipse.jdt.core.dom.MethodInvocation mi
+                && (mi.getExpression() instanceof org.eclipse.jdt.core.dom.ThisExpression || mi.getExpression() instanceof org.eclipse.jdt.core.dom.SuperMethodInvocation)
+                && mi.arguments().isEmpty()) || (originalExpr instanceof org.eclipse.jdt.core.dom.SuperMethodInvocation smi && smi.arguments().isEmpty());
+
+        if (isThisOrSuperGetter) {
+            return originalExpr.toString(); // Preserve "this.getTransitionType()" or "super.getEvent()" for later substitution
+        }
+
+        // Narrow resolution for "localVar.getX()" patterns where localVar is initialized
+        // from a ClassInstanceCreation (directly or via a factory method). This avoids
+        // the broad ENUM_SET fallback when the getter transforms one enum to another.
+        if (originalExpr instanceof org.eclipse.jdt.core.dom.MethodInvocation getterMi
+                && getterMi.getExpression() instanceof org.eclipse.jdt.core.dom.SimpleName instanceSn
+                && getterMi.arguments().isEmpty()) {
+            String narrowed = tryNarrowGetterViaLocalVarChain(getterMi, instanceSn);
+            if (narrowed != null) {
+                return narrowed;
+            }
+        }
+
+        return resolvedValue;
+    }
+    private String findDefiningClass(String className, String methodName) {
+        TypeDeclaration td = context.getTypeDeclaration(className);
+        if (td == null) return null;
+        
+        String resolvedMethodFqn = resolveMethodInTypeHierarchy(td, methodName);
+        if (resolvedMethodFqn != null) {
+            return resolvedMethodFqn.substring(0, resolvedMethodFqn.lastIndexOf('.'));
+        }
+        return null;
+    }
+
+    protected String resolveCalledMethod(MethodInvocation node) {
+        Expression receiver = node.getExpression();
+        String methodName = node.getName().getIdentifier();
+
+        if (receiver instanceof MethodInvocation miReceiver) {
+            String returnType = resolveMethodInvocationReturnType(miReceiver);
+            if (returnType != null) {
+                return returnType + "." + methodName;
+            }
+        }
+
+        if (receiver == null) {
+            TypeDeclaration td = findEnclosingType(node);
+            if (td != null) {
+                return resolveMethodInTypeHierarchy(td, methodName);
+            }
+            return null;
+        }
+
+        ITypeBinding binding = receiver.resolveTypeBinding();
+        if (binding != null) {
+            return binding.getQualifiedName() + "." + 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; 
+        }
+
+        if (receiver instanceof QualifiedName qn) {
+            String fqn = qn.getFullyQualifiedName();
+            TypeDeclaration td = context.getTypeDeclaration(fqn);
+            if (td != null) {
+                return fqn + "." + methodName;
+            }
+            return fqn + "." + methodName; 
+        }
+
+        return null;
+    }
+
+    protected String resolveReceiverTypeFallback(SimpleName receiverNameNode) {
+        String varName = receiverNameNode.getIdentifier();
+        
+        CompilationUnit cu = receiverNameNode.getRoot() instanceof CompilationUnit ? (CompilationUnit) receiverNameNode.getRoot() : null;
+        TypeDeclaration staticTd = context.getTypeDeclaration(varName, cu);
+        if (staticTd != null) {
+            return context.getFqn(staticTd);
+        }
+        TypeDeclaration fallbackStaticTd = context.getTypeDeclaration(varName);
+        if (fallbackStaticTd != null) {
+            return context.getFqn(fallbackStaticTd);
+        }
+
+        // 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 and its superclasses
+        TypeDeclaration enclosingType = findEnclosingType(receiverNameNode);
+        TypeDeclaration currentType = enclosingType;
+        while (currentType != null) {
+            for (FieldDeclaration field : currentType.getFields()) {
+                for (Object fragObj : field.fragments()) {
+                    VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                    if (frag.getName().getIdentifier().equals(varName)) {
+                        return resolveTypeToFqn(field.getType(), receiverNameNode);
+                    }
+                }
+            }
+            String superclass = context.getSuperclassFqn(currentType);
+            currentType = superclass != null ? context.getTypeDeclaration(superclass) : null;
+        }
+
+        return null;
+    }
+
+    protected 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;
+    }
+
+    /**
+     * Attempts to narrow the resolution of {@code instanceVar.getterMethod()} when the
+     * instance variable is initialised from a {@link org.eclipse.jdt.core.dom.ClassInstanceCreation}
+     * (either directly or via a factory/mapper method).
+     *
+     * <p>This handles both:
+     * <ul>
+     *   <li>Simple pass-through: {@code Wrapper(MyEnum e){this.e=e;} getE(){return e;}}</li>
+     *   <li>Transformation: {@code getSmEvent(){return switch(dtoEnum){case A->SmEvents.X;…};}}</li>
+     * </ul>
+     *
+     * @return the resolved constant string, or {@code null} when narrowing is not possible
+     */
+    private String tryNarrowGetterViaLocalVarChain(
+            MethodInvocation getterCall, SimpleName instanceSn) {
+
+        MethodDeclaration enclosing = findEnclosingMethod(getterCall);
+        if (enclosing == null || enclosing.getBody() == null) return null;
+
+        String varName = instanceSn.getIdentifier();
+        String getterName = getterCall.getName().getIdentifier();
+
+        // Find the declared type and initialiser of the local variable
+        String[] varTypeName = {null};
+        Expression[] initExpr = {null};
+        enclosing.getBody().accept(new ASTVisitor() {
+            @Override
+            public boolean visit(VariableDeclarationStatement vds) {
+                for (Object fragObj : vds.fragments()) {
+                    VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                    if (frag.getName().getIdentifier().equals(varName)) {
+                        varTypeName[0] = vds.getType().toString();
+                        initExpr[0] = frag.getInitializer();
+                    }
+                }
+                return super.visit(vds);
+            }
+        });
+        if (varTypeName[0] == null) return null;
+
+        // Obtain the ClassInstanceCreation that created the object
+        org.eclipse.jdt.core.dom.ClassInstanceCreation cic = null;
+        String receiverType = null;
+        if (initExpr[0] instanceof org.eclipse.jdt.core.dom.ClassInstanceCreation directCic) {
+            cic = directCic;
+        } else if (initExpr[0] instanceof MethodInvocation factoryMi
+                && (factoryMi.getExpression() instanceof SimpleName || factoryMi.getExpression() instanceof QualifiedName)) {
+            // e.g. "mapper.toMsg(dto)" or "com.example.Factory.toMsg()"
+            if (factoryMi.getExpression() instanceof SimpleName receiverSn) {
+                receiverType = resolveReceiverTypeFallback(receiverSn);
+            } else if (factoryMi.getExpression() instanceof QualifiedName qn) {
+                receiverType = qn.getFullyQualifiedName();
+            }
+            if (receiverType != null) {
+                cic = findReturnedCIC(receiverType, factoryMi.getName().getIdentifier(), context);
+            }
+        }
+        if (cic == null) {
+            // Support builder pattern: e.g. EventWrapper.builder().event(TransitionEnum.STATE_X).build()
+            if (initExpr[0] instanceof MethodInvocation initMi) {
+                String propName = getterName.startsWith("get") ? getterName.substring(3) : getterName;
+                Expression currentMi = initMi;
+                while (currentMi instanceof MethodInvocation chainMi) {
+                    String mName = chainMi.getName().getIdentifier();
+                    if (mName.equalsIgnoreCase("set" + propName) || mName.equalsIgnoreCase(propName)) {
+                        if (!chainMi.arguments().isEmpty()) {
+                            return chainMi.arguments().get(0).toString();
+                        }
+                    }
+                    currentMi = chainMi.getExpression();
+                }
+            }
+            return null;
+        }
+
+        // Resolve the variable's declared type to a TypeDeclaration
+        CompilationUnit cu = (CompilationUnit) getterCall.getRoot();
+        TypeDeclaration varTypeTd = context.getTypeDeclaration(varTypeName[0], cu);
+        if (varTypeTd == null) varTypeTd = context.getTypeDeclaration(varTypeName[0]);
+        if (varTypeTd == null) return null;
+
+// Evaluate the getter body with field values substituted from the CIC's constructor args
+        java.util.Map<String, String> initialLocals = new java.util.HashMap<>();
+        if (initExpr[0] instanceof MethodInvocation factoryMi) {
+            MethodDeclaration md = context.findMethodDeclaration(context.getTypeDeclaration(receiverType != null ? receiverType : varTypeName[0]), factoryMi.getName().getIdentifier(), true);
+            if (md != null) {
+                for (int i = 0; i < md.parameters().size() && i < factoryMi.arguments().size(); i++) {
+                    SingleVariableDeclaration param = (SingleVariableDeclaration) md.parameters().get(i);
+                    Expression arg = (Expression) factoryMi.arguments().get(i);
+                    String resolvedVal = constantResolver.resolve(arg, context);
+                    if (resolvedVal != null) {
+                        initialLocals.put(param.getName().getIdentifier(), resolvedVal);
+                    }
+                }
+            }
+        }
+        
+        java.util.Map<String, String> fieldValues = constructorAnalyzer.buildFieldValuesFromCIC(varTypeTd, cic, context, this::evaluateMethodCallInConstructor, initialLocals);
+        if (fieldValues.isEmpty()) return null;
+
+        // Track setter calls on the variable between its initialization and the getter call
+        // to capture field updates like e.setType("NEW_VALUE")
+        trackSetterCallsBetween(enclosing.getBody(), varName, getterCall, fieldValues, context);
+
+        MethodDeclaration getter = context.findMethodDeclaration(varTypeTd, getterName, true);
+        if (getter == null || getter.getBody() == null) return null;
+
+        return constantResolver.evaluateMethodBodyWithLocals(
+                getter, fieldValues, context, new java.util.HashSet<>());
+    }
+
+    /**
+     * Scans the method body for setter calls or field assignments to the given variable
+     * that occur between the variable's initialization and the getter call.
+     * Updates fieldValues with any field values set via setters.
+     */
+    private void trackSetterCallsBetween(org.eclipse.jdt.core.dom.Block methodBody, String varName,
+            org.eclipse.jdt.core.dom.MethodInvocation getterCall,
+            java.util.Map<String, String> fieldValues,
+            CodebaseContext context) {
+        java.util.List<org.eclipse.jdt.core.dom.ASTNode> statements = new java.util.ArrayList<>();
+        for (Object stmtObj : methodBody.statements()) {
+            statements.add((org.eclipse.jdt.core.dom.ASTNode) stmtObj);
+        }
+
+        int varDeclIndex = -1;
+        int getterCallIndex = -1;
+        for (int i = 0; i < statements.size(); i++) {
+            org.eclipse.jdt.core.dom.ASTNode stmt = statements.get(i);
+            // Find variable declaration
+            if (varDeclIndex == -1) {
+                if (stmt instanceof org.eclipse.jdt.core.dom.VariableDeclarationStatement vds) {
+                    for (Object fragObj : vds.fragments()) {
+                        if (fragObj instanceof org.eclipse.jdt.core.dom.VariableDeclarationFragment frag
+                                && frag.getName().getIdentifier().equals(varName)) {
+                            varDeclIndex = i;
+                            break;
+                        }
+                    }
+                }
+            }
+            // Find getter call
+            if (getterCallIndex == -1) {
+                if (stmt.toString().contains(getterCall.toString())) {
+                    getterCallIndex = i;
+                    break;
+                }
+            }
+        }
+
+        if (varDeclIndex >= 0 && getterCallIndex > varDeclIndex) {
+            // Scan statements between var declaration and getter call
+            for (int i = varDeclIndex + 1; i < getterCallIndex; i++) {
+                org.eclipse.jdt.core.dom.ASTNode stmt = statements.get(i);
+                if (stmt instanceof org.eclipse.jdt.core.dom.ExpressionStatement es) {
+                    org.eclipse.jdt.core.dom.Expression expr = es.getExpression();
+                    // Check for setter calls: var.setField(value)
+                    if (expr instanceof org.eclipse.jdt.core.dom.MethodInvocation mi) {
+                        if (mi.getExpression() instanceof org.eclipse.jdt.core.dom.SimpleName sn
+                                && sn.getIdentifier().equals(varName)) {
+                            String methodName = mi.getName().getIdentifier();
+                            // Check if it's a setter (setXxx or xxx)
+                            if (methodName.startsWith("set") && methodName.length() > 3) {
+                                String fieldName = Character.toLowerCase(methodName.charAt(3))
+                                        + methodName.substring(4);
+                                if (!mi.arguments().isEmpty()) {
+                                    org.eclipse.jdt.core.dom.Expression arg = (org.eclipse.jdt.core.dom.Expression) mi.arguments().get(0);
+                                    String val = constantResolver.resolve(arg, context);
+                                    if (val != null) {
+                                        fieldValues.put(fieldName, val);
+                                        fieldValues.put("this." + fieldName, val);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Check for direct field assignments: var.field = value
+                    else if (expr instanceof org.eclipse.jdt.core.dom.Assignment assignment) {
+                        if (assignment.getLeftHandSide() instanceof org.eclipse.jdt.core.dom.FieldAccess fa) {
+                            if (fa.getExpression() instanceof org.eclipse.jdt.core.dom.SimpleName sn
+                                    && sn.getIdentifier().equals(varName)) {
+                                String fieldName = fa.getName().getIdentifier();
+                                org.eclipse.jdt.core.dom.Expression rhs = assignment.getRightHandSide();
+                                String val = constantResolver.resolve(rhs, context);
+                                if (val != null) {
+                                    fieldValues.put(fieldName, val);
+                                    fieldValues.put("this." + fieldName, val);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Extracts a string representation of the receiver expression from a MethodInvocation.
+     * Handles ThisExpression, SimpleName, and other expression types.
+     */
+    protected String getReceiverString(Expression receiver) {
+        if (receiver == null) {
+            return null;
+        }
+        if (receiver instanceof ThisExpression) {
+            return "this";
+        }
+        if (receiver instanceof SuperMethodInvocation) {
+            return "super";
+        }
+        if (receiver instanceof SimpleName sn) {
+            return sn.getIdentifier();
+        }
+        return receiver.toString();
+    }
+
+    /**
+     * Finds the receiver expression used in the caller method when calling the target method.
+     * Walks the caller's AST to find a MethodInvocation with the target method name
+     * and returns the receiver string.
+     */
+    protected String findCallerReceiver(String callerFqn, String targetMethodFqn) {
+        int lastDot = callerFqn.lastIndexOf('.');
+        if (lastDot < 0) return null;
+        String callerClass = callerFqn.substring(0, lastDot);
+        String callerMethod = callerFqn.substring(lastDot + 1);
+
+        int targetLastDot = targetMethodFqn.lastIndexOf('.');
+        if (targetLastDot < 0) return null;
+        String targetMethodName = targetMethodFqn.substring(targetLastDot + 1);
+
+        TypeDeclaration callerTd = context.getTypeDeclaration(callerClass);
+        if (callerTd == null) return null;
+
+        MethodDeclaration callerMd = context.findMethodDeclaration(callerTd, callerMethod, false);
+        if (callerMd == null || callerMd.getBody() == null) return null;
+
+        final String[] foundReceiver = {null};
+        callerMd.getBody().accept(new ASTVisitor() {
+            @Override
+            public boolean visit(MethodInvocation node) {
+                if (foundReceiver[0] != null) return false;
+                String called = resolveCalledMethod(node);
+                if (called != null && (called.equals(targetMethodFqn) || called.endsWith("." + targetMethodName))) {
+                    foundReceiver[0] = getReceiverString(node.getExpression());
+                    return false;
+                }
+                return super.visit(node);
+            }
+        });
+        return foundReceiver[0];
+    }
+
+    protected String resolveMethodInvocationReturnType(MethodInvocation mi) {
+        Expression receiver = mi.getExpression();
+        String receiverType = null;
+        if (receiver == null) {
+            TypeDeclaration td = findEnclosingType(mi);
+            if (td != null) {
+                receiverType = context.getFqn(td);
+            }
+        } else if (receiver instanceof SimpleName sn) {
+            receiverType = resolveReceiverTypeFallback(sn);
+        } else if (receiver instanceof FieldAccess fa) {
+            receiverType = resolveReceiverTypeFallback(fa.getName());
+        } else if (receiver instanceof MethodInvocation innerMi) {
+            receiverType = resolveMethodInvocationReturnType(innerMi);
+        }
+        
+        if (receiverType == null) {
+            ITypeBinding binding = receiver != null ? receiver.resolveTypeBinding() : null;
+            if (binding != null) {
+                receiverType = binding.getErasure().getQualifiedName();
+            }
+        }
+        
+        if (receiverType != null) {
+            String rawType = receiverType;
+            if (rawType.contains("<")) {
+                rawType = rawType.substring(0, rawType.indexOf('<'));
+            }
+            if (rawType.equals("java.util.Map") || rawType.equals("Map")) {
+                String valType = resolveMapValueType(mi);
+                if (valType != null) return valType;
+            }
+            if (receiverType.contains("<")) {
+                receiverType = receiverType.substring(0, receiverType.indexOf('<'));
+            }
+            String methodName = mi.getName().getIdentifier();
+            TypeDeclaration td = context.getTypeDeclaration(receiverType);
+            if (td == null && receiverType.contains(".")) {
+                String simpleClass = receiverType.substring(receiverType.lastIndexOf('.') + 1);
+                td = context.getTypeDeclaration(simpleClass);
+            }
+            if (td != null) {
+                MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+                if (md != null && md.getReturnType2() != null) {
+                    return resolveTypeToFqn(md.getReturnType2(), mi);
+                }
+            }
+        }
+        
+        IMethodBinding methodBinding = mi.resolveMethodBinding();
+        if (methodBinding != null && methodBinding.getReturnType() != null) {
+            return methodBinding.getReturnType().getErasure().getQualifiedName();
+        }
+        
+        return null;
+    }
+}

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

@@ -0,0 +1,75 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.RequiredArgsConstructor;
+import org.eclipse.jdt.core.dom.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RequiredArgsConstructor
+public class InterceptorDetector {
+    private final CodebaseContext context;
+
+    public List<EntryPoint> detect(CompilationUnit cu) {
+        List<EntryPoint> entryPoints = new ArrayList<>();
+        cu.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(TypeDeclaration node) {
+                if (isInterceptor(node)) {
+                    processInterceptor(node, entryPoints);
+                }
+                return super.visit(node);
+            }
+        });
+        return entryPoints;
+    }
+
+    private boolean isInterceptor(TypeDeclaration node) {
+        if (node.getSuperclassType() != null) {
+            // Check for common adapter/base classes if needed
+        }
+        for (Object interfaceType : node.superInterfaceTypes()) {
+            String name = interfaceType.toString();
+            if (name.contains("HandlerInterceptor") || name.contains("Filter") || name.contains("WebRequestInterceptor")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void processInterceptor(TypeDeclaration node, List<EntryPoint> entryPoints) {
+        String fqn = context.getFqn(node);
+        for (MethodDeclaration method : node.getMethods()) {
+            String methodName = method.getName().getIdentifier();
+            if (isInterceptorMethod(methodName)) {
+                Map<String, String> metadata = new HashMap<>();
+                metadata.put("interceptorType", getInterceptorType(node));
+
+                entryPoints.add(EntryPoint.builder()
+                        .type(EntryPoint.Type.CUSTOM)
+                        .name("INTERCEPTOR: " + node.getName().getIdentifier() + "." + methodName)
+                        .className(fqn)
+                        .methodName(methodName)
+                        .metadata(metadata)
+                        .build());
+            }
+        }
+    }
+
+    private boolean isInterceptorMethod(String name) {
+        return name.equals("preHandle") || name.equals("postHandle") || name.equals("afterCompletion") || name.equals("doFilter");
+    }
+
+    private String getInterceptorType(TypeDeclaration node) {
+        for (Object interfaceType : node.superInterfaceTypes()) {
+            String name = interfaceType.toString();
+            if (name.contains("HandlerInterceptor")) return "Spring MVC Interceptor";
+            if (name.contains("Filter")) return "Servlet Filter";
+        }
+        return "Generic Interceptor";
+    }
+}

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

@@ -0,0 +1,419 @@
+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;
+    }
+
+    @Override
+    public Map<String, List<CallEdge>> getCallGraph() {
+        return buildCallGraph();
+    }
+
+    @SuppressWarnings("unchecked")
+    protected Map<String, List<CallEdge>> buildCallGraph() {
+        Map<String, List<CallEdge>> cached = (Map<String, List<CallEdge>>) context.getCache().get("jdtCallGraph");
+        if (cached != null) {
+            this.graph = cached;
+            return cached;
+        }
+        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());
+                            String constraint = click.kamil.springstatemachineexporter.ast.common.AstUtils.findConditionConstraint(node);
+                            for (String calledMethod : calledMethods) {
+                                CallEdge edge = new CallEdge(calledMethod, args);
+                                edge.setConstraint(resolveConstraint(node, calledMethod, constraint));
+                                graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(edge);
+                            }
+                            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);
+                                                }
+                                                CallEdge edge = new CallEdge(refMethod, implicitArgs);
+                                                edge.setConstraint(constraint);
+                                                graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(edge);
+                                            }
+                                        }
+                                    } 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);
+                                            }
+                                            CallEdge edge = new CallEdge(calledMethod, implicitArgs);
+                                            edge.setConstraint(constraint);
+                                            graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(edge);
+                                            
+                                            List<String> impls = context.getImplementations(fallbackTypeFqn);
+                                            for (String impl : impls) {
+                                                CallEdge implEdge = new CallEdge(impl + "." + emr.getName().getIdentifier(), args);
+                                                implEdge.setConstraint(constraint);
+                                                graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(implEdge);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    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());
+                                    String constraint = click.kamil.springstatemachineexporter.ast.common.AstUtils.findConditionConstraint(node);
+                                    CallEdge edge = new CallEdge(calledMethod, args);
+                                    edge.setConstraint(constraint);
+                                    graph.computeIfAbsent(currentMethodFqn, k -> new ArrayList<>()).add(edge);
+                                }
+                            }
+                        }
+                    }
+                    return super.visit(node);
+                }
+            });
+        }
+        context.getCache().put("jdtCallGraph", graph);
+        return graph;
+    }
+
+    @Override
+    protected String resolveArgument(org.eclipse.jdt.core.dom.Expression expr) {
+        if (expr == null) {
+            return "null";
+        }
+        // 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
+        String result = super.resolveArgument(expr);
+        if (result != null) {
+            result = result.replaceAll("->\\s*yield\\s+", "-> ");
+        }
+        return result;
+    }
+
+    protected String resolveCalledMethod(MethodInvocation node) {
+        Expression receiver = node.getExpression();
+        String methodName = node.getName().getIdentifier();
+
+        if (receiver instanceof MethodInvocation miReceiver) {
+            String returnType = resolveMethodInvocationReturnType(miReceiver);
+            if (returnType != null) {
+                return returnType + "." + methodName;
+            }
+        }
+
+        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) {
+                log.debug("CALLGRAPH RESOLVING BEAN FOR BINDING: {} calling {}", varBinding.getName(), methodName);
+                String concreteFqn = injectionAnalyzer.resolveInjectedBeanFqn(varBinding);
+                if (concreteFqn != null) {
+                    log.debug("  -> RESOLVED CONCRETE FQN: {}", concreteFqn);
+                    return concreteFqn + "." + methodName;
+                } else {
+                    log.debug("  -> RESOLVE FAILED, RETURNED NULL");
+                }
+            } else {
+                log.debug("CALLGRAPH NAME BINDING IS NOT VARIABLE: {} calling {}", nameBinding, 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()) {
+                org.eclipse.jdt.core.dom.TypeDeclaration resolvedTd = context.getTypeDeclaration(typeName);
+                if (resolvedTd != null && context.findMethodDeclaration(resolvedTd, methodName, true) != null) {
+                    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 and its superclasses
+        TypeDeclaration enclosingType = findEnclosingType(receiverNameNode);
+        TypeDeclaration currentType = enclosingType;
+        while (currentType != null) {
+            for (FieldDeclaration field : currentType.getFields()) {
+                for (Object fragObj : field.fragments()) {
+                    VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                    if (frag.getName().getIdentifier().equals(varName)) {
+                        return resolveTypeToFqn(field.getType(), receiverNameNode);
+                    }
+                }
+            }
+            String superclass = context.getSuperclassFqn(currentType);
+            currentType = superclass != null ? context.getTypeDeclaration(superclass) : null;
+        }
+
+        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 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;
+    }
+
+    protected String resolveMethodInvocationReturnType(MethodInvocation mi) {
+        Expression receiver = mi.getExpression();
+        String receiverType = null;
+        if (receiver == null) {
+            TypeDeclaration td = findEnclosingType(mi);
+            if (td != null) {
+                receiverType = context.getFqn(td);
+            }
+        } else if (receiver instanceof SimpleName sn) {
+            receiverType = resolveReceiverTypeFallback(sn);
+        } else if (receiver instanceof FieldAccess fa) {
+            receiverType = resolveReceiverTypeFallback(fa.getName());
+        } else if (receiver instanceof MethodInvocation innerMi) {
+            receiverType = resolveMethodInvocationReturnType(innerMi);
+        }
+        
+        if (receiverType == null) {
+            ITypeBinding binding = receiver != null ? receiver.resolveTypeBinding() : null;
+            if (binding != null) {
+                receiverType = binding.getErasure().getQualifiedName();
+            }
+        }
+        
+        if (receiverType != null) {
+            String rawType = receiverType;
+            if (rawType.contains("<")) {
+                rawType = rawType.substring(0, rawType.indexOf('<'));
+            }
+            if (rawType.equals("java.util.Map") || rawType.equals("Map")) {
+                String valType = resolveMapValueType(mi);
+                if (valType != null) return valType;
+            }
+            if (receiverType.contains("<")) {
+                receiverType = receiverType.substring(0, receiverType.indexOf('<'));
+            }
+            String methodName = mi.getName().getIdentifier();
+            TypeDeclaration td = context.getTypeDeclaration(receiverType);
+            if (td == null && receiverType.contains(".")) {
+                String simpleClass = receiverType.substring(receiverType.lastIndexOf('.') + 1);
+                td = context.getTypeDeclaration(simpleClass);
+            }
+            if (td != null) {
+                MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+                if (md != null && md.getReturnType2() != null) {
+                    return resolveTypeToFqn(md.getReturnType2(), mi);
+                }
+            }
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,103 @@
+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.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;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
+public class JdtIntelligenceProvider implements CodebaseIntelligenceProvider {
+    private final CodebaseContext context;
+    private final Path rootDir;
+    private final ConstantResolver constantResolver = new ConstantResolver();
+    private final GenericEventDetector eventDetector;
+    private final SpringMvcDetector mvcDetector;
+    private final MessagingDetector messagingDetector;
+    private final CallGraphEngine callGraphEngine;
+    private final LifecycleDetector lifecycleDetector;
+    private final InterceptorDetector interceptorDetector;
+    private final SpringComponentDetector componentDetector;
+    private List<TriggerPoint> cachedTriggers;
+    private List<EntryPoint> cachedEntryPoints;
+
+    public JdtIntelligenceProvider(CodebaseContext context, Path rootDir) {
+        this.context = context;
+        this.rootDir = rootDir;
+        this.eventDetector = new GenericEventDetector(context, constantResolver, context.getLibraryHints());
+        this.mvcDetector = new SpringMvcDetector(context, constantResolver);
+        this.messagingDetector = new MessagingDetector(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);
+    }
+
+    @Override
+    public List<TriggerPoint> findTriggerPoints() {
+        if (cachedTriggers != null) {
+            return cachedTriggers;
+        }
+        List<TriggerPoint> allTriggers = new ArrayList<>();
+        var cus = context.getCompilationUnits();
+        log.info("JdtIntelligenceProvider scanning {} compilation units for triggers", cus.size());
+        for (CompilationUnit cu : cus) {
+            allTriggers.addAll(eventDetector.detect(cu));
+            allTriggers.addAll(lifecycleDetector.detect(cu));
+        }
+        log.info("Found {} triggers (including lifecycle) in total", allTriggers.size());
+        cachedTriggers = allTriggers;
+        return allTriggers;
+    }
+
+    @Override
+    public List<EntryPoint> findEntryPoints() {
+        if (cachedEntryPoints != null) {
+            return cachedEntryPoints;
+        }
+        List<EntryPoint> allEntryPoints = new ArrayList<>();
+        var cus = context.getCompilationUnits();
+        log.info("JdtIntelligenceProvider scanning {} compilation units for entry points", cus.size());
+        for (CompilationUnit cu : cus) {
+            allEntryPoints.addAll(mvcDetector.detect(cu));
+            allEntryPoints.addAll(messagingDetector.detect(cu));
+            allEntryPoints.addAll(interceptorDetector.detect(cu));
+            allEntryPoints.addAll(componentDetector.detect(cu));
+        }
+        log.info("Found {} entry points (including interceptors and listeners) in total", allEntryPoints.size());
+        cachedEntryPoints = allEntryPoints;
+        return allEntryPoints;
+    }
+
+    @Override
+    public List<CallChain> findCallChains(List<EntryPoint> entryPoints, List<TriggerPoint> triggers) {
+        log.info("JdtIntelligenceProvider searching for call chains between {} entry points and {} triggers", entryPoints.size(), triggers.size());
+        return callGraphEngine.findChains(entryPoints, triggers);
+    }
+
+    @Override
+    public Map<String, Map<String, String>> resolveProperties() {
+        return context.getProperties();
+    }
+}

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

@@ -0,0 +1,62 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.TriggerPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.RequiredArgsConstructor;
+import org.eclipse.jdt.core.dom.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RequiredArgsConstructor
+public class LifecycleDetector {
+    private final CodebaseContext context;
+
+    public List<TriggerPoint> detect(CompilationUnit cu) {
+        List<TriggerPoint> lifecyclePoints = new ArrayList<>();
+        cu.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(MethodInvocation node) {
+                String methodName = node.getName().getIdentifier();
+                if ("restore".equals(methodName) || "reset".equals(methodName)) {
+                    TriggerPoint point = buildLifecyclePoint(node, cu, methodName);
+                    if (point != null) {
+                        lifecyclePoints.add(point);
+                    }
+                }
+                return super.visit(node);
+            }
+        });
+        return lifecyclePoints;
+    }
+
+    private TriggerPoint buildLifecyclePoint(MethodInvocation node, CompilationUnit cu, String type) {
+        MethodDeclaration method = findEnclosingMethod(node);
+        TypeDeclaration typeDecl = findEnclosingType(node);
+
+        if (typeDecl == null) return null;
+
+        return TriggerPoint.builder()
+                .event("[LIFECYCLE:" + type.toUpperCase() + "]")
+                .className(context.getFqn(typeDecl))
+                .methodName(method != null ? method.getName().getIdentifier() : "initializer")
+                .lineNumber(cu.getLineNumber(node.getStartPosition()))
+                .build();
+    }
+
+    private MethodDeclaration findEnclosingMethod(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof MethodDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (MethodDeclaration) parent;
+    }
+
+    private TypeDeclaration findEnclosingType(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof TypeDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (TypeDeclaration) parent;
+    }
+}

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

@@ -0,0 +1,129 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.RequiredArgsConstructor;
+import org.eclipse.jdt.core.dom.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RequiredArgsConstructor
+public class MessagingDetector {
+    private final CodebaseContext context;
+
+    public List<EntryPoint> detect(CompilationUnit cu) {
+        List<EntryPoint> entryPoints = new ArrayList<>();
+        cu.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(MethodDeclaration node) {
+                processMethod(node, entryPoints);
+                return super.visit(node);
+            }
+        });
+        return entryPoints;
+    }
+
+    private void processMethod(MethodDeclaration method, List<EntryPoint> entryPoints) {
+        for (Object modifier : method.modifiers()) {
+            if (modifier instanceof Annotation annotation) {
+                String typeName = annotation.getTypeName().getFullyQualifiedName();
+                
+                EntryPoint.Type type = null;
+                String destination = "";
+                
+                if (typeName.endsWith("JmsListener")) {
+                    type = EntryPoint.Type.JMS;
+                    destination = resolveValue(annotation, "destination");
+                } else if (typeName.endsWith("RabbitListener")) {
+                    type = EntryPoint.Type.RABBIT;
+                    destination = resolveValue(annotation, "queues");
+                } else if (typeName.endsWith("SqsListener")) {
+                    type = EntryPoint.Type.SQS;
+                    destination = resolveValue(annotation, "value");
+                    if ("unknown".equals(destination)) {
+                        destination = resolveValue(annotation, "queueNames");
+                    }
+                } else if (typeName.endsWith("SnsListener")) {
+                    type = EntryPoint.Type.SNS;
+                    destination = resolveValue(annotation, "value");
+                    if ("unknown".equals(destination)) {
+                        destination = resolveValue(annotation, "topicNames");
+                    }
+                } else if (typeName.endsWith("KafkaListener")) {
+                    type = EntryPoint.Type.KAFKA;
+                    destination = resolveValue(annotation, "topics");
+                }
+
+                if (type != null) {
+                    Map<String, String> metadata = new HashMap<>();
+                    metadata.put("destination", destination);
+                    
+                    String protocolName = type.name();
+                    if (typeName.endsWith("SqsListener")) protocolName = "SQS";
+                    if (typeName.endsWith("SnsListener")) protocolName = "SNS";
+                    metadata.put("protocol", protocolName);
+                    
+                    entryPoints.add(EntryPoint.builder()
+                            .type(type)
+                            .name(protocolName + ": " + destination)
+                            .className(context.getFqn((TypeDeclaration) method.getParent()))
+                            .methodName(method.getName().getIdentifier())
+                            .sourceFile(context.getRelativePath(context.getFqn((TypeDeclaration) method.getParent())))
+                            .metadata(metadata)
+                            .parameters(extractParameters(method))
+                            .build());
+                }
+            }
+        }
+    }
+
+    private String resolveValue(Annotation annotation, String memberName) {
+        Expression value = null;
+        if (annotation instanceof SingleMemberAnnotation sma) {
+            value = sma.getValue();
+        } else if (annotation instanceof NormalAnnotation na) {
+            for (Object pairObj : na.values()) {
+                MemberValuePair pair = (MemberValuePair) pairObj;
+                if (memberName.equals(pair.getName().getIdentifier())) {
+                    value = pair.getValue();
+                    break;
+                }
+            }
+        }
+
+        if (value != null) {
+            if (value instanceof ArrayInitializer ai) {
+                List<String> values = new ArrayList<>();
+                for (Object o : ai.expressions()) {
+                    values.add(context.resolveExpression((Expression) o));
+                }
+                return String.join(", ", values);
+            }
+            return context.resolveExpression(value);
+        }
+        return "unknown";
+    }
+
+    private List<EntryPoint.Parameter> extractParameters(MethodDeclaration method) {
+        List<EntryPoint.Parameter> parameters = new ArrayList<>();
+        for (Object paramObj : method.parameters()) {
+            if (paramObj instanceof SingleVariableDeclaration param) {
+                List<String> annotations = new ArrayList<>();
+                for (Object mod : param.modifiers()) {
+                    if (mod instanceof Annotation ann) {
+                        annotations.add(ann.getTypeName().getFullyQualifiedName());
+                    }
+                }
+                parameters.add(EntryPoint.Parameter.builder()
+                        .name(param.getName().getIdentifier())
+                        .type(param.getType().toString())
+                        .annotations(annotations)
+                        .build());
+            }
+        }
+        return parameters;
+    }
+}

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

@@ -0,0 +1,117 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.RequiredArgsConstructor;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.Annotation;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
+import org.eclipse.jdt.core.dom.NormalAnnotation;
+import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
+import org.eclipse.jdt.core.dom.TypeDeclaration;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RequiredArgsConstructor
+public class SpringComponentDetector {
+    private final CodebaseContext context;
+
+    public List<EntryPoint> detect(CompilationUnit cu) {
+        List<EntryPoint> entryPoints = new ArrayList<>();
+        cu.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(MethodDeclaration node) {
+                if (!(node.getParent() instanceof TypeDeclaration)) {
+                    return super.visit(node);
+                }
+                TypeDeclaration parentTd = (TypeDeclaration) node.getParent();
+
+                for (Object modifier : node.modifiers()) {
+                    if (modifier instanceof Annotation annotation) {
+                        String typeName = annotation.getTypeName().getFullyQualifiedName();
+                        if (typeName.endsWith("Scheduled")) {
+                            Map<String, String> meta = new HashMap<>();
+                            String cron = extractAnnotationValue(annotation, "cron");
+                            if (!cron.isEmpty())
+                                meta.put("cron", cron);
+                            String fixedRate = extractAnnotationValue(annotation, "fixedRate");
+                            if (!fixedRate.isEmpty())
+                                meta.put("fixedRate", fixedRate);
+                            String fixedDelay = extractAnnotationValue(annotation, "fixedDelay");
+                            if (!fixedDelay.isEmpty())
+                                meta.put("fixedDelay", fixedDelay);
+
+                            entryPoints.add(EntryPoint.builder()
+                                    .type(EntryPoint.Type.CUSTOM)
+                                    .name("@Scheduled: " + node.getName().getIdentifier())
+                                    .className(context.getFqn(parentTd))
+                                    .methodName(node.getName().getIdentifier())
+                                    .sourceFile(context.getRelativePath(context.getFqn(parentTd)))
+                                    .metadata(meta)
+                                    .build());
+                        } else if (typeName.endsWith("EventListener")) {
+                            Map<String, String> meta = new HashMap<>();
+                            String classes = extractAnnotationValue(annotation, "classes");
+                            if (!classes.isEmpty())
+                                meta.put("classes", classes);
+                            String condition = extractAnnotationValue(annotation, "condition");
+                            if (!condition.isEmpty())
+                                meta.put("condition", condition);
+
+                            entryPoints.add(EntryPoint.builder()
+                                    .type(EntryPoint.Type.CUSTOM)
+                                    .name("@EventListener: " + node.getName().getIdentifier())
+                                    .className(context.getFqn(parentTd))
+                                    .methodName(node.getName().getIdentifier())
+                                    .sourceFile(context.getRelativePath(context.getFqn(parentTd)))
+                                    .metadata(meta)
+                                    .build());
+                        } else if (typeName.endsWith("Around") || typeName.endsWith("Before") || typeName.endsWith("After") || typeName.endsWith("AfterReturning") || typeName.endsWith("AfterThrowing")) {
+                            Map<String, String> meta = new HashMap<>();
+                            String value = extractAnnotationValue(annotation, "value");
+                            if (!value.isEmpty())
+                                meta.put("pointcut", value);
+                            else {
+                                String pointcut = extractAnnotationValue(annotation, "pointcut");
+                                if (!pointcut.isEmpty())
+                                    meta.put("pointcut", pointcut);
+                            }
+
+                            entryPoints.add(EntryPoint.builder()
+                                    .type(EntryPoint.Type.CUSTOM)
+                                    .name("@" + annotation.getTypeName().getFullyQualifiedName() + ": " + node.getName().getIdentifier())
+                                    .className(context.getFqn(parentTd))
+                                    .methodName(node.getName().getIdentifier())
+                                    .sourceFile(context.getRelativePath(context.getFqn(parentTd)))
+                                    .metadata(meta)
+                                    .build());
+                        }
+                    }
+                }
+                return super.visit(node);
+            }
+        });
+        return entryPoints;
+    }
+
+    private String extractAnnotationValue(Annotation annotation, String memberName) {
+        if (annotation instanceof SingleMemberAnnotation sma) {
+            if ("value".equals(memberName)) {
+                return sma.getValue().toString();
+            }
+        } else if (annotation instanceof NormalAnnotation na) {
+            for (Object pairObj : na.values()) {
+                MemberValuePair pair = (MemberValuePair) pairObj;
+                if (pair.getName().getIdentifier().equals(memberName)) {
+                    return pair.getValue().toString();
+                }
+            }
+        }
+        return "";
+    }
+}

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

@@ -0,0 +1,256 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.EntryPoint;
+import click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.jdt.core.dom.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
+@RequiredArgsConstructor
+public class SpringMvcDetector {
+    private final CodebaseContext context;
+    private final ConstantResolver constantResolver;
+
+    public List<EntryPoint> detect(CompilationUnit cu) {
+        List<EntryPoint> entryPoints = new ArrayList<>();
+        cu.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(TypeDeclaration node) {
+                if (isRestController(node)) {
+                    processController(node, entryPoints);
+                }
+                // Support WebFlux RouterFunction beans
+                processRouterFunctions(node, entryPoints);
+                return super.visit(node);
+            }
+        });
+        return entryPoints;
+    }
+
+    private void processRouterFunctions(TypeDeclaration td, List<EntryPoint> entryPoints) {
+        for (MethodDeclaration method : td.getMethods()) {
+            if (isBeanMethod(method) && method.getReturnType2() != null && method.getReturnType2().toString().contains("RouterFunction")) {
+                method.accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(MethodInvocation call) {
+                        String name = call.getName().getIdentifier();
+                        String verb = getHttpVerb(name);
+                        if (verb != null && !call.arguments().isEmpty()) {
+                            Expression pathArg = (Expression) call.arguments().get(0);
+                            String path = context.resolveExpression(pathArg);
+
+                            entryPoints.add(EntryPoint.builder()
+                                    .type(EntryPoint.Type.REST)
+                                    .name(verb + " " + path)
+                                    .className(context.getFqn(td))
+                                    .methodName(method.getName().getIdentifier())
+                                    .sourceFile(context.getRelativePath(context.getFqn(td)))
+                                    .metadata(Map.of("path", path, "verb", verb, "style", "WebFlux Functional"))
+                                    .build());
+                        }
+                        return super.visit(call);
+                    }
+                });
+            }
+        }
+    }
+
+    private boolean isBeanMethod(MethodDeclaration method) {
+        for (Object mod : method.modifiers()) {
+            if (mod instanceof Annotation ann && ann.getTypeName().getFullyQualifiedName().endsWith("Bean")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isRestController(TypeDeclaration node) {
+        for (Object modifier : node.modifiers()) {
+            if (modifier instanceof Annotation annotation) {
+                String name = annotation.getTypeName().getFullyQualifiedName();
+                if (name.endsWith("RestController") || name.endsWith("Controller") || name.endsWith("Path") || name.endsWith("RequestMapping")) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private void processController(TypeDeclaration controller, List<EntryPoint> entryPoints) {
+        String basePath = getMappingPathHierarchical(controller);
+        if (basePath.isEmpty()) {
+            basePath = getJaxRsPath(controller);
+        }
+
+        for (MethodDeclaration method : controller.getMethods()) {
+            EntryPoint ep = processMethodHierarchical(method, basePath, controller);
+            if (ep != null) {
+                entryPoints.add(ep);
+            }
+        }
+    }
+
+    private String getMappingPathHierarchical(TypeDeclaration td) {
+        String path = getMappingPath(td);
+        if (!path.isEmpty()) return path;
+
+        for (Object interfaceType : td.superInterfaceTypes()) {
+            TypeDeclaration itd = context.getTypeDeclaration(interfaceType.toString());
+            if (itd != null) {
+                path = getMappingPath(itd);
+                if (!path.isEmpty()) return path;
+            }
+        }
+
+        if (td.getSuperclassType() != null) {
+            TypeDeclaration std = context.getTypeDeclaration(td.getSuperclassType().toString());
+            if (std != null) {
+                return getMappingPathHierarchical(std);
+            }
+        }
+
+        return "";
+    }
+
+    private EntryPoint processMethodHierarchical(MethodDeclaration method, String basePath, TypeDeclaration controller) {
+        EntryPoint ep = processMethod(method, basePath, controller);
+        if (ep != null) return ep;
+
+        String methodName = method.getName().getIdentifier();
+        for (Object interfaceType : controller.superInterfaceTypes()) {
+            TypeDeclaration itd = context.getTypeDeclaration(interfaceType.toString());
+            if (itd != null) {
+                for (MethodDeclaration im : itd.getMethods()) {
+                    if (im.getName().getIdentifier().equals(methodName)) {
+                        ep = processMethod(im, basePath, controller);
+                        if (ep != null) return ep;
+                    }
+                }
+            }
+        }
+        
+        return null;
+    }
+
+    private EntryPoint processMethod(MethodDeclaration method, String basePath, TypeDeclaration controller) {
+        for (Object modifier : method.modifiers()) {
+            if (modifier instanceof Annotation annotation) {
+                String name = annotation.getTypeName().getFullyQualifiedName();
+                String verb = getHttpVerb(name);
+                if (verb != null) {
+                    String methodPath = getMappingPath(annotation);
+                    if (methodPath.isEmpty()) {
+                        methodPath = getJaxRsPath(method);
+                    }
+                    String fullPath = combinePaths(basePath, methodPath);
+                    
+                    Map<String, String> metadata = new HashMap<>();
+                    metadata.put("path", fullPath);
+                    metadata.put("verb", verb);
+
+                    List<EntryPoint.Parameter> parameters = extractParameters(method);
+
+                    return EntryPoint.builder()
+                            .type(EntryPoint.Type.REST)
+                            .name(verb + " " + fullPath)
+                            .className(context.getFqn(controller))
+                            .methodName(method.getName().getIdentifier())
+                            .sourceFile(context.getRelativePath(context.getFqn(controller)))
+                            .metadata(metadata)
+                            .parameters(parameters)
+                            .build();
+                }
+            }
+        }
+        return null;
+    }
+
+    private String getJaxRsPath(BodyDeclaration node) {
+        for (Object mod : node.modifiers()) {
+            if (mod instanceof Annotation ann && ann.getTypeName().getFullyQualifiedName().endsWith("Path")) {
+                return getMappingPath(ann);
+            }
+        }
+        return "";
+    }
+
+    private String getHttpVerb(String annotationName) {
+        if (annotationName.endsWith("PostMapping") || annotationName.endsWith("POST")) return "POST";
+        if (annotationName.endsWith("GetMapping") || annotationName.endsWith("GET")) return "GET";
+        if (annotationName.endsWith("PutMapping") || annotationName.endsWith("PUT")) return "PUT";
+        if (annotationName.endsWith("DeleteMapping") || annotationName.endsWith("DELETE")) return "DELETE";
+        if (annotationName.endsWith("PatchMapping") || annotationName.endsWith("PATCH")) return "PATCH";
+        if (annotationName.endsWith("RequestMapping")) return "REQUEST";
+        return null;
+    }
+
+    private String getMappingPath(TypeDeclaration td) {
+        for (Object modifier : td.modifiers()) {
+            if (modifier instanceof Annotation annotation) {
+                String name = annotation.getTypeName().getFullyQualifiedName();
+                if (name.endsWith("RequestMapping") || name.endsWith("Path")) {
+                    return getMappingPath(annotation);
+                }
+            }
+        }
+        return "";
+    }
+
+    private String getMappingPath(Annotation annotation) {
+        Expression value = null;
+        if (annotation instanceof SingleMemberAnnotation sma) {
+            value = sma.getValue();
+        } else if (annotation instanceof NormalAnnotation na) {
+            for (Object pairObj : na.values()) {
+                MemberValuePair pair = (MemberValuePair) pairObj;
+                if ("value".equals(pair.getName().getIdentifier()) || "path".equals(pair.getName().getIdentifier())) {
+                    value = pair.getValue();
+                    break;
+                }
+            }
+        }
+        
+        if (value != null) {
+            return context.resolveExpression(value);
+        }
+        return "";
+    }
+
+    private List<EntryPoint.Parameter> extractParameters(MethodDeclaration method) {
+        List<EntryPoint.Parameter> parameters = new ArrayList<>();
+        for (Object paramObj : method.parameters()) {
+            if (paramObj instanceof SingleVariableDeclaration param) {
+                List<String> annotations = new ArrayList<>();
+                for (Object mod : param.modifiers()) {
+                    if (mod instanceof Annotation ann) {
+                        String name = ann.getTypeName().getFullyQualifiedName();
+                        if (name.endsWith("PathParam")) name = "PathVariable";
+                        if (name.endsWith("QueryParam")) name = "RequestParam";
+                        annotations.add(name);
+                    }
+                }
+                parameters.add(EntryPoint.Parameter.builder()
+                        .name(param.getName().getIdentifier())
+                        .type(param.getType().toString())
+                        .annotations(annotations)
+                        .build());
+            }
+        }
+        return parameters;
+    }
+
+    private String combinePaths(String base, String method) {
+        String b = base.startsWith("/") ? base : "/" + base;
+        if (b.endsWith("/")) b = b.substring(0, b.length() - 1);
+        String m = method.startsWith("/") ? method : "/" + method;
+        if ("/".equals(m)) m = "";
+        return b + m;
+    }
+}

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

@@ -0,0 +1,148 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.eclipse.jdt.core.dom.*;
+import java.util.*;
+
+public class TypeResolver {
+    private final CodebaseContext context;
+
+    public TypeResolver(CodebaseContext context) {
+        this.context = context;
+    }
+
+    public int getParameterIndex(String methodFqn, String paramName) {
+        if (methodFqn == null || !methodFqn.contains(".")) return -1;
+        String className = methodFqn.substring(0, methodFqn.lastIndexOf('.'));
+        String methodName = methodFqn.substring(methodFqn.lastIndexOf('.') + 1);
+        TypeDeclaration td = context.getTypeDeclaration(className);
+        if (td != null) {
+            MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+            if (md != null) {
+                for (int i = 0; i < md.parameters().size(); i++) {
+                    SingleVariableDeclaration svd = (SingleVariableDeclaration) md.parameters().get(i);
+                    if (svd.getName().getIdentifier().equals(paramName)) {
+                        return i;
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+
+    public String getParameterName(String methodFqn, int index) {
+        if (methodFqn == null || !methodFqn.contains(".") || index < 0) return null;
+        String className = methodFqn.substring(0, methodFqn.lastIndexOf('.'));
+        String methodName = methodFqn.substring(methodFqn.lastIndexOf('.') + 1);
+        TypeDeclaration td = context.getTypeDeclaration(className);
+        if (td != null) {
+            MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+            if (md != null && index < md.parameters().size()) {
+                SingleVariableDeclaration svd = (SingleVariableDeclaration) md.parameters().get(index);
+                return svd.getName().getIdentifier();
+            }
+        }
+        return null;
+    }
+
+    public String getParameterType(String methodFqn, int index) {
+        if (methodFqn == null || !methodFqn.contains(".") || index < 0) return null;
+        String className = methodFqn.substring(0, methodFqn.lastIndexOf('.'));
+        String methodName = methodFqn.substring(methodFqn.lastIndexOf('.') + 1);
+        TypeDeclaration td = context.getTypeDeclaration(className);
+        if (td != null) {
+            MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+            if (md != null && index < md.parameters().size()) {
+                SingleVariableDeclaration svd = (SingleVariableDeclaration) md.parameters().get(index);
+                return svd.getType().toString();
+            }
+        }
+        return null;
+    }
+
+    public boolean isTypeCompatible(String actualType, String expectedType) {
+        if (actualType == null || expectedType == null) return true;
+        if (expectedType.equals("Object") || expectedType.equals("java.lang.Object")) return true;
+        if (actualType.equals("Object") || actualType.equals("java.lang.Object")) return true;
+        if (expectedType.length() == 1 && Character.isUpperCase(expectedType.charAt(0))) return true;
+        if (actualType.length() == 1 && Character.isUpperCase(actualType.charAt(0))) return true;
+        
+        String originalExpectedType = expectedType;
+
+        if (actualType.contains("<")) {
+            String rawType = actualType.substring(0, actualType.indexOf('<'));
+            if (rawType.equals("List") || rawType.equals("Set") || rawType.equals("Collection") || rawType.equals("Iterable") || rawType.endsWith("List") || rawType.endsWith("Set") || rawType.endsWith("Collection")) {
+                int start = actualType.indexOf('<');
+                int end = actualType.lastIndexOf('>');
+                if (start >= 0 && end > start) {
+                    actualType = actualType.substring(start + 1, end);
+                }
+            }
+        }
+        if (expectedType.contains("<")) {
+            String rawType = expectedType.substring(0, expectedType.indexOf('<'));
+            if (rawType.equals("List") || rawType.equals("Set") || rawType.equals("Collection") || rawType.equals("Iterable") || rawType.endsWith("List") || rawType.endsWith("Set") || rawType.endsWith("Collection")) {
+                int start = expectedType.indexOf('<');
+                int end = expectedType.lastIndexOf('>');
+                if (start >= 0 && end > start) {
+                    expectedType = expectedType.substring(start + 1, end);
+                }
+            }
+        }
+
+        if (actualType.contains("<")) {
+            actualType = actualType.substring(0, actualType.indexOf('<'));
+        }
+        if (expectedType.contains("<")) {
+            expectedType = expectedType.substring(0, expectedType.indexOf('<'));
+        }
+        
+        if (actualType.equals(expectedType)) return true;
+        if (actualType.endsWith("." + expectedType) || expectedType.endsWith("." + actualType)) return true;
+
+        AbstractTypeDeclaration td = context.getAbstractTypeDeclaration(actualType);
+        if (td != null) {
+            if (td instanceof TypeDeclaration typeDecl) {
+                String superFqn = context.getSuperclassFqn(typeDecl);
+                while (superFqn != null) {
+                    if (superFqn.contains("<")) {
+                        superFqn = superFqn.substring(0, superFqn.indexOf('<'));
+                    }
+                    if (superFqn.equals(expectedType) || superFqn.endsWith("." + expectedType) || expectedType.endsWith("." + superFqn)) return true;
+                    TypeDeclaration superTd = context.getTypeDeclaration(superFqn);
+                    superFqn = superTd != null ? context.getSuperclassFqn(superTd) : null;
+                }
+            }
+            List interfaces = java.util.Collections.emptyList();
+            if (td instanceof TypeDeclaration typeDecl) {
+                interfaces = typeDecl.superInterfaceTypes();
+            } else if (td instanceof EnumDeclaration enumDecl) {
+                interfaces = enumDecl.superInterfaceTypes();
+            } else if (td instanceof RecordDeclaration recordDecl) {
+                interfaces = recordDecl.superInterfaceTypes();
+            }
+            for (Object interfaceType : interfaces) {
+                String itStr = interfaceType.toString();
+                if (itStr.contains("<")) {
+                    itStr = itStr.substring(0, itStr.indexOf('<'));
+                }
+                if (itStr.equals(expectedType) || itStr.endsWith("." + expectedType) || expectedType.endsWith("." + itStr)) return true;
+            }
+        }
+
+        if (originalExpectedType.contains("<")) {
+            int start = originalExpectedType.indexOf('<');
+            int end = originalExpectedType.lastIndexOf('>');
+            if (start >= 0 && end > start) {
+                String sub = originalExpectedType.substring(start + 1, end);
+                for (String part : sub.split(",")) {
+                    String typeArg = part.trim();
+                    if (isTypeCompatible(actualType, typeArg)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,765 @@
+package click.kamil.springstatemachineexporter.analysis.service;
+
+import click.kamil.springstatemachineexporter.analysis.model.CallEdge;
+import click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.eclipse.jdt.core.dom.*;
+import java.util.*;
+
+public class VariableTracer {
+    private final CodebaseContext context;
+    private final ConstantResolver constantResolver;
+    private ConstantExtractor constantExtractor;
+
+    private final click.kamil.springstatemachineexporter.ast.common.DataFlowModel dataFlowModel;
+
+    public VariableTracer(CodebaseContext context, ConstantResolver constantResolver) {
+        this.context = context;
+        this.constantResolver = constantResolver;
+        this.dataFlowModel = new click.kamil.springstatemachineexporter.ast.common.JdtDataFlowModel(context);
+    }
+
+    public void setConstantExtractor(ConstantExtractor constantExtractor) {
+        this.constantExtractor = constantExtractor;
+    }
+
+    public Expression traceVariable(Expression expr) {
+        List<Expression> all = traceVariableAll(expr);
+        return all.isEmpty() ? expr : all.get(all.size() - 1);
+    }
+
+    private Expression peelExpression(Expression expr) {
+        while (expr instanceof ParenthesizedExpression pe) {
+            expr = pe.getExpression();
+        }
+        if (expr instanceof CastExpression ce) {
+            return peelExpression(ce.getExpression());
+        }
+        return expr;
+    }
+
+    public List<Expression> traceVariableAll(Expression expr) {
+        return dataFlowModel.getReachingDefinitions(expr);
+    }
+
+    public List<Expression> traceVariableAll(Expression expr, Set<String> visitedVariables) {
+        return dataFlowModel.getReachingDefinitions(expr);
+    }
+
+    public Expression traceLocalSetter(String methodFqn, String varName, String getterName) {
+        if (methodFqn == null || !methodFqn.contains(".")) return null;
+        String className = methodFqn.substring(0, methodFqn.lastIndexOf('.'));
+        String methodName = methodFqn.substring(methodFqn.lastIndexOf('.') + 1);
+        TypeDeclaration td = context.getTypeDeclaration(className);
+        if (td != null) {
+            MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+            if (md != null && md.getBody() != null) {
+                final Expression[] setterArg = new Expression[1];
+                String propName = getterName.startsWith("get") ? getterName.substring(3) : getterName;
+                md.getBody().accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(MethodInvocation node) {
+                        if (node.getName().getIdentifier().equalsIgnoreCase("set" + propName) || node.getName().getIdentifier().equalsIgnoreCase(propName)) {
+                            if (node.getExpression() instanceof SimpleName sn && sn.getIdentifier().equals(varName)) {
+                                if (!node.arguments().isEmpty()) {
+                                    setterArg[0] = (Expression) node.arguments().get(0);
+                                }
+                            }
+                        }
+                        return super.visit(node);
+                    }
+                    @Override
+                    public boolean visit(Assignment node) {
+                        if (node.getLeftHandSide() instanceof FieldAccess fa) {
+                            if (fa.getExpression() instanceof SimpleName faSn && faSn.getIdentifier().equals(varName)) {
+                                if (fa.getName().getIdentifier().equalsIgnoreCase(propName)) {
+                                    setterArg[0] = node.getRightHandSide();
+                                }
+                            }
+                        } else if (node.getLeftHandSide() instanceof QualifiedName qqn) {
+                            if (qqn.getQualifier().getFullyQualifiedName().equals(varName)) {
+                                if (qqn.getName().getIdentifier().equalsIgnoreCase(propName)) {
+                                    setterArg[0] = node.getRightHandSide();
+                                }
+                            }
+                        }
+                        return super.visit(node);
+                    }
+                });
+                return setterArg[0];
+            }
+        }
+        return null;
+    }
+
+    private String getFieldType(TypeDeclaration td, String fieldName, CodebaseContext context, java.util.Set<String> visited) {
+        if (td == null) return null;
+        String typeFqn = context.getFqn(td);
+        if (!visited.add(typeFqn)) return null;
+
+        for (FieldDeclaration fd : td.getFields()) {
+            for (Object fragObj : fd.fragments()) {
+                VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                if (frag.getName().getIdentifier().equals(fieldName)) {
+                    return fd.getType().toString();
+                }
+            }
+        }
+        
+        String superFqn = context.getSuperclassFqn(td);
+        if (superFqn != null) {
+            TypeDeclaration superTd = context.getTypeDeclaration(superFqn);
+            if (superTd != null) {
+                String result = getFieldType(superTd, fieldName, context, visited);
+                if (result != null) return result;
+            }
+        }
+        
+        for (Object intfObj : td.superInterfaceTypes()) {
+            Type intfType = (Type) intfObj;
+            String intfName = click.kamil.springstatemachineexporter.ast.common.AstUtils.extractSimpleTypeName(intfType);
+            String resolvedIntf = resolveTypeFqn(intfName, context, td);
+            if (resolvedIntf != null) {
+                TypeDeclaration intfTd = context.getTypeDeclaration(resolvedIntf);
+                if (intfTd != null) {
+                    String result = getFieldType(intfTd, fieldName, context, visited);
+                    if (result != null) return result;
+                }
+            }
+        }
+        
+        return null;
+    }
+    
+    private String resolveTypeFqn(String simpleName, CodebaseContext context, TypeDeclaration td) {
+        CompilationUnit cu = td.getRoot() instanceof CompilationUnit ? (CompilationUnit) td.getRoot() : null;
+        if (cu != null) {
+            for (Object impObj : cu.imports()) {
+                ImportDeclaration imp = (ImportDeclaration) impObj;
+                String name = imp.getName().getFullyQualifiedName();
+                if (name.endsWith("." + simpleName)) {
+                    return name;
+                }
+            }
+            if (cu.getPackage() != null) {
+                return cu.getPackage().getName().getFullyQualifiedName() + "." + simpleName;
+            }
+        }
+        return simpleName;
+    }
+
+    public String getVariableDeclaredType(String methodFqn, String cleanFieldName) {
+        if (methodFqn == null) return null;
+        int lastDot = methodFqn.lastIndexOf('.');
+        if (lastDot > 0) {
+            String fqn = methodFqn.substring(0, lastDot);
+            String methodName = methodFqn.substring(lastDot + 1);
+            TypeDeclaration td = context.getTypeDeclaration(fqn);
+            if (td != null) {
+                MethodDeclaration md = context.findMethodDeclaration(td, methodName, false);
+                if (md != null) {
+                    for (Object pObj : md.parameters()) {
+                        SingleVariableDeclaration svd = (SingleVariableDeclaration) pObj;
+                        if (svd.getName().getIdentifier().equals(cleanFieldName)) {
+                            return svd.getType().toString();
+                        }
+                    }
+                    final String[] foundType = new String[1];
+                    if (md.getBody() != null) {
+                        md.getBody().accept(new ASTVisitor() {
+                        @Override
+                        public boolean visit(VariableDeclarationStatement node) {
+                            for (Object fragObj : node.fragments()) {
+                                VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                                if (frag.getName().getIdentifier().equals(cleanFieldName)) {
+                                    foundType[0] = node.getType().toString();
+                                }
+                            }
+                            return super.visit(node);
+                        }
+                        
+                        @Override
+                        public boolean visit(LambdaExpression node) {
+                            for (Object paramObj : node.parameters()) {
+                                VariableDeclaration param = (VariableDeclaration) paramObj;
+                                if (param.getName().getIdentifier().equals(cleanFieldName)) {
+                                    if (param instanceof SingleVariableDeclaration svd && svd.getType() != null) {
+                                        foundType[0] = svd.getType().toString();
+                                        return false;
+                                    }
+                                    
+                                    ASTNode parent = node.getParent();
+                                    if (parent instanceof MethodInvocation mi) {
+                                        Expression caller = mi.getExpression();
+                                        
+                                        boolean hasMap = false;
+                                        while (caller instanceof MethodInvocation chainMi) {
+                                            String mName = chainMi.getName().getIdentifier();
+                                            if (mName.equals("map") || mName.equals("flatMap")) {
+                                                hasMap = true;
+                                                if (chainMi.arguments().size() == 1 && chainMi.arguments().get(0) instanceof LambdaExpression lambda) {
+                                                    if (lambda.getBody() instanceof MethodInvocation mapMi) {
+                                                        Expression mapCaller = mapMi.getExpression();
+                                                        if (mapCaller instanceof SimpleName mapSn) {
+                                                            String mapCallerType = getVariableDeclaredType(methodFqn, mapSn.getIdentifier());
+                                                            if (mapCallerType != null) {
+                                                                TypeDeclaration currentTd = context.getTypeDeclaration(methodFqn.substring(0, methodFqn.lastIndexOf('.')));
+                                                                CompilationUnit cu = currentTd != null && currentTd.getRoot() instanceof CompilationUnit ? (CompilationUnit) currentTd.getRoot() : null;
+                                                                TypeDeclaration td = context.getTypeDeclaration(mapCallerType, cu);
+                                                                if (td != null) {
+                                                                    MethodDeclaration mapMd = context.findMethodDeclaration(td, mapMi.getName().getIdentifier(), true);
+                                                                    if (mapMd != null && mapMd.getReturnType2() != null) {
+                                                                        foundType[0] = mapMd.getReturnType2().toString();
+                                                                        return false;
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            if (mName.equals("stream") || mName.equals("filter") || mName.equals("map") || 
+                                                mName.equals("flatMap") || mName.equals("peek") || mName.equals("distinct") || 
+                                                mName.equals("sorted") || mName.equals("limit") || mName.equals("skip")) {
+                                                caller = chainMi.getExpression();
+                                            } else {
+                                                break;
+                                            }
+                                        }
+                                        
+                                        if (!hasMap) {
+                                            if (caller instanceof SimpleName callerSn) {
+                                                String callerName = callerSn.getIdentifier();
+                                                if (!callerName.equals(cleanFieldName)) {
+                                                    String callerType = getVariableDeclaredType(methodFqn, callerName);
+                                                    if (callerType != null && callerType.contains("<")) {
+                                                        int start = callerType.indexOf('<');
+                                                        int end = callerType.lastIndexOf('>');
+                                                        if (start >= 0 && end > start) {
+                                                            foundType[0] = callerType.substring(start + 1, end);
+                                                            return false;
+                                                        }
+                                                    }
+                                                }
+                                            } else if (caller instanceof FieldAccess fa) {
+                                                String callerName = fa.getName().getIdentifier();
+                                                if (!callerName.equals(cleanFieldName)) {
+                                                    String callerType = getVariableDeclaredType(methodFqn, callerName);
+                                                    if (callerType != null && callerType.contains("<")) {
+                                                        int start = callerType.indexOf('<');
+                                                        int end = callerType.lastIndexOf('>');
+                                                        if (start >= 0 && end > start) {
+                                                            foundType[0] = callerType.substring(start + 1, end);
+                                                            return false;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            return super.visit(node);
+                        }
+                    });
+                }
+                if (foundType[0] != null) return foundType[0];
+            }
+            
+            // Fallback to fields including superclasses
+            String fieldType = getFieldType(td, cleanFieldName, context, new java.util.HashSet<>());
+            if (fieldType != null) return fieldType;
+        }
+    }
+        
+        // Final fallback: ask constantExtractor to resolve it via method return constant
+        if (constantExtractor != null && methodFqn.contains(".")) {
+            String className = methodFqn.substring(0, methodFqn.lastIndexOf('.'));
+            String methodName = methodFqn.substring(methodFqn.lastIndexOf('.') + 1);
+            TypeDeclaration td = context.getTypeDeclaration(className);
+            CompilationUnit cu = td != null && td.getRoot() instanceof CompilationUnit ? (CompilationUnit) td.getRoot() : null;
+            List<String> values = constantExtractor.resolveMethodReturnConstant(cleanFieldName, methodName, 0, new HashSet<>(), cu);
+            if (values != null && !values.isEmpty()) {
+                // If it resolves to some class constant, we could infer type or return a fallback
+                return null; 
+            }
+        }
+        return null;
+    }
+
+    public String traceLocalVariable(String methodFqn, String varName) {
+        if (methodFqn == null || !methodFqn.contains(".")) return null;
+        String className = methodFqn.substring(0, methodFqn.lastIndexOf('.'));
+        String methodName = methodFqn.substring(methodFqn.lastIndexOf('.') + 1);
+        TypeDeclaration td = context.getTypeDeclaration(className);
+        if (td != null) {
+            MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+            if (md != null && md.getBody() != null) {
+                List<Expression> initializers = new ArrayList<>();
+                md.getBody().accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(VariableDeclarationFragment node) {
+                        if (node.getName().getIdentifier().equals(varName) && node.getInitializer() != null) {
+                            initializers.add(peelExpression(node.getInitializer()));
+                        }
+                        return super.visit(node);
+                    }
+                    @Override
+                    public boolean visit(Assignment node) {
+                        if (node.getLeftHandSide() instanceof SimpleName asn && asn.getIdentifier().equals(varName)) {
+                            initializers.add(peelExpression(node.getRightHandSide()));
+                        }
+                        return super.visit(node);
+                    }
+                });
+                
+                if (!initializers.isEmpty()) {
+                    List<String> stringified = new ArrayList<>();
+                    for (Expression expr : initializers) {
+                        Expression traced = traceVariable(expr);
+                        if (traced instanceof MethodInvocation mi) {
+                            Expression innerMost = unwrapMethodInvocation(mi, 0, methodFqn);
+                            stringified.add(innerMost.toString());
+                        } else if (traced instanceof ArrayInitializer) {
+                            stringified.add("new Object[]" + traced.toString());
+                        } else {
+                            stringified.add(traced.toString());
+                        }
+                    }
+                    if (stringified.size() == 1) {
+                        return stringified.get(0).replaceAll("->\\s*yield\\s+", "-> ");
+                    }
+                    
+                    StringBuilder sb = new StringBuilder();
+                    for (int i = 0; i < stringified.size() - 1; i++) {
+                        sb.append("true ? ").append(stringified.get(i)).append(" : ");
+                    }
+                    sb.append(stringified.get(stringified.size() - 1));
+                    return sb.toString().replaceAll("->\\s*yield\\s+", "-> ");
+                }
+            }
+            
+            // If local variable not found, check field assignments
+            String cleanFieldName = varName.startsWith("this.") ? varName.substring(5) : varName;
+            final Expression[] fieldInitializer = new Expression[1];
+            ASTVisitor fieldVisitor = new ASTVisitor() {
+                @Override
+                public boolean visit(VariableDeclarationFragment node) {
+                    if (node.getName().getIdentifier().equals(cleanFieldName) && node.getInitializer() != null) {
+                        fieldInitializer[0] = node.getInitializer();
+                    }
+                    return super.visit(node);
+                }
+                @Override
+                public boolean visit(Assignment node) {
+                    Expression left = node.getLeftHandSide();
+                    if ((left instanceof SimpleName && ((SimpleName) left).getIdentifier().equals(cleanFieldName)) ||
+                        (left instanceof FieldAccess && ((FieldAccess) left).getName().getIdentifier().equals(cleanFieldName))) {
+                        fieldInitializer[0] = node.getRightHandSide();
+                    }
+                    return super.visit(node);
+                }
+            };
+            
+            for (FieldDeclaration fd : td.getFields()) {
+                for (Object fragObj : fd.fragments()) {
+                    VariableDeclarationFragment frag = (VariableDeclarationFragment) fragObj;
+                    if (frag.getName().getIdentifier().equals(cleanFieldName) && frag.getInitializer() != null) {
+                        fieldInitializer[0] = frag.getInitializer();
+                    }
+                }
+            }
+            if (fieldInitializer[0] != null) return fieldInitializer[0].toString();
+
+            for (MethodDeclaration classMd : td.getMethods()) {
+                if (classMd.isConstructor() && classMd.getBody() != null) {
+                    classMd.getBody().accept(fieldVisitor);
+                }
+            }
+            if (fieldInitializer[0] != null) return fieldInitializer[0].toString();
+            
+            for (MethodDeclaration classMd : td.getMethods()) {
+                if (!classMd.isConstructor() && classMd.getBody() != null) {
+                    classMd.getBody().accept(fieldVisitor);
+                }
+            }
+            if (fieldInitializer[0] != null) return fieldInitializer[0].toString();
+        }
+        return null;
+    }
+
+    public String traceLocalVariable(String methodFqn, String varName, Map<String, String> parameterValues) {
+        String result = traceLocalVariable(methodFqn, varName);
+        if (result != null && parameterValues != null && !parameterValues.isEmpty()) {
+            TypeDeclaration td = context.getTypeDeclaration(methodFqn.substring(0, methodFqn.lastIndexOf('.')));
+            if (td != null) {
+                String methodName = methodFqn.substring(methodFqn.lastIndexOf('.') + 1);
+                MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+                if (md != null && md.getBody() != null) {
+                    final ASTNode[] switchNode = new ASTNode[1];
+                    md.getBody().accept(new ASTVisitor() {
+                        @Override
+                        public boolean visit(VariableDeclarationFragment node) {
+                            if (node.getName().getIdentifier().equals(varName) && node.getInitializer() != null) {
+                                Expression init = node.getInitializer();
+                                if (init.getNodeType() == ASTNode.SWITCH_EXPRESSION) {
+                                    switchNode[0] = init;
+                                    return false;
+                                }
+                                if (init.getNodeType() == ASTNode.SWITCH_STATEMENT) {
+                                    switchNode[0] = init;
+                                    return false;
+                                }
+                            }
+                            return super.visit(node);
+                        }
+                        @Override
+                        public boolean visit(Assignment node) {
+                            if (node.getLeftHandSide() instanceof SimpleName asn && asn.getIdentifier().equals(varName)) {
+                                Expression rhs = node.getRightHandSide();
+                                if (rhs.getNodeType() == ASTNode.SWITCH_EXPRESSION) {
+                                    switchNode[0] = rhs;
+                                    return false;
+                                }
+                                if (rhs.getNodeType() == ASTNode.SWITCH_STATEMENT) {
+                                    switchNode[0] = rhs;
+                                    return false;
+                                }
+                            }
+                            return super.visit(node);
+                        }
+                    });
+                    if (switchNode[0] != null) {
+                        if (switchNode[0] instanceof SwitchExpression se) {
+                            String evaluated = constantResolver.evaluateSwitchWithParams(se, parameterValues, context);
+                            if (evaluated != null) return evaluated;
+                        } else if (switchNode[0] instanceof SwitchStatement ss) {
+                            String evaluated = constantResolver.evaluateSwitchWithParams(ss, parameterValues, context);
+                            if (evaluated != null) return evaluated;
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    public Map<String, String> buildParameterValuesMap(String caller, String target, Map<String, List<CallEdge>> callGraph, List<String> path, int pathIndex) {
+        Map<String, String> paramValues = new HashMap<>();
+        List<CallEdge> edges = callGraph.get(caller);
+        
+        boolean hasEdge = false;
+        if (edges != null) {
+            for (CallEdge edge : edges) {
+                if (edge.getTargetMethod().equals(target) || isHeuristicMatch(edge.getTargetMethod(), target)) {
+                    hasEdge = true;
+                    break;
+                }
+            }
+        }
+
+        // Bridge polymorphic interfaces to implementations without graph edges
+        if (!hasEdge) {
+            String callerSimple = caller.contains(".") ? caller.substring(caller.lastIndexOf('.') + 1) : caller;
+            String targetSimple = target.contains(".") ? target.substring(target.lastIndexOf('.') + 1) : target;
+            if (callerSimple.equals(targetSimple)) {
+                List<String> callerParams = getParameterNames(caller);
+                List<String> targetParams = getParameterNames(target);
+                if (callerParams != null && targetParams != null && callerParams.size() == targetParams.size()) {
+                    for (int i = 0; i < callerParams.size(); i++) {
+                        paramValues.put(targetParams.get(i), callerParams.get(i));
+                    }
+                    return paramValues;
+                }
+            }
+        }
+
+        if (edges == null) {
+            return paramValues;
+        }
+
+        // We also want to support heuristic matches using a helper if isHeuristicMatch is not directly available, but let's check
+        // We can check if name equals or if it resolves to target
+        for (CallEdge edge : edges) {
+            if (edge.getTargetMethod().equals(target) || isHeuristicMatch(edge.getTargetMethod(), target)) {
+                List<String> args = edge.getArguments();
+                if (args == null || args.isEmpty()) break;
+
+                int lastDot = target.lastIndexOf('.');
+                if (lastDot < 0) break;
+                String className = target.substring(0, lastDot);
+                String methodName = target.substring(lastDot + 1);
+
+                TypeDeclaration td = context.getTypeDeclaration(className);
+                if (td == null) break;
+
+                MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+                if (md == null) break;
+
+                List<String> paramNames = new ArrayList<>();
+                for (Object paramObj : md.parameters()) {
+                    SingleVariableDeclaration param = (SingleVariableDeclaration) paramObj;
+                    paramNames.add(param.getName().getIdentifier());
+                }
+
+                int minSize = Math.min(paramNames.size(), args.size());
+                for (int j = 0; j < minSize; j++) {
+                    String argValue = args.get(j);
+                    String resolvedArgValue = resolveArgumentValue(argValue, caller, path, pathIndex, callGraph);
+                    paramValues.put(paramNames.get(j), resolvedArgValue);
+                }
+                break;
+            }
+        }
+        return paramValues;
+    }
+
+    private List<String> getParameterNames(String methodFqn) {
+        int lastDot = methodFqn.lastIndexOf('.');
+        if (lastDot < 0) return null;
+        String className = methodFqn.substring(0, lastDot);
+        String methodName = methodFqn.substring(lastDot + 1);
+
+        TypeDeclaration td = context.getTypeDeclaration(className);
+        if (td == null) return null;
+
+        MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+        if (md == null) return null;
+
+        List<String> paramNames = new ArrayList<>();
+        for (Object paramObj : md.parameters()) {
+            SingleVariableDeclaration param = (SingleVariableDeclaration) paramObj;
+            paramNames.add(param.getName().getIdentifier());
+        }
+        return paramNames;
+    }
+
+    public String resolveArgumentValue(String argValue, String callerMethod, List<String> path, int pathIndex, Map<String, List<CallEdge>> callGraph) {
+        if (argValue == null) return null;
+        if (argValue.contains(".") || argValue.startsWith("new ") || argValue.matches(".*[0-9].*") || (argValue.startsWith("\"") && argValue.endsWith("\""))) {
+            return argValue;
+        }
+
+        String tracedLocal = traceLocalVariable(callerMethod, argValue);
+        if (tracedLocal != null && !tracedLocal.equals(argValue)) {
+            if (tracedLocal.contains(".") || tracedLocal.startsWith("new ") || tracedLocal.matches(".*[0-9].*") || tracedLocal.contains("(") || (tracedLocal.startsWith("\"") && tracedLocal.endsWith("\""))) {
+                return tracedLocal;
+            }
+            argValue = tracedLocal;
+        }
+
+        int callerIndex = path.indexOf(callerMethod);
+        if (callerIndex <= 0) return argValue;
+
+        String prevCaller = path.get(callerIndex - 1);
+        List<CallEdge> prevEdges = callGraph.get(prevCaller);
+        if (prevEdges == null) return argValue;
+
+        for (CallEdge edge : prevEdges) {
+            if (edge.getTargetMethod().equals(callerMethod) || isHeuristicMatch(edge.getTargetMethod(), callerMethod)) {
+                List<String> prevArgs = edge.getArguments();
+                if (prevArgs == null || prevArgs.isEmpty()) break;
+
+                int lastDot = callerMethod.lastIndexOf('.');
+                if (lastDot < 0) break;
+                String className = callerMethod.substring(0, lastDot);
+                String methodName = callerMethod.substring(lastDot + 1);
+
+                TypeDeclaration td = context.getTypeDeclaration(className);
+                if (td == null) break;
+
+                MethodDeclaration md = context.findMethodDeclaration(td, methodName, true);
+                if (md == null) break;
+
+                List<String> paramNames = new ArrayList<>();
+                for (Object paramObj : md.parameters()) {
+                    SingleVariableDeclaration param = (SingleVariableDeclaration) paramObj;
+                    paramNames.add(param.getName().getIdentifier());
+                }
+
+                int paramIdx = paramNames.indexOf(argValue);
+                if (paramIdx >= 0 && paramIdx < prevArgs.size()) {
+                    String prevArg = prevArgs.get(paramIdx);
+                    return resolveArgumentValue(prevArg, prevCaller, path, pathIndex, callGraph);
+                }
+                break;
+            }
+        }
+        return argValue;
+    }
+
+    private boolean isHeuristicMatch(String neighbor, String target) {
+        if (neighbor == null || target == null) return false;
+        if (neighbor.equals(target)) return true;
+
+        if (neighbor.contains(".") && target.contains(".")) {
+            String methodNeighbor = neighbor.substring(neighbor.lastIndexOf('.') + 1);
+            String methodTarget = target.substring(target.lastIndexOf('.') + 1);
+            if (!methodNeighbor.equals(methodTarget)) return false;
+
+            String classNeighbor = neighbor.substring(0, neighbor.lastIndexOf('.'));
+            String classTarget = target.substring(0, target.lastIndexOf('.'));
+            if (classNeighbor.equals(classTarget)) return true;
+
+            String simpleClassNeighbor = classNeighbor.contains(".") ? classNeighbor.substring(classNeighbor.lastIndexOf('.') + 1) : classNeighbor;
+            String simpleClassTarget = classTarget.contains(".") ? classTarget.substring(classTarget.lastIndexOf('.') + 1) : classTarget;
+            if (simpleClassNeighbor.equals(simpleClassTarget)) return true;
+
+            List<String> impls = context.getImplementations(classTarget);
+            if (impls != null) {
+                for (String impl : impls) {
+                    if (impl.equals(classNeighbor) || impl.endsWith("." + classNeighbor)) return true;
+                }
+            }
+
+            List<String> implsN = context.getImplementations(classNeighbor);
+            if (implsN != null) {
+                for (String impl : implsN) {
+                    if (impl.equals(classTarget) || impl.endsWith("." + classTarget)) return true;
+                }
+            }
+            return false;
+        }
+
+        String simpleTarget = target.contains(".") ? target.substring(target.lastIndexOf('.') + 1) : target;
+        String simpleNeighbor = neighbor.contains(".") ? neighbor.substring(neighbor.lastIndexOf('.') + 1) : neighbor;
+        if (!simpleNeighbor.equals(simpleTarget)) return false;
+        
+        String classNeighbor = neighbor.contains(".") ? neighbor.substring(0, neighbor.lastIndexOf('.')) : null;
+        String classTarget = target.contains(".") ? target.substring(0, target.lastIndexOf('.')) : null;
+        String simpleClassTarget = classTarget != null && classTarget.contains(".") ? classTarget.substring(classTarget.lastIndexOf('.') + 1) : classTarget;
+        String simpleClassNeighbor = classNeighbor != null && classNeighbor.contains(".") ? classNeighbor.substring(classNeighbor.lastIndexOf('.') + 1) : classNeighbor;
+
+        if (simpleClassNeighbor != null && simpleClassTarget != null) {
+            if (simpleClassNeighbor.equalsIgnoreCase(simpleClassTarget)) return true;
+            if (simpleClassNeighbor.equals("this") || simpleClassNeighbor.equals("super")) return true;
+            return false;
+        }
+        
+        return true;
+    }
+
+    private MethodDeclaration findEnclosingMethod(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof MethodDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (MethodDeclaration) parent;
+    }
+
+    private TypeDeclaration findEnclosingType(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof TypeDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (TypeDeclaration) parent;
+    }
+
+    private Expression unwrapMethodInvocation(MethodInvocation mi, int depth, String methodFqn) {
+        if (depth > 5) return mi;
+        
+        String targetMethodFqn = resolveTargetMethodFqn(mi, methodFqn);
+        if (targetMethodFqn != null && targetMethodFqn.contains(".")) {
+            String className = targetMethodFqn.substring(0, targetMethodFqn.lastIndexOf('.'));
+            String methodName = targetMethodFqn.substring(targetMethodFqn.lastIndexOf('.') + 1);
+            
+            TypeDeclaration currentTd = methodFqn != null && methodFqn.contains(".") ? context.getTypeDeclaration(methodFqn.substring(0, methodFqn.lastIndexOf('.'))) : null;
+            CompilationUnit cu = currentTd != null && currentTd.getRoot() instanceof CompilationUnit ? (CompilationUnit) currentTd.getRoot() : null;
+            
+            TypeDeclaration td = context.getTypeDeclaration(className, cu);
+            if (td != null) {
+                MethodDeclaration localMd = context.findMethodDeclaration(td, methodName, true);
+                if (localMd != null) {
+                    int paramIdx = getReturnedParameterIndex(localMd);
+                    if (paramIdx >= 0 && paramIdx < mi.arguments().size()) {
+                        Expression arg = peelExpression((Expression) mi.arguments().get(paramIdx));
+                        if (arg instanceof MethodInvocation innerMi) {
+                            return unwrapMethodInvocation(innerMi, depth + 1, methodFqn);
+                        }
+                        return arg;
+                    }
+                }
+            }
+        }
+        
+        if (mi.getExpression() != null) {
+            String exprStr = mi.getExpression().toString();
+            if (!exprStr.equals("Optional") && !exprStr.equals("Stream") && !exprStr.equals("List") && !exprStr.equals("Set") && !exprStr.equals("Arrays") && !exprStr.equals("Objects") && !exprStr.equals("Mono") && !exprStr.equals("Flux")) {
+                return mi;
+            }
+        }
+        
+        if (!mi.arguments().isEmpty()) {
+            String mName = mi.getName().getIdentifier();
+            String lowerName = mName.toLowerCase();
+            
+            if (lowerName.startsWith("map") || lowerName.startsWith("parse") || 
+                lowerName.startsWith("convert") || lowerName.startsWith("to") || 
+                lowerName.startsWith("resolve") || lowerName.startsWith("build") || 
+                lowerName.startsWith("create") || lowerName.startsWith("from") ||
+                lowerName.startsWith("transform") || lowerName.startsWith("translate") ||
+                lowerName.startsWith("derive") || lowerName.startsWith("determine") ||
+                lowerName.startsWith("calculate") || lowerName.startsWith("decode") ||
+                lowerName.startsWith("extract") || lowerName.startsWith("get") ||
+                lowerName.startsWith("find") || lowerName.startsWith("validate")) {
+                return mi;
+            }
+            
+            Expression arg = peelExpression((Expression) mi.arguments().get(0));
+            if (arg instanceof MethodInvocation innerMi) {
+                return unwrapMethodInvocation(innerMi, depth + 1, methodFqn);
+            }
+            return arg;
+        }
+        return mi;
+    }
+    
+    private String resolveTargetMethodFqn(MethodInvocation mi, String currentMethodFqn) {
+        if (currentMethodFqn == null || !currentMethodFqn.contains(".")) return null;
+        String currentClass = currentMethodFqn.substring(0, currentMethodFqn.lastIndexOf('.'));
+        if (mi.getExpression() == null || mi.getExpression().toString().equals("this")) {
+            return currentClass + "." + mi.getName().getIdentifier();
+        }
+        if (mi.getExpression() instanceof SimpleName sn) {
+            String declaredType = getVariableDeclaredType(currentMethodFqn, sn.getIdentifier());
+            if (declaredType != null) {
+                return declaredType + "." + mi.getName().getIdentifier();
+            }
+        } else if (mi.getExpression() instanceof FieldAccess fa) {
+            String declaredType = getVariableDeclaredType(currentMethodFqn, fa.getName().getIdentifier());
+            if (declaredType != null) {
+                return declaredType + "." + mi.getName().getIdentifier();
+            }
+        }
+        return null;
+    }
+
+    private int getReturnedParameterIndex(MethodDeclaration md) {
+        if (md.getBody() == null) return -1;
+        List<?> parameters = md.parameters();
+        if (parameters.isEmpty()) return -1;
+        
+        final List<String> returnedExprs = new ArrayList<>();
+        md.getBody().accept(new ASTVisitor() {
+            @Override
+            public boolean visit(ReturnStatement node) {
+                if (node.getExpression() != null) {
+                    returnedExprs.add(node.getExpression().toString());
+                }
+                return super.visit(node);
+            }
+        });
+        
+        if (returnedExprs.size() == 1) {
+            String retStr = returnedExprs.get(0);
+            for (int i = 0; i < parameters.size(); i++) {
+                if (parameters.get(i) instanceof SingleVariableDeclaration svd) {
+                    if (svd.getName().getIdentifier().equals(retStr)) {
+                        return i;
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+}

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,280 @@
+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, node)) {
+            SpringBean bean = SpringBean.builder()
+                    .typeFqn(typeBinding.getQualifiedName())
+                    .assignableTypes(getAssignableTypes(typeBinding))
+                    .isPrimary(hasPrimary(typeBinding, node))
+                    .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(hasPrimaryMethod(methodBinding, node))
+                        .qualifiers(extractQualifiers(methodBinding))
+                        .order(extractOrder(methodBinding))
+                        .declaringClassFqn(methodBinding.getDeclaringClass() != null ? methodBinding.getDeclaringClass().getQualifiedName() : null)
+                        .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, TypeDeclaration node) {
+        if (hasMetaAnnotation(binding, "org.springframework.stereotype.Component") ||
+               hasMetaAnnotation(binding, "org.springframework.web.bind.annotation.RestController") ||
+               hasAnnotation(binding, "org.springframework.stereotype.Component") ||
+               hasAnnotation(binding, "org.springframework.stereotype.Service") ||
+               hasAnnotation(binding, "org.springframework.stereotype.Repository") ||
+               hasAnnotation(binding, "org.springframework.stereotype.Controller") ||
+               hasAnnotation(binding, "org.springframework.web.bind.annotation.RestController") ||
+               hasAnnotation(binding, "org.springframework.context.annotation.Configuration")) {
+            return true;
+        }
+        for (Object modObj : node.modifiers()) {
+            if (modObj instanceof Annotation ann) {
+                String name = ann.getTypeName().getFullyQualifiedName();
+                if (name.equals("Component") || name.equals("Service") || name.equals("Repository") ||
+                    name.equals("Controller") || name.equals("RestController") || name.equals("Configuration")) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean hasPrimary(ITypeBinding binding, TypeDeclaration node) {
+        if (hasAnnotation(binding, "org.springframework.context.annotation.Primary")) return true;
+        for (Object modObj : node.modifiers()) {
+            if (modObj instanceof Annotation ann) {
+                String name = ann.getTypeName().getFullyQualifiedName();
+                if (name.equals("Primary")) return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean hasPrimaryMethod(IMethodBinding binding, MethodDeclaration node) {
+        if (hasAnnotation(binding, "org.springframework.context.annotation.Primary")) return true;
+        for (Object modObj : node.modifiers()) {
+            if (modObj instanceof Annotation ann) {
+                String name = ann.getTypeName().getFullyQualifiedName();
+                if (name.equals("Primary")) return true;
+            }
+        }
+        return false;
+    }
+    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()) {
+            if (ann.getAnnotationType() == null) continue;
+            String fqn = ann.getAnnotationType().getQualifiedName();
+            if (checkMetaAnnotation(new IAnnotationBinding[]{ann}, "org.springframework.stereotype.Component", new HashSet<>()) ||
+                "org.springframework.stereotype.Component".equals(fqn) ||
+                "org.springframework.stereotype.Service".equals(fqn) ||
+                "org.springframework.stereotype.Repository".equals(fqn) ||
+                "org.springframework.stereotype.Controller".equals(fqn) ||
+                "org.springframework.web.bind.annotation.RestController".equals(fqn) ||
+                "org.springframework.context.annotation.Configuration".equals(fqn)) {
+                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,90 @@
+package click.kamil.springstatemachineexporter.analysis.spring;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+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<>();
+        log.debug("RESOLVING {} qual={} injectionName={}", requiredTypeFqn, qualifier, injectionName);
+
+        // 1. Filter by Type (Exact FQN or Assignable Type)
+        List<SpringBean> candidates = registry.getBeans().stream()
+                .filter(bean -> requiredTypeFqn.equals(bean.getTypeFqn()) || bean.getAssignableTypes().contains(requiredTypeFqn))
+                .collect(Collectors.toList());
+
+        log.debug("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) {
+            log.debug("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)
+        log.debug("RETURNING: {}", candidates.size());
+        return candidates;
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/analysis/util/PlaceholderResolver.java

@@ -0,0 +1,72 @@
+package click.kamil.springstatemachineexporter.analysis.util;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Utility for resolving Spring-style placeholders like ${property.name} or ${property.name:default-value}.
+ * Supports recursive resolution.
+ */
+@Slf4j
+public class PlaceholderResolver {
+
+    private static final Pattern PLACEHOLDER_PATTERN = Pattern.compile("\\$\\{([^:}]+)(?::([^}]*))?}");
+
+    /**
+     * Resolves all placeholders in the given text using the provided properties map.
+     *
+     * @param text       The text containing placeholders.
+     * @param properties The map of property keys and values.
+     * @return The resolved string.
+     */
+    public static String resolve(String text, Map<String, String> properties) {
+        return resolveInternal(text, properties, new HashSet<>());
+    }
+
+    private static String resolveInternal(String text, Map<String, String> properties, Set<String> visited) {
+        if (text == null || !text.contains("${")) {
+            return text;
+        }
+
+        StringBuilder result = new StringBuilder();
+        Matcher matcher = PLACEHOLDER_PATTERN.matcher(text);
+        int lastMatchEnd = 0;
+
+        while (matcher.find()) {
+            result.append(text, lastMatchEnd, matcher.start());
+            String key = matcher.group(1);
+            String defaultValue = matcher.group(2);
+
+            if (visited.contains(key)) {
+                log.warn("Circular placeholder reference detected: {}", key);
+                result.append(matcher.group(0)); // Keep as is
+            } else {
+                String value = properties.get(key);
+                if (value == null) {
+                    value = defaultValue;
+                }
+
+                if (value != null) {
+                    visited.add(key);
+                    try {
+                        result.append(resolveInternal(value, properties, visited));
+                    } finally {
+                        visited.remove(key);
+                    }
+                } else {
+                    log.debug("Property not found and no default value for: {}", key);
+                    result.append(matcher.group(0)); // Keep as is if not resolvable
+                }
+            }
+            lastMatchEnd = matcher.end();
+        }
+        result.append(text.substring(lastMatchEnd));
+
+        return result.toString();
+    }
+}

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

@@ -1,20 +1,14 @@
 package click.kamil.springstatemachineexporter.ast.app;
 
+import click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver;
 import click.kamil.springstatemachineexporter.model.Action;
 import click.kamil.springstatemachineexporter.model.Guard;
 import click.kamil.springstatemachineexporter.model.State;
+import click.kamil.springstatemachineexporter.model.Event;
 import click.kamil.springstatemachineexporter.model.Transition;
 import click.kamil.springstatemachineexporter.model.TransitionType;
 import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
-import org.eclipse.jdt.core.dom.ASTVisitor;
-import org.eclipse.jdt.core.dom.ClassInstanceCreation;
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.dom.Expression;
-import org.eclipse.jdt.core.dom.LambdaExpression;
-import org.eclipse.jdt.core.dom.MethodDeclaration;
-import org.eclipse.jdt.core.dom.MethodInvocation;
-import org.eclipse.jdt.core.dom.SimpleName;
-
+import org.eclipse.jdt.core.dom.*;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -24,8 +18,11 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
+import lombok.extern.slf4j.Slf4j;
 
+@Slf4j
 public class AstTransitionParser {
+    private static final ConstantResolver constantResolver = new ConstantResolver();
 
     private static final Set<String> SUPPORTED_TRANSITION_METHOD_NAMES = Arrays.stream(TransitionType.values())
             .map(TransitionType::getMethodName)
@@ -173,15 +170,15 @@ public class AstTransitionParser {
                 Expression secondArg = resolveArg((Expression) args.get(1), argsMap);
                 if ("last".equals(methodName)) {
                     // For 'last', the second argument is an action, not a guard
-                    parseAction(secondArg, t);
+                    parseAction(secondArg, t, cu, context);
                 } else {
                     // For 'first' and 'then', the second argument is a guard
-                    parseGuard(secondArg, t);
+                    parseGuard(secondArg, t, cu, context);
                 }
             }
             if (args.size() > 2) {
                 Expression thirdArg = resolveArg((Expression) args.get(2), argsMap);
-                parseAction(thirdArg, t);
+                parseAction(thirdArg, t, cu, context);
             }
             t.setOrder(orderCounter++);
             transitions.add(t);
@@ -215,32 +212,344 @@ public class AstTransitionParser {
                 });
                  case "event" -> {
                     Expression resolved = resolveArg((Expression) args.get(0), argsMap);
-                    t.setEvent(QuotedExpression.of(resolved).toStringWithoutQuotes());
+                    String eventValue = constantResolver.resolve(resolved, context);
+                    if (eventValue != null) {
+                        t.setEvent(Event.of(resolved.toString(), eventValue));
+                    } else if (resolved instanceof QualifiedName qn) {
+                        String qualifier = qn.getQualifier().toString();
+                        String name = qn.getName().getIdentifier();
+                        TypeDeclaration td = context.getTypeDeclaration(qualifier, cu);
+                        if (td != null) {
+                            t.setEvent(Event.of(resolved.toString(), context.getFqn(td) + "." + name));
+                        } else {
+                            t.setEvent(Event.of(resolved.toString(), qn.getFullyQualifiedName()));
                         }
-                case "guard" -> {
+                    } else if (resolved instanceof SimpleName sn) {
+                        String name = sn.getIdentifier();
+                        String full = name;
+                        for (Object impObj : cu.imports()) {
+                            ImportDeclaration imp = (ImportDeclaration) impObj;
+                            String impName = imp.getName().getFullyQualifiedName();
+                            if (impName.endsWith("." + name)) {
+                                full = impName;
+                                break;
+                            }
+                        }
+                        t.setEvent(Event.of(resolved.toString(), full));
+                    } else {
+                        t.setEvent(Event.of(QuotedExpression.of(resolved).toStringWithoutQuotes()));
+                    }
+                    if (args.size() > 1) {
+                        Expression actionArg = resolveArg((Expression) args.get(1), argsMap);
+                        parseAction(actionArg, t, cu, context);
+                    }
+                }
+                case "guard", "guardExpression" -> {
                     Expression resolved = resolveArg((Expression) args.get(0), argsMap);
-                    parseGuard(resolved, t);
+                    parseGuard(resolved, t, cu, context);
+                }
+                case "guards" -> {
+                    args.forEach(arg -> {
+                        Expression resolved = resolveArg((Expression) arg, argsMap);
+                        parseGuard(resolved, t, cu, context);
+                    });
                 }
                 case "action" -> {
                     Expression resolved = resolveArg((Expression) args.get(0), argsMap);
-                    parseAction(resolved, t);
+                    parseAction(resolved, t, cu, context);
+                }
+                case "actions" -> {
+                    args.forEach(arg -> {
+                        Expression resolved = resolveArg((Expression) arg, argsMap);
+                        parseAction(resolved, t, cu, context);
+                    });
+                }
+                case "timer", "timerOnce" -> {
+                    Expression resolved = resolveArg((Expression) args.get(0), argsMap);
+                    t.setEvent(Event.of(methodName + "(" + resolved.toString() + ")", methodName + "(" + resolved.toString() + ")"));
                 }
             }
         }
         return t;
     }
 
-    private static void parseGuard(Object arg, Transition t) {
-        QuotedExpression quotedExpr = QuotedExpression.of(arg);
-        if (quotedExpr != null) {
-            t.setGuard(Guard.of(quotedExpr.toStringWithoutQuotes(), isLambdaOrAnonymous(quotedExpr.getExpression())));
+    private static String extractInternalLogic(Expression expr, CompilationUnit cu, CodebaseContext context) {
+        if (expr == null) return null;
+
+        // 1. Lambda Expressions
+        if (expr instanceof LambdaExpression le) {
+            return le.toString();
+        }
+
+        // 2. Anonymous Classes
+        if (expr instanceof ClassInstanceCreation cic && cic.getAnonymousClassDeclaration() != null) {
+            return cic.toString();
+        }
+
+        // 3. Method Invocations
+        if (expr instanceof MethodInvocation mi) {
+            IMethodBinding binding = mi.resolveMethodBinding();
+            if (binding != null) {
+                // Try to resolve deeper logic from the return type (e.g., a Bean returning an Action interface)
+                ITypeBinding returnType = binding.getReturnType();
+                if (returnType != null) {
+                    String returnFqn = returnType.getTypeDeclaration().getQualifiedName();
+                    TypeDeclaration returnTd = context.getTypeDeclaration(returnFqn);
+                    if (returnTd != null) {
+                        for (MethodDeclaration rmd : returnTd.getMethods()) {
+                            String name = rmd.getName().getIdentifier();
+                            if (name.equals("execute") || name.equals("evaluate")) {
+                                return rmd.toString();
+                            }
+                        }
                     }
                 }
 
-    private static void parseAction(Object arg, Transition t) {
+                // 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();
+                }
+
+                // Try other files via CodebaseContext
+                ITypeBinding declaringClass = binding.getDeclaringClass();
+                if (declaringClass != null) {
+                    String fqn = declaringClass.getTypeDeclaration().getQualifiedName();
+                    TypeDeclaration td = context.getTypeDeclaration(fqn);
+                    if (td != null) {
+                        for (MethodDeclaration md : td.getMethods()) {
+                            if (md.getName().getIdentifier().equals(binding.getName()) &&
+                                    md.parameters().size() == binding.getParameterTypes().length) {
+                                
+                                // Special case: if it's a getter/factory for Action/Guard, look into the return statement
+                                if (md.getBody() != null) {
+                                    if (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();
+                            }
+                        }
+                    }
+                }
+            } else {
+                // FALLBACK: Manual resolution by name if binding failed
+                TypeDeclaration currentClass = findEnclosingType(mi);
+                if (currentClass != null) {
+                    return resolveMethodManually(mi.getName().getIdentifier(), currentClass, context);
+                }
+            }
+        }
+
+        // 4. Method References
+        if (expr instanceof MethodReference mr) {
+            IMethodBinding binding = mr.resolveMethodBinding();
+            if (binding != null) {
+                ITypeBinding declaringClass = binding.getDeclaringClass();
+                if (declaringClass != null) {
+                    String fqn = declaringClass.getTypeDeclaration().getQualifiedName();
+                    TypeDeclaration td = context.getTypeDeclaration(fqn);
+                    if (td != null) {
+                        for (MethodDeclaration md : td.getMethods()) {
+                            if (md.getName().getIdentifier().equals(binding.getName()) &&
+                                    md.parameters().size() == binding.getParameterTypes().length) {
+                                return md.toString();
+                            }
+                        }
+                    }
+                }
+            }
+            return mr.toString();
+        }
+
+        // 5. Bean Reference (SimpleName, FieldAccess, etc.)
+        String resolvedBeanBody = resolveBeanClassBody(expr, context);
+        if (resolvedBeanBody != null) {
+            return resolvedBeanBody;
+        }
+
+        return null;
+    }
+
+    private static String resolveBeanClassBody(Expression expr, CodebaseContext context) {
+        String typeFqn = null;
+        ITypeBinding binding = expr.resolveTypeBinding();
+        if (binding != null) {
+            typeFqn = binding.getQualifiedName();
+        } else if (expr instanceof SimpleName sn) {
+            // Check enclosing method first for local variables
+            MethodDeclaration enclosingMethod = findEnclosingMethod(expr);
+            if (enclosingMethod != null) {
+                final String[] foundType = {null};
+                final Expression[] foundInitializer = {null};
+                enclosingMethod.accept(new ASTVisitor() {
+                    @Override
+                    public boolean visit(VariableDeclarationStatement vds) {
+                        for (Object fragObj : vds.fragments()) {
+                            if (fragObj instanceof VariableDeclarationFragment fragment) {
+                                if (fragment.getName().getIdentifier().equals(sn.getIdentifier())) {
+                                    foundType[0] = vds.getType().toString();
+                                    foundInitializer[0] = fragment.getInitializer();
+                                }
+                            }
+                        }
+                        return super.visit(vds);
+                    }
+                });
+                if (foundInitializer[0] != null) {
+                    ASTNode root = expr.getRoot();
+                    if (root instanceof CompilationUnit cu) {
+                        String initLogic = extractInternalLogic(foundInitializer[0], cu, context);
+                        if (initLogic != null) return initLogic;
+                    }
+                }
+                if (foundType[0] != null) {
+                    typeFqn = foundType[0];
+                }
+            }
+
+            if (typeFqn == null) {
+                TypeDeclaration enclosingClass = findEnclosingType(expr);
+                if (enclosingClass != null) {
+                    for (FieldDeclaration fd : enclosingClass.getFields()) {
+                        for (Object fragObj : fd.fragments()) {
+                            if (fragObj instanceof VariableDeclarationFragment fragment) {
+                                if (fragment.getName().getIdentifier().equals(sn.getIdentifier())) {
+                                    if (fragment.getInitializer() != null) {
+                                        ASTNode root = expr.getRoot();
+                                        if (root instanceof CompilationUnit cu) {
+                                            String initLogic = extractInternalLogic(fragment.getInitializer(), cu, context);
+                                            if (initLogic != null) return initLogic;
+                                        }
+                                    }
+                                    typeFqn = fd.getType().toString();
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (typeFqn != null) {
+            if (typeFqn.contains("<")) {
+                typeFqn = typeFqn.substring(0, typeFqn.indexOf('<'));
+            }
+            TypeDeclaration beanTd = context.getTypeDeclaration(typeFqn);
+            if (beanTd == null) {
+                ASTNode root = expr.getRoot();
+                if (root instanceof CompilationUnit cu) {
+                    for (Object impObj : cu.imports()) {
+                        ImportDeclaration imp = (ImportDeclaration) impObj;
+                        if (!imp.isStatic() && !imp.isOnDemand()) {
+                            String impName = imp.getName().getFullyQualifiedName();
+                            if (impName.endsWith("." + typeFqn)) {
+                                beanTd = context.getTypeDeclaration(impName);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (beanTd != null) {
+                for (MethodDeclaration md : beanTd.getMethods()) {
+                    String name = md.getName().getIdentifier();
+                    if ("evaluate".equals(name) || "execute".equals(name)) {
+                        return md.toString();
+                    }
+                }
+                return beanTd.toString();
+            }
+        }
+        return null;
+    }
+
+    private static MethodDeclaration findEnclosingMethod(ASTNode node) {
+        ASTNode current = node;
+        while (current != null) {
+            if (current instanceof MethodDeclaration md) return md;
+            current = current.getParent();
+        }
+        return null;
+    }
+
+    private static String resolveMethodManually(String methodName, TypeDeclaration td, CodebaseContext context) {
+        // Search in this class
+        for (MethodDeclaration md : td.getMethods()) {
+            if (md.getName().getIdentifier().equals(methodName)) {
+                // Found it. Apply the return-statement-extraction logic here too
+                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();
+            }
+        }
+        
+        // Search in superclass
+        if (td.getSuperclassType() != null) {
+            String superName = td.getSuperclassType().toString();
+            // Try to resolve simple name to FQN if possible, or just search by simple name
+            TypeDeclaration superTd = context.getTypeDeclaration(superName);
+            if (superTd != null) {
+                return resolveMethodManually(methodName, superTd, context);
+            }
+        }
+        
+        return null;
+    }
+
+    private static TypeDeclaration findEnclosingType(ASTNode node) {
+        ASTNode current = node;
+        while (current != null) {
+            if (current instanceof TypeDeclaration td) return td;
+            current = current.getParent();
+        }
+        return null;
+    }
+
+    private static void parseGuard(Object arg, Transition t, CompilationUnit cu, CodebaseContext context) {
         QuotedExpression quotedExpr = QuotedExpression.of(arg);
         if (quotedExpr != null) {
-            t.getActions().add(Action.of(quotedExpr.toStringWithoutQuotes(), isLambdaOrAnonymous(quotedExpr.getExpression())));
+            String internalLogic = extractInternalLogic(quotedExpr.getExpression(), cu, context);
+            int lineNumber = cu.getLineNumber(quotedExpr.getExpression().getStartPosition());
+            TypeDeclaration td = findEnclosingType(quotedExpr.getExpression());
+            String fqn = td != null ? context.getFqn(td) : null;
+            String sourceFile = fqn != null ? context.getRelativePath(fqn) : null;
+            t.getGuards().add(Guard.of(quotedExpr.toStringWithoutQuotes(), isLambdaOrAnonymous(quotedExpr.getExpression()), internalLogic, lineNumber, fqn, sourceFile));
+        }
+    }
+
+    private static void parseAction(Object arg, Transition t, CompilationUnit cu, CodebaseContext context) {
+        QuotedExpression quotedExpr = QuotedExpression.of(arg);
+        if (quotedExpr != null) {
+            String internalLogic = extractInternalLogic(quotedExpr.getExpression(), cu, context);
+            int lineNumber = cu.getLineNumber(quotedExpr.getExpression().getStartPosition());
+            TypeDeclaration td = findEnclosingType(quotedExpr.getExpression());
+            String fqn = td != null ? context.getFqn(td) : null;
+            String sourceFile = fqn != null ? context.getRelativePath(fqn) : null;
+            t.getActions().add(Action.of(quotedExpr.toStringWithoutQuotes(), isLambdaOrAnonymous(quotedExpr.getExpression()), internalLogic, lineNumber, fqn, sourceFile));
         }
     }
 

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

@@ -0,0 +1,620 @@
+package click.kamil.springstatemachineexporter.ast.app;
+
+import click.kamil.springstatemachineexporter.model.Transition;
+import click.kamil.springstatemachineexporter.model.TransitionType;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import org.eclipse.jdt.core.dom.*;
+
+import java.util.*;
+
+public class StateMachineAdapterParser {
+    private final CodebaseContext context;
+
+    private enum AnalysisGoal {TRANSITIONS, STATES}
+
+    public record AdapterStates(Set<String> initialStates, Set<String> endStates) {}
+
+    public record AdapterConfig(
+            List<Transition> transitions,
+            Set<String> initialStates,
+            Set<String> endStates
+    ) {}
+
+    public StateMachineAdapterParser(CodebaseContext context) {
+        this.context = context;
+    }
+
+    public AdapterConfig parse(TypeDeclaration startClass) {
+        List<Transition> transitions = parseTransitions(startClass);
+        AdapterStates states = parseStates(startClass);
+        return new AdapterConfig(transitions, states.initialStates(), states.endStates());
+    }
+
+    public List<Transition> parseTransitions(TypeDeclaration startClass) {
+        List<Transition> allTransitions = new ArrayList<>();
+        Set<MethodVisit> visitedMethods = new HashSet<>();
+        aggregateTransitionsRecursive(startClass, startClass, allTransitions, new HashSet<>(), visitedMethods, new HashMap<>());
+        return allTransitions;
+    }
+
+    public AdapterStates parseStates(TypeDeclaration startClass) {
+        Set<String> initialStates = new HashSet<>();
+        Set<String> endStates = new HashSet<>();
+        Set<MethodVisit> visitedMethods = new HashSet<>();
+        aggregateStatesRecursive(startClass, startClass, initialStates, endStates, new HashSet<>(), visitedMethods, new HashMap<>());
+        return new AdapterStates(initialStates, endStates);
+    }
+
+    private void aggregateTransitionsRecursive(TypeDeclaration currentTd, TypeDeclaration searchStartClass, List<Transition> allTransitions, Set<String> visitedClasses, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
+        if (currentTd == null)
+            return;
+        String fqn = context.getFqn(currentTd);
+        if (visitedClasses.contains(fqn))
+            return;
+        visitedClasses.add(fqn);
+
+        for (MethodDeclaration method : currentTd.getMethods()) {
+            if (isConfigureTransitionsMethod(method)) {
+                allTransitions.addAll(parseTransitionsWithMethodCalls(method, searchStartClass, visitedMethods, argsMap));
+            }
+        }
+
+        CompilationUnit cu = (CompilationUnit) currentTd.getRoot();
+
+        // Hierarchy - Superclass
+        Type superclassType = currentTd.getSuperclassType();
+        if (superclassType != null) {
+            TypeDeclaration superclassTd = context.getTypeDeclaration(getSimpleName(superclassType), cu);
+            if (superclassTd != null) {
+                aggregateTransitionsRecursive(superclassTd, searchStartClass, allTransitions, visitedClasses, visitedMethods, argsMap);
+            }
+        }
+
+        // Hierarchy - Interfaces
+        for (Object interfaceTypeObj : currentTd.superInterfaceTypes()) {
+            if (interfaceTypeObj instanceof Type interfaceType) {
+                TypeDeclaration interfaceTd = context.getTypeDeclaration(getSimpleName(interfaceType), cu);
+                if (interfaceTd != null) {
+                    aggregateTransitionsRecursive(interfaceTd, searchStartClass, allTransitions, visitedClasses, visitedMethods, argsMap);
+                }
+            }
+        }
+    }
+
+    private record MethodVisit(MethodDeclaration method, Map<String, Object> args) {
+    }
+
+    private List<Transition> parseTransitionsWithMethodCalls(MethodDeclaration method, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
+        MethodVisit visit = new MethodVisit(method, new HashMap<>(argsMap));
+        if (visitedMethods.contains(visit)) {
+            return new ArrayList<>();
+        }
+        visitedMethods.add(visit);
+
+        Block body = method.getBody();
+        if (body == null) {
+            return new ArrayList<>();
+        }
+
+        return parseTransitionsInBlock(body, searchStartClass, visitedMethods, argsMap);
+    }
+
+    private List<Transition> parseTransitionsInExpression(Expression expr, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
+        List<Transition> transitions = new ArrayList<>();
+        if (expr instanceof MethodInvocation mi) {
+            if (isTransitionChainEntry(mi)) {
+                transitions.addAll(AstTransitionParser.parseTransitionsFromExpression(mi, convertToExpressionMap(argsMap), context));
+            } else if (isTransitionChainContinuation(mi, argsMap)) {
+                transitions.addAll(AstTransitionParser.parseTransitionsFromExpression(mi, convertToExpressionMap(argsMap), true, context));
+            } else if (isForEach(mi)) {
+                transitions.addAll(parseForEach(mi, searchStartClass, visitedMethods, argsMap, AnalysisGoal.TRANSITIONS, null, null));
+            } else {
+                // Check if it's a call on a lambda parameter or a variable that resolved to a lambda
+                Expression lambdaReceiver = mi.getExpression();
+                if (lambdaReceiver instanceof SimpleName sn) {
+                    Object resolved = argsMap.get(sn.getIdentifier());
+                    if (resolved instanceof LambdaExpression lambda) {
+                        transitions.addAll(parseLambdaInvocation(lambda, mi.arguments(), searchStartClass, visitedMethods, argsMap, AnalysisGoal.TRANSITIONS, null, null));
+                    }
+                }
+
+                MethodDeclaration calledMethod = findMethodInHierarchy(mi.getName().getIdentifier(), searchStartClass);
+                if (calledMethod == null) {
+                    // Try to resolve method in another class if it's a static call or on a known type
+                    Expression miReceiver = mi.getExpression();
+                    if (miReceiver instanceof SimpleName sn) {
+                        TypeDeclaration otherTd = context.getTypeDeclaration(sn.getIdentifier(), (CompilationUnit) searchStartClass.getRoot());
+                        if (otherTd != null) {
+                            calledMethod = findMethodInHierarchy(mi.getName().getIdentifier(), otherTd);
+                            if (calledMethod != null) {
+                                // For calls to other classes, we switch the "searchStartClass" to that class
+                                Map<String, Object> nextArgsMap = buildArgsMap(calledMethod, mi, argsMap);
+                                transitions.addAll(parseTransitionsWithMethodCalls(calledMethod, otherTd, visitedMethods, nextArgsMap));
+                                return transitions; // Handled
+                            }
+                        }
+                    }
+                }
+
+                if (calledMethod != null) {
+                    Map<String, Object> nextArgsMap = buildArgsMap(calledMethod, mi, argsMap);
+                    transitions.addAll(parseTransitionsWithMethodCalls(calledMethod, searchStartClass, visitedMethods, nextArgsMap));
+                }
+            }
+        }
+        return transitions;
+    }
+
+    private boolean isForEach(MethodInvocation mi) {
+        return mi.getName().getIdentifier().equals("forEach");
+    }
+
+    private List<Transition> parseLambdaInvocation(LambdaExpression lambda, List<?> arguments, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap, AnalysisGoal goal, Set<String> initialStates, Set<String> endStates) {
+        Map<String, Object> lambdaArgsMap = new HashMap<>(argsMap);
+        List<?> params = lambda.parameters();
+        for (int i = 0; i < params.size() && i < arguments.size(); i++) {
+            Object p = params.get(i);
+            String paramName = "";
+            if (p instanceof VariableDeclaration vp)
+                paramName = vp.getName().getIdentifier();
+            if (!paramName.isEmpty()) {
+                lambdaArgsMap.put(paramName, resolveExpression((Expression) arguments.get(i), argsMap));
+            }
+        }
+
+        if (goal == AnalysisGoal.TRANSITIONS) {
+            if (lambda.getBody() instanceof Block block)
+                return parseTransitionsInBlock(block, searchStartClass, visitedMethods, lambdaArgsMap);
+            else if (lambda.getBody() instanceof Expression lambdaExpr)
+                return parseTransitionsInExpression(lambdaExpr, searchStartClass, visitedMethods, lambdaArgsMap);
+        } else {
+            if (lambda.getBody() instanceof Block block)
+                parseStatesInBlock(block, searchStartClass, initialStates, endStates, visitedMethods, lambdaArgsMap);
+            else if (lambda.getBody() instanceof Expression lambdaExpr)
+                parseStatesInExpression(lambdaExpr, searchStartClass, initialStates, endStates, visitedMethods, lambdaArgsMap);
+        }
+        return Collections.emptyList();
+    }
+
+    private List<Transition> parseForEach(MethodInvocation forEachMi, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap, AnalysisGoal goal, Set<String> initialStates, Set<String> endStates) {
+        List<Transition> transitions = new ArrayList<>();
+        Expression receiver = forEachMi.getExpression();
+        List<Expression> elements = unrollCollection(receiver, argsMap);
+        if (elements.isEmpty() || forEachMi.arguments().isEmpty())
+            return transitions;
+
+        Object lambdaObj = forEachMi.arguments().get(0);
+        if (lambdaObj instanceof LambdaExpression lambda) {
+            String paramName = getLambdaParamName(lambda);
+            for (Expression element : elements) {
+                Map<String, Object> lambdaArgsMap = new HashMap<>(argsMap);
+                if (!paramName.isEmpty())
+                    lambdaArgsMap.put(paramName, element);
+
+                if (goal == AnalysisGoal.TRANSITIONS) {
+                    if (lambda.getBody() instanceof Block block)
+                        transitions.addAll(parseTransitionsInBlock(block, searchStartClass, visitedMethods, lambdaArgsMap));
+                    else if (lambda.getBody() instanceof Expression lambdaExpr)
+                        transitions.addAll(parseTransitionsInExpression(lambdaExpr, searchStartClass, visitedMethods, lambdaArgsMap));
+                } else {
+                    if (lambda.getBody() instanceof Block block)
+                        parseStatesInBlock(block, searchStartClass, initialStates, endStates, visitedMethods, lambdaArgsMap);
+                    else if (lambda.getBody() instanceof Expression lambdaExpr)
+                        parseStatesInExpression(lambdaExpr, searchStartClass, initialStates, endStates, visitedMethods, lambdaArgsMap);
+                }
+            }
+        }
+        return transitions;
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<Transition> parseEnhancedForLoop(EnhancedForStatement efs, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap, AnalysisGoal goal, Set<String> initialStates, Set<String> endStates) {
+        List<Transition> transitions = new ArrayList<>();
+        List<Expression> elements = unrollCollection(efs.getExpression(), argsMap);
+        String paramName = efs.getParameter().getName().getIdentifier();
+
+        for (Expression element : elements) {
+            Map<String, Object> loopArgsMap = new HashMap<>(argsMap);
+            loopArgsMap.put(paramName, element);
+
+            if (goal == AnalysisGoal.TRANSITIONS) {
+                if (efs.getBody() instanceof Block block)
+                    transitions.addAll(parseTransitionsInBlock(block, searchStartClass, visitedMethods, loopArgsMap));
+                else if (efs.getBody() instanceof ExpressionStatement es)
+                    transitions.addAll(parseTransitionsInExpression(es.getExpression(), searchStartClass, visitedMethods, loopArgsMap));
+            } else {
+                if (efs.getBody() instanceof Block block)
+                    parseStatesInBlock(block, searchStartClass, initialStates, endStates, visitedMethods, loopArgsMap);
+                else if (efs.getBody() instanceof ExpressionStatement es)
+                    parseStatesInExpression(es.getExpression(), searchStartClass, initialStates, endStates, visitedMethods, loopArgsMap);
+            }
+        }
+        return transitions;
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<Expression> unrollCollection(Expression expr, Map<String, Object> argsMap) {
+        Set<Expression> visited = new HashSet<>();
+        Expression current = expr;
+        while (current != null) {
+            if (!visited.add(current))
+                break;
+
+            if (current instanceof MethodInvocation mi) {
+                String name = mi.getName().getIdentifier();
+                Expression receiver = mi.getExpression();
+                if ((name.equals("of") && receiver != null && (receiver.toString().equals("Stream") || receiver.toString().equals("List")))
+                        || (name.equals("asList") && receiver != null && receiver.toString().equals("Arrays"))) {
+                    if (mi.arguments().size() == 1) {
+                        Expression arg = (Expression) mi.arguments().get(0);
+                        if (arg instanceof SimpleName sn) {
+                            Object resolved = argsMap.get(sn.getIdentifier());
+                            if (resolved instanceof List list)
+                                return (List<Expression>) list;
+                        }
+                    }
+                    return (List<Expression>) mi.arguments();
+                }
+            }
+            if (current instanceof SimpleName sn) {
+                Object resolved = argsMap.get(sn.getIdentifier());
+                if (resolved instanceof List list)
+                    return (List<Expression>) list;
+                if (resolved instanceof Expression e) {
+                    current = e;
+                    continue;
+                }
+            }
+            if (current instanceof ArrayInitializer ai)
+                return (List<Expression>) ai.expressions();
+            break;
+        }
+        return Collections.emptyList();
+    }
+
+    private String getLambdaParamName(LambdaExpression lambda) {
+        if (lambda.parameters().size() == 1) {
+            Object p = lambda.parameters().get(0);
+            if (p instanceof VariableDeclaration vp)
+                return vp.getName().getIdentifier();
+        }
+        return "";
+    }
+
+    private List<Transition> parseTransitionsInBlock(Block block, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
+        List<Transition> transitions = new ArrayList<>();
+        for (Object stmt : block.statements()) {
+            if (stmt instanceof ExpressionStatement es)
+                transitions.addAll(parseTransitionsInExpression(es.getExpression(), searchStartClass, visitedMethods, argsMap));
+            else if (stmt instanceof VariableDeclarationStatement vds) {
+                for (Object fragmentObj : vds.fragments()) {
+                    if (fragmentObj instanceof VariableDeclarationFragment fragment) {
+                        Expression initializer = fragment.getInitializer();
+                        if (initializer != null) {
+                            Object resolved = resolve(initializer, argsMap);
+                            if (resolved != null)
+                                argsMap.put(fragment.getName().getIdentifier(), resolved);
+                            transitions.addAll(parseTransitionsInExpression(initializer, searchStartClass, visitedMethods, argsMap));
+                        }
+                    }
+                }
+            } else if (stmt instanceof EnhancedForStatement efs)
+                transitions.addAll(parseEnhancedForLoop(efs, searchStartClass, visitedMethods, argsMap, AnalysisGoal.TRANSITIONS, null, null));
+            else if (stmt instanceof TryStatement ts)
+                transitions.addAll(parseTransitionsInBlock(ts.getBody(), searchStartClass, visitedMethods, argsMap));
+        }
+        return transitions;
+    }
+
+    private void parseStatesInBlock(Block block, TypeDeclaration searchStartClass, Set<String> initialStates, Set<String> endStates, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
+        for (Object stmt : block.statements()) {
+            if (stmt instanceof ExpressionStatement es)
+                parseStatesInExpression(es.getExpression(), searchStartClass, initialStates, endStates, visitedMethods, argsMap);
+            else if (stmt instanceof VariableDeclarationStatement vds) {
+                for (Object fragmentObj : vds.fragments()) {
+                    if (fragmentObj instanceof VariableDeclarationFragment fragment) {
+                        Expression initializer = fragment.getInitializer();
+                        if (initializer != null) {
+                            Object resolved = resolve(initializer, argsMap);
+                            if (resolved != null)
+                                argsMap.put(fragment.getName().getIdentifier(), resolved);
+                            parseStatesInExpression(initializer, searchStartClass, initialStates, endStates, visitedMethods, argsMap);
+                        }
+                    }
+                }
+            } else if (stmt instanceof EnhancedForStatement efs)
+                parseEnhancedForLoop(efs, searchStartClass, visitedMethods, argsMap, AnalysisGoal.STATES, initialStates, endStates);
+            else if (stmt instanceof TryStatement ts)
+                parseStatesInBlock(ts.getBody(), searchStartClass, initialStates, endStates, visitedMethods, argsMap);
+        }
+    }
+
+    private void parseStatesInExpression(Expression expr, TypeDeclaration searchStartClass, Set<String> initialStates, Set<String> endStates, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
+        if (expr instanceof MethodInvocation mi) {
+            if (isWithStatesChain(mi, argsMap))
+                parseStateChain(mi, initialStates, endStates, argsMap);
+            else if (isForEach(mi))
+                parseForEach(mi, searchStartClass, visitedMethods, argsMap, AnalysisGoal.STATES, initialStates, endStates);
+            else {
+                // Check if it's a call on a lambda parameter or a variable that resolved to a lambda
+                Expression receiver = mi.getExpression();
+                if (receiver instanceof SimpleName sn) {
+                    Object resolved = argsMap.get(sn.getIdentifier());
+                    if (resolved instanceof LambdaExpression lambda) {
+                        parseLambdaInvocation(lambda, mi.arguments(), searchStartClass, visitedMethods, argsMap, AnalysisGoal.STATES, initialStates, endStates);
+                    }
+                }
+
+                MethodDeclaration calledMethod = findMethodInHierarchy(mi.getName().getIdentifier(), searchStartClass);
+                if (calledMethod != null) {
+                    Map<String, Object> nextArgsMap = buildArgsMap(calledMethod, mi, argsMap);
+                    parseStatesWithMethodCalls(calledMethod, searchStartClass, initialStates, endStates, visitedMethods, nextArgsMap);
+                }
+            }
+        }
+    }
+
+    private Map<String, Object> buildArgsMap(MethodDeclaration method, MethodInvocation call, Map<String, Object> currentArgsMap) {
+        Map<String, Object> map = new HashMap<>(currentArgsMap);
+        List<?> params = method.parameters();
+        List<?> args = call.arguments();
+
+        for (int i = 0; i < params.size(); i++) {
+            SingleVariableDeclaration param = (SingleVariableDeclaration) params.get(i);
+            String paramName = param.getName().getIdentifier();
+            if (param.isVarargs() && i < params.size()) {
+                List<Expression> varargList = new ArrayList<>();
+                for (int j = i; j < args.size(); j++) {
+                    Object resolved = resolve((Expression) args.get(j), currentArgsMap);
+                    if (resolved instanceof List<?> list) {
+                        for (Object item : list) {
+                            if (item instanceof Expression e)
+                                varargList.add(e);
+                        }
+                    } else if (resolved instanceof Expression e) {
+                        varargList.add(e);
+                    }
+                }
+                map.put(paramName, varargList);
+            } else if (i < args.size()) {
+                map.put(paramName, resolve((Expression) args.get(i), currentArgsMap));
+            }
+        }
+        return map;
+    }
+
+    private Object resolve(Expression expr, Map<String, Object> argsMap) {
+        if (expr instanceof NullLiteral)
+            return null;
+        Set<Expression> visited = new HashSet<>();
+        Object current = expr;
+        while (current instanceof SimpleName sn) {
+            if (!visited.add((SimpleName) current))
+                break;
+            Object resolved = argsMap.get(sn.getIdentifier());
+            if (resolved == null || resolved == current)
+                break;
+            current = resolved;
+        }
+        return current;
+    }
+
+    private Expression resolveExpression(Expression expr, Map<String, Object> argsMap) {
+        Object resolved = resolve(expr, argsMap);
+        if (resolved instanceof Expression e)
+            return e;
+        return expr;
+    }
+
+    private Map<String, Expression> convertToExpressionMap(Map<String, Object> argsMap) {
+        Map<String, Expression> map = new HashMap<>();
+        for (Map.Entry<String, Object> entry : argsMap.entrySet()) {
+            if (entry.getValue() instanceof Expression e)
+                map.put(entry.getKey(), e);
+        }
+        return map;
+    }
+
+    private boolean isTransitionChainEntry(MethodInvocation mi) {
+        Expression current = mi;
+        while (current instanceof MethodInvocation call) {
+            String name = call.getName().getIdentifier();
+            if (TransitionType.fromMethodName(name).isPresent())
+                return true;
+            current = call.getExpression();
+        }
+        return false;
+    }
+
+    private boolean isTransitionChainContinuation(MethodInvocation mi, Map<String, Object> argsMap) {
+        Expression current = mi;
+        Set<Expression> visited = new HashSet<>();
+        while (current instanceof MethodInvocation call) {
+            if (!visited.add(current))
+                break;
+            String name = call.getName().getIdentifier();
+            if (Set.of("and", "source", "target", "event", "first", "then", "last").contains(name)) {
+                Expression receiver = call.getExpression();
+                if (receiver instanceof MethodInvocation next) {
+                    current = next;
+                    continue;
+                }
+                Object resolved = resolve(receiver, argsMap);
+                if (resolved instanceof MethodInvocation next) {
+                    current = next;
+                    continue;
+                }
+                return resolved == null; // null means it's a parameter we track
+            }
+            if (TransitionType.fromMethodName(name).isPresent())
+                return true;
+            break;
+        }
+        return false;
+    }
+
+    private MethodDeclaration findMethodInHierarchy(String methodName, TypeDeclaration td) {
+        return findMethodInHierarchy(methodName, td, new HashSet<>());
+    }
+
+    private MethodDeclaration findMethodInHierarchy(String methodName, TypeDeclaration td, Set<String> visited) {
+        if (td == null)
+            return null;
+
+        String fqn = context.getFqn(td);
+        if (visited.contains(fqn))
+            return null;
+        visited.add(fqn);
+
+        for (MethodDeclaration method : td.getMethods())
+            if (method.getName().getIdentifier().equals(methodName))
+                return method;
+
+        Type superclassType = td.getSuperclassType();
+        if (superclassType != null) {
+            TypeDeclaration superclassTd = context.getTypeDeclaration(getSimpleName(superclassType), (CompilationUnit) td.getRoot());
+            return findMethodInHierarchy(methodName, superclassTd, visited);
+        }
+        return null;
+    }
+
+    private boolean isRelevantMethod(MethodDeclaration method) {
+        return true;
+    }
+
+    private MethodDeclaration findConfigureTransitionsMethod(TypeDeclaration td) {
+        for (MethodDeclaration method : td.getMethods())
+            if (isConfigureTransitionsMethod(method))
+                return method;
+        return null;
+    }
+
+    private boolean isConfigureTransitionsMethod(MethodDeclaration method) {
+        if (!method.getName().getIdentifier().equals("configure") || method.parameters().isEmpty())
+            return false;
+        return ((SingleVariableDeclaration) method.parameters().get(0)).getType().toString().contains("StateMachineTransitionConfigurer");
+    }
+
+    private void aggregateStatesRecursive(TypeDeclaration currentTd, TypeDeclaration searchStartClass, Set<String> initialStates, Set<String> endStates, Set<String> visitedClasses, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
+        if (currentTd == null)
+            return;
+        String fqn = context.getFqn(currentTd);
+        if (visitedClasses.contains(fqn))
+            return;
+        visitedClasses.add(fqn);
+
+        for (MethodDeclaration method : currentTd.getMethods()) {
+            if (isConfigureStatesMethod(method)) {
+                parseStatesWithMethodCalls(method, searchStartClass, initialStates, endStates, visitedMethods, argsMap);
+            }
+        }
+
+        CompilationUnit cu = (CompilationUnit) currentTd.getRoot();
+
+        // Hierarchy - Superclass
+        Type superclassType = currentTd.getSuperclassType();
+        if (superclassType != null) {
+            TypeDeclaration superclassTd = context.getTypeDeclaration(getSimpleName(superclassType), cu);
+            if (superclassTd != null)
+                aggregateStatesRecursive(superclassTd, searchStartClass, initialStates, endStates, visitedClasses, visitedMethods, argsMap);
+        }
+
+        // Hierarchy - Interfaces
+        for (Object interfaceTypeObj : currentTd.superInterfaceTypes()) {
+            if (interfaceTypeObj instanceof Type interfaceType) {
+                TypeDeclaration interfaceTd = context.getTypeDeclaration(getSimpleName(interfaceType), cu);
+                if (interfaceTd != null)
+                    aggregateStatesRecursive(interfaceTd, searchStartClass, initialStates, endStates, visitedClasses, visitedMethods, argsMap);
+            }
+        }
+    }
+
+    private void parseStatesWithMethodCalls(MethodDeclaration method, TypeDeclaration searchStartClass, Set<String> initialStates, Set<String> endStates, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
+        MethodVisit visit = new MethodVisit(method, new HashMap<>(argsMap));
+        if (visitedMethods.contains(visit))
+            return;
+        visitedMethods.add(visit);
+        Block body = method.getBody();
+        if (body == null)
+            return;
+
+        parseStatesInBlock(body, searchStartClass, initialStates, endStates, visitedMethods, argsMap);
+    }
+
+    private boolean isWithStatesChain(MethodInvocation mi, Map<String, Object> argsMap) {
+        Expression current = mi;
+        Set<Expression> visited = new HashSet<>();
+        while (current instanceof MethodInvocation call) {
+            if (!visited.add(current))
+                break;
+            if (call.getName().getIdentifier().equals("withStates"))
+                return true;
+            Expression receiver = call.getExpression();
+            if (receiver instanceof MethodInvocation next) {
+                current = next;
+                continue;
+            }
+            Object resolved = resolve(receiver, argsMap);
+            if (resolved instanceof MethodInvocation next) {
+                current = next;
+                continue;
+            }
+            break;
+        }
+        return false;
+    }
+
+    private void parseStateChain(MethodInvocation mi, Set<String> initialStates, Set<String> endStates, Map<String, Object> argsMap) {
+        List<MethodInvocation> chain = new ArrayList<>();
+        Expression current = mi;
+        while (current instanceof MethodInvocation m) {
+            chain.addFirst(m);
+            current = m.getExpression();
+        }
+        CompilationUnit cu = (CompilationUnit) mi.getRoot();
+        for (MethodInvocation call : chain) {
+            String methodName = call.getName().getIdentifier();
+            if (call.arguments().isEmpty())
+                continue;
+            Expression arg = resolveExpression((Expression) call.arguments().get(0), argsMap);
+            if ("initial".equals(methodName)) {
+                if (!isInsideRegionOrFork(call)) {
+                    initialStates.add(context.resolveState(arg, cu).toString());
+                }
+            } else if ("end".equals(methodName)) {
+                endStates.add(context.resolveState(arg, cu).toString());
+            }
+        }
+    }
+
+    private boolean isInsideRegionOrFork(MethodInvocation mi) {
+        Expression expr = mi.getExpression();
+        while (expr instanceof MethodInvocation parent) {
+            if (List.of("fork", "region").contains(parent.getName().getIdentifier()))
+                return true;
+            expr = parent.getExpression();
+        }
+        return false;
+    }
+
+    private MethodDeclaration findConfigureStatesMethod(TypeDeclaration td) {
+        for (MethodDeclaration method : td.getMethods())
+            if (isConfigureStatesMethod(method))
+                return method;
+        return null;
+    }
+
+    private boolean isConfigureStatesMethod(MethodDeclaration method) {
+        if (!method.getName().getIdentifier().equals("configure") || method.parameters().isEmpty())
+            return false;
+        return ((SingleVariableDeclaration) method.parameters().get(0)).getType().toString().contains("StateMachineStateConfigurer");
+    }
+
+    private String getSimpleName(Type type) {
+        if (type.isSimpleType())
+            return ((SimpleType) type).getName().getFullyQualifiedName();
+        if (type.isParameterizedType())
+            return getSimpleName(((ParameterizedType) type).getType());
+        return type.toString();
+    }
+}

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

@@ -1,632 +1,37 @@
 package click.kamil.springstatemachineexporter.ast.app;
 
 import click.kamil.springstatemachineexporter.model.Transition;
-import click.kamil.springstatemachineexporter.model.TransitionType;
 import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
 import lombok.Getter;
-import org.eclipse.jdt.core.dom.ArrayInitializer;
-import org.eclipse.jdt.core.dom.Block;
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.dom.EnhancedForStatement;
-import org.eclipse.jdt.core.dom.Expression;
-import org.eclipse.jdt.core.dom.ExpressionStatement;
-import org.eclipse.jdt.core.dom.LambdaExpression;
-import org.eclipse.jdt.core.dom.MethodDeclaration;
-import org.eclipse.jdt.core.dom.MethodInvocation;
-import org.eclipse.jdt.core.dom.NullLiteral;
-import org.eclipse.jdt.core.dom.ParameterizedType;
-import org.eclipse.jdt.core.dom.SimpleName;
-import org.eclipse.jdt.core.dom.SimpleType;
-import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
-import org.eclipse.jdt.core.dom.TryStatement;
-import org.eclipse.jdt.core.dom.Type;
 import org.eclipse.jdt.core.dom.TypeDeclaration;
-import org.eclipse.jdt.core.dom.VariableDeclaration;
-import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
-import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 public class StateMachineAggregator {
     private final CodebaseContext context;
-
-    private enum AnalysisGoal {TRANSITIONS, STATES}
-
-    public StateMachineAggregator(CodebaseContext context) {
-        this.context = context;
-    }
-
-    public List<Transition> aggregateTransitions(TypeDeclaration startClass) {
-        List<Transition> allTransitions = new ArrayList<>();
-        Set<MethodVisit> visitedMethods = new HashSet<>();
-        aggregateTransitionsRecursive(startClass, startClass, allTransitions, new HashSet<>(), visitedMethods, new HashMap<>());
-        return allTransitions;
-    }
-
-    private void aggregateTransitionsRecursive(TypeDeclaration currentTd, TypeDeclaration searchStartClass, List<Transition> allTransitions, Set<String> visitedClasses, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
-        if (currentTd == null)
-            return;
-        String fqn = context.getFqn(currentTd);
-        if (visitedClasses.contains(fqn))
-            return;
-        visitedClasses.add(fqn);
-
-        for (MethodDeclaration method : currentTd.getMethods()) {
-            if (isConfigureTransitionsMethod(method)) {
-                allTransitions.addAll(parseTransitionsWithMethodCalls(method, searchStartClass, visitedMethods, argsMap));
-            }
-        }
-
-        CompilationUnit cu = (CompilationUnit) currentTd.getRoot();
-
-        // Hierarchy - Superclass
-        Type superclassType = currentTd.getSuperclassType();
-        if (superclassType != null) {
-            TypeDeclaration superclassTd = context.getTypeDeclaration(getSimpleName(superclassType), cu);
-            if (superclassTd != null) {
-                aggregateTransitionsRecursive(superclassTd, searchStartClass, allTransitions, visitedClasses, visitedMethods, argsMap);
-            }
-        }
-
-        // Hierarchy - Interfaces
-        for (Object interfaceTypeObj : currentTd.superInterfaceTypes()) {
-            if (interfaceTypeObj instanceof Type interfaceType) {
-                TypeDeclaration interfaceTd = context.getTypeDeclaration(getSimpleName(interfaceType), cu);
-                if (interfaceTd != null) {
-                    aggregateTransitionsRecursive(interfaceTd, searchStartClass, allTransitions, visitedClasses, visitedMethods, argsMap);
-                }
-            }
-        }
-    }
-
-    private record MethodVisit(MethodDeclaration method, Map<String, Object> args) {
-    }
-
-    private List<Transition> parseTransitionsWithMethodCalls(MethodDeclaration method, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
-        MethodVisit visit = new MethodVisit(method, new HashMap<>(argsMap));
-        if (visitedMethods.contains(visit)) {
-            return new ArrayList<>();
-        }
-        visitedMethods.add(visit);
-
-        Block body = method.getBody();
-        if (body == null) {
-            return new ArrayList<>();
-        }
-
-        return parseTransitionsInBlock(body, searchStartClass, visitedMethods, argsMap);
-    }
-
-    private List<Transition> parseTransitionsInExpression(Expression expr, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
-        List<Transition> transitions = new ArrayList<>();
-        if (expr instanceof MethodInvocation mi) {
-            if (isTransitionChainEntry(mi)) {
-                transitions.addAll(AstTransitionParser.parseTransitionsFromExpression(mi, convertToExpressionMap(argsMap), context));
-            } else if (isTransitionChainContinuation(mi, argsMap)) {
-                transitions.addAll(AstTransitionParser.parseTransitionsFromExpression(mi, convertToExpressionMap(argsMap), true, context));
-            } else if (isForEach(mi)) {
-                transitions.addAll(parseForEach(mi, searchStartClass, visitedMethods, argsMap, AnalysisGoal.TRANSITIONS, null, null));
-            } else {
-                // Check if it's a call on a lambda parameter or a variable that resolved to a lambda
-                Expression lambdaReceiver = mi.getExpression();
-                if (lambdaReceiver instanceof SimpleName sn) {
-                    Object resolved = argsMap.get(sn.getIdentifier());
-                    if (resolved instanceof LambdaExpression lambda) {
-                        transitions.addAll(parseLambdaInvocation(lambda, mi.arguments(), searchStartClass, visitedMethods, argsMap, AnalysisGoal.TRANSITIONS, null, null));
-                    }
-                }
-
-                MethodDeclaration calledMethod = findMethodInHierarchy(mi.getName().getIdentifier(), searchStartClass);
-                if (calledMethod == null) {
-                    // Try to resolve method in another class if it's a static call or on a known type
-                    Expression miReceiver = mi.getExpression();
-                    if (miReceiver instanceof SimpleName sn) {
-                        TypeDeclaration otherTd = context.getTypeDeclaration(sn.getIdentifier(), (CompilationUnit) searchStartClass.getRoot());
-                        if (otherTd != null) {
-                            calledMethod = findMethodInHierarchy(mi.getName().getIdentifier(), otherTd);
-                            if (calledMethod != null) {
-                                // For calls to other classes, we switch the "searchStartClass" to that class
-                                Map<String, Object> nextArgsMap = buildArgsMap(calledMethod, mi, argsMap);
-                                transitions.addAll(parseTransitionsWithMethodCalls(calledMethod, otherTd, visitedMethods, nextArgsMap));
-                                return transitions; // Handled
-                            }
-                        }
-                    }
-                }
-
-                if (calledMethod != null) {
-                    Map<String, Object> nextArgsMap = buildArgsMap(calledMethod, mi, argsMap);
-                    transitions.addAll(parseTransitionsWithMethodCalls(calledMethod, searchStartClass, visitedMethods, nextArgsMap));
-                }
-            }
-        }
-        return transitions;
-    }
-
-    private boolean isForEach(MethodInvocation mi) {
-        return mi.getName().getIdentifier().equals("forEach");
-    }
-
-    private List<Transition> parseLambdaInvocation(LambdaExpression lambda, List<?> arguments, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap, AnalysisGoal goal, Set<String> initialStates, Set<String> endStates) {
-        Map<String, Object> lambdaArgsMap = new HashMap<>(argsMap);
-        List<?> params = lambda.parameters();
-        for (int i = 0; i < params.size() && i < arguments.size(); i++) {
-            Object p = params.get(i);
-            String paramName = "";
-            if (p instanceof VariableDeclaration vp)
-                paramName = vp.getName().getIdentifier();
-            if (!paramName.isEmpty()) {
-                lambdaArgsMap.put(paramName, resolveExpression((Expression) arguments.get(i), argsMap));
-            }
-        }
-
-        if (goal == AnalysisGoal.TRANSITIONS) {
-            if (lambda.getBody() instanceof Block block)
-                return parseTransitionsInBlock(block, searchStartClass, visitedMethods, lambdaArgsMap);
-            else if (lambda.getBody() instanceof Expression lambdaExpr)
-                return parseTransitionsInExpression(lambdaExpr, searchStartClass, visitedMethods, lambdaArgsMap);
-        } else {
-            if (lambda.getBody() instanceof Block block)
-                parseStatesInBlock(block, searchStartClass, initialStates, endStates, visitedMethods, lambdaArgsMap);
-            else if (lambda.getBody() instanceof Expression lambdaExpr)
-                parseStatesInExpression(lambdaExpr, searchStartClass, initialStates, endStates, visitedMethods, lambdaArgsMap);
-        }
-        return Collections.emptyList();
-    }
-
-    private List<Transition> parseForEach(MethodInvocation forEachMi, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap, AnalysisGoal goal, Set<String> initialStates, Set<String> endStates) {
-        List<Transition> transitions = new ArrayList<>();
-        Expression receiver = forEachMi.getExpression();
-        List<Expression> elements = unrollCollection(receiver, argsMap);
-        if (elements.isEmpty() || forEachMi.arguments().isEmpty())
-            return transitions;
-
-        Object lambdaObj = forEachMi.arguments().get(0);
-        if (lambdaObj instanceof LambdaExpression lambda) {
-            String paramName = getLambdaParamName(lambda);
-            for (Expression element : elements) {
-                Map<String, Object> lambdaArgsMap = new HashMap<>(argsMap);
-                if (!paramName.isEmpty())
-                    lambdaArgsMap.put(paramName, element);
-
-                if (goal == AnalysisGoal.TRANSITIONS) {
-                    if (lambda.getBody() instanceof Block block)
-                        transitions.addAll(parseTransitionsInBlock(block, searchStartClass, visitedMethods, lambdaArgsMap));
-                    else if (lambda.getBody() instanceof Expression lambdaExpr)
-                        transitions.addAll(parseTransitionsInExpression(lambdaExpr, searchStartClass, visitedMethods, lambdaArgsMap));
-                } else {
-                    if (lambda.getBody() instanceof Block block)
-                        parseStatesInBlock(block, searchStartClass, initialStates, endStates, visitedMethods, lambdaArgsMap);
-                    else if (lambda.getBody() instanceof Expression lambdaExpr)
-                        parseStatesInExpression(lambdaExpr, searchStartClass, initialStates, endStates, visitedMethods, lambdaArgsMap);
-                }
-            }
-        }
-        return transitions;
-    }
-
-    private List<Transition> parseEnhancedForLoop(EnhancedForStatement efs, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap, AnalysisGoal goal, Set<String> initialStates, Set<String> endStates) {
-        List<Transition> transitions = new ArrayList<>();
-        List<Expression> elements = unrollCollection(efs.getExpression(), argsMap);
-        String paramName = efs.getParameter().getName().getIdentifier();
-
-        for (Expression element : elements) {
-            Map<String, Object> loopArgsMap = new HashMap<>(argsMap);
-            loopArgsMap.put(paramName, element);
-
-            if (goal == AnalysisGoal.TRANSITIONS) {
-                if (efs.getBody() instanceof Block block)
-                    transitions.addAll(parseTransitionsInBlock(block, searchStartClass, visitedMethods, loopArgsMap));
-                else if (efs.getBody() instanceof ExpressionStatement es)
-                    transitions.addAll(parseTransitionsInExpression(es.getExpression(), searchStartClass, visitedMethods, loopArgsMap));
-            } else {
-                if (efs.getBody() instanceof Block block)
-                    parseStatesInBlock(block, searchStartClass, initialStates, endStates, visitedMethods, loopArgsMap);
-                else if (efs.getBody() instanceof ExpressionStatement es)
-                    parseStatesInExpression(es.getExpression(), searchStartClass, initialStates, endStates, visitedMethods, loopArgsMap);
-            }
-        }
-        return transitions;
-    }
-
-    private List<Expression> unrollCollection(Expression expr, Map<String, Object> argsMap) {
-        Set<Expression> visited = new HashSet<>();
-        Expression current = expr;
-        while (current != null) {
-            if (!visited.add(current))
-                break;
-
-            if (current instanceof MethodInvocation mi) {
-                String name = mi.getName().getIdentifier();
-                Expression receiver = mi.getExpression();
-                if ((name.equals("of") && receiver != null && (receiver.toString().equals("Stream") || receiver.toString().equals("List")))
-                        || (name.equals("asList") && receiver != null && receiver.toString().equals("Arrays"))) {
-                    if (mi.arguments().size() == 1) {
-                        Expression arg = (Expression) mi.arguments().get(0);
-                        if (arg instanceof SimpleName sn) {
-                            Object resolved = argsMap.get(sn.getIdentifier());
-                            if (resolved instanceof List list)
-                                return (List<Expression>) list;
-                        }
-                    }
-                    return (List<Expression>) mi.arguments();
-                }
-            }
-            if (current instanceof SimpleName sn) {
-                Object resolved = argsMap.get(sn.getIdentifier());
-                if (resolved instanceof List list)
-                    return (List<Expression>) list;
-                if (resolved instanceof Expression e) {
-                    current = e;
-                    continue;
-                }
-            }
-            if (current instanceof ArrayInitializer ai)
-                return (List<Expression>) ai.expressions();
-            break;
-        }
-        return Collections.emptyList();
-    }
-
-    private String getLambdaParamName(LambdaExpression lambda) {
-        if (lambda.parameters().size() == 1) {
-            Object p = lambda.parameters().get(0);
-            if (p instanceof VariableDeclaration vp)
-                return vp.getName().getIdentifier();
-        }
-        return "";
-    }
-
-    private List<Transition> parseTransitionsInBlock(Block block, TypeDeclaration searchStartClass, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
-        List<Transition> transitions = new ArrayList<>();
-        for (Object stmt : block.statements()) {
-            if (stmt instanceof ExpressionStatement es)
-                transitions.addAll(parseTransitionsInExpression(es.getExpression(), searchStartClass, visitedMethods, argsMap));
-            else if (stmt instanceof VariableDeclarationStatement vds) {
-                for (Object fragmentObj : vds.fragments()) {
-                    if (fragmentObj instanceof VariableDeclarationFragment fragment) {
-                        Expression initializer = fragment.getInitializer();
-                        if (initializer != null) {
-                            Object resolved = resolve(initializer, argsMap);
-                            if (resolved != null)
-                                argsMap.put(fragment.getName().getIdentifier(), resolved);
-                            transitions.addAll(parseTransitionsInExpression(initializer, searchStartClass, visitedMethods, argsMap));
-                        }
-                    }
-                }
-            } else if (stmt instanceof EnhancedForStatement efs)
-                transitions.addAll(parseEnhancedForLoop(efs, searchStartClass, visitedMethods, argsMap, AnalysisGoal.TRANSITIONS, null, null));
-            else if (stmt instanceof TryStatement ts)
-                transitions.addAll(parseTransitionsInBlock(ts.getBody(), searchStartClass, visitedMethods, argsMap));
-        }
-        return transitions;
-    }
-
-    private void parseStatesInBlock(Block block, TypeDeclaration searchStartClass, Set<String> initialStates, Set<String> endStates, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
-        for (Object stmt : block.statements()) {
-            if (stmt instanceof ExpressionStatement es)
-                parseStatesInExpression(es.getExpression(), searchStartClass, initialStates, endStates, visitedMethods, argsMap);
-            else if (stmt instanceof VariableDeclarationStatement vds) {
-                for (Object fragmentObj : vds.fragments()) {
-                    if (fragmentObj instanceof VariableDeclarationFragment fragment) {
-                        Expression initializer = fragment.getInitializer();
-                        if (initializer != null) {
-                            Object resolved = resolve(initializer, argsMap);
-                            if (resolved != null)
-                                argsMap.put(fragment.getName().getIdentifier(), resolved);
-                            parseStatesInExpression(initializer, searchStartClass, initialStates, endStates, visitedMethods, argsMap);
-                        }
-                    }
-                }
-            } else if (stmt instanceof EnhancedForStatement efs)
-                parseEnhancedForLoop(efs, searchStartClass, visitedMethods, argsMap, AnalysisGoal.STATES, initialStates, endStates);
-            else if (stmt instanceof TryStatement ts)
-                parseStatesInBlock(ts.getBody(), searchStartClass, initialStates, endStates, visitedMethods, argsMap);
-        }
-    }
-
-    private void parseStatesInExpression(Expression expr, TypeDeclaration searchStartClass, Set<String> initialStates, Set<String> endStates, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
-        if (expr instanceof MethodInvocation mi) {
-            if (isWithStatesChain(mi, argsMap))
-                parseStateChain(mi, initialStates, endStates, argsMap);
-            else if (isForEach(mi))
-                parseForEach(mi, searchStartClass, visitedMethods, argsMap, AnalysisGoal.STATES, initialStates, endStates);
-            else {
-                // Check if it's a call on a lambda parameter or a variable that resolved to a lambda
-                Expression receiver = mi.getExpression();
-                if (receiver instanceof SimpleName sn) {
-                    Object resolved = argsMap.get(sn.getIdentifier());
-                    if (resolved instanceof LambdaExpression lambda) {
-                        parseLambdaInvocation(lambda, mi.arguments(), searchStartClass, visitedMethods, argsMap, AnalysisGoal.STATES, initialStates, endStates);
-                    }
-                }
-
-                MethodDeclaration calledMethod = findMethodInHierarchy(mi.getName().getIdentifier(), searchStartClass);
-                if (calledMethod != null) {
-                    Map<String, Object> nextArgsMap = buildArgsMap(calledMethod, mi, argsMap);
-                    parseStatesWithMethodCalls(calledMethod, searchStartClass, initialStates, endStates, visitedMethods, nextArgsMap);
-                }
-            }
-        }
-    }
-
-    private Map<String, Object> buildArgsMap(MethodDeclaration method, MethodInvocation call, Map<String, Object> currentArgsMap) {
-        Map<String, Object> map = new HashMap<>(currentArgsMap);
-        List<?> params = method.parameters();
-        List<?> args = call.arguments();
-
-        for (int i = 0; i < params.size(); i++) {
-            SingleVariableDeclaration param = (SingleVariableDeclaration) params.get(i);
-            String paramName = param.getName().getIdentifier();
-            if (param.isVarargs() && i < params.size()) {
-                List<Expression> varargList = new ArrayList<>();
-                for (int j = i; j < args.size(); j++) {
-                    Object resolved = resolve((Expression) args.get(j), currentArgsMap);
-                    if (resolved instanceof List<?> list) {
-                        for (Object item : list) {
-                            if (item instanceof Expression e)
-                                varargList.add(e);
-                        }
-                    } else if (resolved instanceof Expression e) {
-                        varargList.add(e);
-                    }
-                }
-                map.put(paramName, varargList);
-            } else if (i < args.size()) {
-                map.put(paramName, resolve((Expression) args.get(i), currentArgsMap));
-            }
-        }
-        return map;
-    }
-
-    private Object resolve(Expression expr, Map<String, Object> argsMap) {
-        if (expr instanceof NullLiteral)
-            return null;
-        Set<Expression> visited = new HashSet<>();
-        Object current = expr;
-        while (current instanceof SimpleName sn) {
-            if (!visited.add((SimpleName) current))
-                break;
-            Object resolved = argsMap.get(sn.getIdentifier());
-            if (resolved == null || resolved == current)
-                break;
-            current = resolved;
-        }
-        return current;
-    }
-
-    private Expression resolveExpression(Expression expr, Map<String, Object> argsMap) {
-        Object resolved = resolve(expr, argsMap);
-        if (resolved instanceof Expression e)
-            return e;
-        return expr;
-    }
-
-    private Map<String, Expression> convertToExpressionMap(Map<String, Object> argsMap) {
-        Map<String, Expression> map = new HashMap<>();
-        for (Map.Entry<String, Object> entry : argsMap.entrySet()) {
-            if (entry.getValue() instanceof Expression e)
-                map.put(entry.getKey(), e);
-        }
-        return map;
-    }
-
-    private boolean isTransitionChainEntry(MethodInvocation mi) {
-        Expression current = mi;
-        while (current instanceof MethodInvocation call) {
-            String name = call.getName().getIdentifier();
-            if (TransitionType.fromMethodName(name).isPresent())
-                return true;
-            current = call.getExpression();
-        }
-        return false;
-    }
-
-    private boolean isTransitionChainContinuation(MethodInvocation mi, Map<String, Object> argsMap) {
-        Expression current = mi;
-        Set<Expression> visited = new HashSet<>();
-        while (current instanceof MethodInvocation call) {
-            if (!visited.add(current))
-                break;
-            String name = call.getName().getIdentifier();
-            if (Set.of("and", "source", "target", "event", "first", "then", "last").contains(name)) {
-                Expression receiver = call.getExpression();
-                if (receiver instanceof MethodInvocation next) {
-                    current = next;
-                    continue;
-                }
-                Object resolved = resolve(receiver, argsMap);
-                if (resolved instanceof MethodInvocation next) {
-                    current = next;
-                    continue;
-                }
-                return resolved == null; // null means it's a parameter we track
-            }
-            if (TransitionType.fromMethodName(name).isPresent())
-                return true;
-            break;
-        }
-        return false;
-    }
-
-    private MethodDeclaration findMethodInHierarchy(String methodName, TypeDeclaration td) {
-        return findMethodInHierarchy(methodName, td, new HashSet<>());
-    }
-
-    private MethodDeclaration findMethodInHierarchy(String methodName, TypeDeclaration td, Set<String> visited) {
-        if (td == null)
-            return null;
-
-        String fqn = context.getFqn(td);
-        if (visited.contains(fqn))
-            return null;
-        visited.add(fqn);
-
-        for (MethodDeclaration method : td.getMethods())
-            if (method.getName().getIdentifier().equals(methodName))
-                return method;
-
-        Type superclassType = td.getSuperclassType();
-        if (superclassType != null) {
-            TypeDeclaration superclassTd = context.getTypeDeclaration(getSimpleName(superclassType), (CompilationUnit) td.getRoot());
-            return findMethodInHierarchy(methodName, superclassTd, visited);
-        }
-        return null;
-    }
-
-    private boolean isRelevantMethod(MethodDeclaration method) {
-        return true;
-    }
-
-    private MethodDeclaration findConfigureTransitionsMethod(TypeDeclaration td) {
-        for (MethodDeclaration method : td.getMethods())
-            if (isConfigureTransitionsMethod(method))
-                return method;
-        return null;
-    }
-
-    private boolean isConfigureTransitionsMethod(MethodDeclaration method) {
-        if (!method.getName().getIdentifier().equals("configure") || method.parameters().isEmpty())
-            return false;
-        return ((SingleVariableDeclaration) method.parameters().get(0)).getType().toString().contains("StateMachineTransitionConfigurer");
-    }
+    private final StateMachineAdapterParser adapterParser;
 
     @Getter
     private final Set<String> initialStates = new HashSet<>();
     @Getter
     private final Set<String> endStates = new HashSet<>();
 
+    public StateMachineAggregator(CodebaseContext context) {
+        this.context = context;
+        this.adapterParser = new StateMachineAdapterParser(context);
+    }
+
+    public List<Transition> aggregateTransitions(TypeDeclaration startClass) {
+        return adapterParser.parseTransitions(startClass);
+    }
+
     public void aggregateStates(TypeDeclaration startClass) {
-        Set<MethodVisit> visitedMethods = new HashSet<>();
-        aggregateStatesRecursive(startClass, startClass, initialStates, endStates, new HashSet<>(), visitedMethods, new HashMap<>());
-    }
-
-    private void aggregateStatesRecursive(TypeDeclaration currentTd, TypeDeclaration searchStartClass, Set<String> initialStates, Set<String> endStates, Set<String> visitedClasses, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
-        if (currentTd == null)
-            return;
-        String fqn = context.getFqn(currentTd);
-        if (visitedClasses.contains(fqn))
-            return;
-        visitedClasses.add(fqn);
-
-        for (MethodDeclaration method : currentTd.getMethods()) {
-            if (isConfigureStatesMethod(method)) {
-                parseStatesWithMethodCalls(method, searchStartClass, initialStates, endStates, visitedMethods, argsMap);
-            }
-        }
-
-        CompilationUnit cu = (CompilationUnit) currentTd.getRoot();
-
-        // Hierarchy - Superclass
-        Type superclassType = currentTd.getSuperclassType();
-        if (superclassType != null) {
-            TypeDeclaration superclassTd = context.getTypeDeclaration(getSimpleName(superclassType), cu);
-            if (superclassTd != null)
-                aggregateStatesRecursive(superclassTd, searchStartClass, initialStates, endStates, visitedClasses, visitedMethods, argsMap);
-        }
-
-        // Hierarchy - Interfaces
-        for (Object interfaceTypeObj : currentTd.superInterfaceTypes()) {
-            if (interfaceTypeObj instanceof Type interfaceType) {
-                TypeDeclaration interfaceTd = context.getTypeDeclaration(getSimpleName(interfaceType), cu);
-                if (interfaceTd != null)
-                    aggregateStatesRecursive(interfaceTd, searchStartClass, initialStates, endStates, visitedClasses, visitedMethods, argsMap);
-            }
-        }
-    }
-
-    private void parseStatesWithMethodCalls(MethodDeclaration method, TypeDeclaration searchStartClass, Set<String> initialStates, Set<String> endStates, Set<MethodVisit> visitedMethods, Map<String, Object> argsMap) {
-        MethodVisit visit = new MethodVisit(method, new HashMap<>(argsMap));
-        if (visitedMethods.contains(visit))
-            return;
-        visitedMethods.add(visit);
-        Block body = method.getBody();
-        if (body == null)
-            return;
-
-        parseStatesInBlock(body, searchStartClass, initialStates, endStates, visitedMethods, argsMap);
-    }
-
-    private boolean isWithStatesChain(MethodInvocation mi, Map<String, Object> argsMap) {
-        Expression current = mi;
-        Set<Expression> visited = new HashSet<>();
-        while (current instanceof MethodInvocation call) {
-            if (!visited.add(current))
-                break;
-            if (call.getName().getIdentifier().equals("withStates"))
-                return true;
-            Expression receiver = call.getExpression();
-            if (receiver instanceof MethodInvocation next) {
-                current = next;
-                continue;
-            }
-            Object resolved = resolve(receiver, argsMap);
-            if (resolved instanceof MethodInvocation next) {
-                current = next;
-                continue;
-            }
-            break;
-        }
-        return false;
-    }
-
-    private void parseStateChain(MethodInvocation mi, Set<String> initialStates, Set<String> endStates, Map<String, Object> argsMap) {
-        List<MethodInvocation> chain = new ArrayList<>();
-        Expression current = mi;
-        while (current instanceof MethodInvocation m) {
-            chain.addFirst(m);
-            current = m.getExpression();
-        }
-        CompilationUnit cu = (CompilationUnit) mi.getRoot();
-        for (MethodInvocation call : chain) {
-            String methodName = call.getName().getIdentifier();
-            if (call.arguments().isEmpty())
-                continue;
-            Expression arg = resolveExpression((Expression) call.arguments().get(0), argsMap);
-            if ("initial".equals(methodName)) {
-                if (!isInsideRegionOrFork(call)) {
-                    initialStates.add(context.resolveState(arg, cu).toString());
-                }
-            } else if ("end".equals(methodName)) {
-                endStates.add(context.resolveState(arg, cu).toString());
-            }
-        }
-    }
-
-    private boolean isInsideRegionOrFork(MethodInvocation mi) {
-        Expression expr = mi.getExpression();
-        while (expr instanceof MethodInvocation parent) {
-            if (List.of("fork", "region").contains(parent.getName().getIdentifier()))
-                return true;
-            expr = parent.getExpression();
-        }
-        return false;
-    }
-
-    private MethodDeclaration findConfigureStatesMethod(TypeDeclaration td) {
-        for (MethodDeclaration method : td.getMethods())
-            if (isConfigureStatesMethod(method))
-                return method;
-        return null;
-    }
-
-    private boolean isConfigureStatesMethod(MethodDeclaration method) {
-        if (!method.getName().getIdentifier().equals("configure") || method.parameters().isEmpty())
-            return false;
-        return ((SingleVariableDeclaration) method.parameters().get(0)).getType().toString().contains("StateMachineStateConfigurer");
-    }
-
-    private String getSimpleName(Type type) {
-        if (type.isSimpleType())
-            return ((SimpleType) type).getName().getFullyQualifiedName();
-        if (type.isParameterizedType())
-            return getSimpleName(((ParameterizedType) type).getType());
-        return type.toString();
+        StateMachineAdapterParser.AdapterStates states = adapterParser.parseStates(startClass);
+        this.initialStates.clear();
+        this.initialStates.addAll(states.initialStates());
+        this.endStates.clear();
+        this.endStates.addAll(states.endStates());
     }
 }

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

@@ -44,6 +44,23 @@ public class TransitionStateUtils {
                 .collect(Collectors.toSet());
     }
 
+    public static Set<State> findAllStates(Collection<Transition> transitions, Set<String> initialStates, Set<String> endStates) {
+        Set<State> allStates = new java.util.HashSet<>();
+        if (transitions != null) {
+            transitions.forEach(t -> {
+                if (t.getSourceStates() != null) allStates.addAll(t.getSourceStates());
+                if (t.getTargetStates() != null) allStates.addAll(t.getTargetStates());
+            });
+        }
+        if (initialStates != null) {
+            initialStates.forEach(s -> allStates.add(State.of(s)));
+        }
+        if (endStates != null) {
+            endStates.forEach(s -> allStates.add(State.of(s)));
+        }
+        return allStates;
+    }
+
     private static Stream<String> normalizeStates(Collection<State> states) {
         return states.stream()
                 .map(State::toString)

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

@@ -36,4 +36,85 @@ 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) {
+        if (typeBinding == null) return false;
+        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;
+    }
+
+    public static String findConditionConstraint(org.eclipse.jdt.core.dom.ASTNode node) {
+        java.util.List<String> conditions = new java.util.ArrayList<>();
+        org.eclipse.jdt.core.dom.ASTNode current = node;
+        while (current != null && !(current instanceof org.eclipse.jdt.core.dom.MethodDeclaration)) {
+            org.eclipse.jdt.core.dom.ASTNode parent = current.getParent();
+            if (parent instanceof org.eclipse.jdt.core.dom.IfStatement ifStmt) {
+                if (ifStmt.getExpression() != current) {
+                    org.eclipse.jdt.core.dom.Expression cond = ifStmt.getExpression();
+                    if (current == ifStmt.getElseStatement()) {
+                        conditions.add("!(" + cond.toString() + ")");
+                    } else {
+                        conditions.add(cond.toString());
+                    }
+                }
+            }
+            current = parent;
+        }
+        if (conditions.isEmpty()) return null;
+        java.util.Collections.reverse(conditions);
+        return String.join(" && ", conditions);
+    }
 }

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

@@ -0,0 +1,108 @@
+package click.kamil.springstatemachineexporter.ast.common;
+
+import org.eclipse.jdt.core.dom.*;
+import java.util.Set;
+
+public final class BindingResolver {
+
+    private BindingResolver() {
+        // Prevent instantiation
+    }
+
+    /**
+     * Resolves the type binding for a given AST Type node.
+     */
+    public static ITypeBinding resolveType(Type type) {
+        if (type == null) return null;
+        return type.resolveBinding();
+    }
+
+    /**
+     * Resolves the type binding for a given AST Expression node.
+     */
+    public static ITypeBinding resolveType(Expression expression) {
+        if (expression == null) return null;
+        return expression.resolveTypeBinding();
+    }
+
+    /**
+     * Resolves the method binding for a MethodInvocation.
+     */
+    public static IMethodBinding resolveMethod(MethodInvocation invocation) {
+        if (invocation == null) return null;
+        return invocation.resolveMethodBinding();
+    }
+
+    /**
+     * Resolves the constructor binding for a ClassInstanceCreation.
+     */
+    public static IMethodBinding resolveConstructor(ClassInstanceCreation creation) {
+        if (creation == null) return null;
+        return creation.resolveConstructorBinding();
+    }
+
+    /**
+     * Resolves the constructor binding for a ConstructorInvocation (e.g. this(...)).
+     */
+    public static IMethodBinding resolveConstructor(ConstructorInvocation invocation) {
+        if (invocation == null) return null;
+        return invocation.resolveConstructorBinding();
+    }
+
+    /**
+     * Resolves the constructor binding for a SuperConstructorInvocation (e.g. super(...)).
+     */
+    public static IMethodBinding resolveConstructor(SuperConstructorInvocation invocation) {
+        if (invocation == null) return null;
+        return invocation.resolveConstructorBinding();
+    }
+
+    /**
+     * Resolves the type binding of a TypeDeclaration.
+     */
+    public static ITypeBinding resolveType(TypeDeclaration td) {
+        if (td == null) return null;
+        return td.resolveBinding();
+    }
+
+    /**
+     * Gets the fully qualified name of a type binding, safely handling nulls and erasure.
+     */
+    public static String getFullyQualifiedName(ITypeBinding binding) {
+        if (binding == null) return null;
+        return binding.getErasure().getQualifiedName();
+    }
+
+    public static boolean isSubtypeOf(ITypeBinding childBinding, String targetFqn) {
+        return isSubtypeOf(childBinding, targetFqn, new java.util.HashSet<>());
+    }
+
+    private static boolean isSubtypeOf(ITypeBinding childBinding, String targetFqn, Set<String> visited) {
+        if (childBinding == null || targetFqn == null) return false;
+        
+        String key = childBinding.getKey();
+        if (key != null && !visited.add(key)) {
+            return false;
+        }
+
+        // Direct match
+        if (targetFqn.equals(childBinding.getErasure().getQualifiedName())) {
+            return true;
+        }
+
+        // Check interfaces
+        for (ITypeBinding intf : childBinding.getInterfaces()) {
+            if (isSubtypeOf(intf, targetFqn, visited)) {
+                return true;
+            }
+        }
+
+        // Check superclass
+        ITypeBinding superclass = childBinding.getSuperclass();
+        if (superclass != null) {
+            return isSubtypeOf(superclass, targetFqn, visited);
+        }
+
+        return false;
+    }
+}

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

@@ -0,0 +1,170 @@
+package click.kamil.springstatemachineexporter.ast.common;
+
+import org.eclipse.jdt.core.dom.*;
+import java.util.*;
+
+public class CfgBuilder {
+
+    public static ControlFlowGraph build(MethodDeclaration method) {
+        ControlFlowGraph cfg = new ControlFlowGraph(method);
+        if (method.getBody() == null) {
+            cfg.getEntryNode().addSuccessor(cfg.getExitNode());
+            return cfg;
+        }
+
+        // Build CFG recursively
+        List<ControlFlowGraph.CfgNode> exits = buildFlow(method.getBody(), List.of(cfg.getEntryNode()), cfg);
+        for (ControlFlowGraph.CfgNode exit : exits) {
+            exit.addSuccessor(cfg.getExitNode());
+        }
+
+        return cfg;
+    }
+
+    private static List<ControlFlowGraph.CfgNode> buildFlow(
+            ASTNode node, 
+            List<ControlFlowGraph.CfgNode> sources, 
+            ControlFlowGraph cfg) {
+        
+        if (node == null || sources.isEmpty()) {
+            return sources;
+        }
+
+        if (node instanceof Block block) {
+            List<ControlFlowGraph.CfgNode> currentSources = sources;
+            for (Object stmtObj : block.statements()) {
+                currentSources = buildFlow((ASTNode) stmtObj, currentSources, cfg);
+            }
+            return currentSources;
+        }
+
+        if (node instanceof IfStatement ifStmt) {
+            // Condition node
+            ControlFlowGraph.CfgNode condNode = new ControlFlowGraph.CfgNode(ifStmt.getExpression(), ControlFlowGraph.CfgNodeType.STATEMENT);
+            cfg.addNode(condNode);
+            for (ControlFlowGraph.CfgNode src : sources) {
+                src.addSuccessor(condNode);
+            }
+
+            List<ControlFlowGraph.CfgNode> thenExits = buildFlow(ifStmt.getThenStatement(), List.of(condNode), cfg);
+            List<ControlFlowGraph.CfgNode> elseExits;
+            if (ifStmt.getElseStatement() != null) {
+                elseExits = buildFlow(ifStmt.getElseStatement(), List.of(condNode), cfg);
+            } else {
+                elseExits = List.of(condNode);
+            }
+
+            List<ControlFlowGraph.CfgNode> combinedExits = new ArrayList<>();
+            combinedExits.addAll(thenExits);
+            combinedExits.addAll(elseExits);
+            return combinedExits;
+        }
+
+        if (node instanceof WhileStatement whileStmt) {
+            ControlFlowGraph.CfgNode condNode = new ControlFlowGraph.CfgNode(whileStmt.getExpression(), ControlFlowGraph.CfgNodeType.STATEMENT);
+            cfg.addNode(condNode);
+            for (ControlFlowGraph.CfgNode src : sources) {
+                src.addSuccessor(condNode);
+            }
+
+            List<ControlFlowGraph.CfgNode> bodyExits = buildFlow(whileStmt.getBody(), List.of(condNode), cfg);
+            for (ControlFlowGraph.CfgNode exit : bodyExits) {
+                exit.addSuccessor(condNode); // Loop back
+            }
+
+            return List.of(condNode); // Exit loop when cond is false
+        }
+
+        if (node instanceof DoStatement doStmt) {
+            ControlFlowGraph.CfgNode condNode = new ControlFlowGraph.CfgNode(doStmt.getExpression(), ControlFlowGraph.CfgNodeType.STATEMENT);
+            cfg.addNode(condNode);
+
+            List<ControlFlowGraph.CfgNode> bodySources = new ArrayList<>(sources);
+            bodySources.add(condNode);
+
+            List<ControlFlowGraph.CfgNode> bodyExits = buildFlow(doStmt.getBody(), bodySources, cfg);
+            for (ControlFlowGraph.CfgNode exit : bodyExits) {
+                exit.addSuccessor(condNode);
+            }
+            return List.of(condNode);
+        }
+
+        if (node instanceof ForStatement forStmt) {
+            // Initializers
+            List<ControlFlowGraph.CfgNode> currentSources = sources;
+            for (Object initObj : forStmt.initializers()) {
+                ControlFlowGraph.CfgNode initNode = new ControlFlowGraph.CfgNode((ASTNode) initObj, ControlFlowGraph.CfgNodeType.STATEMENT);
+                cfg.addNode(initNode);
+                for (ControlFlowGraph.CfgNode src : currentSources) {
+                    src.addSuccessor(initNode);
+                }
+                currentSources = List.of(initNode);
+            }
+
+            // Condition
+            ControlFlowGraph.CfgNode condNode;
+            if (forStmt.getExpression() != null) {
+                condNode = new ControlFlowGraph.CfgNode(forStmt.getExpression(), ControlFlowGraph.CfgNodeType.STATEMENT);
+            } else {
+                condNode = new ControlFlowGraph.CfgNode(forStmt, ControlFlowGraph.CfgNodeType.STATEMENT); // Dummy node
+            }
+            cfg.addNode(condNode);
+            for (ControlFlowGraph.CfgNode src : currentSources) {
+                src.addSuccessor(condNode);
+            }
+
+            List<ControlFlowGraph.CfgNode> bodyExits = buildFlow(forStmt.getBody(), List.of(condNode), cfg);
+
+            // Updaters
+            List<ControlFlowGraph.CfgNode> updaterSources = bodyExits;
+            for (Object updateObj : forStmt.updaters()) {
+                ControlFlowGraph.CfgNode updateNode = new ControlFlowGraph.CfgNode((ASTNode) updateObj, ControlFlowGraph.CfgNodeType.STATEMENT);
+                cfg.addNode(updateNode);
+                for (ControlFlowGraph.CfgNode src : updaterSources) {
+                    src.addSuccessor(updateNode);
+                }
+                updaterSources = List.of(updateNode);
+            }
+
+            for (ControlFlowGraph.CfgNode src : updaterSources) {
+                src.addSuccessor(condNode); // Loop back
+            }
+
+            return List.of(condNode);
+        }
+
+        if (node instanceof EnhancedForStatement effStmt) {
+            ControlFlowGraph.CfgNode loopNode = new ControlFlowGraph.CfgNode(effStmt.getParameter(), ControlFlowGraph.CfgNodeType.STATEMENT);
+            cfg.addNode(loopNode);
+            for (ControlFlowGraph.CfgNode src : sources) {
+                src.addSuccessor(loopNode);
+            }
+
+            List<ControlFlowGraph.CfgNode> bodyExits = buildFlow(effStmt.getBody(), List.of(loopNode), cfg);
+            for (ControlFlowGraph.CfgNode exit : bodyExits) {
+                exit.addSuccessor(loopNode); // Loop back
+            }
+
+            return List.of(loopNode);
+        }
+
+        if (node instanceof ReturnStatement returnStmt) {
+            ControlFlowGraph.CfgNode retNode = new ControlFlowGraph.CfgNode(returnStmt, ControlFlowGraph.CfgNodeType.STATEMENT);
+            cfg.addNode(retNode);
+            for (ControlFlowGraph.CfgNode src : sources) {
+                src.addSuccessor(retNode);
+            }
+            // Return flows to exit, not to subsequent sequential nodes
+            retNode.addSuccessor(cfg.getExitNode());
+            return Collections.emptyList();
+        }
+
+        // Default: general statement
+        ControlFlowGraph.CfgNode stmtNode = new ControlFlowGraph.CfgNode(node, ControlFlowGraph.CfgNodeType.STATEMENT);
+        cfg.addNode(stmtNode);
+        for (ControlFlowGraph.CfgNode src : sources) {
+            src.addSuccessor(stmtNode);
+        }
+        return List.of(stmtNode);
+    }
+}

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

@@ -1,47 +1,237 @@
 package click.kamil.springstatemachineexporter.ast.common;
 
+import click.kamil.springstatemachineexporter.analysis.model.LibraryHint;
+import click.kamil.springstatemachineexporter.analysis.resolver.ConstantResolver;
+import click.kamil.springstatemachineexporter.analysis.resolver.PropertyResolver;
+import click.kamil.springstatemachineexporter.analysis.util.PlaceholderResolver;
 import click.kamil.springstatemachineexporter.model.State;
-import org.eclipse.jdt.core.dom.AST;
-import org.eclipse.jdt.core.dom.ASTParser;
-import org.eclipse.jdt.core.dom.Annotation;
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.dom.Expression;
-import org.eclipse.jdt.core.dom.ImportDeclaration;
-import org.eclipse.jdt.core.dom.MethodDeclaration;
-import org.eclipse.jdt.core.dom.Modifier;
-import org.eclipse.jdt.core.dom.QualifiedName;
-import org.eclipse.jdt.core.dom.SimpleName;
-import org.eclipse.jdt.core.dom.StringLiteral;
-import org.eclipse.jdt.core.dom.Type;
-import org.eclipse.jdt.core.dom.TypeDeclaration;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.dom.*;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import lombok.extern.slf4j.Slf4j;
+import click.kamil.springstatemachineexporter.spi.SourceContext;
 
-public class CodebaseContext {
+@Slf4j
+public class CodebaseContext implements SourceContext {
     private final Map<String, CompilationUnit> classes = new HashMap<>();
     private final Map<String, Path> classPaths = new HashMap<>();
     private final Map<String, String> simpleNameToFqn = new HashMap<>();
     private final Set<String> ambiguousSimpleNames = new HashSet<>();
+    private final ConstantResolver constantResolver = new ConstantResolver();
+    private final StateResolver stateResolver = new StateResolver(this);
+    private final PropertyResolver propertyResolver = new PropertyResolver();
+
+    public ConstantResolver getConstantResolver() {
+        return constantResolver;
+    }
+    private final List<String> activeProfiles = new ArrayList<>();
+    private Map<String, Map<String, String>> allProperties = new HashMap<>();
+    private List<LibraryHint> libraryHints = new ArrayList<>();
+    private final ObjectMapper objectMapper = new ObjectMapper();
+    private Path projectRoot;
+    private final Map<String, Object> cache = new HashMap<>();
+
+    public Map<String, Object> getCache() {
+        return cache;
+    }
+
+    public void setProjectRoot(Path root) {
+        this.projectRoot = root;
+    }
+
+    @Override
+    public Path getProjectRoot() {
+        return projectRoot;
+    }
+
+    public String getRelativePath(Path fullPath) {
+        if (projectRoot != null && fullPath.isAbsolute() && fullPath.startsWith(projectRoot)) {
+            return projectRoot.relativize(fullPath).toString();
+        }
+        return fullPath.getFileName().toString();
+    }
+
+    public String getRelativePath(String fqn) {
+        Path path = classPaths.get(fqn);
+        return path != null ? getRelativePath(path) : null;
+    }
+
+    public void loadLibraryHints(Path hintsFile) throws IOException {
+        if (Files.exists(hintsFile)) {
+            System.out.println("Loading hints from " + hintsFile.toAbsolutePath());
+            this.libraryHints = objectMapper.readValue(hintsFile.toFile(), new TypeReference<List<LibraryHint>>() {});
+            System.out.println("Loaded " + libraryHints.size() + " library hints");
+        }
+    }
+
+    public List<LibraryHint> getLibraryHints() {
+        return Collections.unmodifiableList(libraryHints);
+    }
+
+    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;
+
+    public Map<String, Map<String, String>> getProperties() {
+        return Collections.unmodifiableMap(allProperties);
+    }
+
+    public void setClasspath(List<String> classpath) {
+        this.classpath = classpath.toArray(new String[0]);
+    }
+
+    public List<String> getClasspath() {
+        return java.util.Arrays.asList(classpath);
+    }
+
+    public void setSourcepath(List<String> sourcepath) {
+        this.sourcepath = sourcepath.toArray(new String[0]);
+    }
+
+    public void setResolveBindings(boolean resolveBindings) {
+        this.resolveBindings = resolveBindings;
+    }
+
+    public void setActiveProfiles(List<String> profiles) {
+        this.activeProfiles.clear();
+        if (profiles != null) {
+            this.activeProfiles.addAll(profiles);
+        }
+        this.propertyResolver.setActiveProfiles(profiles);
+    }
+
+    public String resolveString(String input) {
+        if (input == null) return null;
+
+        Map<String, String> merged = new HashMap<>();
+        // 1. Default properties
+        Map<String, String> defaultProps = allProperties.get("default");
+        if (defaultProps != null) {
+            merged.putAll(defaultProps);
+        }
+
+        // 2. Active profiles (later ones override earlier ones)
+        for (String profile : activeProfiles) {
+            Map<String, String> profileProps = allProperties.get(profile);
+            if (profileProps != null) {
+                merged.putAll(profileProps);
+            }
+        }
+
+        return PlaceholderResolver.resolve(input, merged);
+    }
+
+    public String resolveExpression(Expression expr) {
+        if (expr == null) return null;
+
+        String astResolved = constantResolver.resolve(expr, this);
+        if (astResolved == null) {
+            astResolved = expr.toString().replaceAll("^\"|\"$", "");
+        }
+
+        return resolveString(astResolved);
+    }
+    public TypeDeclaration resolveStaticImport(String memberName, CompilationUnit contextCu) {
+        if (contextCu == null) return null;
+
+        for (Object impObj : contextCu.imports()) {
+            ImportDeclaration imp = (ImportDeclaration) impObj;
+            if (imp.isStatic()) {
+                String impName = imp.getName().getFullyQualifiedName();
+                if (imp.isOnDemand()) {
+                    // Star import: import static com.example.C.*;
+                    TypeDeclaration td = getTypeDeclaration(impName, contextCu);
+                    if (td != null && (hasField(td, memberName) || hasMethod(td, memberName))) {
+                        return td;
+                    }
+                } else {
+                    // Single import: import static com.example.C.A;
+                    if (impName.endsWith("." + memberName)) {
+                        String typeFqn = impName.substring(0, impName.lastIndexOf('.'));
+                        return getTypeDeclaration(typeFqn, contextCu);
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    public boolean hasMethod(TypeDeclaration td, String name) {
+        for (MethodDeclaration md : td.getMethods()) {
+            if (md.getName().getIdentifier().equals(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean hasField(TypeDeclaration td, String name) {
+        for (FieldDeclaration fd : td.getFields()) {
+            for (Object fragObj : fd.fragments()) {
+                if (fragObj instanceof VariableDeclarationFragment fragment) {
+                    if (fragment.getName().getIdentifier().equals(name)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
 
     public void scan(Path rootDir) throws IOException {
-        List<Path> javaFiles = FileUtils.findFilesWithExtension(Set.of(rootDir), ".java");
+        scan(Set.of(rootDir), Collections.emptySet());
+    }
+
+    private final List<CompilationUnit> allCus = new ArrayList<>();
+
+    private final Map<String, List<String>> interfaceToImpls = new HashMap<>();
+    private final Map<String, List<String>> enumValues = new HashMap<>();
+
+    public void scan(Set<Path> rootDirs, Set<String> customIgnorePatterns) throws IOException {
+        this.allProperties = propertyResolver.resolveAllProperties(rootDirs);
+
+        Set<String> activeIgnore = new HashSet<>(ignorePatterns);
+        activeIgnore.addAll(customIgnorePatterns);
+
+        List<Path> javaFiles = FileUtils.findFilesWithExtension(rootDirs, ".java", activeIgnore);
+        log.info("CodebaseContext found {} java files across {} root directories", javaFiles.size(), rootDirs.size());
         for (Path javaFile : javaFiles) {
             String source = Files.readString(javaFile);
-            CompilationUnit cu = parse(source);
+            CompilationUnit cu = parse(source, javaFile.toAbsolutePath().toString());
+            allCus.add(cu);
+            
             String packageName = cu.getPackage() != null ? cu.getPackage().getName().getFullyQualifiedName() : "";
             for (Object type : cu.types()) {
                 if (type instanceof TypeDeclaration td) {
+                    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);
+                }
+            }
+        }
+    }
+
+    private void indexType(TypeDeclaration td, String parentFqn, Path javaFile) {
         String simpleName = td.getName().getIdentifier();
-                    String fqn = packageName.isEmpty() ? simpleName : packageName + "." + simpleName;
-                    classes.put(fqn, cu);
+        String fqn = parentFqn.isEmpty() ? simpleName : parentFqn + "." + simpleName;
+        
+        classes.put(fqn, (CompilationUnit) td.getRoot());
         classPaths.put(fqn, javaFile);
 
         if (simpleNameToFqn.containsKey(simpleName)) {
@@ -52,56 +242,180 @@ public class CodebaseContext {
         } else {
             simpleNameToFqn.put(simpleName, fqn);
         }
+
+        // Inheritance Mapping
+        // Track implementations (for both interfaces and superclasses)
+        if (td.superInterfaceTypes() != null) {
+            for (Object itfObj : td.superInterfaceTypes()) {
+                Type itf = (Type) itfObj;
+                String itfName = extractTypeName(itf);
+                interfaceToImpls.computeIfAbsent(itfName, k -> new ArrayList<>()).add(fqn);
+            }
+        }
+        Type superclass = td.getSuperclassType();
+        if (superclass != null) {
+            String superName = extractTypeName(superclass);
+            interfaceToImpls.computeIfAbsent(superName, k -> new ArrayList<>()).add(fqn);
+        }
+
+        // Recursively index nested types
+        for (Object decl : td.bodyDeclarations()) {
+            if (decl instanceof TypeDeclaration nestedTd) {
+                indexType(nestedTd, fqn, javaFile);
+            } else if (decl instanceof EnumDeclaration nestedEd) {
+                indexEnum(nestedEd, fqn, javaFile);
+            } else if (decl instanceof org.eclipse.jdt.core.dom.RecordDeclaration nestedRd) {
+                indexRecord(nestedRd, fqn, javaFile);
             }
         }
     }
+
+    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 decl : rd.bodyDeclarations()) {
+            if (decl instanceof TypeDeclaration nestedTd) {
+                indexType(nestedTd, fqn, javaFile);
+            } else if (decl instanceof EnumDeclaration nestedEd) {
+                indexEnum(nestedEd, fqn, javaFile);
+            } else if (decl instanceof org.eclipse.jdt.core.dom.RecordDeclaration nestedRd) {
+                indexRecord(nestedRd, fqn, javaFile);
+            }
+        }
+    }
+
+    public List<String> getImplementations(String interfaceName) {
+        String cleanName = interfaceName;
+        if (interfaceName != null && interfaceName.contains("<")) {
+            cleanName = interfaceName.substring(0, interfaceName.indexOf('<'));
+        }
+        Set<String> allImpls = new HashSet<>();
+        collectImplementations(cleanName, allImpls, new HashSet<>());
+        return new ArrayList<>(allImpls);
+    }
+
+    private void collectImplementations(String typeName, Set<String> results, Set<String> visited) {
+        String cleanName = typeName;
+        if (typeName != null && typeName.contains("<")) {
+            cleanName = typeName.substring(0, typeName.indexOf('<'));
+        }
+        if (!visited.add(cleanName)) return;
+
+        // Try direct match
+        List<String> directImpls = interfaceToImpls.get(cleanName);
+        
+        // Try FQN match if input was simple name
+        if (directImpls == null) {
+            String fqn = simpleNameToFqn.get(typeName);
+            if (fqn != null) {
+                directImpls = interfaceToImpls.get(fqn);
+            }
+        }
+        
+        // Try simple name match if input was FQN
+        if (directImpls == null && typeName.contains(".")) {
+            String simpleName = typeName.substring(typeName.lastIndexOf('.') + 1);
+            directImpls = interfaceToImpls.get(simpleName);
+        }
+
+        if (directImpls != null) {
+            for (String impl : directImpls) {
+                results.add(impl);
+                // Recursively find implementations of the implementation (e.g., subclasses of an abstract class)
+                collectImplementations(impl, results, visited);
+            }
+        }
+    }
+
+    private void indexEnum(EnumDeclaration ed, String parentFqn, Path javaFile) {
+        String simpleName = ed.getName().getIdentifier();
+        String fqn = parentFqn.isEmpty() ? simpleName : parentFqn + "." + simpleName;
+        
+        classes.put(fqn, (CompilationUnit) ed.getRoot());
+        classPaths.put(fqn, javaFile);
+        
+        List<String> values = new ArrayList<>();
+        for (Object o : ed.enumConstants()) {
+            if (o instanceof EnumConstantDeclaration ecd) {
+                values.add(fqn + "." + ecd.getName().getIdentifier());
+            }
+        }
+        enumValues.put(fqn, values);
+        if (!simpleNameToFqn.containsKey(simpleName)) {
+            simpleNameToFqn.put(simpleName, fqn);
+        }
+
+        // Recursively index nested types inside enum body
+        for (Object decl : ed.bodyDeclarations()) {
+            if (decl instanceof TypeDeclaration nestedTd) {
+                indexType(nestedTd, fqn, javaFile);
+            } else if (decl instanceof EnumDeclaration nestedEd) {
+                indexEnum(nestedEd, fqn, javaFile);
+            } else if (decl instanceof org.eclipse.jdt.core.dom.RecordDeclaration nestedRd) {
+                indexRecord(nestedRd, fqn, javaFile);
+            }
+        }
+    }
+
+    public Map<String, List<String>> getEnumValuesMap() {
+        return enumValues;
+    }
+
+    public List<String> getEnumValues(String fqnOrSimpleName) {
+        if (fqnOrSimpleName == null) return null;
+        
+        String cleanName = fqnOrSimpleName;
+        if (cleanName.contains("<")) {
+            cleanName = cleanName.substring(0, cleanName.indexOf('<'));
+        }
+        if (cleanName.contains("[")) {
+            cleanName = cleanName.substring(0, cleanName.indexOf('['));
+        }
+        cleanName = cleanName.trim();
+
+        List<String> values = enumValues.get(cleanName);
+        if (values == null) {
+            String fqn = simpleNameToFqn.get(cleanName);
+            if (fqn != null) values = enumValues.get(fqn);
+        }
+        log.debug("getEnumValues called for: {} resolved to {}. Returns: {}", fqnOrSimpleName, cleanName, values);
+        return values;
     }
 
     public State resolveState(Expression expr, CompilationUnit cu) {
-        if (expr == null)
-            return null;
-        if (expr instanceof StringLiteral sl)
-            return State.of(sl.getLiteralValue());
-
-        String raw = expr.toString();
-        if (expr instanceof QualifiedName qn) {
-            String full = resolveQualifiedName(qn, cu);
-            return State.of(raw, full);
-        }
-        if (expr instanceof SimpleName sn) {
-            String full = resolveSimpleName(sn, cu);
-            return State.of(raw, full);
-        }
-        return State.of(raw);
+        return stateResolver.resolveState(expr, cu);
     }
 
-    private String resolveQualifiedName(QualifiedName qn, CompilationUnit cu) {
-        String qualifier = qn.getQualifier().toString();
-        String name = qn.getName().getIdentifier();
-        TypeDeclaration td = getTypeDeclaration(qualifier, cu);
-        if (td != null)
-            return getFqn(td) + "." + name;
-        return qn.getFullyQualifiedName();
-    }
-
-    private String resolveSimpleName(SimpleName sn, CompilationUnit cu) {
-        String name = sn.getIdentifier();
-        if (cu == null)
-            return name;
-        for (Object impObj : cu.imports()) {
-            ImportDeclaration imp = (ImportDeclaration) impObj;
-            String impName = imp.getName().getFullyQualifiedName();
-            if (impName.endsWith("." + name))
-                return impName;
-        }
-        return name;
-    }
-
-    private CompilationUnit parse(String source) {
+    private CompilationUnit parse(String source, String unitName) {
         ASTParser parser = ASTParser.newParser(AST.getJLSLatest());
         parser.setSource(source.toCharArray());
         parser.setKind(ASTParser.K_COMPILATION_UNIT);
-        parser.setResolveBindings(false);
+        parser.setResolveBindings(resolveBindings);
+        parser.setBindingsRecovery(true);
+
+        Map<String, String> options = JavaCore.getOptions();
+        JavaCore.setComplianceOptions(JavaCore.VERSION_21, options);
+        parser.setCompilerOptions(options);
+
+        if (resolveBindings) {
+            parser.setUnitName(unitName);
+            parser.setEnvironment(classpath, sourcepath, null, true);
+        }
         return (CompilationUnit) parser.createAST(null);
     }
 
@@ -138,6 +452,14 @@ public class CodebaseContext {
 
         // 2. Check imports in contextCu
         if (contextCu != null) {
+            for (Object typeObj : contextCu.types()) {
+                if (typeObj instanceof TypeDeclaration tdDecl) {
+                    if (tdDecl.getName().getIdentifier().equals(name)) {
+                        return tdDecl;
+                    }
+                }
+            }
+
             for (Object impObj : contextCu.imports()) {
                 ImportDeclaration imp = (ImportDeclaration) impObj;
                 String impName = imp.getName().getFullyQualifiedName();
@@ -173,26 +495,241 @@ public class CodebaseContext {
         return getTypeDeclaration(name);
     }
 
-    public String getFqn(TypeDeclaration td) {
-        CompilationUnit cu = (CompilationUnit) td.getRoot();
+    public String getSuperclassFqn(TypeDeclaration td) {
+        if (td == null) return null;
+        ITypeBinding binding = td.resolveBinding();
+        if (binding != null) {
+            ITypeBinding superBinding = binding.getSuperclass();
+            if (superBinding != null) {
+                return superBinding.getErasure().getQualifiedName();
+            }
+        }
+        
+        Type superType = td.getSuperclassType();
+        if (superType == null) return null;
+        
+        String superName = extractTypeName(superType);
+        CompilationUnit cu = (td.getRoot() instanceof CompilationUnit) ? (CompilationUnit) td.getRoot() : null;
+        TypeDeclaration superTd = getTypeDeclaration(superName, cu);
+        return superTd != null ? getFqn(superTd) : superName;
+    }
+
+    private String extractTypeName(Type type) {
+        if (type.isParameterizedType()) {
+            return extractTypeName(((ParameterizedType) type).getType());
+        } else if (type.isSimpleType()) {
+            return ((SimpleType) type).getName().getFullyQualifiedName();
+        } else if (type.isQualifiedType()) {
+            return ((QualifiedType) type).getName().getFullyQualifiedName();
+        }
+        return type.toString();
+    }
+
+    public MethodDeclaration findMethodDeclaration(TypeDeclaration td, String methodName, boolean includeSuper) {
+        if (td == null) return null;
+        ITypeBinding binding = td.resolveBinding();
+        if (binding != null && includeSuper) {
+            IMethodBinding methodBinding = findMethodBinding(binding, methodName);
+            if (methodBinding != null && methodBinding.getDeclaringClass() != null) {
+                CompilationUnit declaringCu = classes.get(methodBinding.getDeclaringClass().getErasure().getQualifiedName());
+                if (declaringCu != null) {
+                    ASTNode declNode = declaringCu.findDeclaringNode(methodBinding.getKey());
+                    if (declNode instanceof MethodDeclaration) {
+                        return (MethodDeclaration) declNode;
+                    }
+                }
+            }
+        }
+        return findMethodDeclarationLegacy(td, methodName, includeSuper);
+    }
+
+    private IMethodBinding findMethodBinding(ITypeBinding typeBinding, String methodName) {
+        return findMethodBinding(typeBinding, methodName, new java.util.HashSet<>());
+    }
+
+    private IMethodBinding findMethodBinding(ITypeBinding typeBinding, String methodName, Set<String> visited) {
+        if (typeBinding == null) return null;
+        String key = typeBinding.getKey();
+        if (key != null && !visited.add(key)) {
+            return null;
+        }
+
+        for (IMethodBinding mb : typeBinding.getDeclaredMethods()) {
+            if (mb.getName().equals(methodName)) {
+                return mb;
+            }
+        }
+        
+        ITypeBinding superclass = typeBinding.getSuperclass();
+        if (superclass != null) {
+            IMethodBinding mb = findMethodBinding(superclass, methodName, visited);
+            if (mb != null) return mb;
+        }
+
+        for (ITypeBinding intf : typeBinding.getInterfaces()) {
+            IMethodBinding mb = findMethodBinding(intf, methodName, visited);
+            if (mb != null) return mb;
+        }
+
+        return null;
+    }
+
+    private MethodDeclaration findMethodDeclarationLegacy(TypeDeclaration td, String methodName, boolean includeSuper) {
+        if (td == null) return null;
+        for (MethodDeclaration method : td.getMethods()) {
+            if (method.getName().getIdentifier().equals(methodName)) {
+                return method;
+            }
+        }
+
+        if (includeSuper) {
+            String superFqn = getSuperclassFqn(td);
+            if (superFqn != null) {
+                TypeDeclaration superTd = getTypeDeclaration(superFqn);
+                if (superTd != null) {
+                    return findMethodDeclarationLegacy(superTd, methodName, true);
+                }
+            }
+            
+            // Check interfaces
+            for (Object interfaceTypeObj : td.superInterfaceTypes()) {
+                Type interfaceType = (Type) interfaceTypeObj;
+                String interfaceName = extractTypeName(interfaceType);
+                TypeDeclaration interfaceTd = getTypeDeclaration(interfaceName, (td.getRoot() instanceof CompilationUnit) ? (CompilationUnit) td.getRoot() : null);
+                if (interfaceTd != null) {
+                    MethodDeclaration found = findMethodDeclarationLegacy(interfaceTd, methodName, true);
+                    if (found != null) return found;
+                }
+            }
+        }
+        return null;
+    }
+
+    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) {
+        if (atd == null) return null;
+        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 = (atd.getRoot() instanceof CompilationUnit) ? (CompilationUnit) atd.getRoot() : null;
+        if (cu == null) {
+            return sb.toString();
+        }
         String packageName = cu.getPackage() != null ? cu.getPackage().getName().getFullyQualifiedName() : "";
-        String simpleName = td.getName().getIdentifier();
-        return packageName.isEmpty() ? simpleName : packageName + "." + simpleName;
+        String fqn = sb.toString();
+        return packageName.isEmpty() ? fqn : packageName + "." + fqn;
     }
 
     private TypeDeclaration findTypeInCu(CompilationUnit cu, String fqn) {
-        String packageName = cu.getPackage() != null ? cu.getPackage().getName().getFullyQualifiedName() : "";
         for (Object type : cu.types()) {
             if (type instanceof TypeDeclaration td) {
-                String simpleName = td.getName().getIdentifier();
-                String typeFqn = packageName.isEmpty() ? simpleName : packageName + "." + simpleName;
-                if (typeFqn.equals(fqn))
-                    return td;
+                TypeDeclaration found = findNestedType(td, fqn);
+                if (found != null) return found;
             }
         }
         return null;
     }
 
+    private TypeDeclaration findNestedType(TypeDeclaration td, String targetFqn) {
+        if (getFqn(td).equals(targetFqn)) return td;
+        for (TypeDeclaration nested : td.getTypes()) {
+            TypeDeclaration found = findNestedType(nested, targetFqn);
+            if (found != null) return found;
+        }
+        return null;
+    }
+
     public Path getPath(String className) {
         return classPaths.get(className);
     }
@@ -242,10 +779,19 @@ public class CodebaseContext {
     }
 
     public boolean extendsStateMachineConfigurerAdapter(TypeDeclaration td) {
-        return extendsStateMachineConfigurerAdapter(td, new HashSet<>());
+        ITypeBinding binding = td.resolveBinding();
+        if (binding != null) {
+            boolean isSubtype = BindingResolver.isSubtypeOf(binding, "org.springframework.statemachine.config.builders.StateMachineConfigurer")
+                || BindingResolver.isSubtypeOf(binding, "org.springframework.statemachine.config.StateMachineConfigurerAdapter")
+                || BindingResolver.isSubtypeOf(binding, "org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter");
+            if (isSubtype) {
+                return true;
+            }
+        }
+        return extendsStateMachineConfigurerAdapterLegacy(td, new HashSet<>());
     }
 
-    private boolean extendsStateMachineConfigurerAdapter(TypeDeclaration td, Set<String> visited) {
+    private boolean extendsStateMachineConfigurerAdapterLegacy(TypeDeclaration td, Set<String> visited) {
         String fqn = getFqn(td);
         if (visited.contains(fqn)) {
             return false;
@@ -262,7 +808,7 @@ public class CodebaseContext {
             if (knownAdapters.contains(superclassName))
                 return true;
             TypeDeclaration superTd = getTypeDeclaration(superclassName, cu);
-            if (superTd != null && extendsStateMachineConfigurerAdapter(superTd, visited))
+            if (superTd != null && extendsStateMachineConfigurerAdapterLegacy(superTd, visited))
                 return true;
         }
 
@@ -273,7 +819,7 @@ public class CodebaseContext {
                 if (knownAdapters.contains(interfaceName))
                     return true;
                 TypeDeclaration interfaceTd = getTypeDeclaration(interfaceName, cu);
-                if (interfaceTd != null && extendsStateMachineConfigurerAdapter(interfaceTd, visited))
+                if (interfaceTd != null && extendsStateMachineConfigurerAdapterLegacy(interfaceTd, visited))
                     return true;
             }
         }
@@ -321,4 +867,31 @@ public class CodebaseContext {
     private String getSimpleName(Type type) {
         return AstUtils.extractSimpleTypeName(type);
     }
+
+    public Collection<CompilationUnit> getCompilationUnits() {
+        return Collections.unmodifiableCollection(allCus);
+    }
+
+    public Collection<TypeDeclaration> getTypeDeclarations() {
+        List<TypeDeclaration> types = new ArrayList<>();
+        for (CompilationUnit cu : allCus) {
+            for (Object typeObj : cu.types()) {
+                if (typeObj instanceof TypeDeclaration td) {
+                    types.add(td);
+                    // Handle nested types
+                    types.addAll(getNestedTypes(td));
+                }
+            }
+        }
+        return types;
+    }
+
+    private List<TypeDeclaration> getNestedTypes(TypeDeclaration td) {
+        List<TypeDeclaration> nested = new ArrayList<>();
+        for (TypeDeclaration inner : td.getTypes()) {
+            nested.add(inner);
+            nested.addAll(getNestedTypes(inner));
+        }
+        return nested;
+    }
 }

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

@@ -0,0 +1,78 @@
+package click.kamil.springstatemachineexporter.ast.common;
+
+import org.eclipse.jdt.core.dom.*;
+import java.util.*;
+
+public class ControlFlowGraph {
+    private final MethodDeclaration method;
+    private final CfgNode entryNode = new CfgNode(null, CfgNodeType.ENTRY);
+    private final CfgNode exitNode = new CfgNode(null, CfgNodeType.EXIT);
+    private final List<CfgNode> nodes = new ArrayList<>();
+
+    public enum CfgNodeType {
+        ENTRY,
+        EXIT,
+        STATEMENT
+    }
+
+    public static class CfgNode {
+        private final ASTNode astNode;
+        private final CfgNodeType type;
+        private final Set<CfgNode> predecessors = new HashSet<>();
+        private final Set<CfgNode> successors = new HashSet<>();
+
+        public CfgNode(ASTNode astNode, CfgNodeType type) {
+            this.astNode = astNode;
+            this.type = type;
+        }
+
+        public ASTNode getAstNode() {
+            return astNode;
+        }
+
+        public CfgNodeType getType() {
+            return type;
+        }
+
+        public Set<CfgNode> getPredecessors() {
+            return predecessors;
+        }
+
+        public Set<CfgNode> getSuccessors() {
+            return successors;
+        }
+
+        public void addSuccessor(CfgNode succ) {
+            if (succ != null) {
+                this.successors.add(succ);
+                succ.predecessors.add(this);
+            }
+        }
+    }
+
+    public ControlFlowGraph(MethodDeclaration method) {
+        this.method = method;
+        this.nodes.add(entryNode);
+        this.nodes.add(exitNode);
+    }
+
+    public MethodDeclaration getMethod() {
+        return method;
+    }
+
+    public CfgNode getEntryNode() {
+        return entryNode;
+    }
+
+    public CfgNode getExitNode() {
+        return exitNode;
+    }
+
+    public List<CfgNode> getNodes() {
+        return nodes;
+    }
+
+    public void addNode(CfgNode node) {
+        this.nodes.add(node);
+    }
+}

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

@@ -0,0 +1,18 @@
+package click.kamil.springstatemachineexporter.ast.common;
+
+import org.eclipse.jdt.core.dom.Expression;
+import java.util.List;
+
+public interface DataFlowModel {
+    /**
+     * Resolves all possible Expressions that define the value of the given expression
+     * at its location in the control flow.
+     */
+    List<Expression> getReachingDefinitions(Expression expr);
+
+    /**
+     * Resolves the single constant/literal value if all definitions converge,
+     * or if a single value is expected.
+     */
+    String resolveValue(Expression expr, CodebaseContext context);
+}

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

@@ -1,8 +1,11 @@
 package click.kamil.springstatemachineexporter.ast.common;
 
 import java.io.IOException;
+import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -10,6 +13,14 @@ import java.util.stream.Stream;
 
 public class FileUtils {
     public static List<Path> findFilesWithExtension(Set<Path> startDirs, String extension) throws RuntimeException {
+        return findFilesWithExtension(startDirs, extension, Collections.emptySet());
+    }
+
+    public static List<Path> findFilesWithExtension(Set<Path> startDirs, String extension, Set<String> ignorePatterns) throws RuntimeException {
+        List<PathMatcher> matchers = ignorePatterns.stream()
+                .map(p -> FileSystems.getDefault().getPathMatcher("glob:" + p))
+                .collect(Collectors.toList());
+
         try (Stream<Path> paths = startDirs.stream()
                 .flatMap(startDir -> {
                     try {
@@ -20,6 +31,10 @@ public class FileUtils {
                 })) {
             return paths
                     .filter(p -> Files.isRegularFile(p) && p.toString().endsWith(extension))
+                    .filter(p -> matchers.stream().noneMatch(m -> m.matches(p)))
+                    .map(Path::toAbsolutePath)
+                    .map(Path::normalize)
+                    .distinct()
                     .collect(Collectors.toList());
         }
     }

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

@@ -0,0 +1,31 @@
+package click.kamil.springstatemachineexporter.ast.common;
+
+import org.eclipse.jdt.core.dom.Expression;
+import click.kamil.springstatemachineexporter.analysis.service.VariableTracer;
+import java.util.List;
+
+public class LegacyDataFlowModel implements DataFlowModel {
+    private final VariableTracer variableTracer;
+
+    public LegacyDataFlowModel(VariableTracer variableTracer) {
+        this.variableTracer = variableTracer;
+    }
+
+    @Override
+    public List<Expression> getReachingDefinitions(Expression expr) {
+        if (variableTracer == null || expr == null) {
+            return expr != null ? List.of(expr) : List.of();
+        }
+        return variableTracer.traceVariableAll(expr);
+    }
+
+    @Override
+    public String resolveValue(Expression expr, CodebaseContext context) {
+        if (expr == null) return null;
+        if (variableTracer == null) {
+            return context.resolveExpression(expr);
+        }
+        Expression traced = variableTracer.traceVariable(expr);
+        return context.resolveExpression(traced);
+    }
+}

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

@@ -0,0 +1,155 @@
+package click.kamil.springstatemachineexporter.ast.common;
+
+import org.eclipse.jdt.core.dom.*;
+import java.util.*;
+
+public class ReachingDefinitions {
+    private final ControlFlowGraph cfg;
+    private final Map<ControlFlowGraph.CfgNode, Set<ASTNode>> inMap = new HashMap<>();
+    private final Map<ControlFlowGraph.CfgNode, Set<ASTNode>> outMap = new HashMap<>();
+
+    public ReachingDefinitions(ControlFlowGraph cfg) {
+        this.cfg = cfg;
+        analyze();
+    }
+
+    private void analyze() {
+        List<ControlFlowGraph.CfgNode> cfgNodes = cfg.getNodes();
+        Map<ControlFlowGraph.CfgNode, ASTNode> nodeDefs = new HashMap<>();
+        Map<String, Set<ASTNode>> varToDefs = new HashMap<>();
+
+        for (ControlFlowGraph.CfgNode node : cfgNodes) {
+            ASTNode ast = node.getAstNode();
+            if (ast == null) continue;
+
+            ASTNode def = findDefinition(ast);
+            if (def != null) {
+                nodeDefs.put(node, def);
+                String varName = getDefinedVariableName(def);
+                if (varName != null) {
+                    varToDefs.computeIfAbsent(varName, k -> new HashSet<>()).add(def);
+                }
+            }
+        }
+
+        for (ControlFlowGraph.CfgNode node : cfgNodes) {
+            inMap.put(node, new HashSet<>());
+            outMap.put(node, new HashSet<>());
+        }
+
+        boolean changed = true;
+        int iterations = 0;
+        int maxIterations = 5000;
+        while (changed && iterations < maxIterations) {
+            iterations++;
+            changed = false;
+            for (ControlFlowGraph.CfgNode node : cfgNodes) {
+                Set<ASTNode> newIn = new HashSet<>();
+                for (ControlFlowGraph.CfgNode pred : node.getPredecessors()) {
+                    newIn.addAll(outMap.get(pred));
+                }
+
+                inMap.put(node, newIn);
+
+                Set<ASTNode> newOut = new HashSet<>(newIn);
+                ASTNode def = nodeDefs.get(node);
+                if (def != null) {
+                    String varName = getDefinedVariableName(def);
+                    if (varName != null) {
+                        Set<ASTNode> allDefs = varToDefs.get(varName);
+                        if (allDefs != null) {
+                            newOut.removeAll(allDefs);
+                        }
+                    }
+                    newOut.add(def);
+                }
+
+                Set<ASTNode> oldOut = outMap.put(node, newOut);
+                if (!newOut.equals(oldOut)) {
+                    changed = true;
+                }
+            }
+        }
+        if (iterations >= maxIterations) {
+            // Log warning or print to stderr
+            System.err.println("Warning: ReachingDefinitions analysis reached max iterations (" + maxIterations + ") and terminated early.");
+        }
+    }
+
+    public Set<ASTNode> getReachingDefinitions(ASTNode usageNode, String varName) {
+        ControlFlowGraph.CfgNode cfgNode = findCfgNodeForUsage(usageNode);
+        if (cfgNode == null) {
+            return Collections.emptySet();
+        }
+
+        Set<ASTNode> reaching = new HashSet<>();
+        Set<ASTNode> inDefs = inMap.get(cfgNode);
+        if (inDefs != null) {
+            for (ASTNode def : inDefs) {
+                if (varName.equals(getDefinedVariableName(def))) {
+                    reaching.add(def);
+                }
+            }
+        }
+        return reaching;
+    }
+
+    private ControlFlowGraph.CfgNode findCfgNodeForUsage(ASTNode usageNode) {
+        ASTNode current = usageNode;
+        while (current != null) {
+            for (ControlFlowGraph.CfgNode node : cfg.getNodes()) {
+                if (node.getAstNode() == current) {
+                    return node;
+                }
+            }
+            current = current.getParent();
+        }
+        return null;
+    }
+
+    private ASTNode findDefinition(ASTNode ast) {
+        if (ast instanceof VariableDeclarationStatement vds) {
+            if (!vds.fragments().isEmpty()) {
+                return (ASTNode) vds.fragments().get(0);
+            }
+        }
+        if (ast instanceof VariableDeclarationFragment) {
+            return ast;
+        }
+        if (ast instanceof SingleVariableDeclaration) {
+            return ast;
+        }
+        if (ast instanceof Assignment) {
+            return ast;
+        }
+        if (ast instanceof ExpressionStatement es) {
+            return findDefinition(es.getExpression());
+        }
+        return null;
+    }
+
+    public static String getDefinedVariableName(ASTNode def) {
+        if (def instanceof VariableDeclarationFragment frag) {
+            return frag.getName().getIdentifier();
+        }
+        if (def instanceof SingleVariableDeclaration svd) {
+            return svd.getName().getIdentifier();
+        }
+        if (def instanceof Assignment assign) {
+            if (assign.getLeftHandSide() instanceof SimpleName sn) {
+                return sn.getIdentifier();
+            }
+        }
+        return null;
+    }
+
+    public static Expression getDefinitionExpression(ASTNode def) {
+        if (def instanceof VariableDeclarationFragment frag) {
+            return frag.getInitializer();
+        }
+        if (def instanceof Assignment assign) {
+            return assign.getRightHandSide();
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,119 @@
+package click.kamil.springstatemachineexporter.ast.common;
+
+import click.kamil.springstatemachineexporter.model.State;
+import org.eclipse.jdt.core.dom.*;
+
+public class StateResolver {
+    private final CodebaseContext context;
+
+    public StateResolver(CodebaseContext context) {
+        this.context = context;
+    }
+
+    public State resolveState(Expression expr, CompilationUnit cu) {
+        if (expr == null)
+            return null;
+
+        // 1. Check for constants
+        String resolvedValue = context.getConstantResolver().resolve(expr, context);
+        if (resolvedValue != null) {
+            return State.of(expr.toString(), resolvedValue);
+        }
+
+        // 2. Check for @Value fields (SimpleName)
+        if (expr instanceof SimpleName sn) {
+            String fieldName = sn.getIdentifier();
+            TypeDeclaration td = findEnclosingType(sn);
+            if (td != null) {
+                String value = findValueFromField(td, fieldName);
+                if (value != null) {
+                    return State.of(fieldName, value);
+                }
+            }
+        }
+
+        if (expr instanceof StringLiteral sl)
+            return State.of(sl.getLiteralValue());
+
+        String raw = expr.toString();
+        if (expr instanceof QualifiedName qn) {
+            String full = resolveQualifiedName(qn, cu);
+            return State.of(raw, full);
+        }
+        if (expr instanceof SimpleName sn) {
+            String full = resolveSimpleName(sn, cu);
+            return State.of(raw, full);
+        }
+        return State.of(raw);
+    }
+
+    private String findValueFromField(TypeDeclaration td, String fieldName) {
+        for (FieldDeclaration fd : td.getFields()) {
+            for (Object fragObj : fd.fragments()) {
+                if (fragObj instanceof VariableDeclarationFragment fragment) {
+                    if (fragment.getName().getIdentifier().equals(fieldName)) {
+                        // Check for @Value annotation
+                        for (Object mod : fd.modifiers()) {
+                            if (mod instanceof Annotation ann) {
+                                String name = ann.getTypeName().getFullyQualifiedName();
+                                if (name.endsWith("Value")) {
+                                    return extractAnnotationValue(ann);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    private String extractAnnotationValue(Annotation ann) {
+        if (ann instanceof SingleMemberAnnotation sma) {
+            return stripQuotes(sma.getValue().toString());
+        } else if (ann instanceof NormalAnnotation na) {
+            for (Object pairObj : na.values()) {
+                MemberValuePair pair = (MemberValuePair) pairObj;
+                if ("value".equals(pair.getName().getIdentifier())) {
+                    return stripQuotes(pair.getValue().toString());
+                }
+            }
+        }
+        return null;
+    }
+
+    private String stripQuotes(String s) {
+        if (s == null) return null;
+        return s.replaceAll("^\"|\"$", "");
+    }
+
+    private TypeDeclaration findEnclosingType(ASTNode node) {
+        ASTNode parent = node.getParent();
+        while (parent != null && !(parent instanceof TypeDeclaration)) {
+            parent = parent.getParent();
+        }
+        return (TypeDeclaration) parent;
+    }
+
+    private String resolveQualifiedName(QualifiedName qn, CompilationUnit cu) {
+        String qualifier = qn.getQualifier().toString();
+        String name = qn.getName().getIdentifier();
+        TypeDeclaration td = context.getTypeDeclaration(qualifier, cu);
+        if (td != null)
+            return context.getFqn(td) + "." + name;
+        return qn.getFullyQualifiedName();
+    }
+
+    private String resolveSimpleName(SimpleName sn, CompilationUnit cu) {
+        String name = sn.getIdentifier();
+        if (cu == null)
+            return name;
+        for (Object impObj : cu.imports()) {
+            ImportDeclaration imp = (ImportDeclaration) impObj;
+            String impName = imp.getName().getFullyQualifiedName();
+            if (impName.endsWith("." + name))
+                return impName;
+        }
+        return name;
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/command/ExporterCommand.java

@@ -45,11 +45,31 @@ public class ExporterCommand implements Callable<Integer> {
     @Option(names = {"--no-diamonds"}, description = "Render choice/junction states as regular states instead of diamonds.", negatable = true, defaultValue = "true")
     private boolean renderChoicesAsDiamonds;
 
+    @Option(names = {"-p", "--profiles"}, description = "Spring profiles to activate for property resolution.", split = ",")
+    private List<String> activeProfiles;
+
+    @Option(names = {"--event"}, description = "Format for events when they are enums: fn (fullName, default), fqn (fully qualified name), sn (short name)", defaultValue = "fn")
+    private click.kamil.springstatemachineexporter.exporter.EnumFormat eventFormat;
+
+    @Option(names = {"--state"}, description = "Format for states when they are enums: fn (fullName, default), fqn (fully qualified name), sn (short name)", defaultValue = "fn")
+    private click.kamil.springstatemachineexporter.exporter.EnumFormat stateFormat;
+
+    @Option(names = {"--debug"}, description = "Enable diagnostic mode to show unresolved call chains and detailed analysis logging.", defaultValue = "false")
+    private boolean debug;
+
+    @Option(names = {"--resolve-classpath"}, description = "Automatically run Maven/Gradle to resolve full classpath dependencies for perfect AST bindings.", defaultValue = "false")
+    private boolean resolveClasspath;
+
     @Override
     public Integer call() throws Exception {
         var out = spec.commandLine().getOut();
         var err = spec.commandLine().getErr();
 
+        if (debug) {
+            System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "debug");
+            out.println(CommandLine.Help.Ansi.AUTO.string("@|bold,cyan Diagnostic mode enabled|@"));
+        }
+
         if (inputDir == null && jsonFile == null) {
             inputDir = Path.of(".");
         }
@@ -66,10 +86,11 @@ public class ExporterCommand implements Callable<Integer> {
         }
 
         try {
+            List<String> profiles = activeProfiles != null ? activeProfiles : java.util.Collections.emptyList();
             if (jsonFile != null) {
-                exportService.runJsonExporter(jsonFile, outputDir, selectedFormats);
+                exportService.runJsonExporter(jsonFile, outputDir, selectedFormats, profiles, eventFormat, stateFormat);
             } else {
-                exportService.runExporter(inputDir, outputDir, selectedFormats, renderChoicesAsDiamonds);
+                exportService.runExporter(inputDir, outputDir, selectedFormats, renderChoicesAsDiamonds, profiles, null, null, eventFormat, stateFormat, resolveClasspath);
             }
             out.println(CommandLine.Help.Ansi.AUTO.string("%n@|bold,green SUCCESS:|@ All state machines have been exported to " + outputDir.toAbsolutePath()));
             return 0;

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/exporter/Dot.java

@@ -18,17 +18,21 @@ public class Dot implements StateMachineExporter {
     };
 
     @Override
-    public String export(String name,
-                         List<Transition> transitions,
-                         Set<String> startStates,
-                         Set<String> endStates,
-                         ExportOptions options) {
+    public String export(click.kamil.springstatemachineexporter.analysis.model.AnalysisResult result, ExportOptions options) {
         StringBuilder sb = new StringBuilder();
         sb.append("digraph statemachine {\n");
         sb.append("  rankdir=LR;\n");
         sb.append("  node [shape=rounded, style=filled, fillcolor=white, fontname=\"Arial\"];\n");
         sb.append("  edge [fontname=\"Arial\", fontsize=10];\n\n");
 
+        // --- Core State Machine Rendering ---
+        renderCore(result.getTransitions(), result.getStartStates(), result.getEndStates(), options, sb);
+
+        sb.append("}\n");
+        return sb.toString();
+    }
+
+    private void renderCore(List<Transition> transitions, Set<String> startStates, Set<String> endStates, ExportOptions options, StringBuilder sb) {
         // Choices
         Set<String> statesWithChoice = new LinkedHashSet<>();
         Map<String, String> choiceColorMap = new HashMap<>();
@@ -37,7 +41,7 @@ public class Dot implements StateMachineExporter {
         for (Transition t : transitions) {
             if (t.getType() == TransitionType.CHOICE && t.getSourceStates() != null) {
                 for (State source : t.getSourceStates()) {
-                    String simplified = simplify(source.toString());
+                    String simplified = simplify(options.formatState(source));
                     statesWithChoice.add(simplified);
                     if (!choiceColorMap.containsKey(simplified)) {
                         choiceColorMap.put(simplified, CHOICE_COLORS[colorIndex % CHOICE_COLORS.length]);
@@ -82,11 +86,11 @@ public class Dot implements StateMachineExporter {
             }
 
             for (State rawSourceState : t.getSourceStates()) {
-                String rawSource = rawSourceState.toString();
+                String rawSource = options.formatState(rawSourceState);
                 String source = simplify(rawSource);
 
                 for (State rawTargetState : targets) {
-                    String rawTarget = rawTargetState.toString();
+                    String rawTarget = options.formatState(rawTargetState);
                     String target = simplify(rawTarget);
                     String edgeSource = source;
 
@@ -96,17 +100,26 @@ public class Dot implements StateMachineExporter {
 
                     // Label: event [guard] / actions
                     StringBuilder label = new StringBuilder();
-                    if (t.getEvent() != null && !t.getEvent().isBlank()) {
-                        label.append(escapeDotString(t.getEvent()));
+                    if (t.getEvent() != null) {
+                        String eventStr = options.formatEvent(t.getEvent());
+                        if (eventStr != null && !eventStr.isBlank()) {
+                            label.append(escapeDotString(eventStr));
+                        }
                     }
 
-                    // Guard
-                    if (t.getGuard() != null && !t.getGuard().expression().isBlank()) {
+                    // Guards
+                    if (t.getGuards() != null && !t.getGuards().isEmpty()) {
                         if (!label.isEmpty())
                             label.append(" ");
-                        String guardText = options.isUseLambdaGuards() && t.getGuard().isLambda() ? "λ"
-                                : escapeDotString(t.getGuard().expression().replaceAll("[\\n\\r]+", " ").replaceAll("\\s{2,}", " ").trim());
-                        label.append("[").append(guardText).append("]");
+                        label.append("[");
+                        for (int i = 0; i < t.getGuards().size(); i++) {
+                            if (i > 0) label.append(" && ");
+                            var guard = t.getGuards().get(i);
+                            String guardText = options.isUseLambdaGuards() && guard.isLambda() ? "λ"
+                                    : escapeDotString(guard.expression().replaceAll("[\\n\\r]+", " ").replaceAll("\\s{2,}", " ").trim());
+                            label.append(guardText);
+                        }
+                        label.append("]");
                     }
 
                     // Actions
@@ -182,6 +195,21 @@ public class Dot implements StateMachineExporter {
                 }
             }
         }
+    }
+
+    @Override
+    public String export(String name,
+                         List<Transition> transitions,
+                         Set<String> startStates,
+                         Set<String> endStates,
+                         ExportOptions options) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("digraph statemachine {\n");
+        sb.append("  rankdir=LR;\n");
+        sb.append("  node [shape=rounded, style=filled, fillcolor=white, fontname=\"Arial\"];\n");
+        sb.append("  edge [fontname=\"Arial\", fontsize=10];\n\n");
+        
+        renderCore(transitions, startStates, endStates, options, sb);
         
         sb.append("}\n");
         return sb.toString();

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/exporter/EnumFormat.java

@@ -0,0 +1,5 @@
+package click.kamil.springstatemachineexporter.exporter;
+
+public enum EnumFormat {
+    fn, fqn, sn
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/exporter/ExportOptions.java

@@ -10,4 +10,39 @@ public class ExportOptions {
     boolean useLambdaGuards = true;
     @Builder.Default
     boolean renderChoicesAsDiamonds = true;
+    @Builder.Default
+    boolean embedIdentifiers = false;
+    @Builder.Default
+    boolean includeMetadataPane = true;
+
+    @Builder.Default
+    EnumFormat eventFormat = EnumFormat.fn;
+    @Builder.Default
+    EnumFormat stateFormat = EnumFormat.fn;
+
+    public String formatState(click.kamil.springstatemachineexporter.model.State state) {
+        if (state == null) return null;
+        return format(state.rawName(), state.fullIdentifier(), stateFormat);
+    }
+
+    public String formatEvent(click.kamil.springstatemachineexporter.model.Event event) {
+        if (event == null) return null;
+        return format(event.rawName(), event.fullIdentifier(), eventFormat);
+    }
+
+    private String format(String raw, String fqn, EnumFormat format) {
+        if (fqn == null) return raw;
+        switch (format) {
+            case fqn: return fqn;
+            case sn: return fqn.substring(fqn.lastIndexOf('.') + 1);
+            case fn: 
+                int lastDot = fqn.lastIndexOf('.');
+                if (lastDot > 0) {
+                    int prevDot = fqn.lastIndexOf('.', lastDot - 1);
+                    return prevDot > 0 ? fqn.substring(prevDot + 1) : fqn;
+                }
+                return fqn;
+            default: return raw;
+        }
+    }
 }

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/exporter/JsonExporter.java

@@ -17,6 +17,23 @@ public class JsonExporter implements StateMachineExporter {
                 .enable(SerializationFeature.INDENT_OUTPUT);
     }
 
+    @Override
+    public String export(click.kamil.springstatemachineexporter.analysis.model.AnalysisResult result, ExportOptions options) {
+        try {
+            java.util.Map<String, Object> output = new java.util.HashMap<>();
+            output.put("name", result.getName());
+            output.put("transitions", result.getTransitions());
+            output.put("startStates", result.getStartStates());
+            output.put("endStates", result.getEndStates());
+            output.put("renderChoicesAsDiamonds", options.isRenderChoicesAsDiamonds());
+            output.put("metadata", result.getMetadata());
+            
+            return objectMapper.writeValueAsString(output);
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to export to JSON", e);
+        }
+    }
+
     @Override
     public String export(String name, List<Transition> transitions, Set<String> startStates, Set<String> endStates, ExportOptions options) {
         try {

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/exporter/PlantUml.java

@@ -3,34 +3,20 @@ package click.kamil.springstatemachineexporter.exporter;
 import click.kamil.springstatemachineexporter.model.State;
 import click.kamil.springstatemachineexporter.model.Transition;
 import click.kamil.springstatemachineexporter.model.TransitionType;
-import click.kamil.springstatemachineexporter.ast.common.StringUtils;
 
 import java.io.BufferedReader;
 import java.io.InputStream;
 import java.io.InputStreamReader;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 
 public class PlantUml implements StateMachineExporter {
-    private final List<String> choiceColors = List.of("FF6347", "4682B4", "32CD32", "FFD700", "6A5ACD", "FF69B4");
 
     private final String LAMBDA = "λ";
 
-    private String loadBaseStyle() {
-        try (InputStream is = getClass().getResourceAsStream("/plantuml/default-style.puml")) {
-            if (is == null) return "";
-            return new BufferedReader(new InputStreamReader(is))
-                    .lines()
-                    .collect(Collectors.joining("\n"));
-        } catch (Exception e) {
-            return "";
-        }
+    @Override
+    public String export(click.kamil.springstatemachineexporter.analysis.model.AnalysisResult result, ExportOptions options) {
+        return export(result.getName(), result.getTransitions(), result.getStartStates(), result.getEndStates(), options);
     }
 
     @Override
@@ -42,53 +28,57 @@ public class PlantUml implements StateMachineExporter {
 
         StringBuilder sb = new StringBuilder();
         sb.append("@startuml\n");
+        sb.append("!pragma layout smetana\n");
+        sb.append("set separator none\n");
+        sb.append("hide empty description\n");
+        sb.append("hide stereotype\n");
         
-        String style = loadBaseStyle();
+        // --- Premium Modern Styles ---
+        sb.append("skinparam state {\n");
+        sb.append("  BackgroundColor white\n");
+        sb.append("  BorderColor #94a3b8\n");
+        sb.append("  BorderThickness 1\n");
+        sb.append("  FontName Inter\n");
+        sb.append("  FontSize 9\n"); // Sleek but readable
+        sb.append("  FontStyle bold\n");
+        sb.append("  RoundCorner 20\n");
+        sb.append("  Padding 1\n"); 
+        sb.append("}\n");
+        sb.append("skinparam shadowing false\n");
+        sb.append("skinparam ArrowFontName JetBrains Mono\n");
+        sb.append("skinparam ArrowFontSize 8\n");
+        sb.append("skinparam ArrowColor #cbd5e1\n");
+        sb.append("skinparam ArrowThickness 1\n");
+        sb.append("skinparam dpi 110\n");
+        sb.append("skinparam svgLinkTarget _self\n");
         
-        StringBuilder choiceColorStyles = new StringBuilder();
-        StringBuilder hideChoiceColors = new StringBuilder();
-        for (int i = 0; i < choiceColors.size(); i++) {
-            choiceColorStyles.append("    .choice_color_").append(i)
-                    .append(" { LineColor #").append(choiceColors.get(i)).append(" }\n");
-            hideChoiceColors.append("hide <<choice_color_").append(i).append(">> stereotype\n");
-        }
-
-        style = style.replace("/* CHOICE_COLORS_PLACEHOLDER */", choiceColorStyles.toString());
-        style = style.replace("/* HIDE_CHOICE_COLORS_PLACEHOLDER */", hideChoiceColors.toString());
-
-        sb.append(style).append("\n");
+        sb.append("\n");
 
         for (String start : startStates) {
             sb.append("[*] --> ").append(simplify(start)).append("\n");
         }
         sb.append("\n");
 
-        Set<String> statesWithChoice = new HashSet<>();
+        Set<String> statesWithChoice = new java.util.LinkedHashSet<>();
         for (Transition t : transitions) {
-            if (t.getType() == TransitionType.CHOICE) {
+            if (t.getType() == TransitionType.CHOICE && t.getSourceStates() != null) {
                 for (State source : t.getSourceStates()) {
-                    statesWithChoice.add(simplify(source.toString()));
+                    statesWithChoice.add(simplify(options.formatState(source)));
                 }
             }
         }
 
-        Map<String, String> choiceStateClassMap = new HashMap<>();
-        int colorIndex = 0;
-
         for (String state : statesWithChoice) {
-            String className = "choice_color_" + (colorIndex % choiceColors.size());
             if (options.isRenderChoicesAsDiamonds()) {
                 sb.append("state ").append(state).append(" <<choice>>\n");
             }
-            choiceStateClassMap.put(state, className);
-            colorIndex++;
         }
 
         Set<String> junctionStates = transitions.stream()
                 .filter(t -> t.getType() == TransitionType.JUNCTION)
                 .flatMap(t -> t.getSourceStates().stream())
-                .map(s -> simplify(s.toString()))
-                .collect(Collectors.toSet());
+                .map(s -> simplify(options.formatState(s)))
+                .collect(Collectors.toCollection(java.util.LinkedHashSet::new));
         for (String junction : junctionStates) {
             if (options.isRenderChoicesAsDiamonds()) {
                 sb.append("state ").append(junction).append(" <<choice>>\n");
@@ -97,7 +87,6 @@ public class PlantUml implements StateMachineExporter {
 
         sb.append("\n");
 
-        Set<String> usedEventStereotypes = new HashSet<>();
         for (Transition t : transitions) {
             if (t.getSourceStates() == null || t.getSourceStates().isEmpty())
                 continue;
@@ -107,33 +96,44 @@ public class PlantUml implements StateMachineExporter {
             List<String> targets;
             if (t.getTargetStates() == null || t.getTargetStates().isEmpty()) {
                 if (!allowNoTarget) {
-                    targets = t.getSourceStates().stream().map(s -> s.toString()).toList();
+                    targets = t.getSourceStates().stream().map(s -> options.formatState(s)).toList();
                 } else {
                     continue;
                 }
             } else {
-                targets = t.getTargetStates().stream().map(s -> s.toString()).toList();
+                targets = t.getTargetStates().stream().map(s -> options.formatState(s)).toList();
             }
 
             for (State rawSourceState : t.getSourceStates()) {
-                String source = simplify(rawSourceState.toString());
+                String source = simplify(options.formatState(rawSourceState));
 
                 for (String rawTarget : targets) {
                     String target = simplify(rawTarget);
-                    String transitionSource = source;
 
-                    String styleClass = getStyleClass(t, source, choiceStateClassMap);
-                    String color = getLegacyColor(t, source, choiceStateClassMap);
-                    sb.append(transitionSource).append(" -[#").append(color).append(",bold]-> ").append(target).append(" <<").append(styleClass).append(">>");
+                    String styleClass = getStyleClass(t, source, Collections.emptyMap());
+                    String color = getLegacyColor(t, source, Collections.emptyMap());
+                    sb.append(source).append(" -[#").append(color).append(",bold]-> ").append(target);
                     
-                    if (t.getEvent() != null && !t.getEvent().isBlank()) {
-                        String eventClass = "e_" + normalize(t.getEvent());
-                        sb.append(" <<").append(eventClass).append(">>");
-                        usedEventStereotypes.add(eventClass);
-                    }
+                    sb.append(" <<").append(styleClass).append(">>");
 
-                    String label = buildLabel(t, options.isUseLambdaGuards());
+
+                    String label = buildLabel(t, options);
+                    if (options.isEmbedIdentifiers()) {
+                        String eventStr = t.getEvent() != null ? options.formatEvent(t.getEvent()) : null;
+                        String linkId = eventStr != null && !eventStr.isBlank() ? "link_" + normalize(source) + "__" + normalize(eventStr) : "link_anon_" + normalize(source) + "_" + normalize(target);
+                        
+                        sb.append(" : [[#").append(linkId).append(" ");
                         if (!label.isEmpty()) {
+                            String sanitized = label.replace("[", "&#91;")
+                                                  .replace("]", "&#93;")
+                                                  .replace("<", "&lt;")
+                                                  .replace(">", "&gt;");
+                            sb.append(sanitized);
+                        } else {
+                            sb.append(".");
+                        }
+                        sb.append("]]");
+                    } else if (!label.isEmpty()) {
                         sb.append(" : ").append(label);
                     }
                     sb.append("\n");
@@ -141,10 +141,6 @@ public class PlantUml implements StateMachineExporter {
             }
         }
 
-        for (String eventClass : usedEventStereotypes) {
-            sb.append("hide <<").append(eventClass).append(">> stereotype\n");
-        }
-
         sb.append("\n");
         for (String end : endStates) {
             sb.append(simplify(end)).append(" --> [*]\n");
@@ -161,16 +157,9 @@ public class PlantUml implements StateMachineExporter {
 
     private String getLegacyColor(Transition t, String source, Map<String, String> choiceStateClassMap) {
         if (t.getType() == null)
-            return "000000";
+            return "94a3b8";
         return switch (t.getType()) {
-            case CHOICE -> {
-                String className = choiceStateClassMap.get(source);
-                if (className != null && className.startsWith("choice_color_")) {
-                    int index = Integer.parseInt(className.substring("choice_color_".length()));
-                    yield choiceColors.get(index % choiceColors.size());
-                }
-                yield "000000";
-            }
+            case CHOICE -> "FF6347";
             case EXTERNAL -> "1E90FF";
             case INTERNAL -> "32CD32";
             case LOCAL -> "FFA500";
@@ -184,7 +173,7 @@ public class PlantUml implements StateMachineExporter {
         if (t.getType() == null)
             return "default";
         return switch (t.getType()) {
-            case CHOICE -> choiceStateClassMap.getOrDefault(source, "choice_type");
+            case CHOICE -> "choice_type";
             case EXTERNAL -> "external";
             case INTERNAL -> "internal";
             case LOCAL -> "local";
@@ -199,35 +188,40 @@ public class PlantUml implements StateMachineExporter {
         return ".puml";
     }
 
-    private String getGuardText(Transition t, boolean useLambdaGuards) {
-        if (t.getGuard() == null || StringUtils.isBlank(t.getGuard().expression()))
-            return "";
-        if (useLambdaGuards && t.getGuard().isLambda())
-            return LAMBDA;
-        return t.getGuard().expression().replaceAll("[\\n\\r]+", " ").replaceAll("\\s{2,}", " ").trim();
+    @Override
+    public String simplify(String state) {
+        if (state == null) return "";
+        if (state.contains("\"")) return state;
+        return state.replaceAll("[^a-zA-Z0-9_.]", "");
     }
 
-    private String getActionsText(Transition t, boolean useLambdaGuards) {
-        if (t.getActions() == null || t.getActions().isEmpty())
-            return "";
-        return t.getActions().stream()
-                .map(action -> (useLambdaGuards && action.isLambda()) ? LAMBDA : action.expression())
-                .collect(Collectors.joining(", "));
-    }
-
-    private String buildLabel(Transition t, boolean useLambdaGuards) {
+    private String buildLabel(Transition t, ExportOptions options) {
         List<String> parts = new ArrayList<>();
-        if (t.getEvent() != null && !t.getEvent().isBlank())
-            parts.add(simplify(t.getEvent()));
-        String guard = getGuardText(t, useLambdaGuards);
-        if (!guard.isEmpty())
-            parts.add("[" + guard + "]");
-        String actions = getActionsText(t, useLambdaGuards);
-        if (!actions.isEmpty()) {
-            if (!parts.isEmpty())
-                parts.add("/ " + actions);
-            else
-                parts.add(actions);
+        if (t.getEvent() != null) {
+            String eventStr = options.formatEvent(t.getEvent());
+            if (eventStr != null && !eventStr.isBlank()) {
+                parts.add(eventStr);
+            }
+        }
+        if (t.getGuards() != null && !t.getGuards().isEmpty()) {
+            StringBuilder guardsBuilder = new StringBuilder();
+            guardsBuilder.append("[");
+            for (int i = 0; i < t.getGuards().size(); i++) {
+                if (i > 0) guardsBuilder.append(" && ");
+                var guard = t.getGuards().get(i);
+                if (options.isUseLambdaGuards() && guard.isLambda()) {
+                    guardsBuilder.append(LAMBDA);
+                } else {
+                    guardsBuilder.append(guard.expression().replaceAll("[\\n\\r]+", " ").replaceAll("\\s{2,}", " ").trim());
+                }
+            }
+            guardsBuilder.append("]");
+            parts.add(guardsBuilder.toString());
+        }
+        if (t.getActions() != null && !t.getActions().isEmpty()) {
+            parts.add("/ " + t.getActions().stream()
+                    .map(a -> (options.isUseLambdaGuards() && a.isLambda()) ? LAMBDA : a.expression().replaceAll("[\\n\\r]+", " ").replaceAll("\\s{2,}", " ").trim())
+                    .collect(Collectors.joining(", ")));
         }
         Optional.ofNullable(t.getOrder())
                 .filter(order -> t.getType() == TransitionType.CHOICE || t.getType() == TransitionType.JUNCTION)

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/exporter/Scxml.java

@@ -12,6 +12,11 @@ public class Scxml implements StateMachineExporter {
 
     private static final String LAMBDA = "λ";
 
+    @Override
+    public String export(click.kamil.springstatemachineexporter.analysis.model.AnalysisResult result, ExportOptions options) {
+        return export(result.getName(), result.getTransitions(), result.getStartStates(), result.getEndStates(), options);
+    }
+
     @Override
     public String export(String name,
                          List<Transition> transitions,
@@ -24,10 +29,10 @@ public class Scxml implements StateMachineExporter {
         sb.append(startStates.isEmpty() ? "" : simplify(startStates.iterator().next()));
         sb.append("\">\n");
 
-        Set<String> allStates = new HashSet<>();
+        Set<String> allStates = new java.util.LinkedHashSet<>();
         for (Transition t : transitions) {
-            t.getSourceStates().forEach(s -> allStates.add(s.toString()));
-            t.getTargetStates().forEach(s -> allStates.add(s.toString()));
+            t.getSourceStates().forEach(s -> allStates.add(options.formatState(s)));
+            t.getTargetStates().forEach(s -> allStates.add(options.formatState(s)));
         }
         allStates.addAll(startStates);
         allStates.addAll(endStates);
@@ -36,7 +41,7 @@ public class Scxml implements StateMachineExporter {
             sb.append("  <state id=\"").append(simplify(state)).append("\">\n");
 
             for (Transition t : transitions) {
-                if (t.getSourceStates() == null || t.getSourceStates().stream().noneMatch(s -> s.toString().equals(state)))
+                if (t.getSourceStates() == null || t.getSourceStates().stream().noneMatch(s -> options.formatState(s).equals(state)))
                     continue;
 
                 boolean allowNoTarget = t.getType() == TransitionType.JOIN || t.getType() == TransitionType.FORK;
@@ -53,7 +58,7 @@ public class Scxml implements StateMachineExporter {
                 }
 
                 for (State target : targets) {
-                    sb.append(renderTransition(t, target, options.isUseLambdaGuards()));
+                    sb.append(renderTransition(t, target, options));
                 }
             }
             sb.append("  </state>\n");
@@ -68,15 +73,18 @@ public class Scxml implements StateMachineExporter {
         return ".scxml.xml";
     }
 
-    private String renderTransition(Transition t, State target, boolean useLambdaGuards) {
+    private String renderTransition(Transition t, State target, ExportOptions options) {
         StringBuilder sb = new StringBuilder();
-        sb.append("    <transition target=\"").append(simplify(target.toString())).append("\"");
+        sb.append("    <transition target=\"").append(simplify(options.formatState(target))).append("\"");
 
-        if (t.getEvent() != null && !t.getEvent().isBlank()) {
-            sb.append(" event=\"").append(escapeXml(t.getEvent())).append("\"");
+        if (t.getEvent() != null) {
+            String eventStr = options.formatEvent(t.getEvent());
+            if (eventStr != null && !eventStr.isBlank()) {
+                sb.append(" event=\"").append(escapeXml(eventStr)).append("\"");
+            }
         }
 
-        String guard = getGuardText(t, useLambdaGuards);
+        String guard = getGuardText(t, options.isUseLambdaGuards());
         if (!guard.isBlank()) {
             sb.append(" cond=\"").append(escapeXml(guard)).append("\"");
         }
@@ -94,12 +102,20 @@ public class Scxml implements StateMachineExporter {
     }
 
     private static String getGuardText(Transition t, boolean useLambdaGuards) {
-        if (t.getGuard() == null || t.getGuard().expression().isBlank())
+        if (t.getGuards() == null || t.getGuards().isEmpty())
             return "";
-        if (useLambdaGuards && t.getGuard().isLambda()) {
-            return LAMBDA;
+        
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < t.getGuards().size(); i++) {
+            if (i > 0) sb.append(" && ");
+            var guard = t.getGuards().get(i);
+            if (useLambdaGuards && guard.isLambda()) {
+                sb.append(LAMBDA);
+            } else {
+                sb.append(guard.expression().replaceAll("[\\n\\r]+", " ").replaceAll("\\s{2,}", " ").trim());
             }
-        return t.getGuard().expression().replaceAll("[\\n\\r]+", " ").replaceAll("\\s{2,}", " ").trim();
+        }
+        return sb.toString();
     }
 
     private static String escapeXml(String s) {

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/exporter/StateMachineExporter.java

@@ -1,11 +1,16 @@
 package click.kamil.springstatemachineexporter.exporter;
 
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
 import click.kamil.springstatemachineexporter.model.Transition;
 
 import java.util.List;
 import java.util.Set;
 
 public interface StateMachineExporter {
+    default String export(AnalysisResult result, ExportOptions options) {
+        return export(result.getName(), result.getTransitions(), result.getStartStates(), result.getEndStates(), options);
+    }
+
     String export(String name,
                   List<Transition> transitions,
                   Set<String> startStates,

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/model/Action.java

@@ -1,7 +1,7 @@
 package click.kamil.springstatemachineexporter.model;
 
-public record Action(String expression, boolean isLambda) {
-    public static Action of(String expression, boolean isLambda) {
-        return expression != null ? new Action(expression, isLambda) : null;
+public record Action(String expression, boolean isLambda, String internalLogic, Integer lineNumber, String className, String sourceFile) {
+    public static Action of(String expression, boolean isLambda, String internalLogic, Integer lineNumber, String className, String sourceFile) {
+        return expression != null ? new Action(expression, isLambda, internalLogic, lineNumber, className, sourceFile) : null;
     }
 }

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/model/Event.java

@@ -0,0 +1,16 @@
+package click.kamil.springstatemachineexporter.model;
+
+public record Event(String rawName, String fullIdentifier) {
+    public static Event of(String name) {
+        return new Event(name, name);
+    }
+
+    public static Event of(String raw, String full) {
+        return new Event(raw, full);
+    }
+
+    @Override
+    public String toString() {
+        return fullIdentifier != null ? fullIdentifier : rawName;
+    }
+}

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/model/Guard.java

@@ -1,7 +1,7 @@
 package click.kamil.springstatemachineexporter.model;
 
-public record Guard(String expression, boolean isLambda) {
-    public static Guard of(String expression, boolean isLambda) {
-        return expression != null ? new Guard(expression, isLambda) : null;
+public record Guard(String expression, boolean isLambda, String internalLogic, Integer lineNumber, String className, String sourceFile) {
+    public static Guard of(String expression, boolean isLambda, String internalLogic, Integer lineNumber, String className, String sourceFile) {
+        return expression != null ? new Guard(expression, isLambda, internalLogic, lineNumber, className, sourceFile) : null;
     }
 }

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/model/Transition.java

@@ -14,9 +14,9 @@ public class Transition {
     private TransitionType type;
     private List<State> sourceStates = new ArrayList<>();
     private List<State> targetStates = new ArrayList<>();
-    private String event;
+    private Event event;
 
-    private Guard guard;
+    private List<Guard> guards = new ArrayList<>();
     private List<Action> actions = new ArrayList<>();
 
     private Integer order = null;  // optional order for withChoice or withJunction

state_machine_exporter/src/main/java/click/kamil/springstatemachineexporter/plugin/java/JavaLanguageAnalyzerPlugin.java

@@ -0,0 +1,147 @@
+package click.kamil.springstatemachineexporter.plugin.java;
+
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+import click.kamil.springstatemachineexporter.analysis.service.CallGraphEngine;
+import click.kamil.springstatemachineexporter.analysis.service.CodebaseIntelligenceProvider;
+import click.kamil.springstatemachineexporter.analysis.service.JdtCallGraphEngine;
+import click.kamil.springstatemachineexporter.analysis.service.JdtIntelligenceProvider;
+import click.kamil.springstatemachineexporter.ast.app.AstTransitionParser;
+import click.kamil.springstatemachineexporter.ast.app.StateMachineAggregator;
+import click.kamil.springstatemachineexporter.ast.app.TransitionStateUtils;
+import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
+import click.kamil.springstatemachineexporter.model.Transition;
+import click.kamil.springstatemachineexporter.spi.LanguageAnalyzerPlugin;
+import click.kamil.springstatemachineexporter.spi.SourceContext;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
+import org.eclipse.jdt.core.dom.TypeDeclaration;
+
+import java.nio.file.Path;
+import java.util.*;
+
+public class JavaLanguageAnalyzerPlugin implements LanguageAnalyzerPlugin {
+
+    @Override
+    public boolean supports(Path projectRoot) {
+        return true; 
+    }
+
+    @Override
+    public SourceContext parseProject(Path projectRoot, List<String> classpath, Set<Path> sourcePaths) {
+        CodebaseContext context = new CodebaseContext();
+        context.setProjectRoot(projectRoot);
+        if (classpath != null && !classpath.isEmpty()) {
+            context.setClasspath(classpath);
+        }
+        
+        Path hintsFile = projectRoot.resolve("hints.json");
+        if (!java.nio.file.Files.exists(hintsFile)) {
+            hintsFile = projectRoot.resolve("src/main/resources/hints.json");
+        }
+        if (java.nio.file.Files.exists(hintsFile)) {
+            try {
+                context.loadLibraryHints(hintsFile);
+            } catch (java.io.IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        
+        List<String> sp = sourcePaths.stream()
+                .map(p -> p.resolve("src/main/java"))
+                .filter(p -> java.nio.file.Files.exists(p))
+                .map(Path::toString)
+                .toList();
+        if (sp.isEmpty()) {
+            sp = sourcePaths.stream().map(Path::toString).toList();
+        }
+        context.setSourcepath(sp);
+        
+        context.setResolveBindings(true);
+        try {
+            context.scan(sourcePaths, Collections.emptySet());
+        } catch (java.io.IOException e) {
+            throw new RuntimeException(e);
+        }
+        return context;
+    }
+
+    @Override
+    public CallGraphEngine createCallGraphEngine(SourceContext context) {
+        if (context instanceof CodebaseContext jdtContext) {
+            return new JdtCallGraphEngine(jdtContext, null);
+        }
+        throw new IllegalArgumentException("Expected CodebaseContext");
+    }
+
+    @Override
+    public CodebaseIntelligenceProvider createIntelligenceProvider(SourceContext context) {
+        if (context instanceof CodebaseContext jdtContext) {
+            return new JdtIntelligenceProvider(jdtContext, jdtContext.getProjectRoot());
+        }
+        throw new IllegalArgumentException("Expected CodebaseContext");
+    }
+
+    @Override
+    public List<AnalysisResult> extractStateMachines(SourceContext context, boolean renderChoicesAsDiamonds) {
+        if (context instanceof CodebaseContext jdtContext) {
+            List<AnalysisResult> results = new ArrayList<>();
+            
+            // 1. Find entry point classes (annotated or extending adapter)
+            List<TypeDeclaration> entryPoints = jdtContext.findEntryPointClasses(List.of("EnableStateMachineFactory", "EnableStateMachine"));
+            for (TypeDeclaration td : entryPoints) {
+                String className = jdtContext.getFqn(td);
+                StateMachineAggregator aggregator = new StateMachineAggregator(jdtContext);
+                List<Transition> transitions = aggregator.aggregateTransitions(td);
+                aggregator.aggregateStates(td);
+                Set<String> initialStatesAst = aggregator.getInitialStates();
+                Set<String> endStatesAst = aggregator.getEndStates();
+
+                Set<String> startStates = TransitionStateUtils.findStartStates(transitions, initialStatesAst);
+                Set<String> endStates = TransitionStateUtils.findEndStates(transitions, endStatesAst);
+                Set<click.kamil.springstatemachineexporter.model.State> allStates = TransitionStateUtils.findAllStates(transitions, initialStatesAst, endStatesAst);
+
+                if (allStates.isEmpty() && transitions.isEmpty()) {
+                    continue;
+                }
+
+                results.add(AnalysisResult.builder()
+                        .name(className)
+                        .states(allStates)
+                        .transitions(transitions)
+                        .startStates(startStates)
+                        .endStates(endStates)
+                        .renderChoicesAsDiamonds(renderChoicesAsDiamonds)
+                        .build());
+            }
+
+            // 2. Find methods returning StateMachine beans
+            List<MethodDeclaration> beanMethods = jdtContext.findBeanMethodsReturning(Set.of("StateMachine", "StateMachineFactory", "StateMachineModelFactory"));
+            for (MethodDeclaration m : beanMethods) {
+                TypeDeclaration parentClass = (TypeDeclaration) m.getParent();
+                String parentFqn = jdtContext.getFqn(parentClass);
+                String methodName = m.getName().getIdentifier();
+                String uniqueName = parentFqn + "#" + methodName;
+
+                List<Transition> transitions = AstTransitionParser.parseTransitions(m, jdtContext);
+
+                Set<String> startStates = TransitionStateUtils.findStartStates(transitions, null);
+                Set<String> endStates = TransitionStateUtils.findEndStates(transitions, null);
+                Set<click.kamil.springstatemachineexporter.model.State> allStates = TransitionStateUtils.findAllStates(transitions, null, null);
+
+                if (allStates.isEmpty() && transitions.isEmpty()) {
+                    continue;
+                }
+
+                results.add(AnalysisResult.builder()
+                        .name(uniqueName)
+                        .states(allStates)
+                        .transitions(transitions)
+                        .startStates(startStates)
+                        .endStates(endStates)
+                        .renderChoicesAsDiamonds(renderChoicesAsDiamonds)
+                        .build());
+            }
+            return results;
+        }
+        return Collections.emptyList();
+    }
+}

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

@@ -1,5 +1,14 @@
 package click.kamil.springstatemachineexporter.service;
 
+import click.kamil.springstatemachineexporter.analysis.enricher.CallChainEnricher;
+import click.kamil.springstatemachineexporter.analysis.enricher.EntryPointEnricher;
+import click.kamil.springstatemachineexporter.analysis.enricher.PropertyEnricher;
+import click.kamil.springstatemachineexporter.analysis.enricher.TriggerEnricher;
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
+import click.kamil.springstatemachineexporter.analysis.model.BusinessFlow;
+import click.kamil.springstatemachineexporter.analysis.service.CodebaseIntelligenceProvider;
+import click.kamil.springstatemachineexporter.analysis.service.EnrichmentService;
+import click.kamil.springstatemachineexporter.analysis.service.JdtIntelligenceProvider;
 import click.kamil.springstatemachineexporter.ast.app.AstTransitionParser;
 import click.kamil.springstatemachineexporter.ast.app.StateMachineAggregator;
 import click.kamil.springstatemachineexporter.ast.app.TransitionStateUtils;
@@ -8,48 +17,233 @@ import click.kamil.springstatemachineexporter.model.Transition;
 import click.kamil.springstatemachineexporter.ast.common.CodebaseContext;
 import click.kamil.springstatemachineexporter.exporter.ExportOptions;
 import click.kamil.springstatemachineexporter.exporter.StateMachineExporter;
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.jdt.core.dom.MethodDeclaration;
 import org.eclipse.jdt.core.dom.TypeDeclaration;
+import click.kamil.springstatemachineexporter.spi.LanguageAnalyzerPlugin;
+import click.kamil.springstatemachineexporter.spi.SourceContext;
+import click.kamil.springstatemachineexporter.analysis.service.CompositeIntelligenceProvider;
+import click.kamil.springstatemachineexporter.analysis.service.CallGraphEngine;
+import click.kamil.springstatemachineexporter.analysis.service.JdtCallGraphEngine;
 
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
+import java.util.stream.Collectors;
 
 @Slf4j
-@RequiredArgsConstructor
 public class ExportService {
 
     private final List<StateMachineExporter> exporters;
+    private final EnrichmentService enrichmentService;
+
+    public ExportService(List<StateMachineExporter> exporters, EnrichmentService enrichmentService) {
+        this.exporters = exporters;
+        this.enrichmentService = enrichmentService;
+    }
+
+    public ExportService(List<StateMachineExporter> exporters) {
+        this(exporters, new EnrichmentService(List.of(
+                new TriggerEnricher(),
+                new EntryPointEnricher(),
+                new PropertyEnricher(),
+                new CallChainEnricher(),
+                new click.kamil.springstatemachineexporter.analysis.enricher.path.ForwardPathEstimationEnricher(),
+                new click.kamil.springstatemachineexporter.analysis.enricher.TransitionLinkerEnricher()
+        )));
+    }
+
     private static final List<String> TARGET_ANNOTATIONS = List.of("EnableStateMachineFactory", "EnableStateMachine");
     public static final Set<String> STATE_MACHINE_RETURN_TYPES = Set.of("StateMachine", "StateMachineFactory", "StateMachineModelFactory");
 
     public void runExporter(Path inputDir, Path outputDir, List<String> selectedFormats, boolean renderChoicesAsDiamonds) throws IOException {
+        runExporter(inputDir, outputDir, selectedFormats, renderChoicesAsDiamonds, Collections.emptyList(), null, null, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, false);
+    }
+
+    public void runExporter(Path inputDir, Path outputDir, List<String> selectedFormats, boolean renderChoicesAsDiamonds, List<String> activeProfiles) throws IOException {
+        runExporter(inputDir, outputDir, selectedFormats, renderChoicesAsDiamonds, activeProfiles, null, null, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, false);
+    }
+
+    public void runExporter(Path inputDir, Path outputDir, List<String> selectedFormats, boolean renderChoicesAsDiamonds, List<String> activeProfiles, Path flowsOverride, String machineFilter) throws IOException {
+        runExporter(inputDir, outputDir, selectedFormats, renderChoicesAsDiamonds, activeProfiles, flowsOverride, machineFilter, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, false);
+    }
+
+    public void runExporter(Path inputDir, Path outputDir, List<String> selectedFormats, boolean renderChoicesAsDiamonds, List<String> activeProfiles, click.kamil.springstatemachineexporter.exporter.EnumFormat eventFormat, click.kamil.springstatemachineexporter.exporter.EnumFormat stateFormat) throws IOException {
+        runExporter(inputDir, outputDir, selectedFormats, renderChoicesAsDiamonds, activeProfiles, null, null, eventFormat, stateFormat, false);
+    }
+
+    public void runExporter(Path inputDir, Path outputDir, List<String> selectedFormats, boolean renderChoicesAsDiamonds, List<String> activeProfiles, Path flowsOverride, String machineFilter, click.kamil.springstatemachineexporter.exporter.EnumFormat eventFormat, click.kamil.springstatemachineexporter.exporter.EnumFormat stateFormat, boolean resolveClasspath) throws IOException {
         CodebaseContext context = new CodebaseContext();
-        context.scan(inputDir);
-        exportAll(context, outputDir, selectedFormats, renderChoicesAsDiamonds);
+        context.setActiveProfiles(activeProfiles);
+        
+        click.kamil.springstatemachineexporter.analysis.resolver.SiblingDependencyResolver siblingResolver = new click.kamil.springstatemachineexporter.analysis.resolver.SiblingDependencyResolver();
+        Set<Path> allPaths = new HashSet<>();
+        allPaths.add(inputDir);
+        allPaths.addAll(siblingResolver.resolveSiblings(inputDir));
+        
+        // Find project root (common ancestor)
+        Path projectRoot = inputDir.toAbsolutePath();
+        for (Path p : allPaths) {
+            Path ap = p.toAbsolutePath();
+            while (projectRoot != null && !ap.startsWith(projectRoot)) {
+                projectRoot = projectRoot.getParent();
+            }
+        }
+        context.setProjectRoot(projectRoot);
+        log.info("Project root resolved to: {}", projectRoot);
+        
+        List<String> sourcepaths = allPaths.stream()
+                .map(p -> p.resolve("src/main/java").toString())
+                .filter(p -> Files.exists(Path.of(p)))
+                .collect(Collectors.toList());
+        log.info("Setting JDT sourcepath: {}", sourcepaths);
+        context.setSourcepath(sourcepaths);
+        
+        if (resolveClasspath) {
+            click.kamil.springstatemachineexporter.analysis.service.DynamicClasspathResolver classpathResolver = new click.kamil.springstatemachineexporter.analysis.service.DynamicClasspathResolver();
+            List<String> dynamicClasspath = classpathResolver.resolveClasspath(projectRoot);
+            if (!dynamicClasspath.isEmpty()) {
+                context.setClasspath(dynamicClasspath);
+                log.info("Injected {} external JARs into JDT ASTParser", dynamicClasspath.size());
+            }
+        } else {
+            log.info("Dynamic classpath resolution disabled. Use --resolve-classpath to enable.");
+        }
+        
+        context.setResolveBindings(true);
+        
+        Path hintsFile = inputDir.resolve("hints.json");
+        if (!Files.exists(hintsFile)) {
+            hintsFile = inputDir.resolve("src/main/resources/hints.json");
+        }
+        
+        if (Files.exists(hintsFile)) {
+            log.info("Loading hints from {}", hintsFile.toAbsolutePath());
+            context.loadLibraryHints(hintsFile);
+        }
+
+        List<BusinessFlow> flows = new ArrayList<>();
+        Path flowsFile = flowsOverride != null ? flowsOverride : inputDir.resolve("flows.json");
+        if (flowsOverride == null && !Files.exists(flowsFile)) {
+            flowsFile = inputDir.resolve("src/main/resources/flows.json");
+        }
+        
+        if (Files.exists(flowsFile)) {
+            log.info("Loading business flows from {}", flowsFile.toAbsolutePath());
+            try {
+                flows = new com.fasterxml.jackson.databind.ObjectMapper()
+                        .readValue(flowsFile.toFile(), new com.fasterxml.jackson.core.type.TypeReference<List<BusinessFlow>>() {});
+            } catch (Exception e) {
+                log.error("Failed to load flows.json", e);
+            }
+        }
+
+        context.scan(allPaths, Collections.emptySet());
+        
+        // Load SPI plugins dynamically
+        ServiceLoader<LanguageAnalyzerPlugin> loader = ServiceLoader.load(LanguageAnalyzerPlugin.class);
+        List<LanguageAnalyzerPlugin> plugins = new ArrayList<>();
+        for (LanguageAnalyzerPlugin plugin : loader) {
+            if (plugin.supports(inputDir)) {
+                plugins.add(plugin);
+            }
+        }
+        if (plugins.isEmpty()) {
+            plugins.add(new click.kamil.springstatemachineexporter.plugin.java.JavaLanguageAnalyzerPlugin());
+        }
+
+        List<SourceContext> sourceContexts = new ArrayList<>();
+        List<CodebaseIntelligenceProvider> providers = new ArrayList<>();
+        List<CallGraphEngine> engines = new ArrayList<>();
+        List<AnalysisResult> extractedResults = new ArrayList<>();
+
+        for (LanguageAnalyzerPlugin plugin : plugins) {
+            SourceContext sc = plugin.parseProject(projectRoot, context.getClasspath(), allPaths);
+            sourceContexts.add(sc);
+            providers.add(plugin.createIntelligenceProvider(sc));
+            engines.add(plugin.createCallGraphEngine(sc));
+            extractedResults.addAll(plugin.extractStateMachines(sc, renderChoicesAsDiamonds));
+        }
+
+        CodebaseContext codebaseContext = context;
+        CodebaseIntelligenceProvider unifiedIntelligence;
+        if (plugins.size() == 1) {
+            unifiedIntelligence = providers.get(0);
+            if (sourceContexts.get(0) instanceof CodebaseContext jdtCtx) {
+                codebaseContext = jdtCtx;
+            }
+        } else {
+            unifiedIntelligence = new CompositeIntelligenceProvider(providers, engines);
+        }
+
+        // Process all extracted state machines
+        for (AnalysisResult result : extractedResults) {
+            String name = result.getName();
+            if (machineFilter != null && !name.contains(machineFilter)) {
+                continue;
+            }
+
+            if (result.getFlows() == null || result.getFlows().isEmpty()) {
+                result.setFlows(flows);
+            }
+
+            enrichmentService.enrich(result, codebaseContext, unifiedIntelligence);
+            resolveProperties(result, activeProfiles);
+            generateOutputs(outputDir, result, selectedFormats, eventFormat, stateFormat);
+        }
     }
 
     public void runJsonExporter(Path jsonFile, Path outputDir, List<String> selectedFormats) throws IOException {
-        JsonImportService jsonImportService = new JsonImportService();
-        StateMachineModel model = jsonImportService.importJson(jsonFile);
-        generateOutputs(outputDir, model.getName(), model.getTransitions(), model.getStartStates(), model.getEndStates(), selectedFormats, model.isRenderChoicesAsDiamonds());
+        runJsonExporter(jsonFile, outputDir, selectedFormats, Collections.emptyList(), click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn);
     }
 
-    private void exportAll(CodebaseContext context, Path outputDir, List<String> selectedFormats, boolean renderChoicesAsDiamonds) throws IOException {
+    public void runJsonExporter(Path jsonFile, Path outputDir, List<String> selectedFormats, List<String> activeProfiles) throws IOException {
+        runJsonExporter(jsonFile, outputDir, selectedFormats, activeProfiles, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn, click.kamil.springstatemachineexporter.exporter.EnumFormat.fn);
+    }
+
+    public void runJsonExporter(Path jsonFile, Path outputDir, List<String> selectedFormats, List<String> activeProfiles, click.kamil.springstatemachineexporter.exporter.EnumFormat eventFormat, click.kamil.springstatemachineexporter.exporter.EnumFormat stateFormat) throws IOException {
+        JsonImportService jsonImportService = new JsonImportService();
+        AnalysisResult result = jsonImportService.importAnalysisResult(jsonFile);
+        
+        // Apply property resolution pass if placeholders exist
+        resolveProperties(result, activeProfiles);
+        
+        generateOutputs(outputDir, result, selectedFormats, eventFormat, stateFormat);
+    }
+
+    private void resolveProperties(AnalysisResult result, List<String> activeProfiles) {
+        Map<String, Map<String, String>> allProps = result.getMetadata().getProperties();
+        if (allProps == null || allProps.isEmpty()) return;
+
+        // 1. Merge properties based on active profiles
+        Map<String, String> merged = new HashMap<>();
+        // Start with default
+        if (allProps.containsKey("default")) {
+            merged.putAll(allProps.get("default"));
+        }
+        // Overlay active profiles
+        for (String profile : activeProfiles) {
+            if (allProps.containsKey(profile)) {
+                merged.putAll(allProps.get(profile));
+            }
+        }
+
+        // 2. Delegate to result for resolution
+        result.applyResolution(merged);
+    }
+
+    private void exportAll(CodebaseContext context, CodebaseIntelligenceProvider intelligence, Path outputDir, List<String> selectedFormats, boolean renderChoicesAsDiamonds, List<BusinessFlow> flows, String machineFilter, List<String> activeProfiles, click.kamil.springstatemachineexporter.exporter.EnumFormat eventFormat, click.kamil.springstatemachineexporter.exporter.EnumFormat stateFormat) throws IOException {
         Set<String> processedLocations = new HashSet<>();
 
         // 1. Find entry point classes (annotated or extending adapter)
         List<TypeDeclaration> entryPoints = context.findEntryPointClasses(TARGET_ANNOTATIONS);
         for (TypeDeclaration td : entryPoints) {
             String fqn = context.getFqn(td);
+            if (machineFilter != null && !fqn.contains(machineFilter)) continue;
             if (processedLocations.add(fqn)) {
-                processEntryPoint(td, outputDir, context, selectedFormats, renderChoicesAsDiamonds);
+                processEntryPoint(td, outputDir, context, intelligence, selectedFormats, renderChoicesAsDiamonds, flows, activeProfiles, eventFormat, stateFormat);
             }
         }
 
@@ -61,13 +255,14 @@ public class ExportService {
             String methodName = m.getName().getIdentifier();
             String uniqueId = parentFqn + "#" + methodName;
 
+            if (machineFilter != null && !uniqueId.contains(machineFilter)) continue;
             if (processedLocations.add(uniqueId)) {
-                processBeanMethod(m, outputDir, context, selectedFormats, renderChoicesAsDiamonds);
+                processBeanMethod(m, outputDir, context, intelligence, selectedFormats, renderChoicesAsDiamonds, flows, activeProfiles, eventFormat, stateFormat);
             }
         }
     }
 
-    private void processEntryPoint(TypeDeclaration td, Path outputDir, CodebaseContext context, List<String> selectedFormats, boolean renderChoicesAsDiamonds) throws IOException {
+    private void processEntryPoint(TypeDeclaration td, Path outputDir, CodebaseContext context, CodebaseIntelligenceProvider intelligence, List<String> selectedFormats, boolean renderChoicesAsDiamonds, List<BusinessFlow> flows, List<String> activeProfiles, click.kamil.springstatemachineexporter.exporter.EnumFormat eventFormat, click.kamil.springstatemachineexporter.exporter.EnumFormat stateFormat) throws IOException {
         String className = context.getFqn(td);
         log.info("Processing state machine config: {}", className);
 
@@ -83,11 +278,31 @@ public class ExportService {
 
         Set<String> startStates = TransitionStateUtils.findStartStates(transitions, initialStatesAst);
         Set<String> endStates = TransitionStateUtils.findEndStates(transitions, endStatesAst);
+        Set<click.kamil.springstatemachineexporter.model.State> allStates = TransitionStateUtils.findAllStates(transitions, initialStatesAst, endStatesAst);
 
-        generateOutputs(outputDir, className, transitions, startStates, endStates, selectedFormats, renderChoicesAsDiamonds);
+        if (allStates.isEmpty() && transitions.isEmpty()) {
+            log.info("Skipping empty state machine config: {}", className);
+            return;
         }
 
-    private void processBeanMethod(MethodDeclaration m, Path outputDir, CodebaseContext context, List<String> selectedFormats, boolean renderChoicesAsDiamonds) throws IOException {
+        AnalysisResult result = AnalysisResult.builder()
+                .name(className)
+                .states(allStates)
+                .transitions(transitions)
+                .startStates(startStates)
+                .endStates(endStates)
+                .renderChoicesAsDiamonds(renderChoicesAsDiamonds)
+                .flows(flows)
+                .build();
+
+        enrichmentService.enrich(result, context, intelligence);
+
+        resolveProperties(result, activeProfiles);
+
+        generateOutputs(outputDir, result, selectedFormats, eventFormat, stateFormat);
+    }
+
+    private void processBeanMethod(MethodDeclaration m, Path outputDir, CodebaseContext context, CodebaseIntelligenceProvider intelligence, List<String> selectedFormats, boolean renderChoicesAsDiamonds, List<BusinessFlow> flows, List<String> activeProfiles, click.kamil.springstatemachineexporter.exporter.EnumFormat eventFormat, click.kamil.springstatemachineexporter.exporter.EnumFormat stateFormat) throws IOException {
         TypeDeclaration parentClass = (TypeDeclaration) m.getParent();
         String parentFqn = context.getFqn(parentClass);
         String methodName = m.getName().getIdentifier();
@@ -97,31 +312,55 @@ public class ExportService {
 
         List<Transition> transitions = AstTransitionParser.parseTransitions(m, context);
 
-        Set<String> startStates = TransitionStateUtils.findStartStates(transitions);
-        Set<String> endStates = TransitionStateUtils.findEndStates(transitions);
+        Set<String> startStates = TransitionStateUtils.findStartStates(transitions, null);
+        Set<String> endStates = TransitionStateUtils.findEndStates(transitions, null);
+        Set<click.kamil.springstatemachineexporter.model.State> allStates = TransitionStateUtils.findAllStates(transitions, null, null);
 
-        generateOutputs(outputDir, uniqueName, transitions, startStates, endStates, selectedFormats, renderChoicesAsDiamonds);
+        if (allStates.isEmpty() && transitions.isEmpty()) {
+            log.info("Skipping empty state machine bean: {}", uniqueName);
+            return;
         }
 
-    private void generateOutputs(Path outputDir, String baseName, List<Transition> transitions,
-                                 Set<String> startStates, Set<String> endStates, List<String> selectedFormats, boolean renderChoicesAsDiamonds) throws IOException {
+        AnalysisResult result = AnalysisResult.builder()
+                .name(uniqueName)
+                .states(allStates)
+                .transitions(transitions)
+                .startStates(startStates)
+                .endStates(endStates)
+                .renderChoicesAsDiamonds(renderChoicesAsDiamonds)
+                .flows(flows)
+                .build();
 
-        Path targetDir = outputDir.resolve(baseName);
+        enrichmentService.enrich(result, context, intelligence);
+
+        resolveProperties(result, activeProfiles);
+
+        generateOutputs(outputDir, result, selectedFormats, eventFormat, stateFormat);
+    }
+
+    private void generateOutputs(Path outputDir, AnalysisResult result, List<String> selectedFormats, click.kamil.springstatemachineexporter.exporter.EnumFormat eventFormat, click.kamil.springstatemachineexporter.exporter.EnumFormat stateFormat) throws IOException {
+        if (selectedFormats == null || selectedFormats.isEmpty()) {
+            return;
+        }
+
+        String actualName = result.getName();
+        Path targetDir = outputDir.resolve(actualName);
         Files.createDirectories(targetDir);
 
         ExportOptions options = ExportOptions.builder()
-                .useLambdaGuards(true)
-                .renderChoicesAsDiamonds(renderChoicesAsDiamonds)
+                .renderChoicesAsDiamonds(result.isRenderChoicesAsDiamonds())
+                .eventFormat(eventFormat)
+                .stateFormat(stateFormat)
                 .build();
 
-        for (StateMachineExporter output : exporters) {
-            if (selectedFormats != null && !selectedFormats.isEmpty()) {
-                boolean match = selectedFormats.stream().anyMatch(f -> output.getFileExtension().toLowerCase().contains(f.toLowerCase()));
-                if (!match) continue;
+        for (StateMachineExporter exporter : exporters) {
+            String ext = exporter.getFileExtension().toLowerCase();
+            if (!selectedFormats.stream().anyMatch(fmt -> ext.contains(fmt.toLowerCase()))) {
+                continue;
             }
 
-            String content = output.export(baseName, transitions, startStates, endStates, options);
-            String fileName = baseName + output.getFileExtension();
+            String content = exporter.export(result, options);
+            String fileName = result.getName() + exporter.getFileExtension();
 
             try (PrintWriter out = new PrintWriter(targetDir.resolve(fileName).toFile())) {
                 out.println(content);

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

@@ -1,5 +1,6 @@
 package click.kamil.springstatemachineexporter.service;
 
+import click.kamil.springstatemachineexporter.analysis.model.AnalysisResult;
 import click.kamil.springstatemachineexporter.model.StateMachineModel;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
@@ -23,4 +24,8 @@ public class JsonImportService {
         }
         return model;
     }
+
+    public AnalysisResult importAnalysisResult(Path jsonFile) throws IOException {
+        return objectMapper.readValue(jsonFile.toFile(), AnalysisResult.class);
+    }
 }