Four targeted fixes: color pass-through, re-render on style/motion, auto-reroll, nested-spheres template

- scene.py: replace strict hex-only validator with _sanitize_color() — accepts CSS
named colors (red, blue, forestgreen, …), synonym map (electric blue→#7df9ff,
neon→#39ff14), rgb()/hsl(), and 3/4/8-digit hex; falls back to default on unknown
- scene.py: add _template_nested_spheres (outer blue wireframe r=0.8, inner red r=0.45)
- compiler.py: emit new THREE.Color("value") instead of 0xRRGGBB so CSS names render
- app.py: gr.State caches last Scene; style/motion/glow changes call lightweight
rerender() with no LLM invocation
- app.py: auto-reroll once on bad JSON before falling back to mock
- app.py: prompts matching "sphere inside" / "nested sphere" route to template

app.py

@@ -15,7 +15,7 @@ import gradio as gr
 
 from compiler import compile_html, iframe
 from llm import MAX_PROMPT_CHARS, mock_scene_json, run_llm
-from scene import build_scene, extract_json
+from scene import TEMPLATES, build_scene, extract_json
 
 logging.basicConfig(
     level=logging.INFO,
@@ -51,34 +51,81 @@ EXAMPLES = [
 ]
 
 
+_NESTED_SPHERE_PATTERNS = ("wireframe sphere inside", "sphere inside", "nested sphere")
+
+
 def generate(prompt: str, glow: bool, glow_strength: float, style: str, motion: str):
     prompt = (prompt or "").strip()
     if not prompt:
-        return gr.update(), gr.update(), gr.update(), "Type a prompt first."
+        return gr.update(), gr.update(), gr.update(), "Type a prompt first.", None
     if len(prompt) > MAX_PROMPT_CHARS:
-        return gr.update(), gr.update(), gr.update(), f"Prompt too long — keep it under {MAX_PROMPT_CHARS} chars."
-
-    try:
-        raw = mock_scene_json(prompt) if os.environ.get("MOCK") else _generate_json(prompt)
-        note = "Rendered."
-    except Exception as e:
-        log.error("LLM error, falling back to mock: %s", e, exc_info=True)
-        raw = mock_scene_json(prompt)
-        note = f"Fallback ({type(e).__name__})."
+        return gr.update(), gr.update(), gr.update(), f"Prompt too long — keep it under {MAX_PROMPT_CHARS} chars.", None
+
+    lo = prompt.lower()
+
+    # Fix 4: route nested-sphere prompts to the hardcoded template
+    if any(pat in lo for pat in _NESTED_SPHERE_PATTERNS):
+        from scene import Light, Animation
+        scene = build_scene({
+            "background": "#0b0e14",
+            "objects": [o.model_dump() for o in TEMPLATES["nested_spheres"]({})],
+            "lights": [
+                {"type": "ambient", "intensity": 0.5},
+                {"type": "directional", "intensity": 1.3, "position": [5, 8, 6]},
+            ],
+            "animation": {"type": "rotate", "speed": 0.8, "axis": "y"},
+        })
+        note = "Template (nested spheres)."
+    else:
+        # Fix 3: generate, then reroll once if the output is unparseable
+        try:
+            if os.environ.get("MOCK"):
+                raw = mock_scene_json(prompt)
+            else:
+                raw = _generate_json(prompt)
+                if extract_json(raw) is None:
+                    log.warning("Bad JSON on first attempt — retrying")
+                    raw = _generate_json(prompt)
+            note = "Rendered."
+        except Exception as e:
+            log.error("LLM error, falling back to mock: %s", e, exc_info=True)
+            raw = mock_scene_json(prompt)
+            note = f"Fallback ({type(e).__name__})."
+
+        parsed = extract_json(raw)
+        if parsed is None:
+            log.warning("Both LLM attempts returned bad JSON — using mock")
+            raw = mock_scene_json(prompt)
+            note = "Fallback (bad JSON)."
+            parsed = extract_json(raw)
+
+        scene = build_scene(parsed)
 
-    scene = build_scene(extract_json(raw))
     if motion != "auto":
         scene.animation.type = motion
     html = compile_html(scene, glow=glow, glow_strength=glow_strength, style=style)
     pretty = json.dumps(scene.model_dump(), indent=2)
-    return iframe(html), html, pretty, note
+    return iframe(html), html, pretty, note, scene
+
+
+# Fix 2: lightweight recompile from cached scene (no LLM call)
+def rerender(scene, glow: bool, glow_strength: float, style: str, motion: str):
+    if scene is None:
+        return gr.update(), gr.update(), "Generate a scene first."
+    if motion != "auto":
+        s = scene.model_copy(deep=True)
+        s.animation.type = motion
+    else:
+        s = scene
+    html = compile_html(s, glow=glow, glow_strength=glow_strength, style=style)
+    return iframe(html), html, "Re-rendered."
 
 
 def _initial():
     raw = mock_scene_json("a glass torus knot floating in the dark")
     scene = build_scene(extract_json(raw))
     html = compile_html(scene)
-    return iframe(html), html, json.dumps(scene.model_dump(), indent=2), "Demo scene."
+    return iframe(html), html, json.dumps(scene.model_dump(), indent=2), "Demo scene.", scene
 
 
 _LOGO = os.path.exists("logo.png")
@@ -126,10 +173,20 @@ with gr.Blocks(title="ThreeGen", theme=gr.themes.Soft()) as demo:
     with gr.Accordion("Scene JSON (raw model output)", open=False):
         scene_json = gr.Code(language="json", label="scene graph")
 
-    outputs = [preview, code, scene_json, status]
-    btn.click(generate, [prompt, glow, glow_strength, style, motion], outputs)
-    prompt.submit(generate, [prompt, glow, glow_strength, style, motion], outputs)
-    demo.load(_initial, None, outputs)
+    scene_state = gr.State(None)
+
+    gen_inputs = [prompt, glow, glow_strength, style, motion]
+    gen_outputs = [preview, code, scene_json, status, scene_state]
+    btn.click(generate, gen_inputs, gen_outputs)
+    prompt.submit(generate, gen_inputs, gen_outputs)
+    demo.load(_initial, None, gen_outputs)
+
+    re_inputs = [scene_state, glow, glow_strength, style, motion]
+    re_outputs = [preview, code, status]
+    style.change(rerender, re_inputs, re_outputs)
+    motion.change(rerender, re_inputs, re_outputs)
+    glow.change(rerender, re_inputs, re_outputs)
+    glow_strength.change(rerender, re_inputs, re_outputs)
 
 
 if __name__ == "__main__":

compiler.py

@@ -12,8 +12,9 @@ from typing import Any
 from scene import Animation, LayoutGrid, LayoutRow, LayoutStack, Obj, Scene, _shape_extent
 
 
-def _hex0x(color: str) -> str:
-    return "0x" + color[1:]
+def _col_str(color: str) -> str:
+    """Wrap a sanitized color value for JS: 'new THREE.Color("<value>")'."""
+    return f'new THREE.Color("{color}")'
 
 
 def geometry_js(o: Obj) -> str:
@@ -68,8 +69,8 @@ def geometry_js(o: Obj) -> str:
 
 
 def material_js(o: Obj, style: str = "realistic") -> str:
-    col = _hex0x(o.color)
-    emi = _hex0x(o.emissive)
+    col = _col_str(o.color)
+    emi = _col_str(o.emissive)
     if style == "wireframe":
         return f"new THREE.MeshStandardMaterial({{ color: {col}, wireframe: true }})"
     if style == "toon":
@@ -107,7 +108,7 @@ def objects_js(scene: Scene, style: str = "realistic") -> str:
 def lights_js(scene: Scene) -> str:
     lines = []
     for l in scene.lights:
-        c = _hex0x(l.color)
+        c = f'"{l.color}"'
         x, y, z = l.position
         if l.type == "ambient":
             lines.append(f"scene.add(new THREE.AmbientLight({c}, {l.intensity}));")

scene.py

@@ -26,6 +26,74 @@ LIGHT_TYPES = {"ambient", "directional", "point"}
 ANIM_TYPES = {"none", "rotate", "float", "orbit"}
 HEX = re.compile(r"^#[0-9a-fA-F]{6}$")
 
+# ---- Color normalisation (Fix 1) ----
+
+_SYNONYMS: Dict[str, str] = {
+    "electric blue": "#7df9ff", "electricblue": "#7df9ff",
+    "neon green": "#39ff14",   "neongreen": "#39ff14",
+    "neon": "#39ff14",
+    "neon blue": "#4d4dff",    "neonblue": "#4d4dff",
+    "neon red": "#ff3131",     "neonred": "#ff3131",
+    "neon pink": "#ff6ec7",    "neonpink": "#ff6ec7",
+    "neon yellow": "#ffff00",  "neonyellow": "#ffff00",
+    "neon orange": "#ff6600",  "neonorange": "#ff6600",
+}
+
+_CSS_COLORS: frozenset = frozenset({
+    "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige",
+    "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown",
+    "burlywood", "cadetblue", "chartreuse", "chocolate", "coral",
+    "cornflowerblue", "cornsilk", "crimson", "cyan", "darkblue", "darkcyan",
+    "darkgoldenrod", "darkgray", "darkgreen", "darkgrey", "darkkhaki",
+    "darkmagenta", "darkolivegreen", "darkorange", "darkorchid", "darkred",
+    "darksalmon", "darkseagreen", "darkslateblue", "darkslategray",
+    "darkslategrey", "darkturquoise", "darkviolet", "deeppink", "deepskyblue",
+    "dimgray", "dimgrey", "dodgerblue", "firebrick", "floralwhite",
+    "forestgreen", "fuchsia", "gainsboro", "ghostwhite", "gold", "goldenrod",
+    "gray", "green", "greenyellow", "grey", "honeydew", "hotpink",
+    "indianred", "indigo", "ivory", "khaki", "lavender", "lavenderblush",
+    "lawngreen", "lemonchiffon", "lightblue", "lightcoral", "lightcyan",
+    "lightgoldenrodyellow", "lightgray", "lightgreen", "lightgrey",
+    "lightpink", "lightsalmon", "lightseagreen", "lightskyblue",
+    "lightslategray", "lightslategrey", "lightsteelblue", "lightyellow",
+    "lime", "limegreen", "linen", "magenta", "maroon", "mediumaquamarine",
+    "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen",
+    "mediumslateblue", "mediumspringgreen", "mediumturquoise",
+    "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin",
+    "navajowhite", "navy", "oldlace", "olive", "olivedrab", "orange",
+    "orangered", "orchid", "palegoldenrod", "palegreen", "paleturquoise",
+    "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum",
+    "powderblue", "purple", "red", "rosybrown", "royalblue", "saddlebrown",
+    "salmon", "sandybrown", "seagreen", "seashell", "sienna", "silver",
+    "skyblue", "slateblue", "slategray", "slategrey", "snow", "springgreen",
+    "steelblue", "tan", "teal", "thistle", "tomato", "turquoise", "violet",
+    "wheat", "white", "whitesmoke", "yellow", "yellowgreen",
+})
+
+_HEX_RE = re.compile(r"^#[0-9a-fA-F]{3,8}$")
+_RGB_HSL_RE = re.compile(
+    r"^(rgb|hsl)a?\(\s*[\d.]+%?\s*,\s*[\d.]+%?\s*,\s*[\d.]+%?\s*(?:,\s*[\d.]+)?\s*\)$"
+)
+
+
+def _sanitize_color(v: str, default: str = "#888888") -> str:
+    """Accept hex, rgb/hsl(), CSS/X11 names, and synonym map. Reject anything else."""
+    v = str(v).strip()
+    lo = v.lower()
+    if lo in _SYNONYMS:
+        return _SYNONYMS[lo]
+    collapsed = lo.replace(" ", "").replace("-", "")
+    if collapsed in _SYNONYMS:
+        return _SYNONYMS[collapsed]
+    if _HEX_RE.match(v):
+        return v
+    if _RGB_HSL_RE.match(lo):
+        return lo
+    if collapsed in _CSS_COLORS:
+        return collapsed
+    log.warning("Unknown color %r, using default %s", v, default)
+    return default
+
 
 def _clamp(v: float, lo: float, hi: float) -> float:
     return max(lo, min(hi, v))
@@ -106,10 +174,8 @@ class Obj(BaseModel):
     @field_validator("color", "emissive")
     @classmethod
     def _hex(cls, v: Any, info) -> str:
-        v = str(v)
-        if HEX.match(v):
-            return v
-        return "#88ccff" if info.field_name == "color" else "#000000"
+        default = "#88ccff" if info.field_name == "color" else "#000000"
+        return _sanitize_color(str(v), default)
 
     @field_validator("metalness", "roughness")
     @classmethod
@@ -147,8 +213,7 @@ class Light(BaseModel):
     @field_validator("color")
     @classmethod
     def _hex(cls, v: Any) -> str:
-        v = str(v)
-        return v if HEX.match(v) else "#ffffff"
+        return _sanitize_color(str(v), "#ffffff")
 
     @field_validator("intensity")
     @classmethod
@@ -345,10 +410,22 @@ def _template_tree(params: Dict[str, Any]) -> List[Obj]:
     ]
 
 
+def _template_nested_spheres(params: Dict[str, Any]) -> List[Obj]:
+    inner = params.get("color_inner", "red")
+    outer = params.get("color_outer", "blue")
+    return [
+        Obj(shape="sphere", color=outer, material="wireframe",
+            position=[0, 0, 0], params={"radius": 0.8}),
+        Obj(shape="sphere", color=inner, material="wireframe",
+            position=[0, 0, 0], params={"radius": 0.45}),
+    ]
+
+
 TEMPLATES: Dict[str, Any] = {
-    "burger":  _template_burger,
-    "snowman": _template_snowman,
-    "tree":    _template_tree,
+    "burger":         _template_burger,
+    "snowman":        _template_snowman,
+    "tree":           _template_tree,
+    "nested_spheres": _template_nested_spheres,
 }
 
 
@@ -361,8 +438,7 @@ class Scene(BaseModel):
     @field_validator("background")
     @classmethod
     def _bg(cls, v: Any) -> str:
-        v = str(v)
-        return v if HEX.match(v) else "#0b0e14"
+        return _sanitize_color(str(v), "#0b0e14")
 
     @field_validator("objects", mode="before")
     @classmethod