diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 01c6042..5af35b1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -9,11 +9,14 @@ on:
   workflow_dispatch:
 
 jobs:
-  build-release:
-    name: Build and Test (Release)
+  # Quick check - just build and test JOPA compiler
+  build-and-test:
+    name: Build and Test
     runs-on: ubuntu-latest
-    permissions:
-      contents: write
+    strategy:
+      matrix:
+        variant: [release, debug]
+        target: ['1.5', '1.6', '1.7']
 
     steps:
       - name: Checkout repository
@@ -23,121 +26,45 @@ jobs:
 
       - name: Install Nix
         uses: DeterminateSystems/nix-installer-action@v14
-        with:
-          logger: pretty
-          log-directives: nix_installer=debug
-
-      - name: Setup Nix cache
-        uses: DeterminateSystems/magic-nix-cache-action@v8
 
-      - name: Check flake
-        run: nix flake check --show-trace
-
-      - name: Build JOPA, DevJopaK, and DevJopaK-ECJ (Release)
+      - name: Build and test JOPA (${{ matrix.variant }}, target ${{ matrix.target }})
         run: |
-          nix develop --command bash -c '
-            set -euo pipefail
-            cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
-            cmake --build build -j$(nproc)
-
-            # Configure devjopak with memory tracking wrapper
-            export JOPA_REAL_EXECUTABLE="$(pwd)/build/src/jopa"
-            export JOPA_MEMORY_LOG="/tmp/jopa-memory-release.log"
-            rm -f "$JOPA_MEMORY_LOG"
-
-            cmake -S devjopak -B build-devjopak \
-              -DJOPA_BUILD_DIR=build \
-              -DCMAKE_BUILD_TYPE=Release \
-              -DJOPA_JAVAC_COMMAND="$(pwd)/scripts/jopa-memory-wrapper.sh"
-            cmake --build build-devjopak --target devjopak devjopak-ecj -j$(nproc) 2>&1 | tee /tmp/build-release.log
-          '
+          BUILD_TYPE=${{ matrix.variant == 'debug' && 'Debug' || 'Release' }}
+          nix develop --command bash -c "
+            cmake -S . -B build -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+              -DJOPA_TARGET_VERSION=${{ matrix.target }} \
+              ${{ matrix.variant == 'debug' && '-DJOPA_ENABLE_SANITIZERS=ON -DJOPA_ENABLE_LEAK_SANITIZER=OFF' || '' }}
+            cmake --build build -j\$(nproc)
+            ctest --test-dir build --output-on-failure -j\$(nproc)
+          "
 
-      - name: Report Memory Usage (Release)
+      - name: Generate test summary
         if: always()
         run: |
-          MEMLOG="/tmp/jopa-memory-release.log"
-          if [ -f "$MEMLOG" ] && [ -s "$MEMLOG" ]; then
-            PEAK_KB=$(sort -n "$MEMLOG" | tail -1)
-            PEAK_MB=$(echo "scale=1; $PEAK_KB / 1024" | bc)
-            INVOCATIONS=$(wc -l < "$MEMLOG")
-            AVG_KB=$(awk '{sum+=$1} END {printf "%.0f", sum/NR}' "$MEMLOG")
-            AVG_MB=$(echo "scale=1; $AVG_KB / 1024" | bc)
-
-            echo "## Memory Usage (Release Build)" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "| Metric | Value |" >> $GITHUB_STEP_SUMMARY
-            echo "|--------|-------|" >> $GITHUB_STEP_SUMMARY
-            echo "| Peak RSS | ${PEAK_MB} MB |" >> $GITHUB_STEP_SUMMARY
-            echo "| Avg RSS | ${AVG_MB} MB |" >> $GITHUB_STEP_SUMMARY
-            echo "| Compiler Invocations | ${INVOCATIONS} |" >> $GITHUB_STEP_SUMMARY
+          echo "## ${{ matrix.variant }} Build (target ${{ matrix.target }})" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          if [ -d build ]; then
+            echo "Build completed" >> $GITHUB_STEP_SUMMARY
           else
-            echo "## Memory Usage (Release Build)" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "No memory data collected" >> $GITHUB_STEP_SUMMARY
+            echo "Build failed" >> $GITHUB_STEP_SUMMARY
           fi
 
