fix hang in build123d boolean ops and update reference volumes

Add thread-based timeout (120s) to build123d cut/join/intersection/export_stl
to prevent indefinite hangs on complex gourd-shaped assemblies. The timeout
wraps OCCT boolean operations in a daemon thread and raises TimeoutError if
the operation exceeds the threshold, enabling CI to continue instead of
hanging for hours.

Update reference volumes in all_assembly.py, bottom_assembly.py, and body.py
to use values measured via manifold3d API (accurate, consistent volumes).

Add debug scripts (debug_hang.py, run_build123d_test.py) used during
investigation.

Author: bat52

debug_hang.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+
+"""
+Test to isolate where the hang occurs: generation vs export/volume check
+"""
+
+import sys
+import os
+import time
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+def test_generation_only():
+    """Test just the generation phase without export"""
+    print("Testing generation only for all_assembly with build123d...")
+    
+    try:
+        from pylele.pylele2.all_assembly import LeleAllAssembly
+        
+        # Create assembly instance
+        assembly = LeleAllAssembly()
+        
+        # Manually set up CLI for build123d
+        from argparse import Namespace
+        from b13d.api.core import Implementation, Fidelity
+        
+        assembly.cli = Namespace(
+            implementation=Implementation.BUILD123D,
+            fidelity=Fidelity.LOW,
+            is_cut=False,
+            outdir='.',
+            section_x=[-1000, 1000],
+            section_y=[-1000, 1000],
+            section_z=[-1000, 1000],
+            stl_check_en=False,  # Disable volume checking for now
+            reference_volume=None,
+            reference_volume_tolerance=10,
+            export=None,
+            show_strings=False,
+            show_tuners=False,
+            separate_top=False,
+            separate_bottom=False,
+            separate_neck=False,
+            separate_fretboard=False,
+            separate_bridge=False,
+            all=False,
+            all_distance=0.0,
+            scale_length=25.5,
+            nutWth=43.0,
+            fretboard_rise_angle=0.0,
+            fret_type='round'
+        )
+        
+        # Configure the API
+        assembly.configure()
+        
+        print("Starting generation...")
+        start_time = time.time()
+        
+        # Generate the shape
+        shape = assembly.gen_full()
+        
+        end_time = time.time()
+        
+        print(f"Generation completed in {end_time - start_time:.2f} seconds")
+        print(f"Shape generated: {shape is not None}")
+        
+        if shape is not None:
+            print(f"Shape type: {type(shape)}")
+            if hasattr(shape, 'solid'):
+                print(f"Solid type: {type(shape.solid)}")
+                if shape.solid is not None:
+                    # Try to get volume using build123d's own method
+                    try:
+                        volume = shape.solid().volume
+                        print(f"Build123d volume: {volume}")
+                    except:
+                        print("Could not get volume from build123d solid")
+            
+        return shape is not None
+        
+    except Exception as e:
+        print(f"Error during generation: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_with_export_no_volume_check():
+    """Test generation and export but disable volume checking"""
+    print("\nTesting generation + export (no volume check) for all_assembly with build123d...")
+    
+    try:
+        from pylele.pylele2.all_assembly import LeleAllAssembly
+        
+        # Create assembly instance
+        assembly = LeleAllAssembly()
+        
+        # Manually set up CLI for build123d
+        from argparse import Namespace
+        from b13d.api.core import Implementation, Fidelity
+        
+        assembly.cli = Namespace(
+            implementation=Implementation.BUILD123D,
+            fidelity=Fidelity.LOW,
+            is_cut=False,
+            outdir='./test_output',
+            section_x=[-1000, 1000],
+            section_y=[-1000, 1000],
+            section_z=[-1000, 1000],
+            stl_check_en=False,  # Disable volume checking for now
+            reference_volume=None,
+            reference_volume_tolerance=10,
+            export=None,
+            show_strings=False,
+            show_tuners=False,
+            separate_top=False,
+            separate_bottom=False,
+            separate_neck=False,
+            separate_fretboard=False,
+            separate_bridge=False,
+            all=False,
+            all_distance=0.0,
+            scale_length=25.5,
+            nutWth=43.0,
+            fretboard_rise_angle=0.0,
+            fret_type='round'
+        )
+        
+        # Create output directory
+        os.makedirs('./test_output', exist_ok=True)
+        
+        # Configure the API
+        assembly.configure()
+        
+        print("Starting generation and export...")
+        start_time = time.time()
+        
+        # Generate and export
+        output_file = assembly.export_stl()
+        
+        end_time = time.time()
+        
+        print(f"Export completed in {end_time - start_time:.2f} seconds")
+        print(f"Output file: {output_file}")
+        
+        if output_file and os.path.exists(output_file):
+            size = os.path.getsize(output_file)
+            print(f"STL file size: {size} bytes")
+            return True
+        else:
+            print("Export failed - no output file")
+            return False
+        
+    except Exception as e:
+        print(f"Error during generation/export: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("ISOLATING THE HANG: GENERATION vs EXPORT/VOLUME CHECK")
+    print("=" * 60)
+    
+    # Test 1: Generation only
+    gen_success = test_generation_only()
+    
+    # Test 2: Generation + export (no volume check)
+    export_success = test_with_export_no_volume_check()
+    
+    print("\n" + "=" * 60)
+    print("RESULTS:")
+    print(f"Generation only: {'SUCCESS' if gen_success else 'FAILED'}")
+    print(f"Generation + export (no vol check): {'SUCCESS' if export_success else 'FAILED'}")
+    print("=" * 60)
+    
+    if gen_success and not export_success:
+        print("ISSUE ISOLATED: Problem occurs during export or volume checking")
+    elif not gen_success:
+        print("ISSUE ISOLATED: Problem occurs during generation")
+    else:
+        print("Both generation and export work - issue may be elsewhere")

run_build123d_test.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+
+"""
+Run the actual pylele test but with build123d only and timeout protection
+"""
+
+import subprocess
+import sys
+import os
+import time
+from threading import Timer
+
+class TimeoutException(Exception):
+    pass
+
+def timeout_handler():
+    raise TimeoutException("Test execution timed out")
+
+def run_test_with_timeout(test_command, timeout_seconds=120):
+    """Run a test command with timeout protection"""
+    timer = Timer(timeout_seconds, timeout_handler)
+    timer.start()
+    
+    try:
+        print(f"Running: {' '.join(test_command)}")
+        start_time = time.time()
+        
+        # Run the command and capture output
+        result = subprocess.run(
+            test_command,
+            capture_output=True,
+            text=True,
+            cwd=os.path.dirname(os.path.abspath(__file__))
+        )
+        
+        timer.cancel()
+        
+        end_time = time.time()
+        duration = end_time - start_time
+        
+        print(f"Test completed in {duration:.2f} seconds")
+        print(f"Return code: {result.returncode}")
+        
+        # Show key parts of output
+        if result.stdout:
+            lines = result.stdout.strip().split('\n')
+            # Look for key indicators
+            for line in lines[-20:]:  # Last 20 lines
+                if any(keyword in line.lower() for keyword in ['generation', 'done generating', 'rendering time', 'test passed', 'test failed', 'error', 'warning']):
+                    print(f"  {line}")
+        
+        if result.stderr:
+            print("STDERR (last 15 lines):")
+            stderr_lines = result.stderr.strip().split('\n')
+            for line in stderr_lines[-15:]:
+                print(f"  {line}")
+                
+        return result.returncode == 0, result.stdout, result.stderr
+        
+    except TimeoutException:
+        timer.cancel()
+        print(f"TEST TIMED OUT after {timeout_seconds} seconds!")
+        return False, "", "Test timed out"
+    except Exception as e:
+        timer.cancel()
+        print(f"ERROR running test: {e}")
+        return False, "", str(e)
+
+def main():
+    # Change to the pylele directory
+    os.chdir('/home/marco/programming/pylele')
+    
+    # Test the specific test method that was hanging
+    print("=" * 70)
+    print("RUNNING PYLELE TEST WITH BUILD123D API ONLY")
+    print("=" * 70)
+    
+    # Run the specific test method for all_assembly with build123d
+    test_cmd = [sys.executable, "-m", "unittest", "pylele.test.PyleleTestMethods.test_all_assembly", "-v"]
+    
+    success, stdout, stderr = run_test_with_timeout(test_cmd, timeout_seconds=120)
+    
+    print("\n" + "=" * 70)
+    print("FINAL RESULT:")
+    print(f"Success: {success}")
+    print("=" * 70)
+    
+    if not success:
+        if "timed out" in stderr.lower():
+            print("The test timed out - this confirms the hang issue")
+        elif "error:" in stderr.lower() or "exception" in stderr.lower():
+            print("The test failed with an error")
+        else:
+            print("The test failed for unknown reasons")
+    else:
+        print("The test passed successfully")
+
+if __name__ == "__main__":
+    main()

src/b13d/api/bd.py

@@ -14,6 +14,7 @@
 import os
 from pathlib import Path
 import sys
+import threading
 from typing import Union
 
 import numpy as np
@@ -61,7 +62,12 @@ def export_stl(self, shape: BDShape, path: Union[str, Path]) -> None:
         solid = shape.getImplSolid()
         if isinstance(solid, bd.Compound) and len(solid.solids()) == 0:
             raise ValueError("Cannot export empty Compound (no solids to export)")
-        bd.export_stl(solid, file_ensure_extension(path, ".stl"))
+        # Wrap export in timeout to prevent hang on complex geometry
+        self._run_with_timeout(
+            lambda s, p: bd.export_stl(s, p),
+            (solid, file_ensure_extension(path, ".stl")),
+            self.BOOLEAN_TIMEOUT,
+        )
 
     def export_best(self, shape: BDShape, path: Union[str, Path]) -> None:
         self.export_stl(shape, path)
@@ -261,6 +267,40 @@ def _safe_boolean(self, op_name, a, b, use_resolve=False):
                 "Try using the 'mf' (Manifold) backend instead."
             ) from e
 
+    BOOLEAN_TIMEOUT = 120  # seconds; raise if a single boolean op takes longer
+
+    def _run_with_timeout(self, fn, args, timeout):
+        """Run a callable in a thread with a timeout.
+
+        If the callable does not complete within *timeout* seconds, a
+        TimeoutError is raised.
+        """
+        result = [None]
+        exception = [None]
+
+        def worker():
+            try:
+                result[0] = fn(*args)
+            except Exception as e:
+                exception[0] = e
+
+        t = threading.Thread(target=worker, daemon=True)
+        t.start()
+        t.join(timeout)
+        if t.is_alive():
+            # The operation is still running past the timeout.
+            # We cannot forcibly kill the thread, but we can stop waiting
+            # and let it eventually become a zombie.  To avoid resource
+            # leaks we detach it (daemon=True) and proceed.
+            raise TimeoutError(
+                f"build123d boolean operation timed out after {timeout}s. "
+                "This is a known limitation with complex geometries. "
+                "Try using the 'mf' (Manifold) backend instead."
+            )
+        if exception[0] is not None:
+            raise exception[0]
+        return result[0]
+
     def cut(self, cutter: BDShape) -> BDShape:
         if self.cross_section is not None and cutter is not None and cutter.cross_section is not None:
             self.cross_section = self.cross_section - cutter.cross_section
@@ -273,7 +313,11 @@ def cut(self, cutter: BDShape) -> BDShape:
             return self
         # Try raw Part types first (more reliable for complex geometries),
         # fall back to Solid extraction
-        self.solid = self._safe_boolean('cut', self.solid, cutter.solid)
+        self.solid = self._run_with_timeout(
+            lambda a, b: self._safe_boolean('cut', a, b),
+            (self.solid, cutter.solid),
+            self.BOOLEAN_TIMEOUT,
+        )
         return self
 
     def dup(self) -> BDShape:
@@ -292,7 +336,11 @@ def join(self, joiner: BDShape) -> BDShape:
         if joiner is None or joiner.solid is None:
             return self
         # Use Solid+Solid for join (handles disjoint shapes better than Part+Part)
-        result = self._safe_boolean('join', self.solid, joiner.solid, use_resolve=True)
+        result = self._run_with_timeout(
+            lambda a, b: self._safe_boolean('join', a, b, use_resolve=True),
+            (self.solid, joiner.solid),
+            self.BOOLEAN_TIMEOUT,
+        )
         # build123d returns ShapeList for disjoint solids; convert to Compound for export
         if isinstance(result, ShapeList):
             if len(result) == 0:
@@ -312,7 +360,11 @@ def intersection(self, intersector: BDShape) -> BDShape:
             return self
         # Try raw Part types first (more reliable for complex geometries),
         # fall back to Solid extraction
-        self.solid = self._safe_boolean('intersect', self.solid, intersector.solid)
+        self.solid = self._run_with_timeout(
+            lambda a, b: self._safe_boolean('intersect', a, b),
+            (self.solid, intersector.solid),
+            self.BOOLEAN_TIMEOUT,
+        )
         return self
 
     def mirror(self, normal: tuple[float, float, float] = (0, 1, 0)) -> BDShape: