Update app.py

Make SSD-1B ZeroGPU the required image generator

app.py

@@ -22,6 +22,11 @@ try:
 except Exception:
     InferenceClient = None
 
+try:
+    import spaces as hf_spaces
+except Exception:
+    hf_spaces = None
+
 
 STARTER_HTML = """<!DOCTYPE html>
 <html>
@@ -116,6 +121,16 @@ class IntegrationReport:
 
 
 HF_TOKEN = os.environ.get("HF_TOKEN", "")
+PRIMARY_IMAGE_MODEL = os.environ.get("PRIMARY_IMAGE_MODEL", "segmind/SSD-1B")
+PRIMARY_LORA_MODEL = os.environ.get("PRIMARY_LORA_MODEL", "latent-consistency/lcm-lora-ssd-1b")
+PRIMARY_IMAGE_STEPS = int(os.environ.get("PRIMARY_IMAGE_STEPS", "4"))
+PRIMARY_GUIDANCE_SCALE = float(os.environ.get("PRIMARY_GUIDANCE_SCALE", "1.5"))
+PRIMARY_BACKGROUND_STRENGTH = float(os.environ.get("PRIMARY_BACKGROUND_STRENGTH", "0.72"))
+USE_PRIMARY_IMAGE_MODEL = os.environ.get("USE_PRIMARY_IMAGE_MODEL", "1") == "1"
+REQUIRE_PRIMARY_IMAGE_MODEL = os.environ.get(
+    "REQUIRE_PRIMARY_IMAGE_MODEL",
+    "1" if os.environ.get("SPACE_ID") else "0",
+) == "1"
 FREE_IMAGE_MODEL = os.environ.get("FREE_IMAGE_MODEL", "segmind/tiny-sd")
 FREE_IMAGE_STEPS = int(os.environ.get("FREE_IMAGE_STEPS", "5"))
 USE_HF_PROMPT_PROVIDER = os.environ.get("USE_HF_PROMPT_PROVIDER", "0") == "1"
@@ -136,6 +151,20 @@ FREE_DIFFUSION_PIPE = None
 FREE_DIFFUSION_ERROR = None
 CONTROLNET_PIPE = None
 CONTROLNET_ERROR = None
+PRIMARY_TEXT_PIPE = None
+PRIMARY_IMAGE_TO_IMAGE_PIPE = None
+PRIMARY_MODEL_ERROR = None
+
+
+def gpu_task(duration: int):
+    """Use a real ZeroGPU allocation on Hugging Face and remain importable in local tests."""
+    if hf_spaces is not None:
+        return hf_spaces.GPU(duration=duration)
+
+    def identity(function):
+        return function
+
+    return identity
 
 
 def slugify(value: str) -> str:
@@ -530,7 +559,7 @@ def palette_for(text: str) -> list[tuple[int, int, int]]:
         (("sci-fi", "scifi", "space", "arena", "metal", "shooter"), [(30, 216, 236), (235, 64, 96), (18, 22, 31), (245, 192, 51)]),
     ]
     for words, colors in themed:
-        if any(word in lowered for word in words):
+        if contains_any_term(lowered, words):
             return colors
 
     digest = hashlib.sha256(text.encode("utf-8")).digest()
@@ -672,7 +701,7 @@ def draw_top_down_background(spec: AssetSpec, rng: random.Random) -> bytes:
     colors = palette_for(spec.prompt)
     width, height = spec.width, spec.height
 
-    if any(word in prompt for word in ("sci-fi", "scifi", "cyberpunk", "space station", "spaceship hangar", "metal arena")):
+    if contains_any_term(prompt, ("sci-fi", "scifi", "cyberpunk", "space station", "spaceship hangar", "metal arena")):
         image = Image.new("RGBA", (width, height), (18, 22, 31, 255))
         draw = ImageDraw.Draw(image, "RGBA")
         panel = 64
@@ -690,7 +719,7 @@ def draw_top_down_background(spec: AssetSpec, rng: random.Random) -> bytes:
             draw.line((0, y, width, y), fill=(34, 215, 236, 95), width=2)
         return finish_png(image)
 
-    if any(word in prompt for word in ("desert", "sand", "dune", "badlands", "wasteland", "canyon")):
+    if contains_any_term(prompt, ("desert", "sand", "dune", "badlands", "wasteland", "canyon")):
         image = Image.new("RGBA", (width, height), (202, 166, 99, 255))
         draw = ImageDraw.Draw(image, "RGBA")
         for _ in range(26):
@@ -716,7 +745,7 @@ def draw_top_down_background(spec: AssetSpec, rng: random.Random) -> bytes:
                 draw.line(shifted, fill=(105, 77, 48, 155), width=5, joint="curve")
         return finish_png(image)
 
-    if any(word in prompt for word in ("garden", "flower", "grass", "meadow", "forest", "jungle", "path")):
+    if contains_any_term(prompt, ("garden", "flower", "grass", "meadow", "forest", "jungle", "path")):
         image = Image.new("RGBA", (width, height), (64, 132, 70, 255))
         draw = ImageDraw.Draw(image, "RGBA")
         for _ in range(85):
@@ -753,7 +782,7 @@ def draw_top_down_background(spec: AssetSpec, rng: random.Random) -> bytes:
             draw.ellipse((x - inner, y - inner, x + inner, y + inner), fill=(58, rng.randint(126, 166), 69, 245))
         return finish_png(image)
 
-    if any(word in prompt for word in ("dungeon", "castle", "stone", "crypt")):
+    if contains_any_term(prompt, ("dungeon", "castle", "stone", "crypt")):
         image = Image.new("RGBA", (width, height), (48, 50, 62, 255))
         draw = ImageDraw.Draw(image, "RGBA")
         tile = 54
@@ -767,7 +796,7 @@ def draw_top_down_background(spec: AssetSpec, rng: random.Random) -> bytes:
                 )
         return finish_png(image)
 
-    if any(word in prompt for word in ("lava", "fire", "volcano")):
+    if contains_any_term(prompt, ("lava", "fire", "volcano")):
         image = Image.new("RGBA", (width, height), (52, 23, 18, 255))
         draw = ImageDraw.Draw(image, "RGBA")
         for _ in range(24):
@@ -781,7 +810,7 @@ def draw_top_down_background(spec: AssetSpec, rng: random.Random) -> bytes:
             draw.line(points, fill=(255, 202, 64, 210), width=rng.randint(2, 5), joint="curve")
         return finish_png(image)
 
-    if any(word in prompt for word in ("ocean", "sea", "water", "underwater")):
+    if contains_any_term(prompt, ("ocean", "sea", "water", "underwater")):
         image = Image.new("RGBA", (width, height), (18, 114, 158, 255))
         draw = ImageDraw.Draw(image, "RGBA")
         for _ in range(42):
@@ -836,7 +865,7 @@ def draw_background(spec: AssetSpec, rng: random.Random) -> bytes:
         return draw_isometric_background(spec, rng)
 
     if (
-        any(word in prompt for word in ("sci-fi", "scifi", "cyberpunk", "space station", "spaceship hangar", "metal arena", "hazard grid"))
+        contains_any_term(prompt, ("sci-fi", "scifi", "cyberpunk", "space station", "spaceship hangar", "metal arena", "hazard grid"))
         and not is_space_background_prompt(prompt)
     ):
         image = Image.new("RGBA", (spec.width, spec.height), (18, 22, 31, 255))
@@ -863,11 +892,6 @@ def draw_background(spec: AssetSpec, rng: random.Random) -> bytes:
                     [(x + stripe, y), (x + stripe + 12, y), (x + stripe - 12, y + 34), (x + stripe - 24, y + 34)],
                     fill=(245, 192, 51, 210),
                 )
-        for _ in range(18):
-            x = rng.randint(0, spec.width)
-            y = rng.randint(0, spec.height)
-            r = rng.randint(10, 32)
-            draw.ellipse((x - r, y - r, x + r, y + r), outline=(224, 54, 85, 100), width=2)
         out = io.BytesIO()
         image.save(out, format="PNG")
         return out.getvalue()
@@ -901,7 +925,7 @@ def draw_background(spec: AssetSpec, rng: random.Random) -> bytes:
         image.save(out, format="PNG")
         return out.getvalue()
 
-    if any(word in prompt for word in ("garden", "flower", "grass", "meadow", "forest", "path")):
+    if contains_any_term(prompt, ("garden", "flower", "grass", "meadow", "forest", "path")):
         sky = (184, 224, 239)
         grass = (80, 151, 82)
         image = Image.new("RGBA", (spec.width, spec.height), sky + (255,))
@@ -927,13 +951,16 @@ def draw_background(spec: AssetSpec, rng: random.Random) -> bytes:
             ],
             fill=path_color,
         )
-        for _ in range(18):
-            x = rng.randint(0, spec.width)
-            y = rng.randint(horizon + 48, spec.height - 18)
-            stem = rng.randint(5, 12)
-            draw.line((x, y + stem, x, y), fill=(43, 109, 53, 210), width=2)
-            petal = rng.choice(colors) + (230,)
-            draw.ellipse((x - 4, y - 3, x + 4, y + 5), fill=petal)
+        # Small colored flowers easily read as a generic particle overlay. Only add
+        # them when the request explicitly calls for a flower-rich environment.
+        if contains_any_term(prompt, ("garden", "flower", "flowers", "meadow")):
+            for _ in range(18):
+                x = rng.randint(0, spec.width)
+                y = rng.randint(horizon + 48, spec.height - 18)
+                stem = rng.randint(5, 12)
+                draw.line((x, y + stem, x, y), fill=(43, 109, 53, 210), width=2)
+                petal = rng.choice(colors) + (230,)
+                draw.rectangle((x - 3, y - 2, x + 3, y + 3), fill=petal)
         for _ in range(10):
             x = rng.randint(-40, spec.width)
             y = rng.randint(horizon - 35, horizon + 20)
@@ -942,7 +969,7 @@ def draw_background(spec: AssetSpec, rng: random.Random) -> bytes:
         image.save(out, format="PNG")
         return out.getvalue()
 
-    if any(word in prompt for word in ("lava", "fire", "volcano")):
+    if contains_any_term(prompt, ("lava", "fire", "volcano")):
         image = Image.new("RGBA", (spec.width, spec.height), (52, 23, 18, 255))
         draw = ImageDraw.Draw(image, "RGBA")
         for y in range(0, spec.height, 58):
@@ -951,16 +978,20 @@ def draw_background(spec: AssetSpec, rng: random.Random) -> bytes:
             x = rng.randint(-80, spec.width)
             y = rng.randint(0, spec.height)
             draw.line((x, y, x + rng.randint(120, 320), y + rng.randint(-20, 20)), fill=(255, 111, 43, 220), width=rng.randint(5, 12))
-        for _ in range(45):
-            x = rng.randint(0, spec.width)
-            y = rng.randint(0, spec.height)
-            r = rng.randint(5, 20)
-            draw.ellipse((x - r, y - r, x + r, y + r), fill=(255, 192, 53, rng.randint(70, 140)))
+        # Keep lava as connected terrain cracks. Random glowing circles caused a
+        # persistent confetti/particle layer in every lava-background trial.
+        for x in range(-40, spec.width + 80, 150):
+            y = int(spec.height * 0.68) + rng.randint(-24, 24)
+            draw.polygon(
+                ((x, y), (x + 86, y - 18), (x + 132, y + 4), (x + 52, y + 27)),
+                fill=(82, 42, 30, 245),
+                outline=(119, 55, 34, 255),
+            )
         out = io.BytesIO()
         image.save(out, format="PNG")
         return out.getvalue()
 
-    if any(word in prompt for word in ("dungeon", "castle", "stone", "crypt")):
+    if contains_any_term(prompt, ("dungeon", "castle", "stone", "crypt")):
         image = Image.new("RGBA", (spec.width, spec.height), (48, 50, 62, 255))
         draw = ImageDraw.Draw(image, "RGBA")
         tile = 54
@@ -968,15 +999,11 @@ def draw_background(spec: AssetSpec, rng: random.Random) -> bytes:
             for x in range(0, spec.width, tile):
                 shade = rng.randint(48, 78)
                 draw.rectangle((x, y, x + tile - 2, y + tile - 2), fill=(shade, shade + 2, shade + 8, 255), outline=(27, 29, 38, 190))
-        for _ in range(22):
-            x = rng.randint(0, spec.width)
-            y = rng.randint(0, spec.height)
-            draw.ellipse((x - 8, y - 8, x + 8, y + 8), fill=(185, 146, 80, 110))
         out = io.BytesIO()
         image.save(out, format="PNG")
         return out.getvalue()
 
-    if any(word in prompt for word in ("ocean", "sea", "water", "underwater")):
+    if contains_any_term(prompt, ("ocean", "sea", "water", "underwater")):
         image = Image.new("RGBA", (spec.width, spec.height), (8, 54, 92, 255))
         draw = ImageDraw.Draw(image, "RGBA")
         for y in range(spec.height):
@@ -1000,20 +1027,16 @@ def draw_background(spec: AssetSpec, rng: random.Random) -> bytes:
         color = tuple(int(colors[2][i] * (1 - mix) + colors[0][i] * mix) for i in range(3))
         draw.line((0, y, spec.width, y), fill=color + (255,))
 
-    for _ in range(34):
-        x = rng.randint(-80, spec.width)
-        y = rng.randint(-40, spec.height)
-        w = rng.randint(80, 260)
-        h = rng.randint(36, 150)
-        fill = rng.choice(colors) + (rng.randint(45, 110),)
-        draw.ellipse((x, y, x + w, y + h), fill=fill)
-
-    for _ in range(80):
-        x = rng.randint(0, spec.width)
-        y = rng.randint(0, spec.height)
-        size = rng.randint(2, 7)
-        fill = rng.choice(colors) + (rng.randint(90, 190),)
-        draw.rectangle((x, y, x + size, y + size), fill=fill)
+    # Unknown themes still get large connected terrain bands rather than a field
+    # of unrelated dots, which was repeatedly mistaken for a particle effect.
+    for band in range(7):
+        y = int(spec.height * (band + 1) / 8)
+        offset = rng.randint(-28, 28)
+        draw.line(
+            ((0, y + offset), (spec.width, y - offset)),
+            fill=colors[(band + 1) % len(colors)] + (105,),
+            width=rng.randint(18, 46),
+        )
 
     out = io.BytesIO()
     image.save(out, format="PNG")
@@ -1449,7 +1472,8 @@ def diffusion_negative_prompt(spec: AssetSpec) -> str:
         }.get(spec.camera, "")
         return (
             common
-            + ", person, character, player, hero, creature, monster, vehicle, mascot, foreground subject"
+            + ", person, character, player, hero, creature, monster, vehicle, mascot, foreground subject, "
+            "particle effect, particles, confetti, sparkles, floating dots, glowing orbs, embers, lens flare"
             + camera_negative
         )
     return common + ", landscape, environment scene, room, horizon, opaque background, drop shadow"
@@ -1507,6 +1531,104 @@ def build_camera_control_image(spec: AssetSpec, width: int = 1024, height: int =
     return image.convert("RGB")
 
 
+def initialize_primary_image_model() -> None:
+    """Load the production diffusion pipelines once under ZeroGPU CUDA emulation."""
+    global PRIMARY_TEXT_PIPE, PRIMARY_IMAGE_TO_IMAGE_PIPE, PRIMARY_MODEL_ERROR
+    if not USE_PRIMARY_IMAGE_MODEL or PRIMARY_TEXT_PIPE is not None or PRIMARY_MODEL_ERROR:
+        return
+    if not os.environ.get("SPACE_ID"):
+        return
+
+    try:
+        import torch
+        from diffusers import AutoPipelineForImage2Image, AutoPipelineForText2Image, LCMScheduler
+
+        model_kwargs = {
+            "torch_dtype": torch.float16,
+            "variant": "fp16",
+            "use_safetensors": True,
+        }
+        if HF_TOKEN:
+            model_kwargs["token"] = HF_TOKEN
+
+        text_pipe = AutoPipelineForText2Image.from_pretrained(PRIMARY_IMAGE_MODEL, **model_kwargs)
+        text_pipe.scheduler = LCMScheduler.from_config(text_pipe.scheduler.config)
+        text_pipe.load_lora_weights(PRIMARY_LORA_MODEL)
+        text_pipe.fuse_lora()
+        text_pipe = text_pipe.to("cuda")
+        if hasattr(text_pipe, "set_progress_bar_config"):
+            text_pipe.set_progress_bar_config(disable=True)
+        if hasattr(text_pipe, "enable_vae_slicing"):
+            text_pipe.enable_vae_slicing()
+
+        image_pipe = AutoPipelineForImage2Image.from_pipe(text_pipe)
+        image_pipe.scheduler = LCMScheduler.from_config(image_pipe.scheduler.config)
+        if hasattr(image_pipe, "set_progress_bar_config"):
+            image_pipe.set_progress_bar_config(disable=True)
+
+        PRIMARY_TEXT_PIPE = text_pipe
+        PRIMARY_IMAGE_TO_IMAGE_PIPE = image_pipe
+    except Exception as exc:
+        PRIMARY_MODEL_ERROR = short_error(exc)
+
+
+def primary_diffusion_prompt(spec: AssetSpec) -> str:
+    if is_background_spec(spec):
+        return (
+            f"{spec.prompt} Production-quality 2D game background only. Preserve the supplied camera layout "
+            "and readable gameplay space. Use connected environmental forms and clean terrain structure. "
+            "No characters and no decorative overlay."
+        )
+    return (
+        f"{spec.prompt} One complete isolated game sprite only, centered, fully visible, readable silhouette, "
+        "camera angle exactly as specified, on a plain uniform white studio background."
+    )
+
+
+def primary_diffusion_png(spec: AssetSpec, index: int, run_id: int) -> tuple[bytes | None, str | None]:
+    """Generate every production asset with SSD-1B; backgrounds use camera-guided img2img."""
+    if PRIMARY_MODEL_ERROR:
+        return None, PRIMARY_MODEL_ERROR
+    if PRIMARY_TEXT_PIPE is None:
+        initialize_primary_image_model()
+    if PRIMARY_TEXT_PIPE is None:
+        return None, "primary ZeroGPU diffusion model is not initialized on this runtime"
+
+    try:
+        import torch
+
+        seed = abs(hash(f"primary|{spec.role}|{spec.prompt}|{index}|{run_id}")) % 2147483647
+        generator = torch.Generator(device="cuda").manual_seed(seed)
+        common = {
+            "prompt": primary_diffusion_prompt(spec),
+            "negative_prompt": diffusion_negative_prompt(spec),
+            "num_inference_steps": PRIMARY_IMAGE_STEPS,
+            "guidance_scale": PRIMARY_GUIDANCE_SCALE,
+            "generator": generator,
+        }
+        if is_background_spec(spec):
+            if PRIMARY_IMAGE_TO_IMAGE_PIPE is None:
+                return None, "primary camera-guided image-to-image pipeline is unavailable"
+            guide_png = local_asset_png(spec, index, run_id)
+            guide = Image.open(io.BytesIO(guide_png)).convert("RGB").resize((1344, 768), Image.LANCZOS)
+            image = PRIMARY_IMAGE_TO_IMAGE_PIPE(
+                image=guide,
+                strength=PRIMARY_BACKGROUND_STRENGTH,
+                **common,
+            ).images[0]
+        else:
+            image = PRIMARY_TEXT_PIPE(width=1024, height=1024, **common).images[0]
+        return polish_diffusion_asset(image, spec), None
+    except Exception as exc:
+        return None, short_error(exc)
+
+
+# Hugging Face ZeroGPU virtualizes CUDA placement during module import. Loading
+# here keeps the weights resident between decorated requests instead of paying the
+# model-load cost on every generation.
+initialize_primary_image_model()
+
+
 def controlnet_background_png(spec: AssetSpec, index: int, run_id: int) -> tuple[bytes | None, str | None]:
     """Run SDXL Depth ControlNet when a CUDA Space explicitly enables it."""
     global CONTROLNET_PIPE, CONTROLNET_ERROR
@@ -1677,7 +1799,7 @@ def hf_structure_background_png(spec: AssetSpec, index: int, run_id: int) -> tup
 
 def generate_asset(spec: AssetSpec, index: int, run_id: int) -> tuple[str, str, str | None, str]:
     is_background = is_background_spec(spec)
-    if not is_background and not USE_DIFFUSION_FOR_SPRITES and not USE_HF_IMAGE_PROVIDER:
+    if not is_background and not USE_PRIMARY_IMAGE_MODEL and not USE_DIFFUSION_FOR_SPRITES and not USE_HF_IMAGE_PROVIDER:
         png_content = local_asset_png(spec, index, run_id)
         return (
             png_bytes_to_data_uri(png_content),
@@ -1687,6 +1809,7 @@ def generate_asset(spec: AssetSpec, index: int, run_id: int) -> tuple[str, str,
         )
     background_models_enabled = any(
         (
+            USE_PRIMARY_IMAGE_MODEL,
             USE_CONTROLNET_FOR_BACKGROUNDS,
             USE_HF_STRUCTURE_PROVIDER,
             USE_DIFFUSION_FOR_BACKGROUNDS,
@@ -1706,7 +1829,18 @@ def generate_asset(spec: AssetSpec, index: int, run_id: int) -> tuple[str, str,
     source = ""
     errors: list[str] = []
 
-    if is_background and USE_CONTROLNET_FOR_BACKGROUNDS:
+    if USE_PRIMARY_IMAGE_MODEL:
+        png_content, error = primary_diffusion_png(spec, index, run_id)
+        source = f"{PRIMARY_IMAGE_MODEL} + {PRIMARY_LORA_MODEL} on ZeroGPU"
+        if error:
+            errors.append(f"primary ZeroGPU diffusion: {error}")
+            if REQUIRE_PRIMARY_IMAGE_MODEL:
+                raise RuntimeError(
+                    "Neural image generation is required, but the primary model failed. "
+                    f"No procedural image was returned. Details: {error}"
+                )
+
+    if png_content is None and is_background and USE_CONTROLNET_FOR_BACKGROUNDS:
         png_content, error = controlnet_background_png(spec, index, run_id)
         source = f"{CONTROLNET_BASE_MODEL} + {CONTROLNET_MODEL}"
         if error:
@@ -1737,7 +1871,7 @@ def generate_asset(spec: AssetSpec, index: int, run_id: int) -> tuple[str, str,
     return (
         png_bytes_to_data_uri(png_content),
         write_gallery_image(png_content, spec.role),
-        "; ".join(errors) if source == "local procedural fallback" and errors else None,
+        "; ".join(errors) if errors and "ZeroGPU" not in source else None,
         source,
     )
 
@@ -1898,12 +2032,17 @@ def model_source_note(image_model: str) -> str:
         return "depth-controlled diffusion—stronger camera structure; still requires visual perspective review"
     if "via fal-ai" in lowered or "via replicate" in lowered:
         return "routed image-to-image refinement—preserves a layout guide but consumes account inference credit"
+    if "zerogpu" in lowered:
+        return "locally hosted neural diffusion—no per-image API credit; backgrounds are camera-guided and still require visual review"
     return "diffusion output—higher visual variety; verify subject, perspective, alpha edges, and prompt compliance"
 
 
 def model_configuration_summary() -> str:
     prompt_source = HF_PROMPT_MODEL if USE_HF_PROMPT_PROVIDER else "local prompt interpreter"
     sprite_chain = []
+    primary_source = f"{PRIMARY_IMAGE_MODEL} + {PRIMARY_LORA_MODEL} on ZeroGPU"
+    if USE_PRIMARY_IMAGE_MODEL:
+        sprite_chain.append(primary_source)
     if USE_DIFFUSION_FOR_SPRITES:
         sprite_chain.append(FREE_IMAGE_MODEL)
     if USE_HF_IMAGE_PROVIDER:
@@ -1911,6 +2050,8 @@ def model_configuration_summary() -> str:
     sprite_chain.append("shape-aware procedural renderer (no neural model)")
     sprite_source = " → ".join(sprite_chain)
     background_chain = []
+    if USE_PRIMARY_IMAGE_MODEL:
+        background_chain.append(f"camera-guided {primary_source}")
     if USE_CONTROLNET_FOR_BACKGROUNDS:
         background_chain.append(f"{CONTROLNET_BASE_MODEL} + {CONTROLNET_MODEL}")
     if USE_HF_STRUCTURE_PROVIDER:
@@ -1928,18 +2069,29 @@ def model_configuration_summary() -> str:
         remote_sources.append(HF_IMAGE_MODEL)
     remote_fallback = " → ".join(remote_sources) if remote_sources else "disabled"
     neural_models = []
+    if USE_PRIMARY_IMAGE_MODEL:
+        neural_models.append(f"{PRIMARY_IMAGE_MODEL} + {PRIMARY_LORA_MODEL}")
     if USE_DIFFUSION_FOR_SPRITES or USE_DIFFUSION_FOR_BACKGROUNDS:
         neural_models.append(FREE_IMAGE_MODEL)
     if USE_CONTROLNET_FOR_BACKGROUNDS:
         neural_models.append(f"{CONTROLNET_BASE_MODEL} + {CONTROLNET_MODEL}")
     neural_models.extend(remote_sources)
     neural_status = ", ".join(dict.fromkeys(neural_models)) if neural_models else "none active—procedural code only"
+    enforcement = "required; generation stops on model failure" if REQUIRE_PRIMARY_IMAGE_MODEL else "development fallback allowed"
+    if PRIMARY_MODEL_ERROR:
+        readiness = f"startup error: {PRIMARY_MODEL_ERROR}"
+    elif PRIMARY_TEXT_PIPE is not None:
+        readiness = "loaded on ZeroGPU"
+    else:
+        readiness = "loads in the deployed ZeroGPU runtime"
     return (
         "**Configured model pipeline:** "
         f"prompts: `{prompt_source}` · sprites: `{sprite_source}` · backgrounds: `{background_source}` · "
-        f"remote image fallback: `{remote_fallback}` · neural image models: `{neural_status}`. "
-        "Every background carries an explicit camera contract. The free procedural path enforces that contract "
-        "deterministically; model-based refinements are more varied and still require visual perspective review."
+        f"remote image fallback: `{remote_fallback}` · neural image models: `{neural_status}` · "
+        f"neural enforcement: `{enforcement}` · primary readiness: `{readiness}`. "
+        "Every production image is generated by the primary neural model. Backgrounds start from a deterministic "
+        "camera guide and are refined with image-to-image diffusion; the procedural renderer remains an emergency "
+        "development fallback and is blocked in the deployed Space when the primary model fails."
     )
 
 
@@ -2015,6 +2167,7 @@ def empty_generation_result(message: str, html_code: str = ""):
     )
 
 
+@gpu_task(duration=120)
 def generate_images_and_game(
     html_code: str,
     roles: str,
@@ -2050,14 +2203,17 @@ def generate_images_and_game(
         errors.append(f"prompt model: {prompt_error}")
 
     for index, spec in enumerate(specs):
-        data_uri, gallery_path, error, image_model = generate_asset(spec, index, run_id)
+        try:
+            data_uri, gallery_path, error, image_model = generate_asset(spec, index, run_id)
+        except RuntimeError as exc:
+            return empty_generation_result(str(exc), html_code)
         assets[spec.role] = data_uri
         gallery_paths[spec.role] = gallery_path
         image_models[spec.role] = image_model
         png_content = base64.b64decode(data_uri.split(",", 1)[1])
         quality[spec.role] = validate_asset_png(png_content, spec)
         if error:
-            errors.append(f"{spec.role}: image model failed ({error}); used local procedural fallback")
+            errors.append(f"{spec.role}: generation fallback used ({error}); actual source: {image_model}")
 
     state = {
         "html_code": html_code,
@@ -2079,6 +2235,7 @@ def generate_images_and_game(
     )
 
 
+@gpu_task(duration=90)
 def regenerate_selected_asset(state: dict, selected_role: str, approved_roles: list[str]):
     if not state or not selected_role:
         return (
@@ -2101,7 +2258,16 @@ def regenerate_selected_asset(state: dict, selected_role: str, approved_roles: l
 
     spec = specs[index]
     run_id = time.time_ns()
-    data_uri, gallery_path, error, image_model = generate_asset(spec, index, run_id)
+    try:
+        data_uri, gallery_path, error, image_model = generate_asset(spec, index, run_id)
+    except RuntimeError as exc:
+        rendered = render_generation_state(state, "Kept", [str(exc)])
+        roles = [item.role for item in specs]
+        return (
+            *rendered,
+            state,
+            gr.CheckboxGroup(choices=roles, value=approved_roles or []),
+        )
     state["assets"][selected_role] = data_uri
     state["gallery_paths"][selected_role] = gallery_path
     state["image_models"][selected_role] = image_model