Fix pymeshlab pipeline crash + add post-process progress streaming

- Re-add pymeshlab to requirements.txt: hy3dshape/postprocessors.py
imports it at module level, so removing it broke _get_hy_pipeline().
The import itself works fine; only the OpenGL-dependent filter plugins
print warnings (which we no longer call from our own code).
- Replace inline pymeshlab decimation in generate_hunyuan with
fast_simplification to match stage2_decimate.py
- run_post_process() is now a streaming generator: yields cumulative
status markdown at each step so the UI updates live (⏳ before, ✅/⚠️
after each stage completes)

app.py

@@ -103,153 +103,165 @@ def run_post_process(
     do_albedo, do_material, do_ao, ao_quality,
     do_inpaint, do_lods, do_collision, pivot, scale_m,
 ):
-    state = workspace.get_state()  # rebuilt from disk by get_state()
+    """Run post-processing pipeline. Yields cumulative status markdown for streaming."""
+    state = workspace.get_state()
     current_glb = state.raw_gen_glb or state.high_poly_glb
     if not current_glb or not current_glb.exists():
-        return "❌ No generated asset found. Run Stage 1 (Generate) first."
+        yield "❌ No generated asset found. Run Stage 1 (Generate) first."
+        return
 
     log = []
 
+    def _emit(line: str):
+        log.append(line)
+        return "\n".join(log)
+
     if do_repair:
+        yield _emit("⏳ Repairing mesh (pymeshfix)...")
         try:
             from src.stages.stage2_repair import repair_mesh
             current_glb, msg = repair_mesh(current_glb)
-            log.append(f"✅ {msg}")
+            yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ Repair error: {e}")
+            yield _emit(f"⚠️ Repair error: {e}")
 
     if do_cleanup:
+        yield _emit("⏳ Cleaning geometry (trimesh)...")
         try:
             from src.stages.stage2_cleanup import cleanup_mesh
             current_glb, msg = cleanup_mesh(current_glb)
-            log.append(f"✅ {msg}")
+            yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ Cleanup error: {e}")
+            yield _emit(f"⚠️ Cleanup error: {e}")
 
     if do_decimate:
+        yield _emit(f"⏳ Decimating to {int(target_faces):,} faces...")
         try:
             from src.stages.stage2_decimate import decimate_mesh_final
             current_glb, msg = decimate_mesh_final(current_glb, int(target_faces))
-            log.append(f"✅ {msg}")
+            yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ Decimation error: {e}")
+            yield _emit(f"⚠️ Decimation error: {e}")
 
     if do_symmetry:
+        yield _emit("⏳ Enforcing bilateral symmetry...")
         try:
             from src.stages.stage2_symmetry import apply_symmetry
-            sym_axis = "bilateral-X"  # default; exposed via Advanced in M4 polish
-            current_glb, msg = apply_symmetry(current_glb, sym_axis)
-            log.append(f"✅ {msg}")
+            current_glb, msg = apply_symmetry(current_glb, "bilateral-X")
+            yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ Symmetry error: {e}")
+            yield _emit(f"⚠️ Symmetry error: {e}")
 
     if do_unwrap:
+        yield _emit("⏳ UV unwrapping (xatlas)...")
         try:
             from src.stages.stage2_uv import unwrap_uvs
             current_glb, msg = unwrap_uvs(current_glb)
-            log.append(f"✅ {msg}")
+            yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ UV unwrap error: {e}")
+            yield _emit(f"⚠️ UV unwrap error: {e}")
 
     if do_normal_bake:
+        yield _emit("⏳ Baking normal map (GPU)...")
         try:
             from src.stages.stage2_bake_normal import bake_normal_map
             st = workspace.get_state()
             hp = st.high_poly_glb
             lo = st.unwrapped_glb or current_glb
             if not hp or not hp.exists():
-                log.append("⚠️ Normal bake: no high-poly GLB. Generate first.")
+                yield _emit("⚠️ Normal bake: no high-poly GLB. Generate first.")
             else:
                 _gl, _dx, msg = bake_normal_map(hp, lo, map_size=2048, dx_format=True)
-                log.append(f"✅ {msg}")
+                yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ Normal bake error: {e}")
+            yield _emit(f"⚠️ Normal bake error: {e}")
 
     st = workspace.get_state()
     hp = st.high_poly_glb
     lo = st.unwrapped_glb or current_glb
 
     if do_albedo:
+        yield _emit("⏳ Baking albedo map (GPU)...")
         try:
             from src.stages.stage2_bake_albedo import bake_albedo
             if not hp or not hp.exists():
-                log.append("⚠️ Albedo bake: no high-poly. Generate first.")
+                yield _emit("⚠️ Albedo bake: no high-poly. Generate first.")
             else:
                 _, msg = bake_albedo(hp, lo, map_size=2048)
-                log.append(f"✅ {msg}")
+                yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ Albedo bake error: {e}")
+            yield _emit(f"⚠️ Albedo bake error: {e}")
 
     if do_material:
+        yield _emit("⏳ Baking material maps (GPU)...")
         try:
             from src.stages.stage2_bake_albedo import bake_material
             if not hp or not hp.exists():
-                log.append("⚠️ Material bake: no high-poly. Generate first.")
+                yield _emit("⚠️ Material bake: no high-poly. Generate first.")
             else:
                 _, _, msg = bake_material(hp, lo, map_size=2048)
-                log.append(f"✅ {msg}")
+                yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ Material bake error: {e}")
+            yield _emit(f"⚠️ Material bake error: {e}")
 
     if do_ao:
