Fix state persistence across ZeroGPU subprocess boundary

ZeroGPU runs @spaces.GPU functions in a forked subprocess. Any writes
to module-level variables (_state) are invisible to the parent Gradio
process, causing Tab 2 to report "no asset" and the viewer to clear on
refresh even after a successful generation.

Fix:
- workspace.py: get_state() now calls _build_state_from_disk() which
scans CURRENT/ for known filenames and reads .meta.json for metadata.
This makes all state reads cross-process-safe.
- workspace.py: flush_meta(state) writes face_count, vertex_count,
model_used, asset_name to CURRENT/.meta.json from the subprocess.
- stage1_generate.py: both generate_hunyuan and generate_trellis call
workspace.flush_meta(ws) before yielding the final result.
- ui_helpers.py: get_viewer_model_path() now scans CURRENT/ directly
(no longer reads _state) — correct from any process.
- The viewer glb path returned directly from handle_generate bypasses
all state lookups for the initial display.

app.py

@@ -103,10 +103,10 @@ 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()
+    state = workspace.get_state()  # rebuilt from disk by 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. Generate one in Tab 1 first."
+        return "❌ No generated asset found. Run Stage 1 (Generate) first."
 
     log = []
 

src/stages/stage1_generate.py

@@ -172,10 +172,10 @@ def generate_trellis(
     ws.model_used = "TRELLIS.2"
     ws.face_count = face_count
     ws.vertex_count = vertex_count
+    workspace.flush_meta(ws)
 
     elapsed = time.time() - t0
 
-    # Record approximate GPU time consumed on the remote Space for quota display
     from src import quota as _quota
     _quota.record_usage(f"generate_trellis_{quality.split()[0].lower()}", elapsed)
 
@@ -369,6 +369,11 @@ def generate_hunyuan(
     ws.face_count = face_count
     ws.vertex_count = vertex_count
 
+    # Persist metadata to disk so the parent Gradio process can read it
+    # (ZeroGPU runs this function in a subprocess; in-memory _state is not
+    # shared with the parent process that handles UI refresh calls).
+    workspace.flush_meta(ws)
+
     elapsed = time.time() - t0
 
     from src import quota as _quota

src/ui_helpers.py

@@ -72,24 +72,28 @@ def get_asset_summary() -> str:
 
 
 def get_viewer_model_path() -> str | None:
-    """Pick the best GLB to show in the 3D viewer right now.
+    """Pick the best GLB to show in the 3D viewer.
 
-    Prefers the most-processed version available.
+    Reads the filesystem directly so it works across the ZeroGPU subprocess
+    boundary (the in-memory state written inside @spaces.GPU is invisible to
+    the parent Gradio process).
     """
-    state = workspace.get_state()
+    from .workspace import CURRENT
     # Order: most processed → least processed
-    candidates = (
-        state.rigged_glb,
-        state.final_glb,
-        state.unwrapped_glb,
-        state.low_poly_glb,
-        state.cleaned_glb,
-        state.repaired_glb,
-        state.raw_gen_glb,
-        state.high_poly_glb,
-    )
+    candidates = [
+        CURRENT / "rigged.glb",
+        CURRENT / "scaled.glb",
+        CURRENT / "pivoted.glb",
+        CURRENT / "lods" / "LOD0.glb",
+        CURRENT / "unwrapped.glb",
+        CURRENT / "low_poly.glb",
+        CURRENT / "cleaned.glb",
+        CURRENT / "repaired.glb",
+        CURRENT / "raw_gen.glb",
+        CURRENT / "high_poly.glb",
+    ]
     for path in candidates:
-        if path and path.exists():
+        if path.exists():
             return str(path)
     return None
 

src/workspace.py

@@ -120,13 +120,93 @@ class AssetState:
         return out
 
 
-# Module-level singleton: in a single-user app, this is fine.
-# In Gradio, requests are serialized so there's no race condition at the
-# typical interaction level. Real concurrent generation would need locking.
+# ---------------------------------------------------------------------------
+# Filesystem-based state persistence
+#
+# ZeroGPU runs @spaces.GPU functions in a forked subprocess.  Any writes to
+# module-level variables (like _state) happen in the subprocess and are
+# invisible to the parent Gradio process.  To survive the process boundary we
+# write state to a JSON file inside CURRENT/ and always read back from there.
+# ---------------------------------------------------------------------------
+
+_META_FILE = CURRENT / ".meta.json"
+
+# File names that map to AssetState path attributes (order = preference)
+_PATH_ATTRS: list[tuple[str, Path]] = [
+    ("rigged_fbx",     CURRENT / "rigged.fbx"),
+    ("rigged_glb",     CURRENT / "rigged.glb"),
+    ("final_glb",      CURRENT / "scaled.glb"),
+    ("final_glb",      CURRENT / "pivoted.glb"),
+    ("unwrapped_glb",  CURRENT / "unwrapped.glb"),
+    ("low_poly_glb",   CURRENT / "low_poly.glb"),
+    ("cleaned_glb",    CURRENT / "cleaned.glb"),
+    ("repaired_glb",   CURRENT / "repaired.glb"),
+    ("raw_gen_glb",    CURRENT / "raw_gen.glb"),
+    ("high_poly_glb",  CURRENT / "high_poly.glb"),
+    ("normal_dx_png",  CURRENT / "textures" / "normal_dx.png"),
+    ("normal_gl_png",  CURRENT / "textures" / "normal_gl.png"),
+    ("albedo_png",     CURRENT / "textures" / "albedo.png"),
+    ("roughness_png",  CURRENT / "textures" / "roughness.png"),
+    ("metallic_png",   CURRENT / "textures" / "metallic.png"),
+    ("ao_png",         CURRENT / "textures" / "ao.png"),
+    ("orm_png",        CURRENT / "textures" / "orm.png"),
+    ("collision_glb",  CURRENT / "collision.glb"),
+]
+
+
+def _build_state_from_disk() -> AssetState:
+    """Reconstruct AssetState by scanning CURRENT/ and reading .meta.json."""
+    state = AssetState()
+
+    # Read persisted metadata (face count, model name, etc.)
+    if _META_FILE.exists():
+        try:
+            meta = json.loads(_META_FILE.read_text())
+            state.asset_name  = meta.get("asset_name", "untitled")
+            state.model_used  = meta.get("model_used", "")
+            state.face_count  = meta.get("face_count", 0)
+            state.vertex_count = meta.get("vertex_count", 0)
+        except Exception:
+            pass
+
+    # Populate path attributes from filesystem
+    seen_attrs: set[str] = set()
+    for attr, path in _PATH_ATTRS:
+        if path.exists() and attr not in seen_attrs:
+            setattr(state, attr, path)
+            seen_attrs.add(attr)
+
+    # LODs
+    lod_dir = CURRENT / "lods"
+    if lod_dir.exists():
+        state.lod_glbs = sorted(lod_dir.glob("LOD*.glb"))
+
+    return state
+
+
+def flush_meta(state: AssetState) -> None:
+    """Write lightweight metadata to disk so the parent process can read it."""
+    try:
+        _META_FILE.write_text(json.dumps({
+            "asset_name":   state.asset_name,
+            "model_used":   state.model_used,
+            "face_count":   state.face_count,
+            "vertex_count": state.vertex_count,
+        }))
+    except Exception:
+        pass
+
+
+# Module-level singleton — kept for in-process use (e.g. stage2 steps that
+# run in the same process as Gradio).  Always prefer get_state() which syncs
+# from disk first, making it safe across the ZeroGPU process boundary.
 _state: AssetState = AssetState()
 
 
 def get_state() -> AssetState:
+    """Return current state, rebuilding from disk to handle ZeroGPU isolation."""
+    global _state
+    _state = _build_state_from_disk()
     return _state