Sprint 1: ExtrudeNode type — star, heart, hexagon, badge, shield

scene.py:
- Add EXTRUDE_SHAPES enum set {"star","heart","hexagon","badge","shield"}
- Add ExtrudeNode Pydantic model: type discriminator, shape (validated + fallback
to badge), depth (clamped 0.02-2.0), bevel bool, full material/position fields
- Update _parse_scene_item to route type:"extrude" dicts to ExtrudeNode
- Extend Scene.objects union to include ExtrudeNode

compiler.py:
- SHAPE_LIBRARY: 5 path functions (_shp_star/_shp_heart/_shp_hexagon/_shp_badge/
_shp_shield) returning JS lines; all paths in unit-scale space (~2-unit max extent)
so bevel values (0.03) and depth are scale-consistent across shapes
- extrude_js(): emits a self-contained JS block scope with THREE.ExtrudeGeometry
(explicit: depth/bevelEnabled/bevelThickness 0.03/bevelSize 0.03/bevelSegments 3/
curveSegments 12/steps 1), geometry.center(), computeBoundingBox + uniform scale
to 1.5-unit max dimension so heart and star render at comparable sizes
- _flatten / _node_axis_size updated for ExtrudeNode (treated as 1.5-unit leaf)
- objects_js dispatches to extrude_js for ExtrudeNode, existing Obj path unchanged

llm.py:
- SYSTEM extended with extrude schema and usage hint
- Two new FEWSHOT examples: "a gold star badge" → extrude star (gold, high metalness),
"a shield emblem" → extrude shield (blue)

compiler.py

@@ -7,9 +7,10 @@ and the "copy code" tab, so what the user sees is exactly what they copy.
 from __future__ import annotations
 
 import base64
-from typing import Any
+from typing import Any, Dict
 
-from scene import Animation, LayoutGrid, LayoutRow, LayoutStack, Obj, Scene, _shape_extent
+from scene import (Animation, ExtrudeNode, LayoutGrid, LayoutRow, LayoutStack,
+                   Obj, Scene, _shape_extent)
 
 
 def _col_str(color: str) -> str:
@@ -91,17 +92,20 @@ def material_js(o: Obj, style: str = "realistic") -> str:
 
 def objects_js(scene: Scene, style: str = "realistic") -> str:
     lines = []
-    for i, o in enumerate(_flatten(scene.objects)):
-        px, py, pz = o.position
-        rx, ry, rz = o.rotation
-        sx, sy, sz = o.scale
-        lines += [
-            f"const mesh{i} = new THREE.Mesh({geometry_js(o)}, {material_js(o, style)});",
-            f"mesh{i}.position.set({px}, {py}, {pz});",
-            f"mesh{i}.rotation.set({rx}, {ry}, {rz});",
-            f"mesh{i}.scale.set({sx}, {sy}, {sz});",
-            f"group.add(mesh{i});",
-        ]
+    for i, node in enumerate(_flatten(scene.objects)):
+        if isinstance(node, ExtrudeNode):
+            lines.extend(extrude_js(node, i, style))
+        else:
+            px, py, pz = node.position
+            rx, ry, rz = node.rotation
+            sx, sy, sz = node.scale
+            lines += [
+                f"const mesh{i} = new THREE.Mesh({geometry_js(node)}, {material_js(node, style)});",
+                f"mesh{i}.position.set({px}, {py}, {pz});",
+                f"mesh{i}.rotation.set({rx}, {ry}, {rz});",
+                f"mesh{i}.scale.set({sx}, {sy}, {sz});",
+                f"group.add(mesh{i});",
+            ]
     return "\n      ".join(lines)
 
 
@@ -210,12 +214,137 @@ def animation_js(a: Animation) -> str:
     return ""
 
 