+        yield _emit(f"⏳ Baking AO ({ao_quality}, ray casting)...")
         try:
             from src.stages.stage2_bake_ao import bake_ao
             _, msg = bake_ao(current_glb, lo, map_size=2048, quality=ao_quality)
-            log.append(f"✅ {msg}")
+            yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ AO bake error: {e}")
+            yield _emit(f"⚠️ AO bake error: {e}")
 
-    # Pack ORM if we have the component maps
     st2 = workspace.get_state()
+
     if do_albedo or do_material or do_ao:
+        yield _emit("⏳ Packing ORM texture...")
         try:
             from src.stages.stage2_finalize import pack_orm
             _, msg = pack_orm(st2.ao_png, st2.roughness_png, st2.metallic_png)
-            log.append(f"✅ {msg}")
+            yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ ORM pack error: {e}")
+            yield _emit(f"⚠️ ORM pack error: {e}")
 
     if do_lods:
+        yield _emit("⏳ Generating LODs...")
         try:
             from src.stages.stage2_finalize import generate_lods
             lod_src = st2.final_glb or st2.low_poly_glb or current_glb
             _, msg = generate_lods(lod_src)
-            log.append(f"✅ {msg}")
+            yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ LOD error: {e}")
+            yield _emit(f"⚠️ LOD error: {e}")
 
     if do_collision:
+        yield _emit("⏳ Generating collision mesh (CoACD)...")
         try:
             from src.stages.stage2_finalize import generate_collision
             col_src = st2.low_poly_glb or current_glb
             _, msg = generate_collision(col_src)
-            log.append(f"✅ {msg}")
+            yield _emit(f"✅ {msg}")
         except Exception as e:
-            log.append(f"⚠️ Collision error: {e}")
+            yield _emit(f"⚠️ Collision error: {e}")
 
-    # Pivot + scale (always run if we have a final mesh)
+    yield _emit("⏳ Setting pivot and scale...")
     try:
         from src.stages.stage2_finalize import set_pivot, validate_scale
         piv_src = st2.low_poly_glb or current_glb
         piv_src, msg = set_pivot(piv_src, pivot)
-        log.append(f"✅ {msg}")
+        yield _emit(f"✅ {msg}")
         _, msg = validate_scale(piv_src, float(scale_m))
-        log.append(f"✅ {msg}")
+        yield _emit(f"✅ {msg}")
     except Exception as e:
-        log.append(f"⚠️ Pivot/scale error: {e}")
+        yield _emit(f"⚠️ Pivot/scale error: {e}")
 
     if do_inpaint:
-        log.append("🚧 SDXL inpaint — Milestone 7 (not yet implemented)")
-
-    if not log:
-        return "No processing steps selected."
+        yield _emit("🚧 SDXL inpaint — not yet implemented")
 
     final = workspace.get_state()
     out = final.final_glb or final.low_poly_glb or final.cleaned_glb or final.repaired_glb
     if out and out.exists():
-        log.append(f"\n**Output:** `{out.name}`")
-
-    return "\n".join(log)
+        yield _emit(f"\n**Output:** `{out.name}` · ready for Stage 3 or Export.")
 
 
 def handle_auto_rig(rig_type, seed, spring, fmt):

requirements.txt

@@ -38,9 +38,11 @@ onnxruntime
 # ===== Milestone 3: Stage 2A-2C Mesh Cleanup =====
 trimesh[easy]
 pymeshfix
-# pymeshlab excluded: its mesh-filter plugins need libOpenGL.so.0 which is
-# absent on ZeroGPU Spaces (headless, no display server).  Decimation and
-# LOD generation use fast-simplification (VTK, no OpenGL) instead.
+# pymeshlab is required by hy3dshape/postprocessors.py (imported at module
+# level, so must be installable).  Its OpenGL-dependent filter plugins print
+# warnings on ZeroGPU headless but do NOT crash on import.  Our own pipeline
+# stages use fast-simplification for decimation/LODs to avoid those filters.
+pymeshlab
 fast-simplification
 
 # ===== Milestone 4: Stage 2D-2E UV + Symmetry =====

src/stages/stage1_generate.py

@@ -339,23 +339,18 @@ def generate_hunyuan(
     mesh.export(str(high_poly_path))
 
     try:
-        import pymeshlab
+        import fast_simplification
         import trimesh as _tm
-        with tempfile.NamedTemporaryFile(suffix=".ply", delete=False) as tmp:
-            ply_in = tmp.name
-        mesh.export(ply_in)
-        ms = pymeshlab.MeshSet()
-        ms.load_new_mesh(ply_in)
-        ms.apply_filter(
-            "meshing_decimation_quadric_edge_collapse",
-            targetfacenum=max(100, preset["decimation_target"]),
-            preservenormal=True,
-            autoclean=True,
-        )
-        with tempfile.NamedTemporaryFile(suffix=".ply", delete=False) as tmp2:
-            ply_out = tmp2.name
-        ms.save_current_mesh(ply_out)
-        working = _tm.load(ply_out, force="mesh")
+        target = max(100, preset["decimation_target"])
+        base_faces = len(mesh.faces)
+        reduction = max(0.0, min(1.0 - target / base_faces, 0.99)) if base_faces > target else 0.0
+        if reduction > 0.0:
+            pts_out, faces_out = fast_simplification.simplify(
+                mesh.vertices, mesh.faces, target_reduction=reduction
+            )
+            working = _tm.Trimesh(vertices=pts_out, faces=faces_out, process=False)
+        else:
+            working = mesh
         working.export(str(raw_gen_path))
     except Exception:
         shutil.copy(str(high_poly_path), str(raw_gen_path))