@@ -605,7 +605,7 @@ turns 1 / 2 / 3 m into 7 / 17 / 27 treads. Asserts readback and evaluated Z-exte
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/gn-zone-iterate/"><img src="examples/gn-zone-iterate/preview.webp" alt="GN zone iterate: four brass cubes in a row (Repeat Zone) beside a tower of six teal cubes (For Each Element) on a dark studio floor, proving pair_with_output actually iterates" /></a>
+<a href="examples/gn-zone-iterate/"><img src="examples/gn-zone-iterate/preview.webp" alt="GN zone iterate: four amber-to-red blocks on a walnut plinth (Repeat Zone) beside a spindle of six teal-to-mint blocks (For Each Element) on a dark studio floor, proving pair_with_output actually iterates" /></a>
 </td>
 <td valign="middle">
 
 
@@ -658,7 +658,7 @@
       "name": "gn-zone-iterate",
       "dir": "examples/gn-zone-iterate",
       "teaches": "Repeat Zone and For Each Element only iterate after pair_with_output. Evaluated cube counts follow 8 times (1+N) and 8 times P, not tree structure.",
-      "alt": "Four brass cubes evenly spaced in a row from a Repeat zone beside a vertical stack of six cyan cubes from a For Each zone.",
+      "alt": "Four chamfered blocks graded amber to red, evenly spaced on a walnut plinth by a Repeat zone, beside six teal-to-mint blocks threaded on a steel spindle by a For Each zone.",
       "witnessesFix": "Repeat 32/24 verts/faces with X-centers at k*1.2; For Each 48/36 with Z-centers at i*0.6+0.21. Unpaired evaluates empty; For Each main Geometry passthrough is 6 verts.",
       "hero": "docs/gallery/assets/gn-zone-iterate-hero.webp",
       "preview": "examples/gn-zone-iterate/preview.webp",
 
@@ -41,6 +41,15 @@ blender --background --python gn_zone_iterate.py -- --output zones.png
 The `--output` render path measures framing via `examples/gallery_framing.py`
 (exit 10 on violation).
 
+**Staging.** Everything presentational runs after `check()` has passed on the raw
+evaluated zones. Each zone's blocks are graded along the axis the zone iterates on,
+using Object-space coordinates (amber to red along X for the four Repeat blocks, deep
+teal to mint along Z for the six For Each blocks), so the colour steps count the
+iterations. A render-only Bevel modifier after the GN modifier chamfers the cubes into
+machined blocks. The Repeat row sits on a walnut plinth; the For Each tower is threaded
+on a steel spindle over a round walnut base, so its 0.18 m gaps read as spacing on a
+rod rather than floating cubes.
+
 ## Exit codes
 
 Per-script sequential checks. `9` is a valid check code; there is no rule
 
@@ -356,26 +356,105 @@ def light(name, loc, energy, size, col, rot):
     # Rim from behind so the cube silhouettes separate from the dark wall.
     light("Rim", (-1.0, 4.5, 4.5), 260.0, 4.0, (0.70, 0.82, 1.0), (-50, 0, 180))
 
-    # Presentation only: the check never reads materials. 0.85 metallic in a
-    # near-black world reflected near-black, and the brass read as mustard
-    # card. Less metal and a warmer, brighter base let the key shape it.
-    for ob, rough, metal in ((rpt, 0.42, 0.55), (fee, 0.38, 0.10)):
+    # Presentation only — everything below runs after check() has passed on
+    # the raw evaluated zones. Each zone's blocks are graded along the axis the
+    # zone iterates on (Object-space X for Repeat, Z for For Each), so the
+    # colour steps count the iterations; a small render-only bevel after the
+    # GN modifier turns the cubes into machined blocks.
+    grades = {
+        rpt: ("X", REPEAT_N * REPEAT_STEP,
+              ((0.95, 0.55, 0.10), (0.62, 0.07, 0.04)), 0.30, 0.0),
+        fee: ("Z", (FOREACH_P - 1) * FOREACH_STEP + FOREACH_SIZE,
+              ((0.02, 0.30, 0.36), (0.30, 0.85, 0.72)), 0.28, 0.0),
+    }
+    for ob, (axis, span, (c0, c1), rough, metal) in grades.items():
         for mat in _node_materials(ob):