-      - name: Verify DevJopaK Distribution
-        run: |
-          nix develop --command bash ./scripts/test-devjopak.sh
-
-      - name: Verify DevJopaK-ECJ Distribution
-        run: |
-          nix develop --command bash ./scripts/test-devjopak-ecj.sh
-
-      - name: Run Primary Tests (Release)
-        run: |
-          nix develop --command bash ./scripts/test-primary.sh --release
-
-      - name: Generate test summary
-        if: always()
-        run: |
-          echo '## Release Build Test Results' >> $GITHUB_STEP_SUMMARY
-          echo '' >> $GITHUB_STEP_SUMMARY
-          echo 'Full matrix: -source 1.7 with targets 1.5, 1.6' >> $GITHUB_STEP_SUMMARY
-          echo '' >> $GITHUB_STEP_SUMMARY
-          echo '```' >> $GITHUB_STEP_SUMMARY
-          nix develop --command bash -c "cd build && ctest -N 2>/dev/null | tail -5" >> $GITHUB_STEP_SUMMARY || true
-          echo '```' >> $GITHUB_STEP_SUMMARY
-
-      - name: Upload test artifacts
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: test-results-release
-          path: |
-            build/test/*.class
-            build/Testing/Temporary/LastTest.log
-            /tmp/build-release.log
-          retention-days: 7
-
-      - name: Upload devjopak artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: devjopak
-          path: build-devjopak/devjopak-*.tar.gz
-          retention-days: 30
-
-      - name: Upload devjopak-ecj artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: devjopak-ecj
-          path: build-devjopak/devjopak-ecj-*.tar.gz
-          retention-days: 30
-
-      - name: Create GitHub Release
-        if: startsWith(github.ref, 'refs/tags/v')
-        uses: softprops/action-gh-release@v2
-        with:
-          files: |
-            build-devjopak/devjopak-*.tar.gz
-            build-devjopak/devjopak-ecj-*.tar.gz
-          generate_release_notes: true
-          draft: false
-          prerelease: ${{ contains(github.ref, '-') }}
-
-  build-debug:
-    name: Build and Test (Debug + Sanitizers)
+  # Build DevJopaK distributions
+  build-devjopak:
+    name: Build DevJopaK
     runs-on: ubuntu-latest
+    needs: build-and-test
+    permissions:
+      contents: write
+    strategy:
+      matrix:
+        include:
+          - name: devjopak-gnucp099-jopa201
+            artifact: devjopak-jopa
+          - name: devjopak-gnucp099-ecj421
+            artifact: devjopak-ecj421
+          - name: devjopak-gnucp099-ecj422
+            artifact: devjopak-ecj422
 
     steps:
       - name: Checkout repository
@@ -147,93 +74,52 @@ jobs:
 
       - name: Install Nix
         uses: DeterminateSystems/nix-installer-action@v14
-        with:
-          logger: pretty
-          log-directives: nix_installer=debug
-
-      - name: Setup Nix cache
-        uses: DeterminateSystems/magic-nix-cache-action@v8
 
-      - name: Build JOPA, DevJopaK, and DevJopaK-ECJ (Debug + Sanitizers)
+      - name: Build ${{ matrix.name }}
         run: |
-          nix develop --command bash -c '
-            set -euo pipefail
-            cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DJOPA_ENABLE_SANITIZERS=ON -DJOPA_ENABLE_LEAK_SANITIZER=OFF
-            cmake --build build -j$(nproc)
-
-            # Configure devjopak with memory tracking wrapper
-            export JOPA_REAL_EXECUTABLE="$(pwd)/build/src/jopa"
-            export JOPA_MEMORY_LOG="/tmp/jopa-memory-debug.log"
-            rm -f "$JOPA_MEMORY_LOG"
+          nix build .#${{ matrix.name }} --print-build-logs
 
-            cmake -S devjopak -B build-devjopak \
-              -DJOPA_BUILD_DIR=build \
-              -DCMAKE_BUILD_TYPE=Debug \
-              -DJOPA_JAVAC_COMMAND="$(pwd)/scripts/jopa-memory-wrapper.sh"
-            cmake --build build-devjopak --target devjopak devjopak-ecj -j$(nproc) 2>&1 | tee /tmp/build-debug.log
-          '
-
-      - name: Report Memory Usage (Debug)
-        if: always()
+      - name: Validate ${{ matrix.name }}
         run: |
-          MEMLOG="/tmp/jopa-memory-debug.log"
-          if [ -f "$MEMLOG" ] && [ -s "$MEMLOG" ]; then
-            PEAK_KB=$(sort -n "$MEMLOG" | tail -1)
-            PEAK_MB=$(echo "scale=1; $PEAK_KB / 1024" | bc)
-            INVOCATIONS=$(wc -l < "$MEMLOG")
-            AVG_KB=$(awk '{sum+=$1} END {printf "%.0f", sum/NR}' "$MEMLOG")
-            AVG_MB=$(echo "scale=1; $AVG_KB / 1024" | bc)
-
-            echo "## Memory Usage (Debug Build)" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "| Metric | Value |" >> $GITHUB_STEP_SUMMARY
-            echo "|--------|-------|" >> $GITHUB_STEP_SUMMARY
-            echo "| Peak RSS | ${PEAK_MB} MB |" >> $GITHUB_STEP_SUMMARY
-            echo "| Avg RSS | ${AVG_MB} MB |" >> $GITHUB_STEP_SUMMARY
-            echo "| Compiler Invocations | ${INVOCATIONS} |" >> $GITHUB_STEP_SUMMARY
-          else
-            echo "## Memory Usage (Debug Build)" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "No memory data collected" >> $GITHUB_STEP_SUMMARY
-          fi
+          # Use the bundled validation script
+          ./result/bin/devjopak-validate
 
-      - name: Verify DevJopaK Distribution
+      - name: Create distribution tarball
         run: |
-          nix develop --command bash ./scripts/test-devjopak.sh
+          # Create tarball from nix output
+          VERSION="2.0.1"
+          TARBALL="${{ matrix.name }}-${VERSION}.tar.gz"
 
-      - name: Verify DevJopaK-ECJ Distribution
-        run: |
-          nix develop --command bash ./scripts/test-devjopak-ecj.sh
+          mkdir -p dist
+          cp -rL result dist/${{ matrix.name }}
+          cd dist
+          tar -czf "../${TARBALL}" ${{ matrix.name }}
+          cd ..
 
-      - name: Run Primary Tests (Debug + Sanitizers)
-        run: |
-          nix develop --command bash ./scripts/test-primary.sh --sanitizers
+          echo "Created: ${TARBALL}"
+          ls -la "${TARBALL}"
 
-      - name: Generate test summary
-        if: always()
-        run: |
-          echo '## Debug Build Test Results (with Sanitizers)' >> $GITHUB_STEP_SUMMARY
-          echo '' >> $GITHUB_STEP_SUMMARY
-          echo 'Full matrix: -source 1.7 with targets 1.5, 1.6' >> $GITHUB_STEP_SUMMARY
-          echo '' >> $GITHUB_STEP_SUMMARY
-          echo '```' >> $GITHUB_STEP_SUMMARY
-          nix develop --command bash -c "cd build && ctest -N 2>/dev/null | tail -5" >> $GITHUB_STEP_SUMMARY || true
-          echo '```' >> $GITHUB_STEP_SUMMARY
-
-      - name: Upload test artifacts
-        if: always()
+      - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
-          name: test-results-debug
-          path: |
-            build/test/*.class
-            build/Testing/Temporary/LastTest.log
-            /tmp/build-debug.log
-          retention-days: 7
+          name: ${{ matrix.artifact }}
+          path: ${{ matrix.name }}-*.tar.gz
+          retention-days: 30
 
-  parser-tests-jdk7:
-    name: JDK7 Parser Tests (97.5% threshold)
+  # Parser tests
+  parser-tests:
+    name: Parser Tests
     runs-on: ubuntu-latest
+    needs: build-and-test
+    strategy:
+      matrix:
+        jdk: [7, 8]
+        variant: [release, debug]
+        include:
+          - jdk: 7
+            threshold: 97.5
+          - jdk: 8
+            threshold: 92.8
 
     steps:
       - name: Checkout repository
@@ -243,83 +129,26 @@ jobs:
 
       - name: Install Nix
         uses: DeterminateSystems/nix-installer-action@v14
-        with:
-          logger: pretty
-          log-directives: nix_installer=debug
-
-      - name: Setup Nix cache
-        uses: DeterminateSystems/magic-nix-cache-action@v8
-
-      - name: Run JDK7 Parser Tests
-        run: |
-          nix develop --command bash ./scripts/test-java7-parser.sh --build
 
-      - name: Check JDK7 Success Threshold (97.5%)
+      - name: Build JOPA with Parser Tests (${{ matrix.variant }})
         run: |
-          source build/parser_jdk7_results.env
-          echo "JDK7 Parser Results:"
-          echo "  Passed: ${PARSER_PASSED}"
-          echo "  Whitelisted: ${PARSER_WHITELISTED}"
-
-          if [ "$PARSER_WHITELISTED" -eq 0 ]; then
-            echo "ERROR: No tests were whitelisted"
-            exit 1
-          fi
-
-          SUCCESS_RATE=$(echo "scale=4; $PARSER_PASSED * 100 / $PARSER_WHITELISTED" | bc)
-          echo "  Success rate: ${SUCCESS_RATE}%"
-          echo ""
-
-          # Check if success rate is at least 97.5%
-          THRESHOLD=97.5
-          PASSED_THRESHOLD=$(echo "$SUCCESS_RATE >= $THRESHOLD" | bc)
-
-          if [ "$PASSED_THRESHOLD" -eq 1 ]; then
-            echo "SUCCESS: JDK7 parser tests passed threshold (>= ${THRESHOLD}%)"
-          else
-            echo "FAILURE: JDK7 parser tests below threshold"
-            echo "Expected: >= ${THRESHOLD}%"
-            echo "Actual: ${SUCCESS_RATE}%"
-            exit 1
-          fi
-
-      - name: Upload test artifacts
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: parser-results-jdk7
-          path: |
-            build/parser_results.txt
-            build/parser_jdk7_results.env
-          retention-days: 7
-
-  parser-tests-jdk8:
-    name: JDK8 Parser Tests (92.8% threshold)
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-
-      - name: Install Nix
-        uses: DeterminateSystems/nix-installer-action@v14
-        with:
-          logger: pretty
-          log-directives: nix_installer=debug
-
-      - name: Setup Nix cache
-        uses: DeterminateSystems/magic-nix-cache-action@v8
-
-      - name: Run JDK8 Parser Tests
+          BUILD_TYPE=${{ matrix.variant == 'debug' && 'Debug' || 'Release' }}
+          JDK_FLAG=${{ matrix.jdk == 7 && '-DJOPA_PARSER_TESTS_JDK7=ON' || '-DJOPA_PARSER_TESTS_JDK8=ON' }}
+          nix develop --command bash -c "
+            cmake -S . -B build -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+              -DJOPA_ENABLE_JDK_PARSER_TESTS=ON ${JDK_FLAG} \
+              ${{ matrix.variant == 'debug' && '-DJOPA_ENABLE_SANITIZERS=ON -DJOPA_ENABLE_LEAK_SANITIZER=OFF' || '' }}
+            cmake --build build --target jopa -j\$(nproc)
+          "
+
+      - name: Run JDK${{ matrix.jdk }} Parser Tests (${{ matrix.variant }})
         run: |
-          nix develop --command bash ./scripts/test-java8-parser.sh --build
+          nix develop --command bash ./scripts/test-java${{ matrix.jdk }}-parser.sh
 
-      - name: Check JDK8 Success Threshold (92.8%)
+      - name: Check Success Threshold (${{ matrix.threshold }}%)
         run: |
-          source build/parser_jdk8_results.env
-          echo "JDK8 Parser Results:"
+          source build/parser_jdk${{ matrix.jdk }}_results.env
+          echo "JDK${{ matrix.jdk }} Parser Results (${{ matrix.variant }}):"
           echo "  Passed: ${PARSER_PASSED}"
           echo "  Whitelisted: ${PARSER_WHITELISTED}"
 
@@ -330,34 +159,41 @@ jobs:
 
           SUCCESS_RATE=$(echo "scale=4; $PARSER_PASSED * 100 / $PARSER_WHITELISTED" | bc)
           echo "  Success rate: ${SUCCESS_RATE}%"
-          echo ""
 
-          # Check if success rate is at least 92.8%
-          THRESHOLD=92.8
-          PASSED_THRESHOLD=$(echo "$SUCCESS_RATE >= $THRESHOLD" | bc)
+          THRESHOLD=${{ matrix.threshold }}
+          PASSED=$(echo "$SUCCESS_RATE >= $THRESHOLD" | bc)
 
-          if [ "$PASSED_THRESHOLD" -eq 1 ]; then
-            echo "SUCCESS: JDK8 parser tests passed threshold (>= ${THRESHOLD}%)"
+          if [ "$PASSED" -eq 1 ]; then
+            echo "SUCCESS: Passed threshold (>= ${THRESHOLD}%)"
           else
-            echo "FAILURE: JDK8 parser tests below threshold"
-            echo "Expected: >= ${THRESHOLD}%"
-            echo "Actual: ${SUCCESS_RATE}%"
+            echo "FAILURE: Below threshold (expected >= ${THRESHOLD}%, got ${SUCCESS_RATE}%)"
             exit 1
           fi
 
-      - name: Upload test artifacts
+      - name: Upload artifacts
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: parser-results-jdk8
+          name: parser-results-jdk${{ matrix.jdk }}-${{ matrix.variant }}
           path: |
             build/parser_results.txt
-            build/parser_jdk8_results.env
+            build/parser_jdk${{ matrix.jdk }}_results.env
           retention-days: 7
 
-  compliance-tests-jdk7:
-    name: JDK7 Compliance Tests (96.5% threshold)
+  # Compliance tests
+  compliance-tests:
+    name: Compliance Tests
     runs-on: ubuntu-latest
+    needs: build-and-test
+    strategy:
+      matrix:
+        jdk: [7, 8]
+        variant: [release, debug]
+        include:
+          - jdk: 7
+            threshold: 96.5
+          - jdk: 8
+            threshold: 67.1
 
     steps:
       - name: Checkout repository
@@ -367,91 +203,26 @@ jobs:
 
       - name: Install Nix
         uses: DeterminateSystems/nix-installer-action@v14
-        with:
-          logger: pretty
-          log-directives: nix_installer=debug
-
-      - name: Setup Nix cache
-        uses: DeterminateSystems/magic-nix-cache-action@v8
 
-      - name: Run JDK7 Compliance Tests
+      - name: Build JOPA (${{ matrix.variant }})
         run: |
-          nix develop --command bash ./scripts/test-java7-compliance.sh --build
-
-      - name: Check JDK7 Success Threshold (96.5%)
-        run: |
-          source build/compliance_jdk7_results.env
-          echo "JDK7 Compliance Results:"
-          echo "  Passed: ${COMPLIANCE_PASSED}"
-          echo "  Whitelisted: ${COMPLIANCE_WHITELISTED}"
-          echo "  Failed: ${COMPLIANCE_FAILED}"
-          echo "  Timeout: ${COMPLIANCE_TIMEOUT}"
-
-          if [ "$COMPLIANCE_WHITELISTED" -eq 0 ]; then
-            echo "ERROR: No tests were whitelisted"
-            exit 1
-          fi
-
-          SUCCESS_RATE=$(echo "scale=4; $COMPLIANCE_PASSED * 100 / $COMPLIANCE_WHITELISTED" | bc)
-          echo "  Success rate: ${SUCCESS_RATE}%"
-          echo ""
-
-          # Check if success rate is at least 96.5%
-          THRESHOLD=96.5
-          PASSED_THRESHOLD=$(echo "$SUCCESS_RATE >= $THRESHOLD" | bc)
-
-          if [ "$PASSED_THRESHOLD" -eq 1 ]; then
-            echo "SUCCESS: JDK7 compliance tests passed threshold (>= ${THRESHOLD}%)"
-          else
-            echo "FAILURE: JDK7 compliance tests below threshold"
-            echo "Expected: >= ${THRESHOLD}%"
-            echo "Actual: ${SUCCESS_RATE}%"
-            exit 1
-          fi
-
-      - name: Upload test artifacts
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: compliance-results-jdk7
-          path: |
-            build/compliance_jdk7/results.txt
-            build/compliance_jdk7/failed.txt
-            build/compliance_jdk7/timeout.txt
-            build/compliance_jdk7_results.env
-          retention-days: 7
-
-  compliance-tests-jdk8:
-    name: JDK8 Compliance Tests (67.1% threshold)
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-
-      - name: Install Nix
-        uses: DeterminateSystems/nix-installer-action@v14
-        with:
-          logger: pretty
-          log-directives: nix_installer=debug
-
-      - name: Setup Nix cache
-        uses: DeterminateSystems/magic-nix-cache-action@v8
-
-      - name: Run JDK8 Compliance Tests
+          BUILD_TYPE=${{ matrix.variant == 'debug' && 'Debug' || 'Release' }}
+          nix develop --command bash -c "
+            cmake -S . -B build -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+              ${{ matrix.variant == 'debug' && '-DJOPA_ENABLE_SANITIZERS=ON -DJOPA_ENABLE_LEAK_SANITIZER=OFF' || '' }}
+            cmake --build build --target jopa jopa-stub-rt -j\$(nproc)
+          "
+
+      - name: Run JDK${{ matrix.jdk }} Compliance Tests (${{ matrix.variant }})
         run: |
-          nix develop --command bash ./scripts/test-java8-compliance.sh --build
+          nix develop --command bash ./scripts/test-java${{ matrix.jdk }}-compliance.sh
 
-      - name: Check JDK8 Success Threshold (67.1%)
+      - name: Check Success Threshold (${{ matrix.threshold }}%)
         run: |
-          source build/compliance_jdk8_results.env
-          echo "JDK8 Compliance Results:"
+          source build/compliance_jdk${{ matrix.jdk }}_results.env
+          echo "JDK${{ matrix.jdk }} Compliance Results (${{ matrix.variant }}):"
           echo "  Passed: ${COMPLIANCE_PASSED}"
           echo "  Whitelisted: ${COMPLIANCE_WHITELISTED}"
-          echo "  Failed: ${COMPLIANCE_FAILED}"
-          echo "  Timeout: ${COMPLIANCE_TIMEOUT}"
 
           if [ "$COMPLIANCE_WHITELISTED" -eq 0 ]; then
             echo "ERROR: No tests were whitelisted"
@@ -460,36 +231,37 @@ jobs:
 
           SUCCESS_RATE=$(echo "scale=4; $COMPLIANCE_PASSED * 100 / $COMPLIANCE_WHITELISTED" | bc)
           echo "  Success rate: ${SUCCESS_RATE}%"
-          echo ""
 
-          # Check if success rate is at least 67.1%
-          THRESHOLD=67.1
-          PASSED_THRESHOLD=$(echo "$SUCCESS_RATE >= $THRESHOLD" | bc)
+          THRESHOLD=${{ matrix.threshold }}
+          PASSED=$(echo "$SUCCESS_RATE >= $THRESHOLD" | bc)
 
-          if [ "$PASSED_THRESHOLD" -eq 1 ]; then
-            echo "SUCCESS: JDK8 compliance tests passed threshold (>= ${THRESHOLD}%)"
+          if [ "$PASSED" -eq 1 ]; then
+            echo "SUCCESS: Passed threshold (>= ${THRESHOLD}%)"
           else
-            echo "FAILURE: JDK8 compliance tests below threshold"
-            echo "Expected: >= ${THRESHOLD}%"
-            echo "Actual: ${SUCCESS_RATE}%"
+            echo "FAILURE: Below threshold (expected >= ${THRESHOLD}%, got ${SUCCESS_RATE}%)"
             exit 1
           fi
 
-      - name: Upload test artifacts
+      - name: Upload artifacts
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: compliance-results-jdk8
+          name: compliance-results-jdk${{ matrix.jdk }}-${{ matrix.variant }}
           path: |
-            build/compliance_jdk8/results.txt
-            build/compliance_jdk8/failed.txt
-            build/compliance_jdk8/timeout.txt
-            build/compliance_jdk8_results.env
+            build/compliance_jdk${{ matrix.jdk }}/results.txt
+            build/compliance_jdk${{ matrix.jdk }}/failed.txt
+            build/compliance_jdk${{ matrix.jdk }}_results.env
           retention-days: 7
 
-  build-legacy-classpath:
-    name: Build Legacy Classpath 0.93 (No JamVM)
+  # OpenJDK compliance tests (run with DevJopaK)
+  openjdk-compliance:
+    name: OpenJDK Compliance
     runs-on: ubuntu-latest
+    needs: build-devjopak
+    strategy:
+      matrix:
+        jdk: [7, 8]
+        variant: [release, debug]
 
     steps:
       - name: Checkout repository
@@ -499,83 +271,37 @@ jobs:
 
       - name: Install Nix
         uses: DeterminateSystems/nix-installer-action@v14
-        with:
-          logger: pretty
-          log-directives: nix_installer=debug
 
-      - name: Setup Nix cache
-        uses: DeterminateSystems/magic-nix-cache-action@v8
-
-      - name: Build JOPA and GNU Classpath 0.93
+      - name: Build DevJopaK (${{ matrix.variant }})
         run: |
-          nix develop --command bash -c '
-            set -euo pipefail
-            cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
-            cmake --build build -j$(nproc)
-            cmake -S devjopak -B build-devjopak -DJOPA_BUILD_DIR=build -DCMAKE_BUILD_TYPE=Release -DJOPA_CLASSPATH_VERSION=0.93
-            cmake --build build-devjopak --target gnu_classpath -j$(nproc) 2>&1 | tee /tmp/build-legacy.log
-          '
-
-      - name: Upload build log
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-legacy-log
-          path: /tmp/build-legacy.log
-          retention-days: 7
-
-  openjdk-compliance-jdk7:
-    name: OpenJDK Compliance (JDK7)
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-
-      - name: Install Nix
-        uses: DeterminateSystems/nix-installer-action@v14
-        with:
-          logger: pretty
-          log-directives: nix_installer=debug
+          PACKAGE="devjopak-gnucp099-jopa201${{ matrix.variant == 'debug' && '-debug' || '' }}"
+          nix build .#${PACKAGE} --print-build-logs
 
-      - name: Setup Nix cache
-        uses: DeterminateSystems/magic-nix-cache-action@v8
-
-      - name: Build JOPA and DevJopaK
+      - name: Prepare JDK${{ matrix.jdk }} Tests
         run: |
-          nix develop --command bash -c '
-            set -euo pipefail
-            cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
-            cmake --build build -j$(nproc)
-            cmake -S devjopak -B build-devjopak -DJOPA_BUILD_DIR=build -DCMAKE_BUILD_TYPE=Release
-            cmake --build build-devjopak --target devjopak -j$(nproc)
-          '
+          nix develop --command python3 scripts/compliance_tester.py --prepare --jdk ${{ matrix.jdk }}
 
-      - name: Prepare JDK7 Tests
+      - name: Run JDK${{ matrix.jdk }} Compliance Tests (${{ matrix.variant }})
         run: |
-          nix develop --command python3 scripts/compliance_tester.py --prepare --jdk 7
+          # Set up paths to use built devjopak
+          export DEVJOPAK_HOME="$(pwd)/result"
 
-      - name: Run JDK7 Compliance Tests
-        run: |
           nix develop --command python3 scripts/compliance_tester.py \
-            --test --jdk 7 \
+            --test --jdk ${{ matrix.jdk }} \
             --classpath gnucp \
             --timeout 30 \
             --mode run \
-            --no-success 2>&1 | tee /tmp/jdk7-compliance.log
+            --no-success 2>&1 | tee /tmp/jdk${{ matrix.jdk }}-${{ matrix.variant }}-compliance.log
 
       - name: Check Results
         run: |
-          # Extract results from log
-          TOTAL=$(grep "^Total:" /tmp/jdk7-compliance.log | awk '{print $2}')
-          SUCCESS=$(grep "^Success:" /tmp/jdk7-compliance.log | awk '{print $2}')
-          FAILURE=$(grep "^Failure:" /tmp/jdk7-compliance.log | awk '{print $2}')
-          TIMEOUT=$(grep "^Timeout:" /tmp/jdk7-compliance.log | awk '{print $2}')
-          CRASH=$(grep "^Crash:" /tmp/jdk7-compliance.log | awk '{print $2}')
-
-          echo "## OpenJDK JDK7 Compliance Results" >> $GITHUB_STEP_SUMMARY
+          TOTAL=$(grep "^Total:" /tmp/jdk${{ matrix.jdk }}-${{ matrix.variant }}-compliance.log | awk '{print $2}')
+          SUCCESS=$(grep "^Success:" /tmp/jdk${{ matrix.jdk }}-${{ matrix.variant }}-compliance.log | awk '{print $2}')
+          FAILURE=$(grep "^Failure:" /tmp/jdk${{ matrix.jdk }}-${{ matrix.variant }}-compliance.log | awk '{print $2}')
+          TIMEOUT=$(grep "^Timeout:" /tmp/jdk${{ matrix.jdk }}-${{ matrix.variant }}-compliance.log | awk '{print $2}')
+          CRASH=$(grep "^Crash:" /tmp/jdk${{ matrix.jdk }}-${{ matrix.variant }}-compliance.log | awk '{print $2}')
+
+          echo "## OpenJDK JDK${{ matrix.jdk }} Compliance Results (${{ matrix.variant }})" >> $GITHUB_STEP_SUMMARY
           echo "" >> $GITHUB_STEP_SUMMARY
           echo "| Metric | Count |" >> $GITHUB_STEP_SUMMARY
           echo "|--------|-------|" >> $GITHUB_STEP_SUMMARY
@@ -585,27 +311,24 @@ jobs:
           echo "| Timeout | $TIMEOUT |" >> $GITHUB_STEP_SUMMARY
           echo "| Crash | $CRASH |" >> $GITHUB_STEP_SUMMARY
 
-          # Fail if any test failed
           if [ "$FAILURE" != "0" ] || [ "$TIMEOUT" != "0" ] || [ "$CRASH" != "0" ]; then
-            echo ""
             echo "FAILURE: Some tests did not pass"
             exit 1
           fi
 
-          echo ""
-          echo "SUCCESS: All $TOTAL tests passed"
-
       - name: Upload test log
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: openjdk-compliance-jdk7-log
-          path: /tmp/jdk7-compliance.log
+          name: openjdk-compliance-jdk${{ matrix.jdk }}-${{ matrix.variant }}-log
+          path: /tmp/jdk${{ matrix.jdk }}-${{ matrix.variant }}-compliance.log
           retention-days: 7
 
-  openjdk-compliance-jdk8:
-    name: OpenJDK Compliance (JDK8)
+  # Legacy Classpath 0.93 build
+  build-legacy-classpath:
+    name: Build Legacy Classpath 0.93
     runs-on: ubuntu-latest
+    needs: build-and-test
 
     steps:
       - name: Checkout repository
@@ -615,69 +338,50 @@ jobs:
 
       - name: Install Nix
         uses: DeterminateSystems/nix-installer-action@v14
-        with:
-          logger: pretty
-          log-directives: nix_installer=debug
-
-      - name: Setup Nix cache
-        uses: DeterminateSystems/magic-nix-cache-action@v8
 
-      - name: Build JOPA and DevJopaK
+      - name: Build JOPA and GNU Classpath 0.93
         run: |
           nix develop --command bash -c '
             set -euo pipefail
             cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
             cmake --build build -j$(nproc)
-            cmake -S devjopak -B build-devjopak -DJOPA_BUILD_DIR=build -DCMAKE_BUILD_TYPE=Release
-            cmake --build build-devjopak --target devjopak -j$(nproc)
+            cmake -S devjopak -B build-devjopak \
+              -DJOPA_BUILD_DIR=build \
+              -DCMAKE_BUILD_TYPE=Release \
+              -DJOPA_CLASSPATH_VERSION=0.93
+            cmake --build build-devjopak --target gnu_classpath -j$(nproc) 2>&1 | tee /tmp/build-legacy.log
           '
 
-      - name: Prepare JDK8 Tests
-        run: |
-          nix develop --command python3 scripts/compliance_tester.py --prepare --jdk 8
-
-      - name: Run JDK8 Compliance Tests
-        run: |
-          nix develop --command python3 scripts/compliance_tester.py \
-            --test --jdk 8 \
-            --classpath gnucp \
-            --timeout 30 \
-            --mode run \
-            --no-success 2>&1 | tee /tmp/jdk8-compliance.log
-
-      - name: Check Results
-        run: |
-          # Extract results from log
-          TOTAL=$(grep "^Total:" /tmp/jdk8-compliance.log | awk '{print $2}')
-          SUCCESS=$(grep "^Success:" /tmp/jdk8-compliance.log | awk '{print $2}')
-          FAILURE=$(grep "^Failure:" /tmp/jdk8-compliance.log | awk '{print $2}')
-          TIMEOUT=$(grep "^Timeout:" /tmp/jdk8-compliance.log | awk '{print $2}')
-          CRASH=$(grep "^Crash:" /tmp/jdk8-compliance.log | awk '{print $2}')
-
-          echo "## OpenJDK JDK8 Compliance Results" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "| Metric | Count |" >> $GITHUB_STEP_SUMMARY
-          echo "|--------|-------|" >> $GITHUB_STEP_SUMMARY
-          echo "| Total | $TOTAL |" >> $GITHUB_STEP_SUMMARY
-          echo "| Success | $SUCCESS |" >> $GITHUB_STEP_SUMMARY
-          echo "| Failure | $FAILURE |" >> $GITHUB_STEP_SUMMARY
-          echo "| Timeout | $TIMEOUT |" >> $GITHUB_STEP_SUMMARY
-          echo "| Crash | $CRASH |" >> $GITHUB_STEP_SUMMARY
-
-          # Fail if any test failed
-          if [ "$FAILURE" != "0" ] || [ "$TIMEOUT" != "0" ] || [ "$CRASH" != "0" ]; then
-            echo ""
-            echo "FAILURE: Some tests did not pass"
-            exit 1
-          fi
-
-          echo ""
-          echo "SUCCESS: All $TOTAL tests passed"
-
-      - name: Upload test log
+      - name: Upload build log
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: openjdk-compliance-jdk8-log
-          path: /tmp/jdk8-compliance.log
+          name: build-legacy-log
+          path: /tmp/build-legacy.log
           retention-days: 7
+
+  # Create GitHub release
+  release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    needs: [build-devjopak, parser-tests, compliance-tests, openjdk-compliance]
+    if: startsWith(github.ref, 'refs/tags/v')
+    permissions:
+      contents: write
+
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            artifacts/devjopak-jopa/*.tar.gz
+            artifacts/devjopak-ecj421/*.tar.gz
+            artifacts/devjopak-ecj422/*.tar.gz
+          generate_release_notes: true
+          draft: false
+          prerelease: ${{ contains(github.ref, '-') }}
diff --git a/.gitignore b/.gitignore
index dd540b7..964edd5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -91,6 +91,7 @@ core.*
 *.tgz
 *.zip
 *.jar
+!vendor/*.jar
 
 # Nix
 result
diff --git a/README.md b/README.md
index 25524cd..14b9ee6 100644
--- a/README.md
+++ b/README.md
@@ -176,7 +176,8 @@ Java 7 language features are fully supported for parsing, semantic analysis, and
 | Exception suppression | ✅ Works | ✅ Works | ✅ Works |
 | Binary/underscore literals | ✅ Works | ✅ Works | ✅ Works |
 
-**Note:** Targets 1.5 and 1.6 pass the full test suite with strict JVM verification. Target 1.7 (class version 51.0) has known StackMapTable limitations with complex boolean expressions used as method arguments (e.g., `test("name", a == b)`). For most code, target 1.7 works correctly; alternatively, use `-target 1.5` or `-target 1.6` for maximum compatibility. Generated class files require at least the corresponding JVM major version.
+**Note:** Targets 1.5, 1.6 and 1.7 pass the full test suite with strict JVM verification. 
+Although our implementation of StackMapTable for target 1.7 still might be imperfect. Use `-target 1.5` or `-target 1.6` for maximum compatibility. 
 
 ### JDK Compliance Snapshot
 
diff --git a/TODO.md b/TODO.md
index ed7dec6..329eea8 100644
--- a/TODO.md
+++ b/TODO.md
@@ -25,6 +25,26 @@ and is compiled with `-sourcepath runtime`, the generated class file is corrupte
 - Look at bridge method generation when compiling java.lang classes
 - The issue may be related to how the compiler handles self-referential generics in bootstrap mode
 
+### Target 1.7 StackMapTable generation OOM
+
+Compiling tests with `-target 1.7` causes out-of-memory errors on tests with many boolean method arguments (e.g., `NumericBitwiseBoxingTest.java` with ~47 test calls).
+
+**Reproduction:**
+```bash
+./build/src/jopa -source 1.7 -target 1.7 -classpath ./build/runtime/jopa-stub-rt.jar \
+    -d /tmp/out test/autoboxing/NumericBitwiseBoxingTest.java
+# Process consumes 18GB+ RAM before being killed
+```
+
+**Impact:**
+- Target 1.7 excluded from test matrix
+- StackMapTable generation for class version 51.0 has memory leak
+
+**To investigate:**
+- Memory leak is NOT in: SaveLocals, RecordFrame, PushType, SetLocal (debug confirmed reasonable counts)
+- Issue manifests when combining many int boxing tests with long boxing tests
+- Suspected: exponential growth in some path during type verification inference
+
 ## JDK 7 Compliance (In Progress)
 
 - **Status**: 77.4% (657/849 tests passed).
diff --git a/devjopak/CMakeLists.txt b/devjopak/CMakeLists.txt
index 77193b9..e2f8bc8 100644
--- a/devjopak/CMakeLists.txt
+++ b/devjopak/CMakeLists.txt
@@ -4,7 +4,7 @@ project(devjopak NONE)
 
 # Read version from flake.nix
 file(READ "${CMAKE_CURRENT_SOURCE_DIR}/../flake.nix" FLAKE_NIX_CONTENT)
-string(REGEX MATCH "version = \"([0-9]+\\.[0-9]+)" _ "${FLAKE_NIX_CONTENT}")
+string(REGEX MATCH "version = \"([0-9]+\\.[0-9]+\\.[0-9]+)" _ "${FLAKE_NIX_CONTENT}")
 set(JOPA_VERSION "${CMAKE_MATCH_1}")
 if(NOT JOPA_VERSION)
     message(FATAL_ERROR "Could not extract version from flake.nix")
@@ -135,12 +135,14 @@ if(NOT JOPA_CLASSPATH_VERSION STREQUAL "0.93")
 
         DEPENDS gnu_classpath
 
+        # Use GCC for JamVM - clang 17+ rejects computed gotos into statement expressions
         CONFIGURE_COMMAND ${CMAKE_COMMAND} -E rm -f "${JAMVM_PREBUILT_CLASSES}"
         COMMAND ${CMAKE_COMMAND} -E env
             ${CLEAN_JAVA_ENV_VARS}
             "UBSAN_OPTIONS=halt_on_error=0"
             "ASAN_OPTIONS=detect_leaks=0"
             "JAVAC=${JOPA_JAVAC_COMMAND} --nowarn:unchecked -bootclasspath ${CLASSPATH_INSTALL_DIR}/share/classpath/glibj.zip"
+            "CC=gcc"
             <SOURCE_DIR>/configure
                 --prefix=<INSTALL_DIR>
                 --with-java-runtime-library=gnuclasspath
@@ -185,7 +187,7 @@ ulimit -s unlimited
     execute_process(COMMAND chmod +x "${CMAKE_CURRENT_BINARY_DIR}/ant-javac.sh" "${CMAKE_CURRENT_BINARY_DIR}/ant-java.sh")
 
     ExternalProject_Add(junit
-        URL "https://repo1.maven.org/maven2/junit/junit/3.8.2/junit-3.8.2-sources.jar"
+        URL "${CMAKE_CURRENT_SOURCE_DIR}/../vendor/junit-3.8.2-sources.jar"
         PREFIX "${CMAKE_CURRENT_BINARY_DIR}/junit-prefix"
         INSTALL_DIR "${VENDOR_PREFIX}/junit"
         DEPENDS gnu_classpath
@@ -228,8 +230,9 @@ endif()
 # DevJopaK Distribution
 # ============================================================================ 
 if(NOT JOPA_CLASSPATH_VERSION STREQUAL "0.93")
+    # Tarball naming: devjopak-{jopa_version}-gnucp-{cp_version}-jopa-{jopa_version}
     set(DEVJOPAK_DIR "${CMAKE_BINARY_DIR}/devjopak")
-    set(DEVJOPAK_ARCHIVE "devjopak-${JOPA_VERSION}.tar.gz")
+    set(DEVJOPAK_ARCHIVE "devjopak-${JOPA_VERSION}-gnucp-${JOPA_CLASSPATH_VERSION}-jopa-${JOPA_VERSION}.tar.gz")
 
     set(JAVAC_WRAPPER "${DEVJOPAK_DIR}/bin/javac")
     set(JAVA_WRAPPER "${DEVJOPAK_DIR}/bin/java")
diff --git a/devjopak/ecj_build.cmake b/devjopak/ecj_build.cmake
index 3d497d3..d3f1969 100644
--- a/devjopak/ecj_build.cmake
+++ b/devjopak/ecj_build.cmake
@@ -2,9 +2,15 @@
 # Eclipse Compiler for Java (ECJ) Build
 # ============================================================================
 if(NOT JOPA_CLASSPATH_VERSION STREQUAL "0.93")
-    set(ECJ_VERSION "4.2.1")
+    # ECJ version - can be overridden on command line
+    set(ECJ_VERSION "4.2.1" CACHE STRING "ECJ version to use (4.2.1 or 4.2.2)")
     # Use local source JAR from vendor directory
     set(ECJ_SOURCE_JAR "${CMAKE_CURRENT_SOURCE_DIR}/../vendor/ecjsrc-${ECJ_VERSION}.jar")
+
+    if(NOT EXISTS "${ECJ_SOURCE_JAR}")
+        message(FATAL_ERROR "ECJ source JAR not found at ${ECJ_SOURCE_JAR}. Available versions: 4.2.1, 4.2.2")
+    endif()
+    message(STATUS "ECJ version: ${ECJ_VERSION}")
     
     set(ECJ_BUILD_DIR "${CMAKE_BINARY_DIR}/ecj-build")
     set(ECJ_INSTALL_DIR "${VENDOR_PREFIX}/ecj")
@@ -62,11 +68,12 @@ find \"$1\" -name '*.java' > \"$2\"
 
     add_custom_target(ecj DEPENDS "${ECJ_JAR}")
 
-    # ============================================================================ 
+    # ============================================================================
     # DevJopaK-ECJ Distribution
-    # ============================================================================ 
+    # ============================================================================
+    # Tarball naming: devjopak-{jopa_version}-gnucp-{cp_version}-ecj-{ecj_version}
     set(DEVJOPAK_ECJ_DIR "${CMAKE_BINARY_DIR}/devjopak-ecj")
-    set(DEVJOPAK_ECJ_ARCHIVE "devjopak-ecj-${JOPA_VERSION}.tar.gz")
+    set(DEVJOPAK_ECJ_ARCHIVE "devjopak-${JOPA_VERSION}-gnucp-${JOPA_CLASSPATH_VERSION}-ecj-${ECJ_VERSION}.tar.gz")
     set(JAVAC_ECJ_WRAPPER "${DEVJOPAK_ECJ_DIR}/bin/javac")
     
     add_custom_command(
diff --git a/flake.nix b/flake.nix
index 6d7e757..ea25d9a 100644
--- a/flake.nix
+++ b/flake.nix
@@ -11,91 +11,379 @@
       let
         pkgs = nixpkgs.legacyPackages.${system};
         jdk = pkgs.openjdk8;
-      in
-      {
-        devShells.default = pkgs.mkShell {
-          buildInputs = with pkgs; [
-            # Build tools
-            clang
-            llvm
+
+        # Common build dependencies for JOPA
+        jopaBuildInputs = with pkgs; [
+          clang
+          llvm
+          cmake
+          gnumake
+          pkg-config
+          libzip
+          cpptrace
+        ];
+
+        # Build dependencies for GNU Classpath and JamVM
+        bootstrapBuildInputs = with pkgs; [
+          autoconf
+          automake
+          libtool
+          libffi
+          zlib
+          zip
+          unzip
+          coreutils
+          gnused
+          gnugrep
+          findutils
+          gawk
+          patch
+          cpio
+          which
+          file
+        ];
+
+        # Helper function to build JOPA compiler
+        mkJopa = { debug ? false }: pkgs.clangStdenv.mkDerivation {
+          pname = "jopa${if debug then "-debug" else ""}";
+          version = "2.0.1";
+
+          src = ./.;
+
+          nativeBuildInputs = with pkgs; [
             cmake
-            gnumake
             pkg-config
+            openjdk8  # Required for running tests
+            zip       # Required for building stub runtime
+            python3   # Required for post-processing parser headers
+          ];
 
-            # Libraries
+          buildInputs = with pkgs; [
             libzip
             cpptrace
+          ];
+
+          cmakeFlags = [
+            "-DCMAKE_BUILD_TYPE=${if debug then "Debug" else "Release"}"
+          ] ++ (if debug then [
+            "-DJOPA_ENABLE_SANITIZERS=ON"
+            "-DJOPA_ENABLE_LEAK_SANITIZER=OFF"
+          ] else []);
+
+          installPhase = ''
+            mkdir -p $out/bin $out/lib
+            cp src/jopa $out/bin/
+            cp runtime/jopa-stub-rt.jar $out/lib/
+          '';
+
+          doCheck = true;
+          checkPhase = ''
+            ctest --output-on-failure -j$NIX_BUILD_CORES
+          '';
+
+          meta = with pkgs.lib; {
+            description = "Jopa Java compiler (based on Jikes) with Java 7 support${if debug then " (debug build with sanitizers)" else ""}";
+            homepage = "https://github.com/pshirshov/jopa";
+            license = licenses.ipl10;
+            platforms = platforms.unix;
+          };
+        };
 
-            # Development tools
-            lldb
-            valgrind
+        jopa = mkJopa { debug = false; };
+        jopa-debug = mkJopa { debug = true; };
 
-            # Java for testing
-            openjdk8
-            zip
-            unzip
+        # Helper function to build devjopak variants
+        mkDevjopak = { name, ecjVersion ? null, debug ? false }: pkgs.clangStdenv.mkDerivation {
+          pname = name;
+          version = "2.0.1";
 
-            # Utilities
-            git
-            which
-            file
+          src = ./.;
+
+          nativeBuildInputs = jopaBuildInputs ++ bootstrapBuildInputs ++ [
+            pkgs.openjdk8  # Required for JOPA tests
+            pkgs.python3   # Required for parser header post-processing
+            pkgs.gcc       # Required for JamVM (clang 17+ rejects its computed gotos)
+          ];
 
-            # JamVM + GNU Classpath build dependencies
-            autoconf
-            automake
-            libtool
+          buildInputs = with pkgs; [
             libffi
             zlib
-            antlr
           ];
 
-          shellHook = ''
-            echo "================================================"
-            echo "Jopa Development Environment (Clang)"
-            echo "================================================"
-            export JAVA_HOME=${jdk.home}
-            echo "C++ Compiler: $(clang++ --version | head -1)"
-            echo "CMake: $(${pkgs.cmake}/bin/cmake --version | head -1)"
-            echo "Java: $(java -version 2>&1 | head -1)"
-            echo ""
-            echo "Available commands:"
-            echo "  - Build with CMake: cmake -S . -B build && cmake --build build"
-            echo "  - Run tests: cd build && ctest"
-            echo ""
+          # Disable automatic cmake configure - we do it manually in buildPhase
+          dontConfigure = true;
+
+          postPatch = ''
+            patchShebangs vendor/*.sh devjopak/*.sh
+          '';
+
+          buildPhase = ''
+            export HOME=$TMPDIR
+
+            # Build JOPA compiler and stub runtime first
+            cmake -S . -B build-jopa \
+              -DCMAKE_BUILD_TYPE=${if debug then "Debug" else "Release"} \
+              ${if debug then "-DJOPA_ENABLE_SANITIZERS=ON -DJOPA_ENABLE_LEAK_SANITIZER=OFF" else ""}
+            cmake --build build-jopa --target jopa jopa-stub-rt -j$NIX_BUILD_CORES
+
+            # Build devjopak
+            cmake -S devjopak -B build-devjopak \
+              -DJOPA_BUILD_DIR=$PWD/build-jopa \
+              -DJOPA_CLASSPATH_VERSION=0.99 \
+              ${if ecjVersion != null then "-DECJ_VERSION=${ecjVersion}" else ""} \
+              -DCMAKE_BUILD_TYPE=${if debug then "Debug" else "Release"}
+
+            # Build the target
+            cmake --build build-devjopak --target ${if ecjVersion != null then "devjopak-ecj" else "devjopak"} -j1
+
+            # Find the archive
+            if [ -n "${if ecjVersion != null then ecjVersion else ""}" ]; then
+              ARCHIVE=$(find build-devjopak -name "devjopak-*-ecj-*.tar.gz" | head -n1)
+            else
+              ARCHIVE=$(find build-devjopak -name "devjopak-*-jopa-*.tar.gz" | head -n1)
+            fi
+
+            if [ -z "$ARCHIVE" ]; then
+              echo "Error: Could not find devjopak archive"
+              exit 1
+            fi
+
+            mkdir -p $TMPDIR/dist
+            tar -xzf "$ARCHIVE" -C $TMPDIR/dist
           '';
+
+          installPhase = ''
+            # Find the extracted directory
+            DEVJOPAK_DIR=$(find $TMPDIR/dist -maxdepth 1 -type d -name "devjopak*" | head -n1)
+            if [ -z "$DEVJOPAK_DIR" ]; then
+              echo "Error: Could not find extracted devjopak directory"
+              exit 1
+            fi
+
+            mkdir -p $out
+            cp -r "$DEVJOPAK_DIR"/* $out/
+            chmod +x $out/bin/*
+          '';
+
+          meta = with pkgs.lib; {
+            description = "DevJopaK - Self-contained Java Development Kit${if debug then " (debug)" else ""}";
+            homepage = "https://github.com/pshirshov/jopa";
+            license = licenses.ipl10;
+            platforms = platforms.unix;
+          };
         };
 
-        # Package definition for building Jopa with CMake
-        packages.default = pkgs.stdenv.mkDerivation {
-          pname = "jopa";
-          version = "2.0.1";
+        # DevJopaK variants (Release)
+        devjopak-gnucp099-jopa201 = mkDevjopak {
+          name = "devjopak-gnucp099-jopa201";
+        };
+
+        devjopak-gnucp099-ecj421 = mkDevjopak {
+          name = "devjopak-gnucp099-ecj421";
+          ecjVersion = "4.2.1";
+        };
+
+        devjopak-gnucp099-ecj422 = mkDevjopak {
+          name = "devjopak-gnucp099-ecj422";
+          ecjVersion = "4.2.2";
+        };
+
+        # DevJopaK variants (Debug)
+        devjopak-gnucp099-jopa201-debug = mkDevjopak {
+          name = "devjopak-gnucp099-jopa201-debug";
+          debug = true;
+        };
+
+        devjopak-gnucp099-ecj421-debug = mkDevjopak {
+          name = "devjopak-gnucp099-ecj421-debug";
+          ecjVersion = "4.2.1";
+          debug = true;
+        };
+
+        devjopak-gnucp099-ecj422-debug = mkDevjopak {
+          name = "devjopak-gnucp099-ecj422-debug";
+          ecjVersion = "4.2.2";
+          debug = true;
+        };
+
+        # ECJ standalone builds
+        mkEcj = { ecjVersion, debug ? false }: pkgs.clangStdenv.mkDerivation {
+          pname = "ecj${if debug then "-debug" else ""}";
+          version = ecjVersion;
 
           src = ./.;
 
-          nativeBuildInputs = with pkgs; [
-            cmake
-            pkg-config
+          nativeBuildInputs = jopaBuildInputs ++ bootstrapBuildInputs ++ [
+            pkgs.openjdk8  # Required for JOPA tests
+            pkgs.python3   # Required for parser header post-processing
+            pkgs.gcc       # Required for JamVM (clang 17+ rejects its computed gotos)
           ];
 
           buildInputs = with pkgs; [
-            clang
-            libzip
+            libffi
+            zlib
           ];
 
-          cmakeFlags = [
-            "-DCMAKE_BUILD_TYPE=Release"
+          dontConfigure = true;
+
+          postPatch = ''
+            patchShebangs vendor/*.sh devjopak/*.sh
+          '';
+
+          buildPhase = ''
+            export HOME=$TMPDIR
+
+            # Build JOPA compiler and stub runtime first
+            cmake -S . -B build-jopa \
+              -DCMAKE_BUILD_TYPE=${if debug then "Debug" else "Release"} \
+              ${if debug then "-DJOPA_ENABLE_SANITIZERS=ON -DJOPA_ENABLE_LEAK_SANITIZER=OFF" else ""}
+            cmake --build build-jopa --target jopa jopa-stub-rt -j$NIX_BUILD_CORES
+
+            # Build devjopak with ECJ
+            cmake -S devjopak -B build-devjopak \
+              -DJOPA_BUILD_DIR=$PWD/build-jopa \
+              -DJOPA_CLASSPATH_VERSION=0.99 \
+              -DECJ_VERSION=${ecjVersion} \
+              -DCMAKE_BUILD_TYPE=${if debug then "Debug" else "Release"}
+
+            # Build ECJ target
+            cmake --build build-devjopak --target ecj -j1
+          '';
+
+          installPhase = ''
+            mkdir -p $out/lib
+            cp build-devjopak/vendor-install/ecj/lib/ecj.jar $out/lib/
+          '';
+
+          meta = with pkgs.lib; {
+            description = "Eclipse Compiler for Java ${ecjVersion} built with JOPA${if debug then " (debug)" else ""}";
+            homepage = "https://www.eclipse.org/jdt/core/";
+            license = licenses.epl10;
+            platforms = platforms.unix;
+          };
+        };
+
+        ecj_421 = mkEcj { ecjVersion = "4.2.1"; };
+        ecj_422 = mkEcj { ecjVersion = "4.2.2"; };
+        ecj_421-debug = mkEcj { ecjVersion = "4.2.1"; debug = true; };
+        ecj_422-debug = mkEcj { ecjVersion = "4.2.2"; debug = true; };
+
+        # Apache Ant built with JOPA
+        mkAnt = { debug ? false }: pkgs.clangStdenv.mkDerivation {
+          pname = "ant-jopa${if debug then "-debug" else ""}";
+          version = "1.8.4";
+
+          src = ./.;
+
+          nativeBuildInputs = jopaBuildInputs ++ bootstrapBuildInputs ++ [
+            pkgs.openjdk8  # Required for JOPA tests
+            pkgs.python3   # Required for parser header post-processing
+            pkgs.gcc       # Required for JamVM (clang 17+ rejects its computed gotos)
+          ];
+
+          buildInputs = with pkgs; [
+            libffi
+            zlib
           ];
 
-          # CMake will handle the build automatically
+          dontConfigure = true;
+
+          postPatch = ''
+            patchShebangs vendor/*.sh devjopak/*.sh
+          '';
+
+          buildPhase = ''
+            export HOME=$TMPDIR
+
+            # Build JOPA compiler and stub runtime first
+            cmake -S . -B build-jopa \
+              -DCMAKE_BUILD_TYPE=${if debug then "Debug" else "Release"} \
+              ${if debug then "-DJOPA_ENABLE_SANITIZERS=ON -DJOPA_ENABLE_LEAK_SANITIZER=OFF" else ""}
+            cmake --build build-jopa --target jopa jopa-stub-rt -j$NIX_BUILD_CORES
+
+            # Build devjopak (which includes Ant)
+            cmake -S devjopak -B build-devjopak \
+              -DJOPA_BUILD_DIR=$PWD/build-jopa \
+              -DJOPA_CLASSPATH_VERSION=0.99 \
+              -DCMAKE_BUILD_TYPE=${if debug then "Debug" else "Release"}
+
+            # Build apache_ant target
+            cmake --build build-devjopak --target apache_ant -j1
+          '';
+
+          installPhase = ''
+            mkdir -p $out/bin $out/lib
+            cp -r build-devjopak/vendor-install/ant/* $out/
+          '';
 
           meta = with pkgs.lib; {
-            description = "Jopa Java compiler (based on Jikes) with Java 7 support";
-            homepage = "https://github.com/pshirshov/jopa";
-            license = licenses.ipl10;
+            description = "Apache Ant 1.8.4 built with JOPA${if debug then " (debug)" else ""}";
+            homepage = "https://ant.apache.org/";
+            license = licenses.asl20;
             platforms = platforms.unix;
-            maintainers = [];
           };
         };
+
+        ant = mkAnt { debug = false; };
+        ant-debug = mkAnt { debug = true; };
+
+      in
+      {
+        devShells.default = pkgs.mkShell {
+          buildInputs = jopaBuildInputs ++ bootstrapBuildInputs ++ [
+            pkgs.lldb
+            pkgs.valgrind
+            jdk
+            pkgs.git
+            pkgs.bc
+            pkgs.python3
+          ];
+
+          shellHook = ''
+            echo "================================================"
+            echo "Jopa Development Environment (Clang)"
+            echo "================================================"
+            export JAVA_HOME=${jdk.home}
+            echo "C++ Compiler: $(clang++ --version | head -1)"
+            echo "CMake: $(${pkgs.cmake}/bin/cmake --version | head -1)"
+            echo "Java: $(java -version 2>&1 | head -1)"
+            echo ""
+            echo "Available packages (nix build .#<name>):"
+            echo ""
+            echo "  Release builds:"
+            echo "    - default (jopa)            : JOPA compiler"
+            echo "    - ecj_421, ecj_422          : ECJ built with JOPA"
+            echo "    - ant                       : Apache Ant 1.8.4"
+            echo "    - devjopak-gnucp099-jopa201 : DevJopaK with JOPA"
+            echo "    - devjopak-gnucp099-ecj421  : DevJopaK with ECJ 4.2.1"
+            echo "    - devjopak-gnucp099-ecj422  : DevJopaK with ECJ 4.2.2"
+            echo ""
+            echo "  Debug builds (with sanitizers):"
+            echo "    - jopa-debug                      : JOPA compiler"
+            echo "    - ecj_421-debug, ecj_422-debug    : ECJ"
+            echo "    - ant-debug                       : Apache Ant"
+            echo "    - devjopak-gnucp099-jopa201-debug : DevJopaK with JOPA"
+            echo "    - devjopak-gnucp099-ecj421-debug  : DevJopaK with ECJ 4.2.1"
+            echo "    - devjopak-gnucp099-ecj422-debug  : DevJopaK with ECJ 4.2.2"
+            echo ""
+          '';
+        };
+
+        packages = {
+          default = jopa;
+          inherit jopa jopa-debug;
+          inherit ecj_421 ecj_422 ecj_421-debug ecj_422-debug;
+          inherit ant ant-debug;
+          inherit devjopak-gnucp099-jopa201 devjopak-gnucp099-ecj421 devjopak-gnucp099-ecj422;
+          inherit devjopak-gnucp099-jopa201-debug devjopak-gnucp099-ecj421-debug devjopak-gnucp099-ecj422-debug;
+        };
+
+        # Checks run by `nix flake check`
+        checks = {
+          # Run primary test suite
+          jopa-tests = jopa;
+          jopa-debug-tests = jopa-debug;
+        };
       }
     );
 }
diff --git a/scripts/compliance_tester.py b/scripts/compliance_tester.py
index 2dfb548..dc6eae6 100755
--- a/scripts/compliance_tester.py
+++ b/scripts/compliance_tester.py
@@ -15,9 +15,19 @@
 DEFAULT_COMPILER = "jopa"
 DEFAULT_JVM = "jamvm"
 STUB_RT_PATH = "build/runtime/jopa-stub-rt.jar"
-GNUCP_PATH = "build-devjopak/vendor-install/classpath/share/classpath/glibj.zip"
-JOPA_PATH = "build/src/jopa"
-JAMVM_PATH = "build-devjopak/vendor-install/jamvm/bin/jamvm"
+
+# Support DEVJOPAK_HOME environment variable for nix-built devjopak
+DEVJOPAK_HOME = os.environ.get("DEVJOPAK_HOME")
+if DEVJOPAK_HOME:
+    # Nix-built devjopak - use bin/ wrappers which set up paths correctly
+    GNUCP_PATH = os.path.join(DEVJOPAK_HOME, "lib/glibj.zip")
+    JOPA_PATH = os.path.join(DEVJOPAK_HOME, "bin/javac")
+    JAMVM_PATH = os.path.join(DEVJOPAK_HOME, "bin/java")
+else:
+    # Local cmake build paths
+    GNUCP_PATH = "build-devjopak/vendor-install/classpath/share/classpath/glibj.zip"
+    JOPA_PATH = "build/src/jopa"
+    JAMVM_PATH = "build-devjopak/vendor-install/jamvm/bin/jamvm"
 
 class Test:
     def __init__(self, file_path, instructions, reason):
diff --git a/scripts/test-devjopak-ecj.sh b/scripts/test-devjopak-ecj.sh
index 5bbfd03..d669c2b 100755
--- a/scripts/test-devjopak-ecj.sh
+++ b/scripts/test-devjopak-ecj.sh
@@ -7,40 +7,73 @@ BUILD_DIR="$ROOT_DIR/build"
 DEVJOPAK_ECJ_BUILD_DIR="$ROOT_DIR/build-devjopak-ecj"
 TEST_DIR="$DEVJOPAK_ECJ_BUILD_DIR/test-devjopak-ecj"
 
-echo "Building JOPA Compiler..."
-cmake -S "$ROOT_DIR" -B "$BUILD_DIR" -DCMAKE_BUILD_TYPE=Release
-cmake --build "$BUILD_DIR" --target jopa jopa-stub-rt
-
-echo "Building DevJopaK-ECJ Distribution..."
-# Configure devjopak build (reuses devjopak folder for ECJ build too)
-cmake -S "$ROOT_DIR/devjopak" -B "$DEVJOPAK_ECJ_BUILD_DIR" \
-    -DJOPA_BUILD_DIR="$BUILD_DIR" \
-    -DCMAKE_BUILD_TYPE=Release
-
-cmake --build "$DEVJOPAK_ECJ_BUILD_DIR" --target devjopak-ecj
-
-# Find the archive (handling version variations)
-DIST_ARCHIVE=$(find "$DEVJOPAK_ECJ_BUILD_DIR" -name "devjopak-ecj-*.tar.gz" | head -n 1)
-if [ -z "$DIST_ARCHIVE" ]; then
-    echo "Error: Could not find devjopak-ecj-*.tar.gz in $DEVJOPAK_ECJ_BUILD_DIR"
-    exit 1
-fi
-echo "Found archive: $DIST_ARCHIVE"
+# Check if we should use nix build
+USE_NIX=false
+ECJ_VERSION="4.2.1"
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --nix)
+            USE_NIX=true
+            shift
+            ;;
+        --ecj-version)
+            ECJ_VERSION="$2"
+            shift 2
+            ;;
+        *)
+            shift
+            ;;
+    esac
+done
+
+# Map ECJ version to package name
+case "$ECJ_VERSION" in
+    4.2.1) NIX_PACKAGE="devjopak-gnucp099-ecj421" ;;
+    4.2.2) NIX_PACKAGE="devjopak-gnucp099-ecj422" ;;
+    *) echo "Error: Unknown ECJ version $ECJ_VERSION"; exit 1 ;;
+esac
+
+if [ "$USE_NIX" = true ]; then
+    echo "Building DevJopaK-ECJ (ECJ $ECJ_VERSION) via Nix..."
+    cd "$ROOT_DIR"
+    nix build ".#$NIX_PACKAGE" --print-build-logs
+
+    DEVJOPAK_HOME="$ROOT_DIR/result"
+else
+    echo "Building JOPA Compiler..."
+    cmake -S "$ROOT_DIR" -B "$BUILD_DIR" -DCMAKE_BUILD_TYPE=Release
+    cmake --build "$BUILD_DIR" --target jopa jopa-stub-rt
+
+    echo "Building DevJopaK-ECJ Distribution (ECJ $ECJ_VERSION)..."
+    cmake -S "$ROOT_DIR/devjopak" -B "$DEVJOPAK_ECJ_BUILD_DIR" \
+        -DJOPA_BUILD_DIR="$BUILD_DIR" \
+        -DECJ_VERSION="$ECJ_VERSION" \
+        -DCMAKE_BUILD_TYPE=Release
+
+    cmake --build "$DEVJOPAK_ECJ_BUILD_DIR" --target devjopak-ecj
 
-echo "Setting up test environment in $TEST_DIR..."
-rm -rf "$TEST_DIR"
-mkdir -p "$TEST_DIR"
-tar -xzf "$DIST_ARCHIVE" -C "$TEST_DIR"
+    # Find the archive (handling version variations)
+    # New naming: devjopak-{version}-gnucp-{version}-ecj-{version}.tar.gz
+    DIST_ARCHIVE=$(find "$DEVJOPAK_ECJ_BUILD_DIR" -name "devjopak-*-ecj-*.tar.gz" | head -n 1)
+    if [ -z "$DIST_ARCHIVE" ]; then
+        echo "Error: Could not find devjopak-*-ecj-*.tar.gz in $DEVJOPAK_ECJ_BUILD_DIR"
+        exit 1
+    fi
+    echo "Found archive: $DIST_ARCHIVE"
 
-# Adjust path to point to unpacked devjopak-ecj folder
-DEVJOPAK_HOME="$TEST_DIR/devjopak-ecj"
-# Ensure binaries are executable
-chmod -R +x "$DEVJOPAK_HOME/bin"
+    echo "Setting up test environment in $TEST_DIR..."
+    rm -rf "$TEST_DIR"
+    mkdir -p "$TEST_DIR"
+    tar -xzf "$DIST_ARCHIVE" -C "$TEST_DIR"
+
+    # Adjust path to point to unpacked devjopak-ecj folder
+    DEVJOPAK_HOME="$TEST_DIR/devjopak-ecj"
+    # Ensure binaries are executable
+    chmod -R +x "$DEVJOPAK_HOME/bin"
+fi
 
 export JAVA_HOME="$DEVJOPAK_HOME"
-# Note: ECJ distribution doesn't include Ant currently, so we skip ANT_HOME export or checks
-# If you added Ant to DevJopaK-ECJ, uncomment:
-# export ANT_HOME="$DEVJOPAK_HOME"
 export PATH="$DEVJOPAK_HOME/bin:$PATH"
 
 echo "------------------------------------------------"
@@ -53,8 +86,12 @@ echo "Using: $(which javac)"
 javac -help | head -n 1 || true
 echo "------------------------------------------------"
 
+# Create test directory
+TEST_WORK_DIR="${TEST_DIR:-/tmp/test-devjopak-ecj-$$}"
+mkdir -p "$TEST_WORK_DIR"
+
 # Create Hello.java
-cat > "$TEST_DIR/Hello.java" <<EOF
+cat > "$TEST_WORK_DIR/Hello.java" <<EOF
 public class Hello {
     public static void main(String[] args) {
         System.out.println("Hello from DevJopaK-ECJ!");
@@ -62,7 +99,7 @@ public class Hello {
 }
 EOF
 
-cd "$TEST_DIR"
+cd "$TEST_WORK_DIR"
 echo "Compiling Hello.java with ECJ..."
 javac Hello.java
 
@@ -77,7 +114,7 @@ echo "Output: $OUTPUT"
 
 if [[ "$OUTPUT" == *"Hello from DevJopaK-ECJ!"* ]]; then
     echo "------------------------------------------------"
-    echo "SUCCESS: DevJopaK-ECJ passed verification!"
+    echo "SUCCESS: DevJopaK-ECJ (ECJ $ECJ_VERSION) passed verification!"
     echo "------------------------------------------------"
 else
     echo "------------------------------------------------"
diff --git a/scripts/test-devjopak.sh b/scripts/test-devjopak.sh
index 2313d90..1513dcf 100755
--- a/scripts/test-devjopak.sh
+++ b/scripts/test-devjopak.sh
@@ -7,37 +7,49 @@ BUILD_DIR="$ROOT_DIR/build"
 DEVJOPAK_BUILD_DIR="$ROOT_DIR/build-devjopak"
 TEST_DIR="$DEVJOPAK_BUILD_DIR/test-devjopak"
 
-# Clean up previous builds to ensure fresh state
-# rm -rf "$DEVJOPAK_BUILD_DIR"
-
-echo "Building JOPA Compiler..."
-cmake -S "$ROOT_DIR" -B "$BUILD_DIR" -DCMAKE_BUILD_TYPE=Release
-cmake --build "$BUILD_DIR" --target jopa jopa-stub-rt
-
-echo "Building DevJopaK Distribution..."
-# Configure devjopak build, pointing to the jopa build artifacts
-cmake -S "$ROOT_DIR/devjopak" -B "$DEVJOPAK_BUILD_DIR" \
-    -DJOPA_BUILD_DIR="$BUILD_DIR" \
-    -DCMAKE_BUILD_TYPE=Release
-
-cmake --build "$DEVJOPAK_BUILD_DIR" --target devjopak
-
-# Find the archive (handling version variations, but strictly excluding ecj variant)
-DIST_ARCHIVE=$(find "$DEVJOPAK_BUILD_DIR" -name "devjopak-*.tar.gz" ! -name "*ecj*" | head -n 1)
-if [ -z "$DIST_ARCHIVE" ]; then
-    echo "Error: Could not find devjopak-*.tar.gz in $DEVJOPAK_BUILD_DIR"
-    exit 1
+# Check if we should use nix build
+USE_NIX=false
+if [ "$1" = "--nix" ]; then
+    USE_NIX=true
+    shift
 fi
-echo "Found archive: $DIST_ARCHIVE"
 
-echo "Setting up test environment in $TEST_DIR..."
-rm -rf "$TEST_DIR"
-mkdir -p "$TEST_DIR"
-tar -xzf "$DIST_ARCHIVE" -C "$TEST_DIR"
-
-DEVJOPAK_HOME="$TEST_DIR/devjopak"
-# Ensure binaries are executable (cmake -E tar might not preserve permissions perfectly in all envs)
-chmod -R +x "$DEVJOPAK_HOME/bin"
+if [ "$USE_NIX" = true ]; then
+    echo "Building DevJopaK via Nix..."
+    cd "$ROOT_DIR"
+    nix build .#devjopak-gnucp099-jopa201 --print-build-logs
+
+    DEVJOPAK_HOME="$ROOT_DIR/result"
+else
+    echo "Building JOPA Compiler..."
+    cmake -S "$ROOT_DIR" -B "$BUILD_DIR" -DCMAKE_BUILD_TYPE=Release
+    cmake --build "$BUILD_DIR" --target jopa jopa-stub-rt
+
+    echo "Building DevJopaK Distribution..."
+    cmake -S "$ROOT_DIR/devjopak" -B "$DEVJOPAK_BUILD_DIR" \
+        -DJOPA_BUILD_DIR="$BUILD_DIR" \
+        -DCMAKE_BUILD_TYPE=Release
+
+    cmake --build "$DEVJOPAK_BUILD_DIR" --target devjopak
+
+    # Find the archive (handling version variations)
+    # New naming: devjopak-{version}-gnucp-{version}-jopa-{version}.tar.gz
+    DIST_ARCHIVE=$(find "$DEVJOPAK_BUILD_DIR" -name "devjopak-*-jopa-*.tar.gz" | head -n 1)
+    if [ -z "$DIST_ARCHIVE" ]; then
+        echo "Error: Could not find devjopak-*-jopa-*.tar.gz in $DEVJOPAK_BUILD_DIR"
+        exit 1
+    fi
+    echo "Found archive: $DIST_ARCHIVE"
+
+    echo "Setting up test environment in $TEST_DIR..."
+    rm -rf "$TEST_DIR"
+    mkdir -p "$TEST_DIR"
+    tar -xzf "$DIST_ARCHIVE" -C "$TEST_DIR"
+
+    DEVJOPAK_HOME="$TEST_DIR/devjopak"
+    # Ensure binaries are executable
+    chmod -R +x "$DEVJOPAK_HOME/bin"
+fi
 
 export JAVA_HOME="$DEVJOPAK_HOME"
 export ANT_HOME="$DEVJOPAK_HOME"
@@ -54,13 +66,17 @@ echo "Using: $(which ant)"
 ant -version
 echo "------------------------------------------------"
 
+# Create test directory
+TEST_WORK_DIR="${TEST_DIR:-/tmp/test-devjopak-$$}"
+mkdir -p "$TEST_WORK_DIR"
+
 # Create Hello.java
-cat > "$TEST_DIR/Hello.java" <<EOF
+cat > "$TEST_WORK_DIR/Hello.java" <<EOF
 public class Hello {
     public static void main(String[] args) {
         System.out.println("Hello from DevJopaK!");
     }
-    
+
     public String getMessage() {
         return "Hello";
     }
@@ -68,7 +84,7 @@ public class Hello {
 EOF
 
 # Create HelloTest.java (JUnit 3)
-cat > "$TEST_DIR/HelloTest.java" <<EOF
+cat > "$TEST_WORK_DIR/HelloTest.java" <<EOF
 import junit.framework.TestCase;
 
 public class HelloTest extends TestCase {
@@ -80,7 +96,7 @@ public class HelloTest extends TestCase {
 EOF
 
 # Create build.xml
-cat > "$TEST_DIR/build.xml" <<EOF
+cat > "$TEST_WORK_DIR/build.xml" <<EOF
 <project name="TestDevJopaK" default="test" basedir=".">
     <target name="init">
         <mkdir dir="classes"/>
@@ -126,7 +142,7 @@ cat > "$TEST_DIR/build.xml" <<EOF
 </project>
 EOF
 
-cd "$TEST_DIR"
+cd "$TEST_WORK_DIR"
 echo "Running Ant run..."
 ant run
 
@@ -135,4 +151,4 @@ ant test
 
 echo "------------------------------------------------"
 echo "SUCCESS: DevJopaK passed verification!"
-echo "------------------------------------------------"
\ No newline at end of file
+echo "------------------------------------------------"
diff --git a/scripts/test-primary.sh b/scripts/test-primary.sh
index 0fb0903..e5f89ac 100755
--- a/scripts/test-primary.sh
+++ b/scripts/test-primary.sh
@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Primary test suite - runs semantic/bytecode tests with target version matrix
-# All tests use -source 1.7, targets: 1.5, 1.6, 1.7
+# All tests use -source 1.7, targets: 1.5, 1.6
 #
 # Usage: test-primary.sh [OPTIONS]
 #   --clean        Remove build directory and do a full clean rebuild
@@ -85,14 +85,13 @@ echo "JamVM: ${USE_JAMVM}"
 echo ""
 
 # Target versions to test
-# Note: Target 1.7 has known StackMapTable limitations with complex boolean
-# expressions used as method arguments. Tests pass with targets 1.5 and 1.6.
+# Target 1.7 generates StackMapTable for proper JVM verification
 if $QUICK_MODE; then
-    TARGETS=("1.5")
-    echo "Mode: Quick (target 1.5 only)"
+    TARGETS=("1.7")
+    echo "Mode: Quick (target 1.7 only)"
 else
-    TARGETS=("1.5" "1.6")
-    echo "Mode: Full matrix (targets 1.5, 1.6)"
+    TARGETS=("1.5" "1.6" "1.7")
+    echo "Mode: Full matrix (targets 1.5, 1.6, 1.7)"
 fi
 echo ""
 
@@ -119,7 +118,7 @@ RESULTS=()
 
 for TARGET in "${TARGETS[@]}"; do
     echo "========================================"
-    echo "  Testing with -source 1.7 -target ${TARGET}"
+    echo "  Testing with -target ${TARGET}"
     echo "========================================"
     echo ""
 
diff --git a/src/codegen/bytecode.h b/src/codegen/bytecode.h
index 5cc8418..9775d8f 100644
--- a/src/codegen/bytecode.h
+++ b/src/codegen/bytecode.h
@@ -117,6 +117,128 @@ class StackMapGenerator
     void PopTypes(int count);
     void ClearStack();
 
+    //
+    // DUP operations - duplicate stack values
+    //
+    void Dup()
+    {
+        if (current_stack.Length() > 0)
+            current_stack.Next() = current_stack[current_stack.Length() - 1];
+    }
+
+    void Dup2()
+    {
+        // Duplicates top two values (or one category 2 value)
+        unsigned len = current_stack.Length();
+        if (len >= 2)
+        {
+            current_stack.Next() = current_stack[len - 2];
+            current_stack.Next() = current_stack[len - 1];
+        }
+        else if (len == 1)
+        {
+            current_stack.Next() = current_stack[len - 1];
+        }
+    }
+
+    void DupX1()
+    {
+        // ..., value2, value1 -> ..., value1, value2, value1
+        unsigned len = current_stack.Length();
+        if (len >= 2)
+        {
+            VerificationType v1 = current_stack[len - 1];
+            VerificationType v2 = current_stack[len - 2];
+            current_stack[len - 2] = v1;
+            current_stack[len - 1] = v2;
+            current_stack.Next() = v1;
+        }
+    }
+
+    void DupX2()
+    {
+        // ..., value3, value2, value1 -> ..., value1, value3, value2, value1
+        unsigned len = current_stack.Length();
+        if (len >= 3)
+        {
+            VerificationType v1 = current_stack[len - 1];
+            VerificationType v2 = current_stack[len - 2];
+            VerificationType v3 = current_stack[len - 3];
+            current_stack[len - 3] = v1;
+            current_stack[len - 2] = v3;
+            current_stack[len - 1] = v2;
+            current_stack.Next() = v1;
+        }
+    }
+
+    void Dup2X1()
+    {
+        // ..., value3, value2, value1 -> ..., value2, value1, value3, value2, value1
+        unsigned len = current_stack.Length();
+        if (len >= 3)
+        {
+            VerificationType v1 = current_stack[len - 1];
+            VerificationType v2 = current_stack[len - 2];
+            VerificationType v3 = current_stack[len - 3];
+            current_stack[len - 3] = v2;
+            current_stack[len - 2] = v1;
+            current_stack[len - 1] = v3;
+            current_stack.Next() = v2;
+            current_stack.Next() = v1;
+        }
+    }
+
+    void Dup2X2()
+    {
+        // ..., v4, v3, v2, v1 -> ..., v2, v1, v4, v3, v2, v1
+        unsigned len = current_stack.Length();
+        if (len >= 4)
+        {
+            VerificationType v1 = current_stack[len - 1];
+            VerificationType v2 = current_stack[len - 2];
+            VerificationType v3 = current_stack[len - 3];
+            VerificationType v4 = current_stack[len - 4];
+            current_stack[len - 4] = v2;
+            current_stack[len - 3] = v1;
+            current_stack[len - 2] = v4;
+            current_stack[len - 1] = v3;
+            current_stack.Next() = v2;
+            current_stack.Next() = v1;
+        }
+    }
+
+    void Swap()
+    {
+        unsigned len = current_stack.Length();
+        if (len >= 2)
+        {
+            VerificationType tmp = current_stack[len - 1];
+            current_stack[len - 1] = current_stack[len - 2];
+            current_stack[len - 2] = tmp;
+        }
+    }
+
+    //
+    // Save/restore stack state for branch targets
+    //
+    Tuple<VerificationType>* SaveStack() const
+    {
+        Tuple<VerificationType>* saved = new Tuple<VerificationType>(current_stack.Length());
+        for (unsigned i = 0; i < current_stack.Length(); i++)
+            saved->Next() = current_stack[i];
+        return saved;
+    }
+
+    void RestoreStack(Tuple<VerificationType>* saved)
+    {
+        current_stack.Reset();
+        if (saved)
+        {
+            for (unsigned i = 0; i < saved->Length(); i++)
+                current_stack.Next() = (*saved)[i];
+        }
+    }
+
     //
     // Local operations
     //
@@ -129,7 +251,7 @@ class StackMapGenerator
     //
     Tuple<VerificationType>* SaveLocals() const
     {
-        Tuple<VerificationType>* saved = new Tuple<VerificationType>(current_locals.Length(), 8);
+        Tuple<VerificationType>* saved = new Tuple<VerificationType>(current_locals.Length());
         for (unsigned i = 0; i < current_locals.Length(); i++)
             saved->Next() = current_locals[i];
         return saved;
@@ -186,6 +308,16 @@ class StackMapGenerator
     //
     void RecordFrameWithSavedStackPlusInt(u2 pc, Tuple<VerificationType>* saved_stack);
 
+    //
+    // Record a frame at the given PC with saved locals and saved stack.
+    // This is used for forward branches that jump over variable declarations -
+    // the frame at the target should reflect the state at the branch point,
+    // not the state when the label is defined.
+    //
+    void RecordFrameWithSavedLocalsAndStack(u2 pc,
+                                            Tuple<VerificationType>* saved_locals,
+                                            Tuple<VerificationType>* saved_stack);
+
     //
     // Check if we already have a frame at this PC
     //
@@ -240,6 +372,13 @@ class Label
     // Saved stack types for forward branches (for StackMapTable generation)
     // This captures the actual stack types at the first forward reference to this label
     Tuple<StackMapTableAttribute::VerificationTypeInfo>* saved_stack_types;
+    // Saved locals types for forward branches (for StackMapTable generation)
+    // This captures the actual locals types at the first forward reference to this label
+    Tuple<StackMapTableAttribute::VerificationTypeInfo>* saved_locals_types;
+    // Saved locals at definition time (for backward branches)
+    // This captures the locals state when DefineLabel is called, before any code
+    // that might modify locals (like loop bodies)
+    Tuple<StackMapTableAttribute::VerificationTypeInfo>* definition_locals;
     int saved_stack_depth;
     bool stack_saved;
 
@@ -252,7 +391,12 @@ class Label
     // Used for boolean-to-value patterns where both paths merge with an int result.
     bool needs_int_on_stack;
 
-    Label() : defined(false), definition(0), saved_stack_types(NULL), saved_stack_depth(0), stack_saved(false), no_frame(false), needs_int_on_stack(false) {}
+    // The result type that should be on the stack at this label's merge point.
+    // If non-NULL, DefineLabel will create a frame with this type on the stack.
+    // This is used for general ternary expressions (not just int).
+    TypeSymbol* result_type;
+
+    Label() : defined(false), definition(0), saved_stack_types(NULL), saved_locals_types(NULL), definition_locals(NULL), saved_stack_depth(0), stack_saved(false), no_frame(false), needs_int_on_stack(false), result_type(NULL) {}
 
     //
     // All used labels should have been completed and reset, otherwise a goto
@@ -268,6 +412,8 @@ class Label
             uses.Reset();
         }
         delete saved_stack_types;
+        delete saved_locals_types;
+        delete definition_locals;
     }
 
     void Reset()
@@ -277,6 +423,10 @@ class Label
        definition = 0;
        delete saved_stack_types;
        saved_stack_types = NULL;
+       delete saved_locals_types;
+       saved_locals_types = NULL;
+       delete definition_locals;
+       definition_locals = NULL;
        saved_stack_depth = 0;
        stack_saved = false;
        no_frame = false;
@@ -1194,7 +1344,8 @@ class ByteCode : public ClassFile, public StringConstant, public Operators
     bool EmitSwitchBlockStatement(AstSwitchBlockStatement*, bool);
     void CloseSwitchLocalVariables(AstBlock*, u2 op_start);
     void EmitTryStatement(AstTryStatement*);
-    void EmitResourceCleanup(AstTryStatement*, int variable_index);  // Java 7 try-with-resources
+    void EmitResourceCleanup(AstTryStatement*, int variable_index,
+                             Tuple<StackMapTableAttribute::VerificationTypeInfo>* saved_locals);  // Java 7 try-with-resources
     void EmitAssertStatement(AstAssertStatement*);
     void EmitForeachStatement(AstForeachStatement*);
     void EmitBranchIfExpression(AstExpression*, bool, Label&,
diff --git a/src/codegen/bytecode_expr.cpp b/src/codegen/bytecode_expr.cpp
index 5f9e6d3..92c76af 100644
--- a/src/codegen/bytecode_expr.cpp
+++ b/src/codegen/bytecode_expr.cpp
@@ -46,6 +46,8 @@ int ByteCode::EmitExpression(AstExpression* expression, bool need_value)
         if (need_value)
         {
             PutOp(OP_ALOAD_0);
+            if (stack_map_generator)
+                stack_map_generator->PushType(unit_type);
             return 1;
         }
         return 0;
@@ -58,6 +60,8 @@ int ByteCode::EmitExpression(AstExpression* expression, bool need_value)
         if (need_value)
         {
             PutOp(OP_ALOAD_0);
+            if (stack_map_generator)
+                stack_map_generator->PushType(unit_type);
             return 1;
         }
         return 0;
@@ -78,8 +82,14 @@ int ByteCode::EmitExpression(AstExpression* expression, bool need_value)
                 assert(type == control.Class());
                 LoadConstantAtIndex(RegisterClass(class_lit -> type ->
                                                   symbol));
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.Class());
                 if (! need_value)
+                {
                     PutOp(OP_POP);
+                    if (stack_map_generator)
+                        stack_map_generator->PopType();
+                }
             }
             else if (need_value)
             {
@@ -88,6 +98,8 @@ int ByteCode::EmitExpression(AstExpression* expression, bool need_value)
                 PutOp(OP_GETSTATIC);
                 PutU2(RegisterFieldref((VariableSymbol*) expression ->
                                        symbol));
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.Class());
             }
             return need_value ? 1 : 0;
         }
@@ -130,6 +142,8 @@ int ByteCode::EmitExpression(AstExpression* expression, bool need_value)
         if (need_value)
         {
             PutOp(OP_ACONST_NULL);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.null_type);
             return 1;
         }
         return 0;
@@ -232,12 +246,19 @@ void ByteCode::EmitFieldAccessLhs(AstExpression* expression)
 {
     EmitFieldAccessLhsBase(expression);
     PutOp(OP_DUP);     // save base address of field for later store
+    if (stack_map_generator)
+        stack_map_generator->Dup();
     PutOp(OP_GETFIELD);
     if (control.IsDoubleWordType(expression -> Type()))
         ChangeStack(1);
 
     VariableSymbol* sym = (VariableSymbol*) expression -> symbol;
     PutU2(RegisterFieldref(VariableTypeResolution(expression, sym), sym));
+    if (stack_map_generator)
+    {
+        stack_map_generator->PopType();  // pop object ref consumed by GETFIELD
+        stack_map_generator->PushType(expression->Type());  // push field value
+    }
 }
 
 
@@ -875,7 +896,11 @@ int ByteCode::EmitArrayCreationExpression(AstArrayCreationExpression* expression
         {
             EmitNewArray(num_dims, expression -> Type());
             if (! need_value)
+            {
                 PutOp(OP_POP);
+                if (stack_map_generator)
+                    stack_map_generator->PopType();
+            }
         }
     }
 
@@ -979,6 +1004,8 @@ int ByteCode::EmitAssignmentExpression(AstAssignmentExpression* assignment_expre
             // lhs must be array access
             EmitArrayAccessLhs(left_hand_side -> ArrayAccessCast());
             PutOp(OP_DUP2); // save base and index for later store
+            if (stack_map_generator)
+                stack_map_generator->Dup2();  // duplicate array_ref and index
 
             //
             // load current value
@@ -1040,16 +1067,23 @@ int ByteCode::EmitAssignmentExpression(AstAssignmentExpression* assignment_expre
              AstAssignmentExpression::PLUS_EQUAL) &&
             left_type == control.String())
         {
+            TypeSymbol* builder_type = control.option.target >= JopaOption::SDK1_5
+                                       ? control.StringBuilder()
+                                       : control.StringBuffer();
             PutOp(OP_NEW);
-            PutU2(RegisterClass(control.option.target >= JopaOption::SDK1_5
-                                ? control.StringBuilder()
-                                : control.StringBuffer()));
+            PutU2(RegisterClass(builder_type));
+            if (stack_map_generator)
+                stack_map_generator->PushType(builder_type);
             PutOp(OP_DUP_X1);
+            if (stack_map_generator)
+                stack_map_generator->DupX1();
             PutOp(OP_INVOKESPECIAL);
             PutU2(RegisterLibraryMethodref
                   (control.option.target >= JopaOption::SDK1_5
                    ? control.StringBuilder_InitMethod()
                    : control.StringBuffer_InitMethod()));
+            if (stack_map_generator)
+                stack_map_generator->PopType();  // INVOKESPECIAL consumes 'this'
             EmitStringAppendMethod(control.String());
             AppendString(assignment_expression -> expression, true);
             PutOp(OP_INVOKEVIRTUAL);
@@ -1058,6 +1092,11 @@ int ByteCode::EmitAssignmentExpression(AstAssignmentExpression* assignment_expre
                    ? control.StringBuilder_toStringMethod()
                    : control.StringBuffer_toStringMethod()));
             ChangeStack(1); // account for return value
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopType();  // pop StringBuilder
+                stack_map_generator->PushType(control.String());  // push String result
+            }
         }
         //
         // Here for operation other than string concatenation. Determine the
@@ -1223,6 +1262,14 @@ int ByteCode::EmitAssignmentExpression(AstAssignmentExpression* assignment_expre
 
             PutOp(opc);
 
+            // Track the arithmetic operation in stack_map_generator
+            // The operation pops 2 operands and pushes 1 result
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);  // pop LHS value and RHS value
+                stack_map_generator->PushType(op_type);  // push result
+            }
+
             if (casted_left_hand_side) // now cast result back to type of result
                 EmitCast(left_type, casted_left_hand_side -> Type());
         }
@@ -1312,6 +1359,8 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
         if (! need_value)
         {
             PutOp(OP_POP);
+            if (stack_map_generator)
+                stack_map_generator->PopType();  // pop StringBuilder
             return 0;
         }
         PutOp(OP_INVOKEVIRTUAL);
@@ -1320,6 +1369,11 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
                ? control.StringBuilder_toStringMethod()
                : control.StringBuffer_toStringMethod()));
         ChangeStack(1); // account for return value
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopType();  // pop StringBuilder
+            stack_map_generator->PushType(control.String());  // push String result
+        }
         return 1;
     }
 
@@ -1349,6 +1403,8 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
                 type = left_expr -> Type();
                 EmitExpression(left_expr);
                 PutOp(type == control.long_type ? OP_LCONST_0 : OP_ICONST_0);
+                if (stack_map_generator)
+                    stack_map_generator->PushType(type);
             }
             else
             {
@@ -1359,13 +1415,27 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
             {
                 PutOp(expression -> Tag() == AstBinaryExpression::SLASH
                       ? OP_LDIV : OP_LREM);
+                if (stack_map_generator)
+                {
+                    stack_map_generator->PopTypes(2);  // pop two longs
+                    stack_map_generator->PushType(control.long_type);  // push result
+                }
                 PutOp(OP_POP2);
+                if (stack_map_generator)
+                    stack_map_generator->PopType();  // pop long result
             }
             else
             {
                 PutOp(expression -> Tag() == AstBinaryExpression::SLASH
                       ? OP_IDIV : OP_IREM);
+                if (stack_map_generator)
+                {
+                    stack_map_generator->PopTypes(2);  // pop two ints
+                    stack_map_generator->PushType(control.int_type);  // push result
+                }
                 PutOp(OP_POP);
+                if (stack_map_generator)
+                    stack_map_generator->PopType();  // pop int result
             }
         }
         else if (expression -> Tag() == AstBinaryExpression::OR_OR)
@@ -1442,13 +1512,23 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
         {
         case AstBinaryExpression::AND_AND:
             PutOp(OP_ICONST_0);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
             return 1;
         case AstBinaryExpression::EQUAL_EQUAL:
             if (right_type != control.boolean_type)
                 break;
             EmitExpression(right_expr);
             PutOp(OP_ICONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
             PutOp(OP_IXOR);
+            // XOR pops 2 ints, pushes 1 int - net effect: pop 1
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.int_type);
+            }
             return 1;
         case AstBinaryExpression::NOT_EQUAL:
             if (right_type != control.boolean_type)
@@ -1500,6 +1580,8 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
 
             EmitExpression(right_expr, false);
             PutOp(type == control.long_type ? OP_LCONST_0 : OP_ICONST_0);
+            if (stack_map_generator)
+                stack_map_generator->PushType(type);
             return GetTypeWords(type);
         case AstBinaryExpression::MINUS:
             //
@@ -1559,12 +1641,21 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
                 // Fallthrough
             case AstBinaryExpression::OR_OR:
                 PutOp(OP_ICONST_1);
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.int_type);
                 break;
             case AstBinaryExpression::NOT_EQUAL:
             case AstBinaryExpression::XOR:
                 EmitExpression(expression -> right_expression);
                 PutOp(OP_ICONST_1);
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.int_type);
                 PutOp(OP_IXOR);
+                if (stack_map_generator)
+                {
+                    stack_map_generator->PopTypes(2);
+                    stack_map_generator->PushType(control.int_type);
+                }
                 break;
             default:
                 assert(false && "Invalid operator on boolean");
@@ -1591,7 +1682,14 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
                 break;
             EmitExpression(left_expr);
             PutOp(OP_ICONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
             PutOp(OP_IXOR);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.int_type);
+            }
             return 1;
         case AstBinaryExpression::NOT_EQUAL:
             if (left_type != control.boolean_type)
@@ -1648,6 +1746,8 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
 
             EmitExpression(left_expr, false);
             PutOp(type == control.long_type ? OP_LCONST_0 : OP_ICONST_0);
+            if (stack_map_generator)
+                stack_map_generator->PushType(type);
             return GetTypeWords(type);
         default:
             break;
@@ -1675,12 +1775,21 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
             case AstBinaryExpression::OR_OR:
                 EmitExpression(expression -> left_expression, false);
                 PutOp(OP_ICONST_1);
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.int_type);
                 break;
             case AstBinaryExpression::NOT_EQUAL:
             case AstBinaryExpression::XOR:
                 EmitExpression(expression -> left_expression);
                 PutOp(OP_ICONST_1);
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.int_type);
                 PutOp(OP_IXOR);
+                if (stack_map_generator)
+                {
+                    stack_map_generator->PopTypes(2);
+                    stack_map_generator->PushType(control.int_type);
+                }
                 break;
             default:
                 assert(false && "Invalid operator on boolean");
@@ -1699,10 +1808,22 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
         EmitExpression(expression -> left_expression);
         EmitExpression(expression -> right_expression);
         PutOp(OP_IXOR);
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(2);
+            stack_map_generator->PushType(control.int_type);
+        }
         if (expression -> Tag() == AstBinaryExpression::EQUAL_EQUAL)
         {
             PutOp(OP_ICONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
             PutOp(OP_IXOR);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.int_type);
+            }
         }
         return 1;
     }
@@ -1728,16 +1849,28 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
             // At MERGE, both paths have: [...stuff, int] where int is 0 or 1.
             // This pattern has only ONE branch target (MERGE), not two.
             //
-            // For Java 7+ bytecode, we mark this as no_frame because the stack
-            // tracking for internal expression labels is incomplete. The StackMapTable
-            // generator doesn't track all stack operations, so we can't reliably
-            // record the correct frame. Use target 1.6 for strict verification.
+            // For Java 7+ bytecode, we need proper StackMapTable frames at all
+            // branch targets. The boolean-to-value pattern has both paths converging
+            // at MERGE with the same stack: [...original, int] where int is 0 or 1.
+            //
+            // Save the underlying stack depth before pushing iconst_0. This will be
+            // used at DefineLabel to correctly size the result stack.
+            int underlying_depth = stack_depth;
             Label label;
-            label.no_frame = true;
+            label.needs_int_on_stack = true;
             PutOp(OP_ICONST_0); // push false (assume false)
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
             EmitBranchIfExpression(expression, false, label);
             PutOp(OP_POP); // pop the false
+            if (stack_map_generator)
+                stack_map_generator->PopType();
             PutOp(OP_ICONST_1); // push true
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
+            // Override saved_stack_depth to be the underlying depth + 1 (for the result)
+            // This fixes the calculation in DefineLabel which subtracts 1 to get underlying
+            label.saved_stack_depth = underlying_depth + 1;
             DefineLabel(label);
             CompleteLabel(label);
         }
@@ -1808,6 +1941,14 @@ int ByteCode::EmitBinaryExpression(AstBinaryExpression* expression,
         assert(false && "binary unknown tag");
     }
 
+    // Binary arithmetic operations pop 2 operands and push 1 result
+    // Track this transformation in stack_map_generator
+    if (stack_map_generator)
+    {
+        stack_map_generator->PopTypes(2); // pop both operands
+        stack_map_generator->PushType(type); // push result
+    }
+
     return GetTypeWords(expression -> Type());
 }
 
@@ -1892,6 +2033,8 @@ int ByteCode::EmitCastExpression(AstCastExpression* expression,
         {
             assert(source_type -> IsSubtype(control.Object()));
             PutOp(OP_POP);
+            if (stack_map_generator)
+                stack_map_generator->PopType();
         }
     }
 
@@ -2088,11 +2231,22 @@ void ByteCode::EmitCheckForNull(AstExpression* expression, bool need_value)
     //
     EmitExpression(expression, true);
     if (need_value)
+    {
         PutOp(OP_DUP);
+        if (stack_map_generator)
+            stack_map_generator->Dup();
+    }
     PutOp(OP_INVOKEVIRTUAL);
     ChangeStack(1); // for returned value
     PutU2(RegisterLibraryMethodref(control.Object_getClassMethod()));
+    if (stack_map_generator)
+    {
+        stack_map_generator->PopType();  // pop object ref consumed by getClass
+        stack_map_generator->PushType(control.Class());  // push Class result
+    }
     PutOp(OP_POP);
+    if (stack_map_generator)
+        stack_map_generator->PopType();  // pop Class result
 }
 
 int ByteCode::EmitClassCreationExpression(AstClassCreationExpression* expr,
@@ -2108,8 +2262,14 @@ int ByteCode::EmitClassCreationExpression(AstClassCreationExpression* expr,
 
     PutOp(OP_NEW);
     PutU2(RegisterClass(type));
+    if (stack_map_generator)
+        stack_map_generator->PushType(type);
     if (need_value) // save address of new object for constructor
+    {
         PutOp(OP_DUP);
+        if (stack_map_generator)
+            stack_map_generator->Dup();
+    }
 
     //
     // Pass enclosing instance along, then real arguments, then shadow
@@ -2135,11 +2295,16 @@ int ByteCode::EmitClassCreationExpression(AstClassCreationExpression* expr,
     if (expr -> arguments -> NeedsExtraNullArgument())
     {
         PutOp(OP_ACONST_NULL);
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.null_type);
         stack_words++;
     }
 
     PutOp(OP_INVOKESPECIAL);
     ChangeStack(-stack_words);
+    // Constructor consumes 'this' + all arguments, returns void
+    if (stack_map_generator)
+        stack_map_generator->PopTypes(stack_words + 1);
     PutU2(RegisterMethodref(type, constructor));
     return 1;
 }
@@ -2225,8 +2390,15 @@ int ByteCode::EmitConditionalExpression(AstConditionalExpression* expression,
                     return EmitExpression(expression -> test_expression);
                 if (left -> value == right -> value + 1)
                 {
+                    // boolean-to-value pushes int, EmitExpression for constant also pushes
                     EmitExpression(expression -> test_expression);
                     EmitExpression(expression -> false_expression);
+                    // Pop both types since IADD consumes them, then it produces 1 int
+                    if (stack_map_generator)
+                    {
+                        stack_map_generator->PopTypes(2);
+                        stack_map_generator->PushType(control.int_type);
+                    }
                     PutOp(OP_IADD);
                     return 1;
                 }
@@ -2234,6 +2406,12 @@ int ByteCode::EmitConditionalExpression(AstConditionalExpression* expression,
                 {
                     EmitExpression(expression -> false_expression);
                     EmitExpression(expression -> test_expression);
+                    // Pop both since ISUB consumes them, then it produces 1 int
+                    if (stack_map_generator)
+                    {
+                        stack_map_generator->PopTypes(2);
+                        stack_map_generator->PushType(control.int_type);
+                    }
                     PutOp(OP_ISUB);
                     return 1;
                 }
@@ -2250,11 +2428,19 @@ int ByteCode::EmitConditionalExpression(AstConditionalExpression* expression,
             //
             Label label;
             if (need_value)
+            {
                 PutOp(IsZero(expression -> true_expression)
                       ? OP_ICONST_0 : OP_ICONST_1);
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.int_type);
+            }
             EmitBranchIfExpression(expression -> test_expression, true, label);
             if (need_value)
+            {
                 PutOp(OP_POP);
+                if (stack_map_generator)
+                    stack_map_generator->PopType();
+            }
             EmitExpression(expression -> false_expression, need_value);
             DefineLabel(label);
             CompleteLabel(label);
@@ -2269,14 +2455,25 @@ int ByteCode::EmitConditionalExpression(AstConditionalExpression* expression,
         //
         // Optimize (cond ? a : 0) to (cond && a)
         // Optimize (cond ? a : 1) to (!cond || a)
+        // Pattern: push 0/1, branch if false, pop, push true_expr, merge
+        // At merge point, both paths have int on stack.
         //
         Label label;
+        label.needs_int_on_stack = need_value;
         if (need_value)
+        {
             PutOp(IsZero(expression -> false_expression)
                   ? OP_ICONST_0 : OP_ICONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
+        }
         EmitBranchIfExpression(expression -> test_expression, false, label);
         if (need_value)
+        {
             PutOp(OP_POP);
+            if (stack_map_generator)
+                stack_map_generator->PopType();
+        }
         EmitExpression(expression -> true_expression, need_value);
         DefineLabel(label);
         CompleteLabel(label);
@@ -2284,6 +2481,12 @@ int ByteCode::EmitConditionalExpression(AstConditionalExpression* expression,
     }
     Label lab1,
         lab2;
+    // Set the result type on lab2 so DefineLabel creates the correct frame
+    // with the expression result on the stack. This avoids trying to track
+    // types through nested expressions (which is error-prone since PutOp
+    // doesn't update stack_map_generator).
+    if (need_value)
+        lab2.result_type = expression->Type();
     EmitBranchIfExpression(expression -> test_expression, false, lab1);
     EmitExpression(expression -> true_expression, need_value);
     EmitBranch(OP_GOTO, lab2);
@@ -2352,7 +2555,12 @@ int ByteCode::EmitMethodInvocation(AstMethodInvocation* expression,
             is_super = base -> SuperExpressionCast() != NULL;
             EmitExpression(base);
         }
-        else PutOp(OP_ALOAD_0);
+        else
+        {
+            PutOp(OP_ALOAD_0);
+            if (stack_map_generator)
+                stack_map_generator->PushType(unit_type);
+        }
     }
 
     int stack_words = 0; // words on stack needed for arguments
@@ -2384,6 +2592,8 @@ int ByteCode::EmitMethodInvocation(AstMethodInvocation* expression,
 
             // Generate: newarray/anewarray <component_type> with count 0
             PutOp(OP_ICONST_0);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
             if (control.IsPrimitive(component_type))
             {
                 PutOp(OP_NEWARRAY);
@@ -2401,6 +2611,12 @@ int ByteCode::EmitMethodInvocation(AstMethodInvocation* expression,
                 PutOp(OP_ANEWARRAY);
                 PutU2(RegisterClass(component_type));
             }
+            // newarray/anewarray pops count, pushes array
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopType(); // pop count
+                stack_map_generator->PushType(varargs_type); // push array
+            }
             ChangeStack(0); // iconst_0 (+1), newarray/anewarray uses it and produces array (+0 net)
             stack_words++;
         }
@@ -2452,6 +2668,17 @@ int ByteCode::CompleteCall(MethodSymbol* msym, int stack_words,
     if (! msym)
         return need_value ? 1 : 0;
     ChangeStack(- stack_words);
+
+    // Track argument consumption in stack_map_generator
+    // Arguments were pushed by EmitExpression calls, now they're consumed by the invoke
+    // For instance methods, also pop the receiver
+    if (stack_map_generator)
+    {
+        stack_map_generator->PopTypes(stack_words);
+        if (!msym->ACC_STATIC())
+            stack_map_generator->PopType(); // pop receiver
+    }
+
     TypeSymbol* type = (base_type ? base_type : msym -> containing_type);
     PutU2(RegisterMethodref(type, msym));
     // invokeinterface requires extra bytes (count and zero)
@@ -2469,9 +2696,16 @@ int ByteCode::CompleteCall(MethodSymbol* msym, int stack_words,
         return 0;
     bool wide = control.IsDoubleWordType(msym -> Type());
     ChangeStack(wide ? 2 : 1);
+
+    // Track return value in stack_map_generator
+    if (stack_map_generator)
+        stack_map_generator->PushType(msym->Type());
+
     if (! need_value)
     {
         PutOp(wide ? OP_POP2 : OP_POP);
+        if (stack_map_generator)
+            stack_map_generator->PopType();
         return 0;
     }
     return wide ? 2 : 1;
@@ -2569,6 +2803,11 @@ void ByteCode::EmitNewArray(unsigned num_dims, const TypeSymbol* type)
             PutOp(OP_ANEWARRAY);
             PutU2(RegisterClass(element_type));
         }
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopType();  // pop size (int)
+            stack_map_generator->PushType(const_cast<TypeSymbol*>(type));  // push array reference
+        }
     }
     else
     {
@@ -2576,6 +2815,11 @@ void ByteCode::EmitNewArray(unsigned num_dims, const TypeSymbol* type)
         PutU2(RegisterClass(type));
         PutU1(num_dims); // load dims count
         ChangeStack(1 - static_cast<int>(num_dims));
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(num_dims);  // pop all dimension sizes
+            stack_map_generator->PushType(const_cast<TypeSymbol*>(type));  // push array reference
+        }
     }
 }
 
diff --git a/src/codegen/bytecode_init.cpp b/src/codegen/bytecode_init.cpp
index 7e964c0..862479c 100644
--- a/src/codegen/bytecode_init.cpp
+++ b/src/codegen/bytecode_init.cpp
@@ -1284,6 +1284,8 @@ void ByteCode::InitializeArray(const TypeSymbol* type,
     if (need_value)
     {
         LoadImmediateInteger(array_initializer -> NumVariableInitializers());
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.int_type);
         EmitNewArray(1, type); // make the array
     }
     for (unsigned i = 0;
@@ -1317,7 +1319,11 @@ void ByteCode::InitializeArray(const TypeSymbol* type,
         if (need_value)
         {
             PutOp(OP_DUP);
+            if (stack_map_generator)
+                stack_map_generator->Dup();
             LoadImmediateInteger(i);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
         }
         if (expr)
              EmitExpression(expr, need_value);
diff --git a/src/codegen/bytecode_ops.cpp b/src/codegen/bytecode_ops.cpp
index 722b8a4..80f7f69 100644
--- a/src/codegen/bytecode_ops.cpp
+++ b/src/codegen/bytecode_ops.cpp
@@ -117,7 +117,11 @@ void ByteCode::EmitPostUnaryExpressionField(VariableCategory kind,
         // For post-increment, we need to save the original value
         // Stack: [obj_ref, wrapper_val]
         if (need_value)
+        {
             PutOp(OP_DUP_X1); // duplicate wrapper value under obj ref
+            if (stack_map_generator)
+                stack_map_generator->DupX1();
+        }
 
         // Unbox, increment, rebox
         EmitUnboxingConversion(expression_type, unboxed_type);
@@ -125,27 +129,55 @@ void ByteCode::EmitPostUnaryExpressionField(VariableCategory kind,
         if (control.IsSimpleIntegerValueType(unboxed_type))
         {
             PutOp(OP_ICONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
             PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                   ? OP_IADD : OP_ISUB);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.int_type);
+            }
             EmitCast(unboxed_type, control.int_type);
         }
         else if (unboxed_type == control.long_type)
         {
             PutOp(OP_LCONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.long_type);
             PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                   ? OP_LADD : OP_LSUB);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.long_type);
+            }
         }
         else if (unboxed_type == control.float_type)
         {
             PutOp(OP_FCONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.float_type);
             PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                   ? OP_FADD : OP_FSUB);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.float_type);
+            }
         }
         else if (unboxed_type == control.double_type)
         {
             PutOp(OP_DCONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.double_type);
             PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                   ? OP_DADD : OP_DSUB);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.double_type);
+            }
         }
 
         EmitBoxingConversion(unboxed_type, expression_type);
@@ -153,33 +185,73 @@ void ByteCode::EmitPostUnaryExpressionField(VariableCategory kind,
     else
     {
         if (need_value)
-            PutOp(control.IsDoubleWordType(expression_type)
-                  ? OP_DUP2_X1 : OP_DUP_X1);
+        {
+            if (control.IsDoubleWordType(expression_type))
+            {
+                PutOp(OP_DUP2_X1);
+                if (stack_map_generator)
+                    stack_map_generator->Dup2X1();
+            }
+            else
+            {
+                PutOp(OP_DUP_X1);
+                if (stack_map_generator)
+                    stack_map_generator->DupX1();
+            }
+        }
 
         if (control.IsSimpleIntegerValueType(expression_type))
         {
             PutOp(OP_ICONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
             PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                   ? OP_IADD : OP_ISUB);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.int_type);
+            }
             EmitCast(expression_type, control.int_type);
         }
         else if (expression_type == control.long_type)
         {
             PutOp(OP_LCONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.long_type);
             PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                   ? OP_LADD : OP_LSUB);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.long_type);
+            }
         }
         else if (expression_type == control.float_type)
         {
             PutOp(OP_FCONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.float_type);
             PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                   ? OP_FADD : OP_FSUB);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.float_type);
+            }
         }
         else if (expression_type == control.double_type)
         {
             PutOp(OP_DCONST_1); // load 1.0
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.double_type);
             PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                   ? OP_DADD : OP_DSUB);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.double_type);
+            }
         }
     }
 
@@ -194,6 +266,14 @@ void ByteCode::EmitPostUnaryExpressionField(VariableCategory kind,
         PutOp(OP_PUTFIELD);
         if (control.IsDoubleWordType(expression_type))
             ChangeStack(-1);
+        // PUTFIELD pops objectref and value
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopType();  // pop value
+            if (control.IsDoubleWordType(expression_type))
+                stack_map_generator->PopType();  // pop second slot for wide types
+            stack_map_generator->PopType();  // pop objectref
+        }
 
         VariableSymbol* sym = (VariableSymbol*) expression -> symbol;
         PutU2(RegisterFieldref(VariableTypeResolution(expression ->
@@ -226,32 +306,73 @@ void ByteCode::EmitPostUnaryExpressionSimple(VariableCategory kind,
     LoadVariable(kind, StripNops(expression -> expression));
 
     if (need_value)
-        PutOp(control.IsDoubleWordType(expression_type) ? OP_DUP2 : OP_DUP);
+    {
+        if (control.IsDoubleWordType(expression_type))
+        {
+            PutOp(OP_DUP2);
+            if (stack_map_generator)
+                stack_map_generator->Dup2();
+        }
+        else
+        {
+            PutOp(OP_DUP);
+            if (stack_map_generator)
+                stack_map_generator->Dup();
+        }
+    }
 
     if (control.IsSimpleIntegerValueType(expression_type))
     {
         PutOp(OP_ICONST_1);
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.int_type);
         PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
               ? OP_IADD : OP_ISUB);
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(2);
+            stack_map_generator->PushType(control.int_type);
+        }
         EmitCast(expression_type, control.int_type);
     }
     else if (expression_type == control.long_type)
     {
         PutOp(OP_LCONST_1);
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.long_type);
         PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
               ? OP_LADD : OP_LSUB);
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(2);
+            stack_map_generator->PushType(control.long_type);
+        }
     }
     else if (expression_type == control.float_type)
     {
         PutOp(OP_FCONST_1);
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.float_type);
         PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
               ? OP_FADD : OP_FSUB);
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(2);
+            stack_map_generator->PushType(control.float_type);
+        }
     }
     else if (expression_type == control.double_type)
     {
         PutOp(OP_DCONST_1); // load 1.0
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.double_type);
         PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
               ? OP_DADD : OP_DSUB);
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(2);
+            stack_map_generator->PushType(control.double_type);
+        }
     }
 
     if (kind == ACCESSED_VAR)
@@ -278,80 +399,208 @@ void ByteCode::EmitPostUnaryExpressionArray(AstPostUnaryExpression* expression,
     EmitArrayAccessLhs((AstArrayAccess*) StripNops(expression -> expression));
     // lhs must be array access
     PutOp(OP_DUP2); // save array base and index for later store
+    if (stack_map_generator)
+        stack_map_generator->Dup2();
 
     TypeSymbol* expression_type = expression -> Type();
     if (expression_type == control.int_type)
     {
          PutOp(OP_IALOAD);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.int_type);
+         }
          if (need_value) // save value below saved array base and index
+         {
              PutOp(OP_DUP_X2);
+             if (stack_map_generator)
+                 stack_map_generator->DupX2();
+         }
          PutOp(OP_ICONST_1);
+         if (stack_map_generator)
+             stack_map_generator->PushType(control.int_type);
          PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                ? OP_IADD : OP_ISUB);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.int_type);
+         }
          PutOp(OP_IASTORE);
+         if (stack_map_generator)
+             stack_map_generator->PopTypes(3);
     }
     else if (expression_type == control.byte_type )
     {
          PutOp(OP_BALOAD);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.int_type);
+         }
          if (need_value) // save value below saved array base and index
+         {
              PutOp(OP_DUP_X2);
+             if (stack_map_generator)
+                 stack_map_generator->DupX2();
+         }
          PutOp(OP_ICONST_1);
+         if (stack_map_generator)
+             stack_map_generator->PushType(control.int_type);
          PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                ? OP_IADD : OP_ISUB);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.int_type);
+         }
          PutOp(OP_I2B);
          PutOp(OP_BASTORE);
+         if (stack_map_generator)
+             stack_map_generator->PopTypes(3);
     }
     else if (expression_type == control.char_type )
     {
          PutOp(OP_CALOAD);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.int_type);
+         }
          if (need_value) // save value below saved array base and index
+         {
              PutOp(OP_DUP_X2);
+             if (stack_map_generator)
+                 stack_map_generator->DupX2();
+         }
          PutOp(OP_ICONST_1);
+         if (stack_map_generator)
+             stack_map_generator->PushType(control.int_type);
          PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                ? OP_IADD : OP_ISUB);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.int_type);
+         }
          PutOp(OP_I2C);
          PutOp(OP_CASTORE);
+         if (stack_map_generator)
+             stack_map_generator->PopTypes(3);
     }
     else if (expression_type == control.short_type)
     {
          PutOp(OP_SALOAD);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.int_type);
+         }
          if (need_value) // save value below saved array base and index
+         {
              PutOp(OP_DUP_X2);
+             if (stack_map_generator)
+                 stack_map_generator->DupX2();
+         }
          PutOp(OP_ICONST_1);
+         if (stack_map_generator)
+             stack_map_generator->PushType(control.int_type);
          PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                ? OP_IADD : OP_ISUB);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.int_type);
+         }
          PutOp(OP_I2S);
          PutOp(OP_SASTORE);
+         if (stack_map_generator)
+             stack_map_generator->PopTypes(3);
     }
     else if (expression_type == control.long_type)
     {
          PutOp(OP_LALOAD);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.long_type);
+         }
          if (need_value) // save value below saved array base and index
+         {
              PutOp(OP_DUP2_X2);
+             if (stack_map_generator)
+                 stack_map_generator->Dup2X2();
+         }
          PutOp(OP_LCONST_1);
+         if (stack_map_generator)
+             stack_map_generator->PushType(control.long_type);
          PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                ? OP_LADD : OP_LSUB);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.long_type);
+         }
          PutOp(OP_LASTORE);
+         if (stack_map_generator)
+             stack_map_generator->PopTypes(3);
     }
     else if (expression_type == control.float_type)
     {
          PutOp(OP_FALOAD);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.float_type);
+         }
          if (need_value) // save value below saved array base and index
+         {
              PutOp(OP_DUP_X2);
+             if (stack_map_generator)
+                 stack_map_generator->DupX2();
+         }
          PutOp(OP_FCONST_1);
+         if (stack_map_generator)
+             stack_map_generator->PushType(control.float_type);
          PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                ? OP_FADD : OP_FSUB);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.float_type);
+         }
          PutOp(OP_FASTORE);
+         if (stack_map_generator)
+             stack_map_generator->PopTypes(3);
     }
     else if (expression_type == control.double_type)
     {
          PutOp(OP_DALOAD);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.double_type);
+         }
          if (need_value) // save value below saved array base and index
+         {
              PutOp(OP_DUP2_X2);
+             if (stack_map_generator)
+                 stack_map_generator->Dup2X2();
+         }
          PutOp(OP_DCONST_1);
+         if (stack_map_generator)
+             stack_map_generator->PushType(control.double_type);
          PutOp(expression -> Tag() == AstPostUnaryExpression::PLUSPLUS
                ? OP_DADD : OP_DSUB);
+         if (stack_map_generator)
+         {
+             stack_map_generator->PopTypes(2);
+             stack_map_generator->PushType(control.double_type);
+         }
          PutOp(OP_DASTORE);
+         if (stack_map_generator)
+             stack_map_generator->PopTypes(3);
     }
     else assert(false && "unsupported postunary type");
 }
@@ -390,20 +639,41 @@ int ByteCode::EmitPreUnaryExpression(AstPreUnaryExpression* expression,
             if (control.IsSimpleIntegerValueType(type))
             {
                 PutOp(OP_ICONST_M1); // -1
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.int_type);
                 PutOp(OP_IXOR);      // exclusive or to get result
+                if (stack_map_generator)
+                {
+                    stack_map_generator->PopTypes(2);
+                    stack_map_generator->PushType(control.int_type);
+                }
             }
             else if (type == control.long_type)
             {
                 PutOp(OP_LCONST_1); // make -1
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.long_type);
                 PutOp(OP_LNEG);
                 PutOp(OP_LXOR);     // exclusive or to get result
+                if (stack_map_generator)
+                {
+                    stack_map_generator->PopTypes(2);
+                    stack_map_generator->PushType(control.long_type);
+                }
             }
             else assert(false && "unary ~ on unsupported type");
             break;
         case AstPreUnaryExpression::NOT:
             assert(type == control.boolean_type);
             PutOp(OP_ICONST_1);
+            if (stack_map_generator)
+                stack_map_generator->PushType(control.int_type);
             PutOp(OP_IXOR); // !(e) <=> (e)^true
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopTypes(2);
+                stack_map_generator->PushType(control.int_type);
+            }
             break;
         default:
             assert(false && "unknown preunary tag");
@@ -475,35 +745,79 @@ void ByteCode::EmitPreUnaryIncrementExpressionSimple(VariableCategory kind,
     if (control.IsSimpleIntegerValueType(type))
     {
         PutOp(OP_ICONST_1);
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.int_type);
         PutOp(expression -> Tag() == AstPreUnaryExpression::PLUSPLUS
               ? OP_IADD : OP_ISUB);
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(2);
+            stack_map_generator->PushType(control.int_type);
+        }
         EmitCast(type, control.int_type);
         if (need_value)
+        {
             PutOp(OP_DUP);
+            if (stack_map_generator)
+                stack_map_generator->Dup();
+        }
     }
     else if (type == control.long_type)
     {
         PutOp(OP_LCONST_1);
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.long_type);
         PutOp(expression -> Tag() == AstPreUnaryExpression::PLUSPLUS
               ? OP_LADD : OP_LSUB);
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(2);
+            stack_map_generator->PushType(control.long_type);
+        }
         if (need_value)
+        {
             PutOp(OP_DUP2);
+            if (stack_map_generator)
+                stack_map_generator->Dup2();
+        }
     }
     else if (type == control.float_type)
     {
         PutOp(OP_FCONST_1);
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.float_type);
         PutOp(expression -> Tag() == AstPreUnaryExpression::PLUSPLUS
               ? OP_FADD : OP_FSUB);
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(2);
+            stack_map_generator->PushType(control.float_type);
+        }
         if (need_value)
+        {
             PutOp(OP_DUP);
+            if (stack_map_generator)
+                stack_map_generator->Dup();
+        }
     }
     else if (type == control.double_type)
     {
         PutOp(OP_DCONST_1); // load 1.0
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.double_type);
         PutOp(expression -> Tag() == AstPreUnaryExpression::PLUSPLUS
               ? OP_DADD : OP_DSUB);
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopTypes(2);
+            stack_map_generator->PushType(control.double_type);
+        }
         if (need_value)
+        {
             PutOp(OP_DUP2);
+            if (stack_map_generator)
+                stack_map_generator->Dup2();
+        }
     }
 
     if (kind == ACCESSED_VAR)
@@ -773,6 +1087,9 @@ void ByteCode::EmitThisInvocation(AstThisCall* this_call)
 
     PutOp(OP_INVOKESPECIAL);
     ChangeStack(-stack_words);
+    // After this() call, 'this' is initialized
+    if (stack_map_generator)
+        stack_map_generator->MarkSuperCalled();
 
     PutU2(RegisterMethodref(unit_type, this_call -> symbol));
 }
@@ -817,6 +1134,9 @@ void ByteCode::EmitSuperInvocation(AstSuperCall* super_call)
 
     PutOp(OP_INVOKESPECIAL);
     ChangeStack(-stack_words);
+    // After super() call, 'this' is initialized
+    if (stack_map_generator)
+        stack_map_generator->MarkSuperCalled();
     PutU2(RegisterMethodref(unit_type -> super, super_call -> symbol));
 }
 
@@ -847,11 +1167,16 @@ void ByteCode::ConcatenateString(AstBinaryExpression* expression,
     }
     else
     {
+        TypeSymbol* sb_type = control.option.target >= JopaOption::SDK1_5
+                              ? control.StringBuilder()
+                              : control.StringBuffer();
         PutOp(OP_NEW);
-        PutU2(RegisterClass(control.option.target >= JopaOption::SDK1_5
-                            ? control.StringBuilder()
-                            : control.StringBuffer()));
+        PutU2(RegisterClass(sb_type));
+        if (stack_map_generator)
+            stack_map_generator->PushType(sb_type);
         PutOp(OP_DUP);
+        if (stack_map_generator)
+            stack_map_generator->Dup();
         if (left_expr -> IsConstant())
         {
             //
@@ -871,16 +1196,24 @@ void ByteCode::ConcatenateString(AstBinaryExpression* expression,
                       (control.option.target >= JopaOption::SDK1_5
                        ? control.StringBuilder_InitMethod()
                        : control.StringBuffer_InitMethod()));
+                // Constructor consumes 'this', returns void
+                if (stack_map_generator)
+                    stack_map_generator->PopType();
             }
             else
             {
                 LoadConstantAtIndex(RegisterString(value));
+                if (stack_map_generator)
+                    stack_map_generator->PushType(control.String());
                 PutOp(OP_INVOKESPECIAL);
                 PutU2(RegisterLibraryMethodref
                       (control.option.target >= JopaOption::SDK1_5
                        ? control.StringBuilder_InitWithStringMethod()
                        : control.StringBuffer_InitWithStringMethod()));
                 ChangeStack(-1); // account for the argument
+                // Constructor consumes 'this' + String arg, returns void
+                if (stack_map_generator)
+                    stack_map_generator->PopTypes(2);
             }
         }
         else
@@ -890,6 +1223,9 @@ void ByteCode::ConcatenateString(AstBinaryExpression* expression,
                   (control.option.target >= JopaOption::SDK1_5
                    ? control.StringBuilder_InitMethod()
                    : control.StringBuffer_InitMethod()));
+            // Constructor consumes 'this', returns void
+            if (stack_map_generator)
+                stack_map_generator->PopType();
             //
             // Don't pass stripped left_expr, or ((int)char)+"" would be
             // treated as a char append rather than int append.
@@ -1028,14 +1364,28 @@ void ByteCode::EmitStringAppendMethod(TypeSymbol* type)
     if (control.IsDoubleWordType(type))
         ChangeStack(-1);
     PutU2(RegisterLibraryMethodref(append_method));
+
+    // Track stack_map_generator: append(X) pops arg and receiver, pushes StringBuilder
+    if (stack_map_generator)
+    {
+        TypeSymbol* sb_type = control.option.target >= JopaOption::SDK1_5
+                              ? control.StringBuilder()
+                              : control.StringBuffer();
+        // Pop the argument (type is the argument type)
+        stack_map_generator->PopType();
+        // Pop the receiver (StringBuilder)
+        stack_map_generator->PopType();
+        // Push the result (StringBuilder)
+        stack_map_generator->PushType(sb_type);
+    }
 }
 
 
 #ifdef JOPA_DEBUG
 static void op_trap()
 {
-    int i = 0; // used for debugger trap
-    i++;       // avoid compiler warnings about unused variable
+    volatile int i = 0; // used for debugger trap
+    (void)i;
 }
 #endif // JOPA_DEBUG
 
@@ -1194,24 +1544,153 @@ void ByteCode::DefineLabel(Label& lab)
     if (lab.uses.Length())
         last_label_pc = lab.definition;
 
+    //
+    // Save the locals state at definition time for potential backward branches.
+    // This is critical because backward branches (like loop back-edges) need
+    // to use the locals state at the label definition, not the state at the
+    // branch point (which may include variables declared inside the loop body).
+    //
+    if (stack_map_generator && !lab.no_frame)
+    {
+        lab.definition_locals = stack_map_generator->SaveLocals();
+    }
+
     //
     // Record StackMapTable frame at branch targets (Java 7+)
     // A label with forward references (uses) indicates a branch target that
     // needs a stack map frame for verification.
     // Skip if no_frame is set (internal expression labels like boolean-to-value pattern).
     //
+    // IMPORTANT: For forward branches, we use the saved locals AND stack from the
+    // branch site, not the current state. This is critical because the branch may
+    // jump over variable declarations, and the frame at the target should reflect
+    // the state at the branch point.
+    //
     if (stack_map_generator && lab.uses.Length() > 0 && !lab.no_frame)
     {
-        if (lab.stack_saved && lab.saved_stack_types && lab.needs_int_on_stack)
+        if (lab.result_type)
+        {
+            // Ternary expression merge point: use saved locals with result type on stack
+            // This is for general ternary expressions that produce a value. The result_type
+            // is set by EmitConditionalExpression and represents the type of the result.
+            Tuple<StackMapGenerator::VerificationType>* result_stack =
+                new Tuple<StackMapGenerator::VerificationType>(4);
+            result_stack->Next() = stack_map_generator->TypeToVerificationType(lab.result_type);
+            // For wide types (long, double), add a second slot
+            if (lab.result_type == control.long_type || lab.result_type == control.double_type)
+            {
+                result_stack->Next() = StackMapGenerator::VerificationType(
+                    StackMapGenerator::VerificationType::TYPE_Top);
+            }
+            stack_map_generator->RecordFrameWithSavedLocalsAndStack(
+                lab.definition, lab.saved_locals_types, result_stack);
+            delete result_stack;
+        }
+        else if (lab.stack_saved && lab.needs_int_on_stack)
         {
-            // Boolean-to-value pattern: saved stack + int result
-            stack_map_generator->RecordFrameWithSavedStackPlusInt(lab.definition, lab.saved_stack_types);
+            // Boolean-to-value pattern: saved locals, saved stack + Integer
+            // The frame at MERGE point has: saved_locals, saved_stack, and an Integer on top.
+            //
+            // WORKAROUND: saved_stack_types is often empty because PutOp doesn't update
+            // the stack_map_generator. However, saved_stack_depth correctly tracks the
+            // number of items. For integer operations (like the nested ternary optimization),
+            // we can safely assume all stack items are integers.
+            //
+            // Frame will have: saved_stack_depth integers + 1 more integer for the boolean result
+            int underlying_depth = lab.saved_stack_depth - 1; // -1 because iconst_0 was pushed
+            if (underlying_depth < 0) underlying_depth = 0;
+
+            Tuple<StackMapGenerator::VerificationType>* result_stack =
+                new Tuple<StackMapGenerator::VerificationType>(underlying_depth + 4);
+
+            // First, try to use saved_stack_types if available
+            unsigned types_used = 0;
+            if (lab.saved_stack_types && lab.saved_stack_types->Length() > 0)
+            {
+                // Use all saved types except the last one (which is the iconst_0)
+                for (unsigned i = 0; i + 1 < lab.saved_stack_types->Length(); i++)
+                {
+                    result_stack->Next() = (*lab.saved_stack_types)[i];
+                    types_used++;
+                }
+            }
+
+            // Fill remaining slots with Integer (assumes integer operations)
+            for (int i = types_used; i < underlying_depth; i++)
+            {
+                result_stack->Next() = StackMapGenerator::VerificationType(
+                    StackMapGenerator::VerificationType::TYPE_Integer);
+            }
+
+            // Add the Integer result from the boolean expression
+            result_stack->Next() = StackMapGenerator::VerificationType(
+                StackMapGenerator::VerificationType::TYPE_Integer);
+
+            stack_map_generator->RecordFrameWithSavedLocalsAndStack(
+                lab.definition, lab.saved_locals_types, result_stack);
+            // Restore current_stack to match what was recorded
+            stack_map_generator->RestoreStack(result_stack);
+            delete result_stack;
+        }
+        else if (lab.stack_saved && lab.saved_locals_types)
+        {
+            // Forward branch with saved locals - but first merge with current locals
+            // to handle fallthrough paths (e.g., catch block falling through to after try-catch)
+            Tuple<StackMapGenerator::VerificationType>* current_locals =
+                stack_map_generator->SaveLocals();
+
+            unsigned max_len = lab.saved_locals_types->Length();
+            if (current_locals->Length() > max_len)
+                max_len = current_locals->Length();
+
+            // Create merged locals
+            Tuple<StackMapGenerator::VerificationType>* merged_locals =
+                new Tuple<StackMapGenerator::VerificationType>(max_len + 4);
+
+            for (unsigned i = 0; i < max_len; i++)
+            {
+                StackMapGenerator::VerificationType saved_type =
+                    (i < lab.saved_locals_types->Length())
+                    ? (*lab.saved_locals_types)[i]
+                    : StackMapGenerator::VerificationType(
+                        StackMapGenerator::VerificationType::TYPE_Top);
+                StackMapGenerator::VerificationType current_type =
+                    (i < current_locals->Length())
+                    ? (*current_locals)[i]
+                    : StackMapGenerator::VerificationType(
+                        StackMapGenerator::VerificationType::TYPE_Top);
+
+                // Use TOP where types differ
+                if (saved_type != current_type)
+                {
+                    merged_locals->Next() = StackMapGenerator::VerificationType(
+                        StackMapGenerator::VerificationType::TYPE_Top);
+                }
+                else
+                {
+                    merged_locals->Next() = saved_type;
+                }
+            }
+
+            delete current_locals;
+            stack_map_generator->RecordFrameWithSavedLocalsAndStack(
+                lab.definition, merged_locals, lab.saved_stack_types);
+            // Restore current state to match what was recorded
+            // This is critical: subsequent code must track from the MERGED state,
+            // not the pre-merge state. Otherwise, variables defined only in some
+            // paths (like loop bodies) will incorrectly appear as defined.
+            stack_map_generator->RestoreStack(lab.saved_stack_types);
+            stack_map_generator->RestoreLocals(merged_locals);
+            // Now safe to delete after restoring
+            delete merged_locals;
         }
         else if (lab.stack_saved && lab.saved_stack_types)
         {
             // Use the saved stack types from the branch point
             // This handles all cases: empty stack, non-empty stack with any types
             stack_map_generator->RecordFrameWithSavedStack(lab.definition, lab.saved_stack_types);
+            // Restore current_stack to match what was recorded, so subsequent code tracks correctly
+            stack_map_generator->RestoreStack(lab.saved_stack_types);
         }
         else if (lab.stack_saved && lab.saved_stack_depth == 0)
         {
@@ -1289,16 +1768,82 @@ void ByteCode::UseLabel(Label& lab, int _length, int _op_offset)
     lab.uses[lab_index].use_offset = code_attribute -> CodeLength();
 
     //
-    // For forward branches (label not yet defined), save the current stack state.
+    // For forward branches (label not yet defined), save the current stack and locals state.
     // This is needed for StackMapTable generation - the frame at the branch target
-    // should reflect the stack types at the branch point (before the branch instruction
-    // pops its operands).
+    // should reflect the types at the branch point, not at the label definition point.
+    // This is critical for branches that jump over variable declarations.
     //
-    if (stack_map_generator && !lab.defined && !lab.stack_saved)
+    // When multiple forward branches target the same label (e.g., from try and catch blocks),
+    // we need to merge the saved locals with the current locals. Where they differ, use TOP.
+    //
+    if (stack_map_generator && !lab.defined)
     {
-        lab.saved_stack_depth = stack_depth;
-        lab.saved_stack_types = stack_map_generator->SaveStack();
-        lab.stack_saved = true;
+        if (!lab.stack_saved)
+        {
+            // First forward branch - save the state
+            lab.saved_stack_depth = stack_depth;
+            lab.saved_stack_types = stack_map_generator->SaveStack();
+            lab.saved_locals_types = stack_map_generator->SaveLocals();
+            lab.stack_saved = true;
+#ifdef JOPA_DEBUG
+            if (control.option.debug_trace_stack_change)
+            {
+                Coutput << "UseLabel: first branch at pc " << code_attribute->CodeLength()
+                        << " depth=" << stack_depth
+                        << " stack_types=" << lab.saved_stack_types->Length() << endl;
+                for (unsigned dbg_i = 0; dbg_i < lab.saved_stack_types->Length(); dbg_i++)
+                {
+                    Coutput << "  stack[" << dbg_i << "] = " << (*lab.saved_stack_types)[dbg_i].Tag() << endl;
+                }
+            }
+#endif
+        }
+        else if (lab.saved_locals_types)
+        {
+            // Subsequent forward branch - merge locals (use TOP where they differ)
+            // This is critical for try-catch where try and catch have different types
+            // in the same local slot
+            Tuple<StackMapGenerator::VerificationType>* current_locals =
+                stack_map_generator->SaveLocals();
+
+            unsigned max_len = lab.saved_locals_types->Length();
+            if (current_locals->Length() > max_len)
+                max_len = current_locals->Length();
+
+            // Create new merged locals tuple
+            Tuple<StackMapGenerator::VerificationType>* merged_locals =
+                new Tuple<StackMapGenerator::VerificationType>(max_len + 4);
+
+            // Merge: use TOP where types differ
+            for (unsigned i = 0; i < max_len; i++)
+            {
+                StackMapGenerator::VerificationType saved_type =
+                    (i < lab.saved_locals_types->Length())
+                    ? (*lab.saved_locals_types)[i]
+                    : StackMapGenerator::VerificationType(
+                        StackMapGenerator::VerificationType::TYPE_Top);
+                StackMapGenerator::VerificationType current_type =
+                    (i < current_locals->Length())
+                    ? (*current_locals)[i]
+                    : StackMapGenerator::VerificationType(
+                        StackMapGenerator::VerificationType::TYPE_Top);
+
+                // If types differ, use TOP; otherwise keep the saved type
+                if (saved_type != current_type)
+                {
+                    merged_locals->Next() = StackMapGenerator::VerificationType(
+                        StackMapGenerator::VerificationType::TYPE_Top);
+                }
+                else
+                {
+                    merged_locals->Next() = saved_type;
+                }
+            }
+
+            delete current_locals;
+            delete lab.saved_locals_types;
+            lab.saved_locals_types = merged_locals;
+        }
     }
 
     //
@@ -1306,15 +1851,27 @@ void ByteCode::UseLabel(Label& lab, int _length, int _op_offset)
     // at the target if one hasn't been recorded already. This is critical for
     // loop back-edges where the target was defined before any branches to it.
     //
+    // IMPORTANT: We use the locals state saved at definition time, NOT the current
+    // locals. This is because backward branches often occur after the loop body
+    // has declared additional variables that shouldn't appear in the frame at
+    // the loop header.
+    //
     if (stack_map_generator && lab.defined && !lab.no_frame)
     {
-        // Record a frame at the backward branch target.
-        // Use the current locals state but with an empty stack (typical for loop back-edges).
-        // The frame recording function will handle duplicate detection.
         if (!stack_map_generator->HasFrameAt(lab.definition))
         {
-            stack_map_generator->ClearStack();
-            stack_map_generator->RecordFrame(lab.definition);
+            // Use definition_locals if available (preferred for correct frames)
+            if (lab.definition_locals)
+            {
+                stack_map_generator->RecordFrameWithSavedLocalsAndStack(
+                    lab.definition, lab.definition_locals, NULL);
+            }
+            else
+            {
+                // Fallback: use current locals (may be incorrect for some patterns)
+                stack_map_generator->ClearStack();
+                stack_map_generator->RecordFrame(lab.definition);
+            }
         }
     }
 
@@ -1359,6 +1916,10 @@ void ByteCode::LoadLocal(int varno, const TypeSymbol* type)
              PutOp((Opcode) (OP_ALOAD_0 + varno)); // Exploit opcode encodings
          else PutOpWide(OP_ALOAD, varno);
     }
+
+    // Track type in stack_map_generator
+    if (stack_map_generator)
+        stack_map_generator->PushType(const_cast<TypeSymbol*>(type));
 }
 
 
@@ -1453,6 +2014,10 @@ void ByteCode::LoadLiteral(LiteralValue* litp, const TypeSymbol* type)
         }
     }
     else assert(false && "unsupported constant kind");
+
+    // Track type in stack_map_generator
+    if (stack_map_generator)
+        stack_map_generator->PushType(const_cast<TypeSymbol*>(type));
 }
 
 
@@ -1592,9 +2157,16 @@ int ByteCode::LoadVariable(VariableCategory kind, AstExpression* expr,
             }
             EmitExpression(base);
             PutOp(OP_ARRAYLENGTH);
+            if (stack_map_generator)
+            {
+                stack_map_generator->PopType(); // pop array ref
+                stack_map_generator->PushType(control.int_type); // push length
+            }
             if (need_value)
                 return 1;
             PutOp(OP_POP);
+            if (stack_map_generator)
+                stack_map_generator->PopType();
             return 0;
         }
         if (sym -> initial_value)
@@ -1614,8 +2186,19 @@ int ByteCode::LoadVariable(VariableCategory kind, AstExpression* expr,
         }
         if (base)
             EmitExpression(base);
-        else PutOp(OP_ALOAD_0);
+        else
+        {
+            PutOp(OP_ALOAD_0);
+            if (stack_map_generator)
+                stack_map_generator->PushType(unit_type);
+        }
         PutOp(OP_GETFIELD);
+        // GETFIELD pops object ref and pushes field value
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopType(); // pop object ref
+            stack_map_generator->PushType(expression_type); // push field value
+        }
         break;
     case STATIC_VAR:
         //
@@ -1637,6 +2220,9 @@ int ByteCode::LoadVariable(VariableCategory kind, AstExpression* expr,
                 return GetTypeWords(expression_type);
             }
             PutOp(OP_GETSTATIC);
+            // GETSTATIC pushes field value
+            if (stack_map_generator)
+                stack_map_generator->PushType(expression_type);
             break;
         }
         else return 0;
@@ -1665,6 +2251,8 @@ int ByteCode::LoadVariable(VariableCategory kind, AstExpression* expr,
         return GetTypeWords(expression_type);
     }
     PutOp(control.IsDoubleWordType(expression_type) ? OP_POP2 : OP_POP);
+    if (stack_map_generator)
+        stack_map_generator->PopType();
     return 0;
 }
 
@@ -1681,6 +2269,14 @@ int ByteCode::LoadArrayElement(const TypeSymbol* type)
           : type == control.double_type ? OP_DALOAD
           : OP_AALOAD); // assume reference
 
+    // XALOAD: pops index (int), pops arrayref, pushes element
+    if (stack_map_generator)
+    {
+        stack_map_generator->PopType(); // pop index
+        stack_map_generator->PopType(); // pop arrayref
+        stack_map_generator->PushType(const_cast<TypeSymbol*>(type)); // push element
+    }
+
     return GetTypeWords(type);
 }
 
@@ -1696,6 +2292,10 @@ void ByteCode::StoreArrayElement(const TypeSymbol* type)
           : type == control.float_type ? OP_FASTORE
           : type == control.double_type ? OP_DASTORE
           : OP_AASTORE); // assume reference
+
+    // XASTORE: pops value, pops index, pops arrayref
+    if (stack_map_generator)
+        stack_map_generator->PopTypes(3);
 }
 
 
@@ -1710,11 +2310,17 @@ void ByteCode::StoreField(AstExpression* expression)
     {
         PutOp(OP_PUTSTATIC);
         ChangeStack(1 - GetTypeWords(expression_type));
+        // PUTSTATIC pops value
+        if (stack_map_generator)
+            stack_map_generator->PopType();
     }
     else
     {
         PutOp(OP_PUTFIELD);
         ChangeStack(1 - GetTypeWords(expression_type));
+        // PUTFIELD pops value and objectref
+        if (stack_map_generator)
+            stack_map_generator->PopTypes(2);
     }
 
     PutU2(RegisterFieldref(VariableTypeResolution(expression, sym), sym));
@@ -1734,6 +2340,8 @@ void ByteCode::StoreLocal(int varno, const TypeSymbol* type)
                 StackMapTableAttribute::VerificationTypeInfo(
                     StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
         }
+        // Store pops a value from the stack
+        stack_map_generator->PopType();
     }
 
     if (control.IsSimpleIntegerValueType(type) || type == control.boolean_type)
@@ -1784,12 +2392,30 @@ void ByteCode::StoreVariable(VariableCategory kind, AstExpression* expr)
             {
                 PutOp(OP_PUTSTATIC);
                 ChangeStack(1 - GetTypeWords(expr -> Type()));
+                // PUTSTATIC pops the value from the stack
+                if (stack_map_generator)
+                {
+                    stack_map_generator->PopType();
+                    // For double-word types, pop the second slot too
+                    if (control.IsDoubleWordType(expr -> Type()))
+                        stack_map_generator->PopType();
+                }
             }
             else
             {
                 PutOp(OP_ALOAD_0); // get address of "this"
+                if (stack_map_generator)
+                    stack_map_generator->PushType(unit_type);
                 PutOp(OP_PUTFIELD);
                 ChangeStack(1 - GetTypeWords(expr -> Type()));
+                // PUTFIELD pops objectref and value
+                if (stack_map_generator)
+                {
+                    stack_map_generator->PopType();  // pop value
+                    if (control.IsDoubleWordType(expr -> Type()))
+                        stack_map_generator->PopType();  // pop second slot for wide types
+                    stack_map_generator->PopType();  // pop objectref
+                }
             }
 
             PutU2(RegisterFieldref(VariableTypeResolution(expr, sym), sym));
@@ -2717,6 +3343,92 @@ void StackMapGenerator::RecordFrameWithSavedStackPlusInt(u2 pc, Tuple<Verificati
     }
 }
 
+void StackMapGenerator::RecordFrameWithSavedLocalsAndStack(u2 pc,
+                                                           Tuple<VerificationType>* saved_locals,
+                                                           Tuple<VerificationType>* saved_stack)
+{
+    // Check if a frame already exists at this PC
+    for (unsigned i = 0; i < recorded_frames.Length(); i++)
+    {
+        if (recorded_frames[i]->pc == pc)
+        {
+            // Frame exists - merge by finding common prefix of matching types
+            // When types differ, truncate to that point (conservative approach)
+            FrameEntry* existing = recorded_frames[i];
+            if (saved_locals)
+            {
+                unsigned min_len = existing->locals.Length();
+                if (saved_locals->Length() < min_len)
+                    min_len = saved_locals->Length();
+
+                // Find the common prefix where types match
+                unsigned common_len = 0;
+                for (unsigned j = 0; j < min_len; j++)
+                {
+                    if (existing->locals[j] != (*saved_locals)[j])
+                        break;
+                    common_len++;
+                }
+
+                // Truncate existing locals to common prefix
+                if (common_len < existing->locals.Length())
+                {
+                    Tuple<VerificationType> truncated(common_len + 4);
+                    for (unsigned j = 0; j < common_len; j++)
+                        truncated.Next() = existing->locals[j];
+
+                    existing->locals.Reset();
+                    for (unsigned j = 0; j < truncated.Length(); j++)
+                        existing->locals.Next() = truncated[j];
+                }
+            }
+            return;
+        }
+    }
+
+    // No existing frame - create new one
+    FrameEntry* entry = new FrameEntry(pc);
+
+    // Copy saved locals (this is the key difference from RecordFrameWithSavedStack)
+    if (saved_locals)
+    {
+        for (unsigned i = 0; i < saved_locals->Length(); i++)
+            entry->locals.Next() = (*saved_locals)[i];
+    }
+
+    // Copy saved stack
+    if (saved_stack)
+    {
+        for (unsigned i = 0; i < saved_stack->Length(); i++)
+            entry->stack.Next() = (*saved_stack)[i];
+    }
+
+    // Insert in sorted order by PC
+    unsigned insert_pos = recorded_frames.Length();
+    for (unsigned i = 0; i < recorded_frames.Length(); i++)
+    {
+        if (recorded_frames[i]->pc > pc)
+        {
+            insert_pos = i;
+            break;
+        }
+    }
+
+    // Make room and insert
+    if (insert_pos == recorded_frames.Length())
+    {
+        recorded_frames.Next() = entry;
+    }
+    else
+    {
+        // Shift elements to make room
+        recorded_frames.Next() = NULL; // Extend array
+        for (unsigned i = recorded_frames.Length() - 1; i > insert_pos; i--)
+            recorded_frames[i] = recorded_frames[i - 1];
+        recorded_frames[insert_pos] = entry;
+    }
+}
+
 bool StackMapGenerator::HasFrameAt(u2 pc) const
 {
     for (unsigned i = 0; i < recorded_frames.Length(); i++)
diff --git a/src/codegen/bytecode_stmt.cpp b/src/codegen/bytecode_stmt.cpp
index ad39728..dc136d5 100644
--- a/src/codegen/bytecode_stmt.cpp
+++ b/src/codegen/bytecode_stmt.cpp
@@ -254,6 +254,36 @@ bool ByteCode::EmitStatement(AstStatement* statement)
                 }
                 EmitBlockStatement(for_statement -> statement);
                 assert(stack_depth == 0);
+
+                // Clear FOR init variables when FOR loop ends (early return path)
+                if (stack_map_generator)
+                {
+                    for (unsigned k = 0; k < for_statement -> NumForInitStatements(); k++)
+                    {
+                        AstLocalVariableStatement* local_var =
+                            for_statement -> ForInitStatement(k) -> LocalVariableStatementCast();
+                        if (local_var)
+                        {
+                            for (unsigned m = 0; m < local_var -> NumVariableDeclarators(); m++)
+                            {
+                                VariableSymbol* var_sym = local_var -> VariableDeclarator(m) -> symbol;
+                                if (var_sym)
+                                {
+                                    stack_map_generator->SetLocal(var_sym->LocalVariableIndex(),
+                                        StackMapTableAttribute::VerificationTypeInfo(
+                                            StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
+                                    if (control.IsDoubleWordType(var_sym->Type()))
+                                    {
+                                        stack_map_generator->SetLocal(var_sym->LocalVariableIndex() + 1,
+                                            StackMapTableAttribute::VerificationTypeInfo(
+                                                StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
                 return abrupt;
             }
             Label& continue_label = method_stack -> TopContinueLabel();
@@ -301,6 +331,41 @@ bool ByteCode::EmitStatement(AstStatement* statement)
                             for_statement -> statement);
             CompleteLabel(continue_label);
             CompleteLabel(begin_label);
+
+            //
+            // Clear FOR init variables in StackMapGenerator when FOR loop ends.
+            // This is critical for labeled break/continue that target outer scopes -
+            // the FOR init variables should be Top at the label target.
+            //
+            if (stack_map_generator)
+            {
+                for (unsigned k = 0; k < for_statement -> NumForInitStatements(); k++)
+                {
+                    AstLocalVariableStatement* local_var =
+                        for_statement -> ForInitStatement(k) -> LocalVariableStatementCast();
+                    if (local_var)
+                    {
+                        for (unsigned m = 0; m < local_var -> NumVariableDeclarators(); m++)
+                        {
+                            VariableSymbol* var_sym = local_var -> VariableDeclarator(m) -> symbol;
+                            if (var_sym)
+                            {
+                                stack_map_generator->SetLocal(var_sym->LocalVariableIndex(),
+                                    StackMapTableAttribute::VerificationTypeInfo(
+                                        StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
+                                // For long/double, also clear the second slot
+                                if (control.IsDoubleWordType(var_sym->Type()))
+                                {
+                                    stack_map_generator->SetLocal(var_sym->LocalVariableIndex() + 1,
+                                        StackMapTableAttribute::VerificationTypeInfo(
+                                            StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
             return abrupt && ! for_statement -> can_complete_normally;
         }
     case Ast::FOREACH: // JSR 201
@@ -410,7 +475,32 @@ bool ByteCode::EmitBlockStatement(AstBlock* block)
     method_stack -> Push(block);
     bool abrupt = false;
     for (unsigned i = 0; i < block -> NumStatements() && ! abrupt; i++)
+    {
         abrupt = EmitStatement(block -> Statement(i));
+    }
+
+    //
+    // Clear block-scoped variables in StackMapGenerator before defining any labels.
+    // This is critical for labeled break/continue that target outer scopes - the
+    // variables defined in this block should be Top at the label target.
+    //
+    if (stack_map_generator)
+    {
+        for (unsigned i = 0; i < block -> NumLocallyDefinedVariables(); i++)
+        {
+            VariableSymbol* variable = block -> LocallyDefinedVariable(i);
+            stack_map_generator->SetLocal(variable->LocalVariableIndex(),
+                StackMapTableAttribute::VerificationTypeInfo(
+                    StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
+            // For long/double, also clear the second slot
+            if (control.IsDoubleWordType(variable->Type()))
+            {
+                stack_map_generator->SetLocal(variable->LocalVariableIndex() + 1,
+                    StackMapTableAttribute::VerificationTypeInfo(
+                        StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
+            }
+        }
+    }
 
     //
     // If contained break statements jump out of this block, define the label.
@@ -699,6 +789,9 @@ bool ByteCode::EmitSwitchStatement(AstSwitchStatement* switch_statement)
     }
 
     PutOp(use_lookup ? OP_LOOKUPSWITCH : OP_TABLESWITCH);
+    // tableswitch/lookupswitch consumes the key value from the stack
+    if (stack_map_generator)
+        stack_map_generator->PopType();
     op_start = last_op_pc; // pc at start of instruction
 
     //
@@ -1112,8 +1205,20 @@ void ByteCode::CloseSwitchLocalVariables(AstBlock* switch_block,
 //   +0: primary_exception (set by catch-all handler if try throws)
 //   +2: close_exception (accumulated close exceptions in normal path)
 //
-void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_index)
+void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_index,
+                                   Tuple<StackMapTableAttribute::VerificationTypeInfo>* passed_saved_locals)
 {
+    // saved_locals is passed from EmitTryStatement and contains the locals state
+    // at try block start (after helper variables are initialized)
+    // If NULL (from ProcessAbruptExit), capture current state as fallback
+    Tuple<StackMapTableAttribute::VerificationTypeInfo>* saved_locals = passed_saved_locals;
+    bool owns_saved_locals = false;
+    if (!saved_locals && stack_map_generator)
+    {
+        saved_locals = stack_map_generator->SaveLocals();
+        owns_saved_locals = true;
+    }
+
     // Close resources in reverse order
     for (int r = statement -> NumResources() - 1; r >= 0; r--)
     {
@@ -1131,6 +1236,8 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
             Label skip_close;
             Label after_catch;
             PutOp(OP_DUP);
+            if (stack_map_generator)
+                stack_map_generator->Dup();
             int stack_at_branch = stack_depth;  // = 2
 
             EmitBranch(OP_IFNULL, skip_close);
@@ -1145,6 +1252,8 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
             PutU1(1);  // 1 argument (just 'this')
             PutU1(0);  // reserved
             // After close(): stack = 0
+            if (stack_map_generator)
+                stack_map_generator->PopType();  // pop object ref consumed by close()
 
             // Record end of try block
             u2 close_try_end = code_attribute -> CodeLength();
@@ -1155,12 +1264,18 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
             u2 catch_handler_pc = code_attribute -> CodeLength();
 
             // Record StackMapTable frame for exception handler entry
-            if (stack_map_generator)
+            // At exception handler entry, stack has exactly 1 item: the caught exception
+            // Use saved locals from cleanup start for consistent frame
+            // Use RecordFrameWithLocalsAndStack to explicitly set both locals and stack
+            // This ensures correct frame encoding even if previous frames have wrong locals
+            if (stack_map_generator && saved_locals)
             {
+                stack_map_generator->RecordFrameWithLocalsAndStack(
+                    catch_handler_pc, saved_locals, control.Throwable());
+                // Sync stack_map_generator's current state to match what we recorded
+                stack_map_generator->RestoreLocals(saved_locals);
                 stack_map_generator->ClearStack();
                 stack_map_generator->PushType(control.Throwable());
-                stack_map_generator->RecordFrame(catch_handler_pc);
-                stack_map_generator->ClearStack(); // Reset for subsequent non-handler code
             }
 
             stack_depth = 1;  // caught exception is on stack
@@ -1179,8 +1294,11 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
             // Load primary_exception and check if non-null
             // Stack: [caught]
             LoadLocal(variable_index, control.Throwable());
+            // Note: LoadLocal already pushes to stack_map_generator
             // Stack: [caught, primary]
             PutOp(OP_DUP);
+            if (stack_map_generator)
+                stack_map_generator->Dup();
             // Stack: [caught, primary, primary]
             EmitBranch(OP_IFNULL, check_close_exception);
             // Stack: [caught, primary]
@@ -1191,14 +1309,20 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
             {
                 // Stack: [caught, primary]
                 PutOp(OP_POP2);  // discard both
+                if (stack_map_generator)
+                    stack_map_generator->PopTypes(2);
                 // Stack: []
             }
             else
             {
                 PutOp(OP_SWAP);
+                if (stack_map_generator)
+                    stack_map_generator->Swap();
                 // Stack: [primary, caught]
                 PutOp(OP_INVOKEVIRTUAL);
                 PutU2(RegisterLibraryMethodref(control.Throwable_addSuppressedMethod()));
+                if (stack_map_generator)
+                    stack_map_generator->PopTypes(2);  // pops object + arg, void return
                 // Stack: []
             }
             EmitBranch(OP_GOTO, after_catch, statement);
@@ -1215,12 +1339,17 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
             DefineLabel(check_close_exception);
             CompleteLabel(check_close_exception);
             PutOp(OP_POP);  // pop null (was primary)
+            if (stack_map_generator)
+                stack_map_generator->PopType();
             // Stack: [caught]
 
             // Load close_exception and check if non-null
             LoadLocal(variable_index + 2, control.Throwable());
+            // Note: LoadLocal already pushes to stack_map_generator
             // Stack: [caught, close]
             PutOp(OP_DUP);
+            if (stack_map_generator)
+                stack_map_generator->Dup();
             // Stack: [caught, close, close]
             EmitBranch(OP_IFNULL, first_close_exception);
             // Stack: [caught, close]
@@ -1231,14 +1360,20 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
             {
                 // Stack: [caught, close]
                 PutOp(OP_POP2);  // discard both
+                if (stack_map_generator)
+                    stack_map_generator->PopTypes(2);
                 // Stack: []
             }
             else
             {
                 PutOp(OP_SWAP);
+                if (stack_map_generator)
+                    stack_map_generator->Swap();
                 // Stack: [close, caught]
                 PutOp(OP_INVOKEVIRTUAL);
                 PutU2(RegisterLibraryMethodref(control.Throwable_addSuppressedMethod()));
+                if (stack_map_generator)
+                    stack_map_generator->PopTypes(2);  // pops object + arg, void return
                 // Stack: []
             }
             EmitBranch(OP_GOTO, after_catch, statement);
@@ -1255,6 +1390,8 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
             DefineLabel(first_close_exception);
             CompleteLabel(first_close_exception);
             PutOp(OP_POP);  // pop null (was close)
+            if (stack_map_generator)
+                stack_map_generator->PopType();
             // Stack: [caught]
             StoreLocal(variable_index + 2, control.Throwable());
             // Stack: []
@@ -1271,6 +1408,8 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
             DefineLabel(skip_close);
             CompleteLabel(skip_close);
             PutOp(OP_POP);  // pop the null reference
+            if (stack_map_generator)
+                stack_map_generator->PopType();
             // Stack: []
 
             // After all paths converge
@@ -1320,6 +1459,9 @@ void ByteCode::EmitResourceCleanup(AstTryStatement* statement, int variable_inde
     }
     DefineLabel(done_cleanup);
     CompleteLabel(done_cleanup);
+    // Clean up saved_locals only if we captured it locally
+    if (owns_saved_locals && saved_locals)
+        delete saved_locals;
 }
 
 //
@@ -1361,8 +1503,12 @@ void ByteCode::EmitTryStatement(AstTryStatement* statement)
         int variable_index = method_stack -> TopBlock() ->
             block_symbol -> helper_variable_index;
         PutOp(OP_ACONST_NULL);
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.null_type);
         StoreLocal(variable_index, control.Throwable());  // primary_exception = null
         PutOp(OP_ACONST_NULL);
+        if (stack_map_generator)
+            stack_map_generator->PushType(control.null_type);
         StoreLocal(variable_index + 2, control.Throwable());  // close_exception = null
     }
 
@@ -1495,7 +1641,12 @@ void ByteCode::EmitTryStatement(AstTryStatement* statement)
                 StoreLocal(parameter_symbol -> LocalVariableIndex(),
                            parameter_symbol -> Type());
             }
-            else PutOp(OP_POP);
+            else
+            {
+                PutOp(OP_POP);
+                if (stack_map_generator)
+                    stack_map_generator->PopType();
+            }
             u2 handler_type = RegisterClass(parameter_symbol -> Type());
             for (int j = handler_starts.Length(); --j >= 0; )
             {
@@ -1598,7 +1749,7 @@ void ByteCode::EmitTryStatement(AstTryStatement* statement)
                     // Emit inlined finally code
                     if (has_resources)
                     {
-                        EmitResourceCleanup(statement, variable_index);
+                        EmitResourceCleanup(statement, variable_index, saved_locals);
                     }
                     if (emit_explicit_finally)
                     {
@@ -1612,9 +1763,11 @@ void ByteCode::EmitTryStatement(AstTryStatement* statement)
                 {
                     // Finally cannot complete normally, just pop exception
                     PutOp(OP_POP);
+                    if (stack_map_generator)
+                        stack_map_generator->PopType();
                     if (has_resources)
                     {
-                        EmitResourceCleanup(statement, variable_index);
+                        EmitResourceCleanup(statement, variable_index, saved_locals);
                     }
                     if (emit_explicit_finally)
                     {
@@ -1636,33 +1789,25 @@ void ByteCode::EmitTryStatement(AstTryStatement* statement)
                 // For normal completion path, emit inlined finally code
                 if (IsLabelUsed(end_label))
                 {
-                    // Reset stack_map_generator's local state for normal path
-                    // The exception handler set variable_index to Throwable,
-                    // but the normal path (GOTO from try body) doesn't have it set
-                    if (stack_map_generator)
+                    // Don't let DefineLabel record a frame - we need to record it
+                    // manually with the correct locals state (saved_locals).
+                    end_label.no_frame = true;
+                    DefineLabel(end_label);
+                    CompleteLabel(end_label);
+
+                    // Restore locals to the state at try block start.
+                    // For try-with-resources, this has helper variables set to Throwable.
+                    // Record a frame at this point so subsequent exception handlers
+                    // see the correct locals state.
+                    if (stack_map_generator && saved_locals)
                     {
-                        // Reset exception-handler-specific locals to Top
-                        stack_map_generator->SetLocal(variable_index,
-                            StackMapTableAttribute::VerificationTypeInfo(
-                                StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
-                        // Also reset the return address slot if it was used
-                        stack_map_generator->SetLocal(variable_index + 1,
-                            StackMapTableAttribute::VerificationTypeInfo(
-                                StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
-                        if (has_resources)
-                        {
-                            // Reset close_exception slot too
-                            stack_map_generator->SetLocal(variable_index + 2,
-                                StackMapTableAttribute::VerificationTypeInfo(
-                                    StackMapTableAttribute::VerificationTypeInfo::TYPE_Top));
-                        }
+                        stack_map_generator->RestoreLocals(saved_locals);
                         stack_map_generator->ClearStack();
+                        stack_map_generator->RecordFrame(code_attribute->CodeLength());
                     }
-                    DefineLabel(end_label);
-                    CompleteLabel(end_label);
                     if (has_resources)
                     {
-                        EmitResourceCleanup(statement, variable_index);
+                        EmitResourceCleanup(statement, variable_index, saved_locals);
                     }
                     if (emit_explicit_finally)
                     {
@@ -1689,6 +1834,8 @@ void ByteCode::EmitTryStatement(AstTryStatement* statement)
                     // the finally clause overrides it.
                     //
                     PutOp(OP_POP);
+                    if (stack_map_generator)
+                        stack_map_generator->PopType();
                 }
                 method_stack -> TopHandlerRangeEnd().Push(special_end_pc);
                 unsigned count = method_stack -> TopHandlerRangeStart().Length();
@@ -1722,7 +1869,7 @@ void ByteCode::EmitTryStatement(AstTryStatement* statement)
                 // Java 7: Emit close() calls for resources before explicit finally
                 if (has_resources)
                 {
-                    EmitResourceCleanup(statement, variable_index);
+                    EmitResourceCleanup(statement, variable_index, saved_locals);
                 }
 
                 // Emit explicit finally block if present
@@ -1782,7 +1929,7 @@ void ByteCode::EmitTryStatement(AstTryStatement* statement)
         {
             int variable_index = method_stack -> TopBlock() ->
                 block_symbol -> helper_variable_index;
-            EmitResourceCleanup(statement, variable_index);
+            EmitResourceCleanup(statement, variable_index, saved_locals);
         }
         if (emit_explicit_finally)
             EmitBlockStatement(statement -> finally_clause_opt -> block);
@@ -1853,7 +2000,8 @@ bool ByteCode::ProcessAbruptExit(unsigned level, u2 width,
                     ! IsNop(try_stmt -> finally_clause_opt -> block);
                 if (has_resources)
                 {
-                    EmitResourceCleanup(try_stmt, var_index);
+                    // Pass NULL for saved_locals - will capture from current state
+                    EmitResourceCleanup(try_stmt, var_index, NULL);
                 }
                 if (emit_explicit_finally)
                 {
@@ -1888,7 +2036,8 @@ bool ByteCode::ProcessAbruptExit(unsigned level, u2 width,
                     ! IsNop(try_stmt -> finally_clause_opt -> block);
                 if (has_resources)
                 {
-                    EmitResourceCleanup(try_stmt, var_index);
+                    // Pass NULL for saved_locals - will capture from current state
+                    EmitResourceCleanup(try_stmt, var_index, NULL);
                 }
                 if (emit_explicit_finally)
                 {
@@ -2796,7 +2945,16 @@ void ByteCode::EmitBranchIfExpression(AstExpression* p, bool cond, Label& lab,
     else assert(false && "comparison of unsupported type");
 
     if (opcode != OP_NOP)
+    {
         PutOp(opcode); // if need to emit comparison before branch
+        // Update stack_map_generator: comparison opcodes pop 2 operands and push int
+        if (stack_map_generator)
+        {
+            stack_map_generator->PopType(); // pop second operand
+            stack_map_generator->PopType(); // pop first operand
+            stack_map_generator->PushType(control.int_type); // push int result
+        }
+    }
 
     EmitBranch (cond ? op_true : op_false, lab, over);
 }
diff --git a/src/codegen/class.h b/src/codegen/class.h
index cec3d0c..2de7c0a 100644
--- a/src/codegen/class.h
+++ b/src/codegen/class.h
@@ -1787,6 +1787,7 @@ class StackMapTableAttribute : public AttributeInfo
 #ifdef JOPA_DEBUG
         void Print(const ConstantPool& constant_pool) const
         {
+            (void)constant_pool;  // May be used in future for symbol resolution
             switch (tag)
             {
             case TYPE_Top: Coutput << "top"; break;
diff --git a/src/error.cpp b/src/error.cpp
index fd0291a..3000ac0 100644
--- a/src/error.cpp
+++ b/src/error.cpp
@@ -1225,7 +1225,7 @@ void SemanticError::InitializeMessages()
         "The file \"%1\" is not a valid directory.";
     messages[PACKAGE_NOT_FOUND] =
         "You need to modify your classpath, sourcepath, bootclasspath, "
-        "and/or extdirs setup. Jikes could not find %P1 in: %C";
+        "and/or extdirs setup. JOPA could not find %P1 in: %C";
     messages[CANNOT_OPEN_DIRECTORY] = "Unable to open directory \"%1\".";
     messages[BAD_INPUT_FILE] =
         "The input file \"%1\" does not have the \".java\" extension.";
diff --git a/src/option.cpp b/src/option.cpp
index 4da0639..54646f2 100644
--- a/src/option.cpp
+++ b/src/option.cpp
@@ -876,7 +876,6 @@ Option::Option(ArgumentExpander& arguments,
             source = SDK1_4;
             break;
         case UNKNOWN:
-            // Default to Java 6 (SDK1_6) to avoid StackMapTable verification issues
             target = SDK1_6;
             source = SDK1_6;
             break;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 6bd152b..902bf6d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -23,12 +23,12 @@ option(JOPA_PARSER_TESTS_JDK8 "Enable JDK8 parser tests" ON)
 option(JOPA_ENABLE_JVM_TESTS "Enable runtime tests using real JVM (requires Java)" ON)
 
 # Option to use -noverify flag for JVM tests
-# Required until StackMapTable generation is implemented for Java 7+ bytecode
+# Default OFF: StackMapTable generation should handle complex control flow correctly
 option(JOPA_USE_NOVERIFY "Use -noverify flag for JVM runtime tests" OFF)
 
 # Bytecode target version for tests (1.5, 1.6, or 1.7)
-# 1.5 and 1.6 work without StackMapTable, 1.7 requires it
-set(JOPA_TARGET_VERSION "1.5" CACHE STRING "Bytecode target version for tests (1.5, 1.6, 1.7)")
+# 1.7 generates StackMapTable (class version 51.0)
+set(JOPA_TARGET_VERSION "1.7" CACHE STRING "Bytecode target version for tests (1.5, 1.6, 1.7)")
 set_property(CACHE JOPA_TARGET_VERSION PROPERTY STRINGS "1.5" "1.6" "1.7")
 
 # Find Java for runtime tests (only if JVM tests are enabled)
diff --git a/vendor/CMakeLists.txt b/vendor/CMakeLists.txt
index f42ed16..ca627a3 100644
--- a/vendor/CMakeLists.txt
+++ b/vendor/CMakeLists.txt
@@ -143,12 +143,14 @@ if(NOT JOPA_CLASSPATH_VERSION STREQUAL "0.93")
 
         # Delete prebuilt classes.zip, then configure with JOPA as compiler
         # Use GNU Classpath's glibj.zip as bootclasspath for JamVM classes
+        # Use GCC for JamVM - clang 17+ rejects computed gotos into statement expressions
         CONFIGURE_COMMAND ${CMAKE_COMMAND} -E rm -f "${JAMVM_PREBUILT_CLASSES}"
         COMMAND ${CMAKE_COMMAND} -E env
             ${CLEAN_JAVA_ENV_VARS}
             "UBSAN_OPTIONS=halt_on_error=0"
             "ASAN_OPTIONS=detect_leaks=0"
             "JAVAC=${JOPA_EXECUTABLE} --nowarn:unchecked -bootclasspath ${CLASSPATH_INSTALL_DIR}/share/classpath/glibj.zip"
+            "CC=gcc"
             <SOURCE_DIR>/configure
                 --prefix=<INSTALL_DIR>
                 --with-java-runtime-library=gnuclasspath
@@ -219,7 +221,7 @@ ulimit -s unlimited
 
     # --- JUnit 3.8.2 (Source Build) ---
     ExternalProject_Add(junit
-        URL "https://repo1.maven.org/maven2/junit/junit/3.8.2/junit-3.8.2-sources.jar"
+        URL "${CMAKE_CURRENT_SOURCE_DIR}/junit-3.8.2-sources.jar"
         PREFIX "${CMAKE_CURRENT_BINARY_DIR}/junit-prefix"
         INSTALL_DIR "${VENDOR_PREFIX}/junit"
         DEPENDS gnu_classpath
diff --git a/vendor/ecjsrc-4.2.2.jar b/vendor/ecjsrc-4.2.2.jar
new file mode 100644
index 0000000..b2eb118
Binary files /dev/null and b/vendor/ecjsrc-4.2.2.jar differ
diff --git a/vendor/junit-3.8.2-sources.jar b/vendor/junit-3.8.2-sources.jar
new file mode 100644
index 0000000..28ea5fc
Binary files /dev/null and b/vendor/junit-3.8.2-sources.jar differ