+# ---- Extrude shape-path library ----
+# Each function returns a list of JS lines that build `const _shp = new THREE.Shape(); ...`
+# All paths are defined in a unit-scale coordinate space (max extent ~2 units) so that
+# bevel values (0.03) and depth (node.depth) are scale-consistent across all shapes.
+# geometry.center() + uniform scale to 1.5 normalise every shape to the same apparent size.
+
+def _shp_star() -> list:
+    return [
+        "const _shp = new THREE.Shape();",
+        "const _outerR = 1.0, _innerR = 0.4, _pts = 5;",
+        "for (let _i = 0; _i < _pts * 2; _i++) {",
+        "  const _r = _i % 2 === 0 ? _outerR : _innerR;",
+        "  const _a = (_i / (_pts * 2)) * Math.PI * 2 - Math.PI / 2;",
+        "  _shp[_i === 0 ? 'moveTo' : 'lineTo'](Math.cos(_a) * _r, Math.sin(_a) * _r);",
+        "}",
+        "_shp.closePath();",
+    ]
+
+
+def _shp_heart() -> list:
+    # Original Three.js docs heart path scaled by 1/50 → fits in ~[-0.6,1.6] × [0,1.9]
+    return [
+        "const _shp = new THREE.Shape();",
+        "_shp.moveTo(0.5, 0.5);",
+        "_shp.bezierCurveTo(0.5, 0.5, 0.4, 0, 0, 0);",
+        "_shp.bezierCurveTo(-0.6, 0, -0.6, 0.7, -0.6, 0.7);",
+        "_shp.bezierCurveTo(-0.6, 1.1, -0.2, 1.54, 0.5, 1.9);",
+        "_shp.bezierCurveTo(1.2, 1.54, 1.6, 1.1, 1.6, 0.7);",
+        "_shp.bezierCurveTo(1.6, 0.7, 1.6, 0, 1.0, 0);",
+        "_shp.bezierCurveTo(0.7, 0, 0.5, 0.5, 0.5, 0.5);",
+    ]
+
+
+def _shp_hexagon() -> list:
+    return [
+        "const _shp = new THREE.Shape();",
+        "for (let _i = 0; _i < 6; _i++) {",
+        "  const _a = (Math.PI / 3) * _i + Math.PI / 6;",  # flat-top orientation
+        "  _shp[_i === 0 ? 'moveTo' : 'lineTo'](Math.cos(_a), Math.sin(_a));",
+        "}",
+        "_shp.closePath();",
+    ]
+
+
+def _shp_badge() -> list:
+    # Rounded rectangle — w=1.6, h=1.0, corner radius=0.25
+    return [
+        "const _shp = new THREE.Shape();",
+        "const _bw = 1.6, _bh = 1.0, _br = 0.25;",
+        "const _bx = -_bw / 2, _by = -_bh / 2;",
+        "_shp.moveTo(_bx, _by + _br);",
+        "_shp.lineTo(_bx, _by + _bh - _br);",
+        "_shp.quadraticCurveTo(_bx, _by + _bh, _bx + _br, _by + _bh);",
+        "_shp.lineTo(_bx + _bw - _br, _by + _bh);",
+        "_shp.quadraticCurveTo(_bx + _bw, _by + _bh, _bx + _bw, _by + _bh - _br);",
+        "_shp.lineTo(_bx + _bw, _by + _br);",
+        "_shp.quadraticCurveTo(_bx + _bw, _by, _bx + _bw - _br, _by);",
+        "_shp.lineTo(_bx + _br, _by);",
+        "_shp.quadraticCurveTo(_bx, _by, _bx, _by + _br);",
+    ]
+
+
+def _shp_shield() -> list:
+    # Heraldic heater shield: flat top, two curved sides, tapers to bottom point
+    # x ∈ [-1, 1], y ∈ [-1.3, 1.0]
+    return [
+        "const _shp = new THREE.Shape();",
+        "_shp.moveTo(-1.0, 1.0);",
+        "_shp.lineTo( 1.0, 1.0);",
+        "_shp.lineTo( 1.0, 0.2);",
+        "_shp.quadraticCurveTo( 1.0, -0.8,  0.0, -1.3);",
+        "_shp.quadraticCurveTo(-1.0, -0.8, -1.0,  0.2);",
+        "_shp.lineTo(-1.0, 1.0);",
+    ]
+
+
+SHAPE_LIBRARY: Dict[str, Any] = {
+    "star":    _shp_star,
+    "heart":   _shp_heart,
+    "hexagon": _shp_hexagon,
+    "badge":   _shp_badge,
+    "shield":  _shp_shield,
+}
+
+
+def extrude_js(node: ExtrudeNode, idx: int, style: str = "realistic") -> list:
+    """Return JS lines for one extruded shape mesh, self-contained in a block scope."""
+    shape_fn = SHAPE_LIBRARY.get(node.shape, _shp_badge)
+    # Duck-type: ExtrudeNode has the same material fields as Obj
+    mat = material_js(node, style)  # type: ignore[arg-type]
+    bevel = "true" if node.bevel else "false"
+    depth = node.depth
+    px, py, pz = node.position
+    rx, ry, rz = node.rotation
+    sx, sy, sz = node.scale
+
+    lines = ["{  // extrude: " + node.shape]
+    lines.extend("  " + l for l in shape_fn())
+    lines += [
+        f"  const _geo = new THREE.ExtrudeGeometry(_shp, {{",
+        f"    depth: {depth}, bevelEnabled: {bevel},",
+        f"    bevelThickness: 0.03, bevelSize: 0.03, bevelSegments: 3,",
+        f"    curveSegments: 12, steps: 1",
+        f"  }});",
+        f"  _geo.center();",
+        f"  _geo.computeBoundingBox();",
+        f"  const _mxdim = Math.max(",
+        f"    _geo.boundingBox.max.x - _geo.boundingBox.min.x,",
+        f"    _geo.boundingBox.max.y - _geo.boundingBox.min.y,",
+        f"    _geo.boundingBox.max.z - _geo.boundingBox.min.z",
+        f"  ) || 1;",
+        f"  const _nsc = 1.5 / _mxdim;",
+        f"  _geo.scale(_nsc, _nsc, _nsc);",
+        f"  const mesh{idx} = new THREE.Mesh(_geo, {mat});",
+        f"  mesh{idx}.position.set({px}, {py}, {pz});",
+        f"  mesh{idx}.rotation.set({rx}, {ry}, {rz});",
+        f"  mesh{idx}.scale.set({sx}, {sy}, {sz});",
+        f"  group.add(mesh{idx});",
+        "}",
+    ]
+    return lines
+
+
 # ---- Layout resolver: flattens containers into positioned Obj list ----
 
 def _node_axis_size(node: Any, axis: int) -> float:
     """Estimate the bounding-box size of a node along one axis (0=x,1=y,2=z)."""
     if isinstance(node, Obj):
         return _shape_extent(node.shape, node.params)[axis]