-            bsdf = mat.node_tree.nodes.get("Principled BSDF")
-            if bsdf is not None:
-                bsdf.inputs["Metallic"].default_value = metal
-                bsdf.inputs["Roughness"].default_value = rough
+            nt = mat.node_tree
+            bsdf = nt.nodes.get("Principled BSDF")
+            bsdf.inputs["Metallic"].default_value = metal
+            bsdf.inputs["Roughness"].default_value = rough
+            if "Coat Weight" in bsdf.inputs:
+                bsdf.inputs["Coat Weight"].default_value = 0.5
+            coord = nt.nodes.new("ShaderNodeTexCoord")
+            sep = nt.nodes.new("ShaderNodeSeparateXYZ")
+            nt.links.new(coord.outputs["Object"], sep.inputs["Vector"])
+            norm = nt.nodes.new("ShaderNodeMapRange")
+            norm.inputs["From Min"].default_value = 0.0
+            norm.inputs["From Max"].default_value = span
+            nt.links.new(sep.outputs[axis], norm.inputs["Value"])
+            ramp = nt.nodes.new("ShaderNodeValToRGB")
+            ramp.color_ramp.elements[0].color = (*c0, 1.0)
+            ramp.color_ramp.elements[1].color = (*c1, 1.0)
+            nt.links.new(norm.outputs["Result"], ramp.inputs["Fac"])
+            nt.links.new(ramp.outputs["Color"], bsdf.inputs["Base Color"])
+        bev = ob.modifiers.new("Chamfer", "BEVEL")
+        bev.width = 0.035
+        bev.segments = 3
+        bev.limit_method = "NONE"
+
+    walnut = principled("Walnut", (0.19, 0.09, 0.045, 1.0), 0.0, 0.5)
+    steel = principled("Steel", (0.55, 0.56, 0.58, 1.0), 1.0, 0.3)
+    brass = principled("Finial", (0.88, 0.62, 0.26, 1.0), 1.0, 0.28)
+
+    def solid(name, build, mat, loc):
+        me = bpy.data.meshes.new(name)
+        bm = bmesh.new()
+        try:
+            build(bm)
+            for f in bm.faces:
+                f.smooth = True
+            bm.to_mesh(me)
+        finally:
+            bm.free()
+        me.materials.append(mat)
+        ob = bpy.data.objects.new(name, me)
+        ob.location = loc
+        scene.collection.objects.link(ob)
+        return ob
+
+    def box(sx, sy, sz):
+        def b(bm):
+            bmesh.ops.create_cube(bm, size=1.0)
+            bmesh.ops.scale(bm, vec=(sx, sy, sz), verts=bm.verts)
+            bmesh.ops.bevel(bm, geom=list(bm.edges), offset=0.025, segments=3,
+                            profile=0.5, affect="EDGES", clamp_overlap=True)
+        return b
+
+    def cyl(r, h, segs=48):
+        def b(bm):
+            bmesh.ops.create_cone(bm, cap_ends=True, segments=segs, radius1=r, radius2=r, depth=h)
+        return b
+
+    # Stands: the blocks are lifted onto them (render only, after the check).
+    base_h = 0.14
+    for ob in (rpt, fee):
+        ob.location.z = base_h
+    x0 = rpt.location.x - REPEAT_SIZE / 2 - 0.25
+    x1 = rpt.location.x + REPEAT_N * REPEAT_STEP + REPEAT_SIZE / 2 + 0.25
+    row_base = solid("RowPlinth", box(x1 - x0, 1.0, base_h), walnut,
+                     ((x0 + x1) / 2, 0.0, base_h / 2))
+    tower_top = base_h + (FOREACH_P - 1) * FOREACH_STEP + FOREACH_SIZE
+    tower_base = solid("TowerBase", cyl(0.52, base_h), walnut,
+                       (fee.location.x, 0.0, base_h / 2))
+    # a steel spindle threads the For Each blocks, so the gaps between them
+    # read as spacing on a rod, not blocks floating
+    spindle = solid("Spindle", cyl(0.045, tower_top - base_h + 0.18, 24), steel,
+                    (fee.location.x, 0.0, base_h + (tower_top - base_h + 0.18) / 2))
+    finial = solid("Finial", lambda bm: bmesh.ops.create_uvsphere(
+        bm, u_segments=24, v_segments=12, radius=0.09), brass,
+        (fee.location.x, 0.0, tower_top + 0.2))
+    props = [row_base, tower_base, spindle, finial]
 
     # Centred on the pair and more frontal: from (6.6, -9.3) the repeat row
     # foreshortened into a diagonal and the tower hugged the right edge.
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (-0.10, 0.0, 1.62)
+    aim.location = (-0.10, 0.0, 1.85)
     aim.hide_render = True
     scene.collection.objects.link(aim)
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 50.0
+    cam_data.lens = 56.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (2.7, -10.6, 3.1)
+    cam.location = (1.4, -11.8, 3.6)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new("TRACK_TO")
@@ -398,8 +477,9 @@ def light(name, loc, energy, size, col, rot):
     scene.view_settings.view_transform = "Standard"
 
     hero = [rpt, fee]
+    bpy.context.view_layer.update()
     fcode = gallery_framing.check_framing(
-        scene, cam, hero=hero, elements=hero, stage=[floor, wall],
+        scene, cam, hero=hero, elements=hero + props, stage=[floor, wall],
     )
     if fcode:
         return fcode