+    if isinstance(node, ExtrudeNode):
+        return 1.5  # normalised to 1.5-unit max dimension at render time
     if isinstance(node, LayoutStack):
         ai = {"x": 0, "y": 1, "z": 2}.get(node.axis, 1)
         sizes = [_node_axis_size(c, ai) for c in node.children]
@@ -224,10 +353,10 @@ def _node_axis_size(node: Any, axis: int) -> float:
 
 
 def _flatten(items: list, ox: float = 0.0, oy: float = 0.0, oz: float = 0.0) -> list:
-    """Recursively resolve layout containers into a flat list of positioned Obj."""
+    """Recursively resolve layout containers into a flat list of positioned leaf nodes."""
     result = []
     for item in items:
-        if isinstance(item, Obj):
+        if isinstance(item, (Obj, ExtrudeNode)):
             result.append(item.model_copy(update={
                 "position": [item.position[0] + ox,
                              item.position[1] + oy,

llm.py

@@ -24,21 +24,21 @@ log = logging.getLogger(__name__)
 SYSTEM = """You convert a short scene description into a JSON scene graph for a 3D renderer.
 Output ONLY valid JSON. No markdown, no comments, no prose, no code fences.
 
-Schema:
+Schema — primitive object:
 {
   "background": "#RRGGBB",
   "objects": [
     {
       "shape": "box|sphere|cylinder|cone|torus|torusKnot|plane|tetrahedron|icosahedron|dodecahedron|octahedron|capsule|ring|circle|tube|roundedBox",
       "position": [x, y, z],
-      "rotation": [x, y, z],          // radians, optional
-      "scale": [x, y, z],             // optional
+      "rotation": [x, y, z],
+      "scale": [x, y, z],
       "color": "#RRGGBB",
       "material": "standard|basic|phong|wireframe",
-      "metalness": 0.0-1.0,           // optional
-      "roughness": 0.0-1.0,           // optional
-      "emissive": "#RRGGBB",          // optional
-      "params": { }                   // shape sizes, e.g. {"radius":0.6,"tube":0.2}
+      "metalness": 0.0-1.0,
+      "roughness": 0.0-1.0,
+      "emissive": "#RRGGBB",
+      "params": {}
     }
   ],
   "lights": [
@@ -47,6 +47,20 @@ Schema:
   "animation": {"type": "none|rotate|float|orbit", "speed": 1.0, "axis": "x|y|z"}
 }
 
+For stars, badges, shields, hearts, hexagons, coins, logos, or emblems use an EXTRUDE object instead:
+{
+  "type": "extrude",
+  "shape": "star|heart|hexagon|badge|shield",
+  "depth": 0.2,
+  "bevel": true,
+  "color": "#RRGGBB",
+  "material": "standard",
+  "metalness": 0.0-1.0,
+  "roughness": 0.0-1.0,
+  "emissive": "#RRGGBB",
+  "position": [x, y, z]
+}
+
 Keep scenes small (1-4 objects). Center the composition near the origin."""
 
 FEWSHOT = [
@@ -167,6 +181,36 @@ FEWSHOT = [
         ],
         "animation": {"type": "rotate", "speed": 0.8, "axis": "y"},
     })},
+    {"role": "user", "content": "a gold star badge"},
+    {"role": "assistant", "content": json.dumps({
+        "background": "#1a1205",
+        "objects": [{
+            "type": "extrude", "shape": "star", "depth": 0.3, "bevel": True,
+            "color": "#ffd700", "material": "standard",
+            "metalness": 0.9, "roughness": 0.2, "emissive": "#332200",
+            "position": [0, 0, 0],
+        }],
+        "lights": [
+            {"type": "ambient", "intensity": 0.3},
+            {"type": "directional", "color": "#fff8e0", "intensity": 2.0, "position": [3, 5, 4]},
+        ],
+        "animation": {"type": "rotate", "speed": 0.6, "axis": "y"},
+    })},
+    {"role": "user", "content": "a shield emblem"},
+    {"role": "assistant", "content": json.dumps({
+        "background": "#0d1117",
+        "objects": [{
+            "type": "extrude", "shape": "shield", "depth": 0.25, "bevel": True,
+            "color": "#3a6bc4", "material": "standard",
+            "metalness": 0.5, "roughness": 0.3, "emissive": "#061833",
+            "position": [0, 0, 0],
+        }],
+        "lights": [
+            {"type": "ambient", "intensity": 0.4},
+            {"type": "directional", "color": "#ffffff", "intensity": 1.8, "position": [4, 6, 3]},
+        ],
+        "animation": {"type": "rotate", "speed": 0.5, "axis": "y"},
+    })},
 ]
 
 _tok = None

scene.py

@@ -21,6 +21,7 @@ SHAPES = {
     "tetrahedron", "icosahedron", "dodecahedron", "octahedron",
     "capsule", "ring", "circle", "tube", "roundedBox",
 }
+EXTRUDE_SHAPES = {"star", "heart", "hexagon", "badge", "shield"}
 MATERIALS = {"standard", "basic", "phong", "wireframe"}
 LIGHT_TYPES = {"ambient", "directional", "point"}
 ANIM_TYPES = {"none", "rotate", "float", "orbit"}
@@ -355,9 +356,73 @@ class LayoutGrid(BaseModel):
         return [_parse_scene_item(c) for c in v] if isinstance(v, list) else []
 
 
+class ExtrudeNode(BaseModel):
+    """A 2-D shape path extruded into 3-D with a bevel."""
+    type: Literal["extrude"] = "extrude"
+    shape: str = "badge"
+    depth: float = 0.2
+    bevel: bool = True
+    color: str = "#88ccff"
+    material: str = "standard"
+    metalness: float = 0.3
+    roughness: float = 0.4
+    emissive: str = "#000000"
+    position: List[float] = Field(default_factory=lambda: [0.0, 0.0, 0.0])
+    rotation: List[float] = Field(default_factory=lambda: [0.0, 0.0, 0.0])
+    scale: List[float] = Field(default_factory=lambda: [1.0, 1.0, 1.0])
+
+    @field_validator("shape")
+    @classmethod
+    def _shape(cls, v: Any) -> str:
+        v = str(v).lower()
+        return v if v in EXTRUDE_SHAPES else "badge"
+
+    @field_validator("depth")
+    @classmethod
+    def _depth(cls, v: Any) -> float:
+        try:
+            return _clamp(float(v), 0.02, 2.0)
+        except Exception:
+            return 0.2
+
+    @field_validator("color", "emissive")
+    @classmethod
+    def _hex(cls, v: Any, info) -> str:
+        default = "#88ccff" if info.field_name == "color" else "#000000"
+        return _sanitize_color(str(v), default)
+
+    @field_validator("material")
+    @classmethod
+    def _material(cls, v: Any) -> str:
+        v = str(v)
+        return v if v in MATERIALS else "standard"
+
+    @field_validator("metalness", "roughness")
+    @classmethod
+    def _unit(cls, v: Any) -> float:
+        try:
+            return _clamp(float(v), 0.0, 1.0)
+        except Exception:
+            return 0.4
+
+    @field_validator("position", "rotation", "scale")
+    @classmethod
+    def _vec3(cls, v: Any, info) -> List[float]:
+        fill = 1.0 if info.field_name == "scale" else 0.0
+        out: List[float] = []
+        try:
+            for x in list(v)[:3]:
+                out.append(float(x))
+        except Exception:
+            out = []
+        while len(out) < 3:
+            out.append(fill)
+        return out
+
+
 def _parse_scene_item(v: Any) -> Any:
     """Parse a dict (or existing model) into the correct scene node type."""
-    if isinstance(v, (Obj, LayoutStack, LayoutRow, LayoutGrid)):
+    if isinstance(v, (Obj, LayoutStack, LayoutRow, LayoutGrid, ExtrudeNode)):
         return v
     if not isinstance(v, dict):
         return Obj()
@@ -369,6 +434,8 @@ def _parse_scene_item(v: Any) -> Any:
             return LayoutRow(**v)
         if t == "grid":
             return LayoutGrid(**v)
+        if t == "extrude":
+            return ExtrudeNode(**v)
         return Obj(**v)
     except Exception:
         return Obj()
@@ -431,7 +498,7 @@ TEMPLATES: Dict[str, Any] = {
 
 class Scene(BaseModel):
     background: str = "#0b0e14"
-    objects: List[Union[Obj, LayoutStack, LayoutRow, LayoutGrid]] = Field(default_factory=list)
+    objects: List[Union[Obj, LayoutStack, LayoutRow, LayoutGrid, ExtrudeNode]] = Field(default_factory=list)
     lights: List[Light] = Field(default_factory=list)
     animation: Animation = Field(default_factory=Animation)