diff --git a/.github/workflows/blender-smoke.yml b/.github/workflows/blender-smoke.yml
index 8437253..22cb32c 100644
--- a/.github/workflows/blender-smoke.yml
+++ b/.github/workflows/blender-smoke.yml
@@ -198,9 +198,10 @@ jobs:
       - name: Shipped example - temp-override join (context override)
         run: |
           set -euo pipefail
-          # Frame-independent check only (no render): three cubes joined under
+          # Frame-independent check only (no render): three-step staircase joined under
           # bpy.context.temp_override; asserts one mesh remains, sources are gone,
-          # and topology is verts=24 faces=18. Exits non-zero on failure.
+          # topology verts=24 faces=18, and local Z spans all steps. Exits non-zero
+          # on failure.
           xvfb-run -a "$BLENDER" --background \
             --python examples/temp-override-join/temp_override_join.py --
 
@@ -208,17 +209,18 @@ jobs:
         run: |
           set -euo pipefail
           # Frame-independent check only (no render): generative GN tree instances a
-          # cube on a 3x3 grid and realizes; asserts eval verts=72 faces=54 and Set
-          # Material carries Lime. Exits non-zero on failure.
+          # cube on a 3x3 grid and realizes; asserts eval verts=72 faces=54, Set
+          # Material carries Lime, and corner center matches the grid. Exits non-zero
+          # on failure.
           xvfb-run -a "$BLENDER" --background \
             --python examples/gn-instance-grid/gn_instance_grid.py --
 
       - name: Shipped example - shape-key blend (data API + evaluated mesh)
         run: |
           set -euo pipefail
-          # Frame-independent check only (no render): relative Tall shape key at
-          # value=0.5; asserts undeformed mesh stays at Basis and evaluated z matches
-          # basis + value*(key-basis). Exits non-zero on failure.
+          # Frame-independent check only (no render): relative Tall key lifts+flares
+          # at value=0.5; asserts undeformed mesh stays at Basis and every evaluated
+          # vert matches basis + value*(key-basis). Exits non-zero on failure.
           xvfb-run -a "$BLENDER" --background \
             --python examples/shape-key-blend/shape_key_blend.py --
 
@@ -226,7 +228,7 @@ jobs:
         run: |
           set -euo pipefail
           # Frame-independent check only (no render): beveled Bezier semicircle via
-          # curve data API; asserts 8 points, bevel_depth=0.12, eval verts=850
-          # faces=840, tube rests on floor. Exits non-zero on failure.
+          # curve data API; asserts 8 points, bevel_depth=0.15, fill caps, eval
+          # verts=1044 faces=1028, tube rests on floor. Exits non-zero on failure.
           xvfb-run -a "$BLENDER" --background \
             --python examples/curve-bevel-arc/curve_bevel_arc.py --
diff --git a/README.md b/README.md
index d7cc82c..fa352c5 100644
--- a/README.md
+++ b/README.md
@@ -165,15 +165,15 @@ materials with different Tint values. Witnesses the grouping contract: shared da
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/temp-override-join/"><img src="examples/temp-override-join/preview.webp" alt="Temp-override join: an amber L-shaped mesh made of three joined unit cubes on a dark studio floor, viewed into the open corner" /></a>
+<a href="examples/temp-override-join/"><img src="examples/temp-override-join/preview.webp" alt="Temp-override join: an amber three-step staircase of joined unit cubes on a dark studio floor" /></a>
 </td>
 <td valign="middle">
 
 ### [temp-override-join](examples/temp-override-join/)
 
-Three unit cubes joined into one L-shaped mesh under `bpy.context.temp_override` — the
-supported replacement for the removed `context.copy()` dict-pass form. Asserts one mesh
-remains, sources are gone, and topology is verts = 8 × blocks, faces = 6 × blocks.
+Three unit cubes joined into a staircase under `bpy.context.temp_override` — the supported
+replacement for the removed `context.copy()` dict-pass form. Asserts one mesh remains,
+sources are gone, and local Z spans all three steps.
 
 </td>
 </tr>
@@ -193,16 +193,15 @@ verts = 72, faces = 54, and `Set Material` carries the lime accent.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/shape-key-blend/"><img src="examples/shape-key-blend/preview.webp" alt="Shape-key blend: a tall violet rectangular block on a dark studio floor, stretched by a relative Tall shape key at value 0.5" /></a>
+<a href="examples/shape-key-blend/"><img src="examples/shape-key-blend/preview.webp" alt="Shape-key blend: a violet truncated pyramid on a dark studio floor, lifted and flared by a relative Tall shape key at value 0.5" /></a>
 </td>
 <td valign="middle">
 
 ### [shape-key-blend](examples/shape-key-blend/)
 
-A relative shape key authored through the data API — `shape_key_add`, per-vertex
-`key_blocks` data, and `.value`. Witnesses that shape keys do not rewrite
-`mesh.vertices`: undeformed top stays at Basis, evaluated z matches
-`basis + value × (key − basis)`.
+A relative Tall shape key that lifts and flares the top face — authored through
+`shape_key_add` / `key_blocks` / `.value`. Witnesses that shape keys do not rewrite
+`mesh.vertices`: every evaluated vert matches `basis + value × (key − basis)`.
 
 </td>
 </tr>
@@ -215,9 +214,9 @@ A relative shape key authored through the data API — `shape_key_add`, per-vert
 ### [curve-bevel-arc](examples/curve-bevel-arc/)
 
 A beveled Bezier semicircle authored on `bpy.types.Curve` — `splines.new('BEZIER')`,
-`bezier_points`, `bevel_depth` — so the curve renders as a tube without a prior mesh
-conversion. Asserts eight points, `bevel_depth == 0.12`, and evaluated topology
-850 verts / 840 faces.
+`bezier_points`, `bevel_depth`, `use_fill_caps` — so the curve renders as a solid tube
+without a prior mesh conversion. Asserts eight points, `bevel_depth == 0.15`, and
+evaluated topology 1044 verts / 1028 faces.
 
 </td>
 </tr>
diff --git a/docs/gallery/assets/curve-bevel-arc-hero.webp b/docs/gallery/assets/curve-bevel-arc-hero.webp
index 0a65f1b..5620709 100644
Binary files a/docs/gallery/assets/curve-bevel-arc-hero.webp and b/docs/gallery/assets/curve-bevel-arc-hero.webp differ
diff --git a/docs/gallery/assets/gn-instance-grid-hero.webp b/docs/gallery/assets/gn-instance-grid-hero.webp
index e0e97fa..4a19136 100644
Binary files a/docs/gallery/assets/gn-instance-grid-hero.webp and b/docs/gallery/assets/gn-instance-grid-hero.webp differ
diff --git a/docs/gallery/assets/shape-key-blend-hero.webp b/docs/gallery/assets/shape-key-blend-hero.webp
index 000dc7d..6ecfd93 100644
Binary files a/docs/gallery/assets/shape-key-blend-hero.webp and b/docs/gallery/assets/shape-key-blend-hero.webp differ
diff --git a/docs/gallery/assets/temp-override-join-hero.webp b/docs/gallery/assets/temp-override-join-hero.webp
index cc7e9f2..6428d88 100644
Binary files a/docs/gallery/assets/temp-override-join-hero.webp and b/docs/gallery/assets/temp-override-join-hero.webp differ
diff --git a/docs/gallery/curve-bevel-arc/index.html b/docs/gallery/curve-bevel-arc/index.html
index ccfeff0..dc67c9c 100644
--- a/docs/gallery/curve-bevel-arc/index.html
+++ b/docs/gallery/curve-bevel-arc/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>curve-bevel-arc — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth — so the curve renders as a tube without a prior mesh conversion." />
+  <meta name="description" content="A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth, use_fill_caps — so the curve renders as a solid tube without a prior mesh conversion." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/curve-bevel-arc/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="curve-bevel-arc — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth — so the curve renders as a tube without a prior mesh conversion." />
+  <meta property="og:description" content="A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth, use_fill_caps — so the curve renders as a solid tube without a prior mesh conversion." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/curve-bevel-arc/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/curve-bevel-arc-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="curve-bevel-arc — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth — so the curve renders as a tube without a prior mesh conversion." />
+  <meta name="twitter:description" content="A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth, use_fill_caps — so the curve renders as a solid tube without a prior mesh conversion." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/curve-bevel-arc-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -170,21 +170,21 @@
   </div>
   <header class="hero">
     <h1>curve-bevel-arc</h1>
-    <p>A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth — so the curve renders as a tube without a prior mesh conversion.</p>
+    <p>A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth, use_fill_caps — so the curve renders as a solid tube without a prior mesh conversion.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom curve-bevel-arc render">
       <img src="../assets/curve-bevel-arc-hero.webp" alt="curve-bevel-arc render" width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Curve tubes are curve datablocks: eight Bezier points, bevel_depth == 0.12, and the evaluated mesh has deterministic topology (850 verts, 840 faces) resting on the floor.</div>
+    <div class="callout"><span class="tag">witnesses</span> Curve tubes are curve datablocks: eight Bezier points, bevel_depth == 0.15, filled caps, and the evaluated mesh has deterministic topology (1044 verts, 1028 faces) resting on the floor.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/curve-bevel-arc/curve_bevel_arc.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that builds a beveled Bezier semicircle entirely through the curve data API — <code>splines.new(&#x27;BEZIER&#x27;)</code>, per-point <code>bezier_points</code>, and <code>bevel_depth</code> — so the curve renders as a tube without a prior mesh conversion.</p>
-<p><strong>What it witnesses:</strong> renderable curve tubes are curve datablocks, not meshes. The check asserts eight Bezier points, <code>bevel_depth == 0.12</code>, and that the depsgraph-evaluated mesh has the deterministic topology (850 verts, 840 faces for these resolution settings) with a Z span that rests on the floor (<code>[≈0, 2 × bevel]</code>).</p>
+<p>A runnable example that builds a beveled Bezier semicircle entirely through the curve data API — <code>splines.new(&#x27;BEZIER&#x27;)</code>, per-point <code>bezier_points</code>, <code>bevel_depth</code>, and <code>use_fill_caps</code> — so the curve renders as a solid tube without a prior mesh conversion.</p>
+<p><strong>What it witnesses:</strong> renderable curve tubes are curve datablocks, not meshes. The check asserts eight Bezier points, <code>bevel_depth == 0.15</code>, <code>use_fill_caps</code>, and that the depsgraph-evaluated mesh has the deterministic topology (1044 verts, 1028 faces for these resolution settings) with a Z span that rests on the floor (<code>[0, 2 × bevel]</code>) and an X span of <code>2 × radius + 2 × bevel</code>.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python curve_bevel_arc.py --
@@ -192,7 +192,7 @@ <h2>Run</h2>
 # Also render a still (EEVEE on a GPU host; use --engine cycles on GPU-less hosts):
 blender --background --python curve_bevel_arc.py -- --output arc.png
 blender --background --python curve_bevel_arc.py -- --output arc.png --engine cycles</code></pre>
-<p>It exits non-zero on failure (wrong point count, bevel, topology, or Z span). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
+<p>It exits non-zero on failure (wrong point count, bevel, caps, topology, or span). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -203,10 +203,10 @@ <h2>Source</h2>
       <pre><span class="s">&quot;&quot;&quot;Beveled Bezier arc via the curve data API — a runnable example.
 
 Witnesses that renderable tubes are authored on `bpy.types.Curve` directly
-(`splines.new(&#x27;BEZIER&#x27;)`, `bezier_points`, `bevel_depth`) — not by meshing
-first or calling curve operators. The check asserts the closed-form point
-count, bevel depth, and that the depsgraph-evaluated mesh has the
-deterministic topology and Z span of a tube whose centerline sits at
+(`splines.new(&#x27;BEZIER&#x27;)`, `bezier_points`, `bevel_depth`, `use_fill_caps`) —
+not by meshing first or calling curve operators. The check asserts the
+closed-form point count, bevel depth, filled-cap topology, and that the
+depsgraph-evaluated mesh has a Z span of a tube whose centerline sits at
 `z = bevel_depth` (resting on the floor).
 
 By default it runs only the correctness check (no render) — the CI smoke
@@ -219,12 +219,12 @@ <h2>Source</h2>
 
 N_POINTS = <span class="n">8</span>
 RADIUS = <span class="n">1.5</span>
-BEVEL = <span class="n">0.12</span>
-BEVEL_RES = <span class="n">3</span>
+BEVEL = <span class="n">0.15</span>
+BEVEL_RES = <span class="n">4</span>
 RES_U = <span class="n">12</span>
-<span class="c"># measured for the parameters above — identical on 4.4 and 5.1</span>
-EXPECT_VERTS = <span class="n">850</span>
-EXPECT_FACES = <span class="n">840</span>
+<span class="c"># measured for the parameters above with use_fill_caps=True — identical on 4.4 and 5.1</span>
+EXPECT_VERTS = <span class="n">1044</span>
+EXPECT_FACES = <span class="n">1028</span>
 
 
 <span class="k">def</span> build():
@@ -234,6 +234,7 @@ <h2>Source</h2>
     curve.bevel_depth = BEVEL
     curve.bevel_resolution = BEVEL_RES
     curve.resolution_u = RES_U
+    curve.use_fill_caps = <span class="k">True</span>  <span class="c"># solid ends — not a hollow pipe</span>
 
     spline = curve.splines.new(<span class="s">&#x27;BEZIER&#x27;</span>)
     spline.bezier_points.add(N_POINTS - <span class="n">1</span>)  <span class="c"># one point exists already</span>
@@ -261,6 +262,9 @@ <h2>Source</h2>
     <span class="k">if</span> abs(curve.bevel_depth - BEVEL) &gt; <span class="n">1e-6</span>:
         print(<span class="s">f&quot;</span><span class="s">ERROR: bevel_depth </span>{curve.bevel_depth}<span class="s"> != </span>{BEVEL}<span class="s">&quot;</span>, file=sys.stderr)
         <span class="k">return</span> <span class="n">5</span>
+    <span class="k">if</span> <span class="k">not</span> curve.use_fill_caps:
+        print(<span class="s">&quot;ERROR: use_fill_caps is False — ends should be capped&quot;</span>, file=sys.stderr)
+        <span class="k">return</span> <span class="n">6</span>
 
     bpy.context.view_layer.update()
     dg = bpy.context.evaluated_depsgraph_get()
@@ -271,6 +275,9 @@ <h2>Source</h2>
         got_f = len(em.polygons)
         zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> em.vertices]
         z_lo, z_hi = min(zs), max(zs)
+        <span class="c"># arc spans x in [-RADIUS, +RADIUS] at the endpoints</span>
+        xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> em.vertices]
+        x_span = max(xs) - min(xs)
     <span class="k">finally</span>:
         ev.to_mesh_clear()
 
@@ -278,19 +285,24 @@ <h2>Source</h2>
         print(<span class="s">f&quot;</span><span class="s">ERROR: evaluated topology verts=</span>{got_v}<span class="s"> faces=</span>{got_f}<span class="s"> != </span><span class="s">&quot;</span>
               <span class="s">f&quot;</span><span class="s">expected verts=</span>{EXPECT_VERTS}<span class="s"> faces=</span>{EXPECT_FACES}<span class="s">&quot;</span>,
               file=sys.stderr)
-        <span class="k">return</span> <span class="n">6</span>
-
-    <span class="c"># tube diameter ≈ 2 * bevel; centerline at z=BEVEL → span [0, 2*BEVEL]</span>
-    <span class="k">if</span> z_lo &lt; -<span class="n">0.02</span> <span class="k">or</span> z_lo &gt; <span class="n">0.03</span>:
-        print(<span class="s">f&quot;</span><span class="s">ERROR: tube does not rest on floor (z_lo=</span>{z_lo:<span class="s">.4f</span>}<span class="s">)</span><span class="s">&quot;</span>, file=sys.stderr)
         <span class="k">return</span> <span class="n">7</span>
-    <span class="k">if</span> abs(z_hi - <span class="n">2</span> * BEVEL) &gt; <span class="n">0.03</span>:
+
+    <span class="c"># tube diameter = 2 * bevel; centerline at z=BEVEL → span [0, 2*BEVEL]</span>
+    <span class="k">if</span> abs(z_lo) &gt; <span class="n">1e-4</span>:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: tube does not rest on floor (z_lo=</span>{z_lo:<span class="s">.6f</span>}<span class="s">)</span><span class="s">&quot;</span>, file=sys.stderr)
+        <span class="k">return</span> <span class="n">8</span>
+    <span class="k">if</span> abs(z_hi - <span class="n">2</span> * BEVEL) &gt; <span class="n">1e-4</span>:
         print(<span class="s">f&quot;</span><span class="s">ERROR: tube height </span>{z_hi:<span class="s">.4f</span>}<span class="s"> != 2*bevel=</span>{<span class="n">2</span> * BEVEL:<span class="s">.4f</span>}<span class="s">&quot;</span>,
               file=sys.stderr)
-        <span class="k">return</span> <span class="n">8</span>
-
-    print(<span class="s">f&quot;</span><span class="s">points=</span>{n}<span class="s"> bevel=</span>{BEVEL}<span class="s"> eval_verts=</span>{got_v}<span class="s"> eval_faces=</span>{got_f}<span class="s"> </span><span class="s">&quot;</span>
-          <span class="s">f&quot;</span><span class="s">z=</span>{z_lo:<span class="s">.3f</span>}<span class="s">..</span>{z_hi:<span class="s">.3f</span>}<span class="s">&quot;</span>)
+        <span class="k">return</span> <span class="n">9</span>
+    <span class="c"># diameter adds 2*BEVEL to the arc&#x27;s 2*RADIUS span</span>
+    expect_x_span = <span class="n">2</span> * RADIUS + <span class="n">2</span> * BEVEL
+    <span class="k">if</span> abs(x_span - expect_x_span) &gt; <span class="n">0.05</span>:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: x span </span>{x_span:<span class="s">.4f</span>}<span class="s"> != </span>{expect_x_span:<span class="s">.4f</span>}<span class="s">&quot;</span>, file=sys.stderr)
+        <span class="k">return</span> <span class="n">10</span>
+
+    print(<span class="s">f&quot;</span><span class="s">points=</span>{n}<span class="s"> bevel=</span>{BEVEL}<span class="s"> caps=True eval_verts=</span>{got_v}<span class="s"> </span><span class="s">&quot;</span>
+          <span class="s">f&quot;</span><span class="s">eval_faces=</span>{got_f}<span class="s"> z=</span>{z_lo:<span class="s">.3f</span>}<span class="s">..</span>{z_hi:<span class="s">.3f</span>}<span class="s"> x_span=</span>{x_span:<span class="s">.3f</span>}<span class="s">&quot;</span>)
     <span class="k">return</span> <span class="n">0</span>
 
 
@@ -303,10 +315,10 @@ <h2>Source</h2>
     mat = bpy.data.materials.new(<span class="s">&quot;Rose&quot;</span>)
     mat.use_nodes = <span class="k">True</span>
     bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.92</span>, <span class="n">0.14</span>, <span class="n">0.42</span>, <span class="n">1.0</span>)  <span class="c"># rose</span>
-    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.28</span>
+    bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.95</span>, <span class="n">0.10</span>, <span class="n">0.38</span>, <span class="n">1.0</span>)  <span class="c"># rose</span>
+    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.24</span>
     obj.data.materials.append(mat)
-    obj.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(-<span class="n">20</span>))
+    obj.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(-<span class="n">18</span>))
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -334,7 +346,7 @@ <h2>Source</h2>
     scene.world = world
 
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.4</span>, BEVEL)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.35</span>, BEVEL)
     scene.collection.objects.link(aim)
 
     <span class="k">def</span> light(name, loc, energy, size, col):
@@ -350,14 +362,14 @@ <h2>Source</h2>
         lc.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
         lc.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
 
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.5</span>, -<span class="n">4.5</span>, <span class="n">5.5</span>), <span class="n">1400.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">320.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">2.0</span>), <span class="n">420.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.5</span>, -<span class="n">4.5</span>, <span class="n">5.5</span>), <span class="n">1500.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">340.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">2.0</span>), <span class="n">480.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>))
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">2.8</span>, -<span class="n">4.0</span>, <span class="n">2.4</span>)
+    cam.location = (<span class="n">3.0</span>, -<span class="n">4.2</span>, <span class="n">2.6</span>)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
@@ -397,7 +409,7 @@ <h2>Source</h2>
     <span class="k">if</span> args.output:
         <span class="k">if</span> <span class="k">not</span> render_still(obj, os.path.abspath(args.output), args.engine):
             print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
-            <span class="k">return</span> <span class="n">9</span>
+            <span class="k">return</span> <span class="n">11</span>
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
 
     print(<span class="s">&quot;curve-bevel-arc OK&quot;</span>)
diff --git a/docs/gallery/gn-instance-grid/index.html b/docs/gallery/gn-instance-grid/index.html
index 703c67e..78e4796 100644
--- a/docs/gallery/gn-instance-grid/index.html
+++ b/docs/gallery/gn-instance-grid/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>gn-instance-grid — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances — attached as a NODES modifier with no Group Input geometry." />
+  <meta name="description" content="A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/gn-instance-grid/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="gn-instance-grid — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances — attached as a NODES modifier with no Group Input geometry." />
+  <meta property="og:description" content="A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/gn-instance-grid/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gn-instance-grid-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="gn-instance-grid — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances — attached as a NODES modifier with no Group Input geometry." />
+  <meta name="twitter:description" content="A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gn-instance-grid-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -170,21 +170,21 @@
   </div>
   <header class="hero">
     <h1>gn-instance-grid</h1>
-    <p>A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances — attached as a NODES modifier with no Group Input geometry.</p>
+    <p>A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom gn-instance-grid render">
       <img src="../assets/gn-instance-grid-hero.webp" alt="gn-instance-grid render" width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Realized instances produce closed-form topology: eval verts = grid points × cube verts (3 × 3 × 8 = 72), and Set Material carries the accent onto the evaluated mesh.</div>
+    <div class="callout"><span class="tag">witnesses</span> Realized instances produce closed-form topology (72 verts, 54 faces), Set Material carries Lime, and the corner instance center sits at its closed-form grid coordinate.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/gn-instance-grid/gn_instance_grid.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that builds a generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Transform — and attaches it as a <code>NODES</code> modifier, following the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/geometry-nodes-python/SKILL.md"><code>geometry-nodes-python</code></a> skill. The tree has no Group Input: the grid and cube primitives live inside the node group.</p>
-<p><strong>What it witnesses:</strong> instancing is not free geometry until you realize it. The check asserts the closed-form evaluated topology — verts = grid points × cube verts (3 × 3 × 8 = 72), faces = 9 × 6 — and that a <code>Set Material</code> node carries the lime accent onto the evaluated mesh. If Realize Instances is omitted, the evaluated mesh is empty and the counts fail.</p>
+<p>A runnable example that builds a generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Transform → Set Shade Smooth — and attaches it as a <code>NODES</code> modifier, following the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/geometry-nodes-python/SKILL.md"><code>geometry-nodes-python</code></a> skill. The tree has no Group Input: the grid and cube primitives live inside the node group.</p>
+<p><strong>What it witnesses:</strong> instancing is not free geometry until you realize it. The check asserts the closed-form evaluated topology — verts = grid points × cube verts (3 × 3 × 8 = 72), faces = 9 × 6 — that a <code>Set Material</code> node carries the lime accent, and that the corner instance center sits at its closed-form grid coordinate. If Realize Instances is omitted, the evaluated mesh is empty and the counts fail.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python gn_instance_grid.py --
@@ -192,7 +192,7 @@ <h2>Run</h2>
 # Also render a still (EEVEE on a GPU host; use --engine cycles on GPU-less hosts):
 blender --background --python gn_instance_grid.py -- --output grid.png
 blender --background --python gn_instance_grid.py -- --output grid.png --engine cycles</code></pre>
-<p>It exits non-zero on failure (wrong carrier, topology mismatch, or missing material). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
+<p>It exits non-zero on failure (wrong carrier, topology mismatch, missing material, or misplaced corner). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -207,7 +207,8 @@ <h2>Source</h2>
 Instances → Transform) attached as a NODES modifier, with no Group Input
 geometry. The check asserts the closed-form evaluated topology —
 verts = grid_points × cube_verts — proving instances were realized, not
-left as empty instance geometry.
+left as empty instance geometry, and that a corner instance sits at its
+closed-form grid coordinate.
 
 By default it runs only the correctness check (no render) — the CI smoke
 check. Pass --output to also render a still:
@@ -219,13 +220,17 @@ <h2>Source</h2>
 
 GRID_X = <span class="n">3</span>
 GRID_Y = <span class="n">3</span>
-GRID_SIZE = <span class="n">2.0</span>
-CUBE_SIZE = <span class="n">0.35</span>
+GRID_SIZE = <span class="n">2.4</span>
+CUBE_SIZE = <span class="n">0.42</span>
 CUBE_VERTS = <span class="n">8</span>
 CUBE_FACES = <span class="n">6</span>
 GRID_POINTS = GRID_X * GRID_Y
 EXPECT_VERTS = GRID_POINTS * CUBE_VERTS
 EXPECT_FACES = GRID_POINTS * CUBE_FACES
+<span class="c"># Mesh Grid spans [-GRID_SIZE/2, +GRID_SIZE/2]; corner point at (+half, +half)</span>
+GRID_HALF = GRID_SIZE / <span class="n">2</span>
+<span class="c"># after Transform lift, corner cube center is at (GRID_HALF, GRID_HALF, CUBE_SIZE/2)</span>
+CORNER_CENTER = (GRID_HALF, GRID_HALF, CUBE_SIZE / <span class="n">2</span>)
 
 
 <span class="k">def</span> build_instance_grid_tree(material=<span class="k">None</span>):
@@ -251,11 +256,16 @@ <h2>Source</h2>
     <span class="c"># cubes are centered on grid points at z=0; lift so they rest on the floor</span>
     xform.inputs[<span class="s">&quot;Translation&quot;</span>].default_value = (<span class="n">0.0</span>, <span class="n">0.0</span>, CUBE_SIZE / <span class="n">2</span>)
 
+    <span class="c"># crisp facets — matches the other studio examples</span>
+    shade = tree.nodes.new(<span class="s">&#x27;GeometryNodeSetShadeSmooth&#x27;</span>)
+    shade.inputs[<span class="s">&quot;Shade Smooth&quot;</span>].default_value = <span class="k">False</span>
+
     tree.links.new(grid.outputs[<span class="s">&quot;Mesh&quot;</span>], iop.inputs[<span class="s">&quot;Points&quot;</span>])
     tree.links.new(cube.outputs[<span class="s">&quot;Mesh&quot;</span>], iop.inputs[<span class="s">&quot;Instance&quot;</span>])
     tree.links.new(iop.outputs[<span class="s">&quot;Instances&quot;</span>], realize.inputs[<span class="s">&quot;Geometry&quot;</span>])
     tree.links.new(realize.outputs[<span class="s">&quot;Geometry&quot;</span>], xform.inputs[<span class="s">&quot;Geometry&quot;</span>])
-    out_socket = xform.outputs[<span class="s">&quot;Geometry&quot;</span>]
+    tree.links.new(xform.outputs[<span class="s">&quot;Geometry&quot;</span>], shade.inputs[<span class="s">&quot;Geometry&quot;</span>])
+    out_socket = shade.outputs[<span class="s">&quot;Geometry&quot;</span>]
 
     <span class="k">if</span> material <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
         set_mat = tree.nodes.new(<span class="s">&#x27;GeometryNodeSetMaterial&#x27;</span>)
@@ -278,8 +288,8 @@ <h2>Source</h2>
     mat = bpy.data.materials.new(<span class="s">&quot;Lime&quot;</span>)
     mat.use_nodes = <span class="k">True</span>
     bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.28</span>, <span class="n">0.92</span>, <span class="n">0.08</span>, <span class="n">1.0</span>)  <span class="c"># lime</span>
-    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.24</span>
+    bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.22</span>, <span class="n">0.95</span>, <span class="n">0.06</span>, <span class="n">1.0</span>)  <span class="c"># lime</span>
+    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.22</span>
 
     tree = build_instance_grid_tree(material=mat)
     mod = obj.modifiers.new(<span class="s">&quot;instance_grid&quot;</span>, <span class="s">&#x27;NODES&#x27;</span>)
@@ -300,6 +310,16 @@ <h2>Source</h2>
         got_v = len(em.vertices)
         got_f = len(em.polygons)
         mat_names = [m.name <span class="k">for</span> m <span class="k">in</span> em.materials <span class="k">if</span> m <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>]
+        <span class="c"># corner instance: the 8 verts nearest CORNER_CENTER should average to it</span>
+        corner = [v.co <span class="k">for</span> v <span class="k">in</span> em.vertices
+                  <span class="k">if</span> (v.co.x &gt; GRID_HALF - CUBE_SIZE <span class="k">and</span> v.co.y &gt; GRID_HALF - CUBE_SIZE)]
+        <span class="k">if</span> len(corner) != CUBE_VERTS:
+            print(<span class="s">f&quot;</span><span class="s">ERROR: corner instance has </span>{len(corner)}<span class="s"> verts, expected </span>{CUBE_VERTS}<span class="s">&quot;</span>,
+                  file=sys.stderr)
+            <span class="k">return</span> <span class="n">4</span>
+        cx = sum(c.x <span class="k">for</span> c <span class="k">in</span> corner) / CUBE_VERTS
+        cy = sum(c.y <span class="k">for</span> c <span class="k">in</span> corner) / CUBE_VERTS
+        cz = sum(c.z <span class="k">for</span> c <span class="k">in</span> corner) / CUBE_VERTS
     <span class="k">finally</span>:
         ev.to_mesh_clear()
 
@@ -307,15 +327,24 @@ <h2>Source</h2>
         print(<span class="s">f&quot;</span><span class="s">ERROR: evaluated topology verts=</span>{got_v}<span class="s"> faces=</span>{got_f}<span class="s"> != </span><span class="s">&quot;</span>
               <span class="s">f&quot;</span><span class="s">expected verts=</span>{EXPECT_VERTS}<span class="s"> faces=</span>{EXPECT_FACES}<span class="s">&quot;</span>,
               file=sys.stderr)
-        <span class="k">return</span> <span class="n">4</span>
+        <span class="k">return</span> <span class="n">5</span>
 
     <span class="k">if</span> <span class="s">&quot;Lime&quot;</span> <span class="k">not</span> <span class="k">in</span> mat_names:
         print(<span class="s">f&quot;</span><span class="s">ERROR: Set Material did not carry Lime onto evaluated mesh </span><span class="s">&quot;</span>
               <span class="s">f&quot;</span><span class="s">(materials=</span>{mat_names}<span class="s">)</span><span class="s">&quot;</span>, file=sys.stderr)
-        <span class="k">return</span> <span class="n">5</span>
+        <span class="k">return</span> <span class="n">6</span>
+
+    <span class="k">for</span> got, exp, axis <span class="k">in</span> ((cx, CORNER_CENTER[<span class="n">0</span>], <span class="s">&#x27;x&#x27;</span>),
+                           (cy, CORNER_CENTER[<span class="n">1</span>], <span class="s">&#x27;y&#x27;</span>),
+                           (cz, CORNER_CENTER[<span class="n">2</span>], <span class="s">&#x27;z&#x27;</span>)):
+        <span class="k">if</span> abs(got - exp) &gt; <span class="n">1e-3</span>:
+            print(<span class="s">f&quot;</span><span class="s">ERROR: corner center </span>{axis}<span class="s">=</span>{got:<span class="s">.4f</span>}<span class="s"> != </span>{exp:<span class="s">.4f</span>}<span class="s">&quot;</span>,
+                  file=sys.stderr)
+            <span class="k">return</span> <span class="n">7</span>
 
     print(<span class="s">f&quot;</span><span class="s">grid=</span>{GRID_X}<span class="s">x</span>{GRID_Y}<span class="s"> points=</span>{GRID_POINTS}<span class="s"> </span><span class="s">&quot;</span>
-          <span class="s">f&quot;</span><span class="s">eval_verts=</span>{got_v}<span class="s"> eval_faces=</span>{got_f}<span class="s"> material=Lime</span><span class="s">&quot;</span>)
+          <span class="s">f&quot;</span><span class="s">eval_verts=</span>{got_v}<span class="s"> eval_faces=</span>{got_f}<span class="s"> </span><span class="s">&quot;</span>
+          <span class="s">f&quot;</span><span class="s">corner=(</span>{cx:<span class="s">.2f</span>}<span class="s">,</span>{cy:<span class="s">.2f</span>}<span class="s">,</span>{cz:<span class="s">.2f</span>}<span class="s">) material=Lime</span><span class="s">&quot;</span>)
     <span class="k">return</span> <span class="n">0</span>
 
 
@@ -351,31 +380,34 @@ <h2>Source</h2>
     world.node_tree.nodes[<span class="s">&quot;Background&quot;</span>].inputs[<span class="s">&quot;Color&quot;</span>].default_value = (<span class="n">0.008</span>, <span class="n">0.009</span>, <span class="n">0.012</span>, <span class="n">1.0</span>)
     scene.world = world
 
-    <span class="k">def</span> light(name, loc, energy, size, col, rot):
+    <span class="c"># tip the grid so depth reads; cubes already rest on the floor via the tree</span>
+    obj.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(<span class="n">24</span>))
+
+    aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, CUBE_SIZE / <span class="n">2</span>)
+    scene.collection.objects.link(aim)
+
+    <span class="k">def</span> light(name, loc, energy, size, col):
         ld = bpy.data.lights.new(name, <span class="s">&#x27;AREA&#x27;</span>)
         ld.energy = energy
         ld.size = size
         ld.color = col
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
-        ob.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
         scene.collection.objects.link(ob)
+        lc = ob.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
+        lc.target = aim
+        lc.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
+        lc.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
 
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.5</span>, -<span class="n">4.5</span>, <span class="n">5.5</span>), <span class="n">1400.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>), (<span class="n">48</span>, <span class="n">0</span>, -<span class="n">35</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">320.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>), (<span class="n">65</span>, <span class="n">0</span>, <span class="n">50</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">2.0</span>), <span class="n">420.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>), (-<span class="n">82</span>, <span class="n">0</span>, <span class="n">165</span>))
-
-    <span class="c"># tip the grid so depth reads; cubes already rest on the floor via the tree</span>
-    obj.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(<span class="n">22</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.5</span>, -<span class="n">4.5</span>, <span class="n">5.5</span>), <span class="n">1500.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">340.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">2.0</span>), <span class="n">480.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>))
 
-    aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, CUBE_SIZE / <span class="n">2</span>)
-    scene.collection.objects.link(aim)
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">55.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    <span class="c"># three-quarter view so the 3x3 grid reads as depth, not a flat array</span>
-    cam.location = (<span class="n">3.2</span>, -<span class="n">3.8</span>, <span class="n">2.6</span>)
+    cam.location = (<span class="n">3.6</span>, -<span class="n">4.2</span>, <span class="n">2.8</span>)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
@@ -415,7 +447,7 @@ <h2>Source</h2>
     <span class="k">if</span> args.output:
         <span class="k">if</span> <span class="k">not</span> render_still(obj, os.path.abspath(args.output), args.engine):
             print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
-            <span class="k">return</span> <span class="n">6</span>
+            <span class="k">return</span> <span class="n">8</span>
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
 
     print(<span class="s">&quot;gn-instance-grid OK&quot;</span>)
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index dbcf9c6..26e0a5f 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -284,34 +284,34 @@ <h2><a href="shader-node-group/">shader-node-group</a></h2>
       </article>
       <article class="card" data-tags="operators context">
         <a class="card-media" href="temp-override-join/" aria-label="temp-override-join example detail page">
-          <img src="assets/temp-override-join-hero.webp" alt="temp-override-join — Join three unit cubes into one L-shaped mesh under bpy" loading="lazy" decoding="async" />
+          <img src="assets/temp-override-join-hero.webp" alt="temp-override-join — Join three unit cubes into a staircase under bpy" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="temp-override-join/">temp-override-join</a></h2>
-          <p class="teaches">Join three unit cubes into one L-shaped mesh under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> temp_override actually applies: join consumes the sources, exactly one mesh remains, and topology is verts = 8 × blocks, faces = 6 × blocks.</p>
+          <p class="teaches">Join three unit cubes into a staircase under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> temp_override actually applies: join consumes the sources, exactly one mesh remains, topology is verts = 8 × steps, and local Z spans all three steps.</p>
           <a class="card-link" href="temp-override-join/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
       <article class="card" data-tags="geometry-nodes instancing">
         <a class="card-media" href="gn-instance-grid/" aria-label="gn-instance-grid example detail page">
-          <img src="assets/gn-instance-grid-hero.webp" alt="gn-instance-grid — A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances — attached as a NODES modifier with no Group Input geometry" loading="lazy" decoding="async" />
+          <img src="assets/gn-instance-grid-hero.webp" alt="gn-instance-grid — A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="gn-instance-grid/">gn-instance-grid</a></h2>
-          <p class="teaches">A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances — attached as a NODES modifier with no Group Input geometry.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Realized instances produce closed-form topology: eval verts = grid points × cube verts (3 × 3 × 8 = 72), and Set Material carries the accent onto the evaluated mesh.</p>
+          <p class="teaches">A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Realized instances produce closed-form topology (72 verts, 54 faces), Set Material carries Lime, and the corner instance center sits at its closed-form grid coordinate.</p>
           <a class="card-link" href="gn-instance-grid/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
       <article class="card" data-tags="mesh shape-keys">
         <a class="card-media" href="shape-key-blend/" aria-label="shape-key-blend example detail page">
-          <img src="assets/shape-key-blend-hero.webp" alt="shape-key-blend — A relative shape key authored entirely through the data API — shape_key_add, per-vertex key_blocks data, and " loading="lazy" decoding="async" />
+          <img src="assets/shape-key-blend-hero.webp" alt="shape-key-blend — A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / " loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="shape-key-blend/">shape-key-blend</a></h2>
-          <p class="teaches">A relative shape key authored entirely through the data API — shape_key_add, per-vertex key_blocks data, and .value — read back from the depsgraph-evaluated mesh.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Shape keys do not rewrite mesh.vertices: undeformed top z stays at Basis, and evaluated z matches basis + value × (key − basis).</p>
+          <p class="teaches">A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / .value — read back from the depsgraph-evaluated mesh.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Shape keys do not rewrite mesh.vertices: every evaluated vert matches basis + value × (key − basis), including the flared top half-extent.</p>
           <a class="card-link" href="shape-key-blend/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -321,8 +321,8 @@ <h2><a href="shape-key-blend/">shape-key-blend</a></h2>
         </a>
         <div class="card-body">
           <h2><a href="curve-bevel-arc/">curve-bevel-arc</a></h2>
-          <p class="teaches">A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth — so the curve renders as a tube without a prior mesh conversion.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Curve tubes are curve datablocks: eight Bezier points, bevel_depth == 0.12, and the evaluated mesh has deterministic topology (850 verts, 840 faces) resting on the floor.</p>
+          <p class="teaches">A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth, use_fill_caps — so the curve renders as a solid tube without a prior mesh conversion.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Curve tubes are curve datablocks: eight Bezier points, bevel_depth == 0.15, filled caps, and the evaluated mesh has deterministic topology (1044 verts, 1028 faces) resting on the floor.</p>
           <a class="card-link" href="curve-bevel-arc/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/shape-key-blend/index.html b/docs/gallery/shape-key-blend/index.html
index 4e8ff14..0fca64d 100644
--- a/docs/gallery/shape-key-blend/index.html
+++ b/docs/gallery/shape-key-blend/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>shape-key-blend — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A relative shape key authored entirely through the data API — shape_key_add, per-vertex key_blocks data, and .value — read back from the depsgraph-evaluated mesh." />
+  <meta name="description" content="A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / .value — read back from the depsgraph-evaluated mesh." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/shape-key-blend/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="shape-key-blend — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A relative shape key authored entirely through the data API — shape_key_add, per-vertex key_blocks data, and .value — read back from the depsgraph-evaluated mesh." />
+  <meta property="og:description" content="A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / .value — read back from the depsgraph-evaluated mesh." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/shape-key-blend/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/shape-key-blend-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="shape-key-blend — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A relative shape key authored entirely through the data API — shape_key_add, per-vertex key_blocks data, and .value — read back from the depsgraph-evaluated mesh." />
+  <meta name="twitter:description" content="A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / .value — read back from the depsgraph-evaluated mesh." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/shape-key-blend-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -170,21 +170,21 @@
   </div>
   <header class="hero">
     <h1>shape-key-blend</h1>
-    <p>A relative shape key authored entirely through the data API — shape_key_add, per-vertex key_blocks data, and .value — read back from the depsgraph-evaluated mesh.</p>
+    <p>A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / .value — read back from the depsgraph-evaluated mesh.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom shape-key-blend render">
       <img src="../assets/shape-key-blend-hero.webp" alt="shape-key-blend render" width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Shape keys do not rewrite mesh.vertices: undeformed top z stays at Basis, and evaluated z matches basis + value × (key − basis).</div>
+    <div class="callout"><span class="tag">witnesses</span> Shape keys do not rewrite mesh.vertices: every evaluated vert matches basis + value × (key − basis), including the flared top half-extent.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/shape-key-blend/shape_key_blend.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that authors a relative shape key entirely through the data API — <code>shape_key_add</code>, per-vertex <code>key_blocks[&quot;Tall&quot;].data[i].co</code>, and <code>.value</code> — then reads the blend back from the depsgraph-evaluated mesh.</p>
-<p><strong>What it witnesses:</strong> shape keys do not rewrite <code>mesh.vertices</code>. The undeformed mesh stays at Basis; the closed-form blend <code>co = basis + value × (key − basis)</code> appears only on the evaluated mesh. The check asserts key names <code>Basis</code>/<code>Tall</code>, <code>Tall.value == 0.5</code>, undeformed top z equals the basis half-extent, and evaluated z matches <code>[−half, half + value × lift]</code>.</p>
+<p>A runnable example that authors a relative shape key entirely through the data API — <code>shape_key_add</code>, per-vertex <code>key_blocks[&quot;Tall&quot;].data[i].co</code>, and <code>.value</code> — then reads the blend back from the depsgraph-evaluated mesh. The Tall key both lifts and flares the top face, so the silhouette is a truncated pyramid.</p>
+<p><strong>What it witnesses:</strong> shape keys do not rewrite <code>mesh.vertices</code>. The undeformed mesh stays at Basis; every evaluated vertex matches the closed-form blend <code>co = basis + value × (key − basis)</code>. The check also asserts the flared top half-extent (<code>0.5 + value × flare</code>) so a uniform-scale mistake cannot pass.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python shape_key_blend.py --
@@ -192,7 +192,7 @@ <h2>Run</h2>
 # Also render a still (EEVEE on a GPU host; use --engine cycles on GPU-less hosts):
 blender --background --python shape_key_blend.py -- --output blend.png
 blender --background --python shape_key_blend.py -- --output blend.png --engine cycles</code></pre>
-<p>It exits non-zero on failure (missing keys, wrong value, or evaluated z mismatch). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
+<p>It exits non-zero on failure (missing keys, wrong value, per-vert blend mismatch, or flare miss). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -209,6 +209,9 @@ <h2>Source</h2>
 wrong block, forgets Basis, or reads undeformed `mesh.vertices` instead of
 the evaluated mesh.
 
+The Tall key both lifts and flares the top face, so the silhouette is a
+truncated pyramid — clearly a blend, not a uniformly scaled box.
+
 By default it runs only the correctness check (no render) — the CI smoke
 check. Pass --output to also render a still:
 
@@ -218,12 +221,13 @@ <h2>Source</h2>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse
 
 CUBE_SIZE = <span class="n">1.0</span>
-LIFT = <span class="n">1.2</span>
+LIFT = <span class="n">2.0</span>
+FLARE = <span class="n">0.45</span>  <span class="c"># extra half-extent on top face in XY at full key</span>
 BLEND = <span class="n">0.5</span>
-<span class="c"># cube spans [-half, +half]; top verts start at +half</span>
 HALF = CUBE_SIZE / <span class="n">2</span>
 EXPECT_TOP_Z = HALF + BLEND * LIFT
 EXPECT_BOT_Z = -HALF
+EXPECT_TOP_HALF = HALF + BLEND * FLARE  <span class="c"># |x| and |y| of top verts</span>
 
 
 <span class="k">def</span> build():
@@ -246,10 +250,19 @@ <h2>Source</h2>
         co = tall.data[i].co
         <span class="k">if</span> co.z &gt; <span class="n">0.0</span>:
             co.z += LIFT
+            <span class="c"># flare top face outward so the blend reads as a taper, not a box</span>
+            co.x = math.copysign(HALF + FLARE, co.x)
+            co.y = math.copysign(HALF + FLARE, co.y)
     tall.value = BLEND
     <span class="k">return</span> obj
 
 
+<span class="k">def</span> blended_co(basis_kb, key_kb, i, value):
+    b = basis_kb.data[i].co
+    k = key_kb.data[i].co
+    <span class="k">return</span> b + value * (k - b)
+
+
 <span class="k">def</span> check(obj):
     keys = obj.data.shape_keys
     <span class="k">if</span> keys <span class="k">is</span> <span class="k">None</span>:
@@ -259,6 +272,7 @@ <h2>Source</h2>
     <span class="k">if</span> names != [<span class="s">&quot;Basis&quot;</span>, <span class="s">&quot;Tall&quot;</span>]:
         print(<span class="s">f&quot;</span><span class="s">ERROR: key names </span>{names}<span class="s"> != [&#x27;Basis&#x27;, &#x27;Tall&#x27;]</span><span class="s">&quot;</span>, file=sys.stderr)
         <span class="k">return</span> <span class="n">4</span>
+    basis = keys.key_blocks[<span class="s">&quot;Basis&quot;</span>]
     tall = keys.key_blocks[<span class="s">&quot;Tall&quot;</span>]
     <span class="k">if</span> abs(tall.value - BLEND) &gt; <span class="n">1e-6</span>:
         print(<span class="s">f&quot;</span><span class="s">ERROR: Tall.value </span>{tall.value}<span class="s"> != </span>{BLEND}<span class="s">&quot;</span>, file=sys.stderr)
@@ -266,9 +280,11 @@ <h2>Source</h2>
 
     <span class="c"># undeformed mesh.vertices stay at Basis — the trap this example catches</span>
     raw_top = max(v.co.z <span class="k">for</span> v <span class="k">in</span> obj.data.vertices)
-    <span class="k">if</span> abs(raw_top - HALF) &gt; <span class="n">1e-4</span>:
-        print(<span class="s">f&quot;</span><span class="s">ERROR: undeformed top z </span>{raw_top}<span class="s"> != basis </span>{HALF}<span class="s"> </span><span class="s">&quot;</span>
-              <span class="s">f&quot;</span><span class="s">(shape keys do not rewrite mesh.vertices)</span><span class="s">&quot;</span>, file=sys.stderr)
+    raw_xy = max(max(abs(v.co.x), abs(v.co.y)) <span class="k">for</span> v <span class="k">in</span> obj.data.vertices)
+    <span class="k">if</span> abs(raw_top - HALF) &gt; <span class="n">1e-4</span> <span class="k">or</span> abs(raw_xy - HALF) &gt; <span class="n">1e-4</span>:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: undeformed mesh not at Basis </span><span class="s">&quot;</span>
+              <span class="s">f&quot;</span><span class="s">(top_z=</span>{raw_top}<span class="s">, xy=</span>{raw_xy}<span class="s">, expected half=</span>{HALF}<span class="s">)</span><span class="s">&quot;</span>,
+              file=sys.stderr)
         <span class="k">return</span> <span class="n">6</span>
 
     bpy.context.view_layer.update()
@@ -276,19 +292,32 @@ <h2>Source</h2>
     ev = obj.evaluated_get(dg)
     em = ev.to_mesh()
     <span class="k">try</span>:
+        <span class="c"># every evaluated vert must match the closed-form blend from key_blocks</span>
+        <span class="k">for</span> i, v <span class="k">in</span> enumerate(em.vertices):
+            expect = blended_co(basis, tall, i, BLEND)
+            <span class="k">if</span> (v.co - expect).length &gt; <span class="n">1e-4</span>:
+                print(<span class="s">f&quot;</span><span class="s">ERROR: vert </span>{i}<span class="s"> evaluated </span>{tuple(v.co)}<span class="s"> != </span><span class="s">&quot;</span>
+                      <span class="s">f&quot;</span><span class="s">blend </span>{tuple(expect)}<span class="s">&quot;</span>, file=sys.stderr)
+                <span class="k">return</span> <span class="n">7</span>
         zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> em.vertices]
+        top_xy = [max(abs(v.co.x), abs(v.co.y)) <span class="k">for</span> v <span class="k">in</span> em.vertices <span class="k">if</span> v.co.z &gt; <span class="n">0.0</span>]
         top = max(zs)
         bot = min(zs)
+        flare = max(top_xy)
     <span class="k">finally</span>:
         ev.to_mesh_clear()
 
     <span class="k">if</span> abs(top - EXPECT_TOP_Z) &gt; <span class="n">1e-4</span> <span class="k">or</span> abs(bot - EXPECT_BOT_Z) &gt; <span class="n">1e-4</span>:
         print(<span class="s">f&quot;</span><span class="s">ERROR: evaluated z [</span>{bot:<span class="s">.4f</span>}<span class="s">, </span>{top:<span class="s">.4f</span>}<span class="s">] != </span><span class="s">&quot;</span>
               <span class="s">f&quot;</span><span class="s">[</span>{EXPECT_BOT_Z:<span class="s">.4f</span>}<span class="s">, </span>{EXPECT_TOP_Z:<span class="s">.4f</span>}<span class="s">]</span><span class="s">&quot;</span>, file=sys.stderr)
-        <span class="k">return</span> <span class="n">7</span>
+        <span class="k">return</span> <span class="n">8</span>
+    <span class="k">if</span> abs(flare - EXPECT_TOP_HALF) &gt; <span class="n">1e-4</span>:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: top flare </span>{flare:<span class="s">.4f</span>}<span class="s"> != </span>{EXPECT_TOP_HALF:<span class="s">.4f</span>}<span class="s">&quot;</span>,
+              file=sys.stderr)
+        <span class="k">return</span> <span class="n">9</span>
 
     print(<span class="s">f&quot;</span><span class="s">keys=</span>{names}<span class="s"> value=</span>{BLEND}<span class="s"> eval_z=</span>{bot:<span class="s">.3f</span>}<span class="s">..</span>{top:<span class="s">.3f</span>}<span class="s"> </span><span class="s">&quot;</span>
-          <span class="s">f&quot;</span><span class="s">undeformed_top=</span>{raw_top:<span class="s">.3f</span>}<span class="s">&quot;</span>)
+          <span class="s">f&quot;</span><span class="s">top_half=</span>{flare:<span class="s">.3f</span>}<span class="s"> undeformed_top=</span>{raw_top:<span class="s">.3f</span>}<span class="s">&quot;</span>)
     <span class="k">return</span> <span class="n">0</span>
 
 
@@ -303,13 +332,13 @@ <h2>Source</h2>
     mat = bpy.data.materials.new(<span class="s">&quot;Violet&quot;</span>)
     mat.use_nodes = <span class="k">True</span>
     bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.48</span>, <span class="n">0.08</span>, <span class="n">0.95</span>, <span class="n">1.0</span>)  <span class="c"># violet</span>
-    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.24</span>
+    bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.52</span>, <span class="n">0.06</span>, <span class="n">0.98</span>, <span class="n">1.0</span>)  <span class="c"># violet</span>
+    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.22</span>
     obj.data.materials.clear()
     obj.data.materials.append(mat)
     <span class="c"># bottom verts stay at -HALF; lift so the block rests on the floor</span>
     obj.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, HALF)
-    obj.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(<span class="n">32</span>))
+    obj.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(<span class="n">28</span>))
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -336,9 +365,9 @@ <h2>Source</h2>
     world.node_tree.nodes[<span class="s">&quot;Background&quot;</span>].inputs[<span class="s">&quot;Color&quot;</span>].default_value = (<span class="n">0.008</span>, <span class="n">0.009</span>, <span class="n">0.012</span>, <span class="n">1.0</span>)
     scene.world = world
 
-    <span class="c"># world-space mid-height of the blended block (bottom at 0, top at HALF+EXPECT_TOP_Z)</span>
+    world_top = HALF + EXPECT_TOP_Z
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, (HALF + EXPECT_TOP_Z) / <span class="n">2</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, world_top / <span class="n">2</span>)
     scene.collection.objects.link(aim)
 
     <span class="k">def</span> light(name, loc, energy, size, col):
@@ -354,14 +383,14 @@ <h2>Source</h2>
         lc.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
         lc.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
 
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.5</span>, -<span class="n">4.5</span>, <span class="n">5.5</span>), <span class="n">1400.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">320.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">2.0</span>), <span class="n">420.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.5</span>, -<span class="n">4.5</span>, <span class="n">5.5</span>), <span class="n">1500.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">340.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">2.0</span>), <span class="n">480.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>))
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">3.2</span>, -<span class="n">5.0</span>, <span class="n">2.2</span>)
+    cam.location = (<span class="n">3.6</span>, -<span class="n">4.8</span>, <span class="n">2.4</span>)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
@@ -401,7 +430,7 @@ <h2>Source</h2>
     <span class="k">if</span> args.output:
         <span class="k">if</span> <span class="k">not</span> render_still(obj, os.path.abspath(args.output), args.engine):
             print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
-            <span class="k">return</span> <span class="n">8</span>
+            <span class="k">return</span> <span class="n">10</span>
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
 
     print(<span class="s">&quot;shape-key-blend OK&quot;</span>)
diff --git a/docs/gallery/temp-override-join/index.html b/docs/gallery/temp-override-join/index.html
index cba8fd5..be85552 100644
--- a/docs/gallery/temp-override-join/index.html
+++ b/docs/gallery/temp-override-join/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>temp-override-join — Examples — Blender Developer Tools</title>
-  <meta name="description" content="Join three unit cubes into one L-shaped mesh under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form." />
+  <meta name="description" content="Join three unit cubes into a staircase under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/temp-override-join/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="temp-override-join — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="Join three unit cubes into one L-shaped mesh under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form." />
+  <meta property="og:description" content="Join three unit cubes into a staircase under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/temp-override-join/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/temp-override-join-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="temp-override-join — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="Join three unit cubes into one L-shaped mesh under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form." />
+  <meta name="twitter:description" content="Join three unit cubes into a staircase under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/temp-override-join-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -170,21 +170,21 @@
   </div>
   <header class="hero">
     <h1>temp-override-join</h1>
-    <p>Join three unit cubes into one L-shaped mesh under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form.</p>
+    <p>Join three unit cubes into a staircase under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom temp-override-join render">
       <img src="../assets/temp-override-join-hero.webp" alt="temp-override-join render" width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> temp_override actually applies: join consumes the sources, exactly one mesh remains, and topology is verts = 8 × blocks, faces = 6 × blocks.</div>
+    <div class="callout"><span class="tag">witnesses</span> temp_override actually applies: join consumes the sources, exactly one mesh remains, topology is verts = 8 × steps, and local Z spans all three steps.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/temp-override-join/temp_override_join.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that joins three unit cubes into one L-shaped mesh using <code>bpy.context.temp_override</code>, following the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/rules/prefer-temp-override-over-context-copy.mdc"><code>prefer-temp-override-over-context-copy</code></a> rule and the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/operators/SKILL.md"><code>operators</code></a> skill: operators that need a fabricated active/selection context run under <code>temp_override(**kwargs)</code>, not the deprecated <code>bpy.context.copy()</code> dict-pass form removed in Blender 5.x.</p>
-<p><strong>What it witnesses:</strong> <code>object.join</code> under <code>temp_override</code> actually consumes the sources. The check asserts the closed-form topology — verts = 8 × blocks, faces = 6 × blocks — that exactly one mesh object remains (the target), and that the source objects are gone. If the override is ignored (the 5.x failure mode of the old dict-pass path), join no-ops and the counts fail.</p>
+<p>A runnable example that joins three unit cubes into a staircase using <code>bpy.context.temp_override</code>, following the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/rules/prefer-temp-override-over-context-copy.mdc"><code>prefer-temp-override-over-context-copy</code></a> rule and the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/operators/SKILL.md"><code>operators</code></a> skill: operators that need a fabricated active/selection context run under <code>temp_override(**kwargs)</code>, not the deprecated <code>bpy.context.copy()</code> dict-pass form removed in Blender 5.x.</p>
+<p><strong>What it witnesses:</strong> <code>object.join</code> under <code>temp_override</code> actually consumes the sources. The check asserts closed-form topology (verts = 8 × steps, faces = 6 × steps), that exactly one mesh remains, that the sources are gone, and that the local Z span covers all three steps (<code>[-0.5, 2.5]</code>). A no-op override (the 5.x failure mode of the old dict-pass path) leaves only step 0 and the Z span fails.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python temp_override_join.py --
@@ -192,7 +192,7 @@ <h2>Run</h2>
 # Also render a still (EEVEE on a GPU host; use --engine cycles on GPU-less hosts):
 blender --background --python temp_override_join.py -- --output join.png
 blender --background --python temp_override_join.py -- --output join.png --engine cycles</code></pre>
-<p>It exits non-zero on failure (wrong object count, topology mismatch, or sources still alive). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
+<p>It exits non-zero on failure (wrong object count, topology mismatch, sources still alive, or incomplete Z span). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -206,8 +206,9 @@ <h2>Source</h2>
 need a fabricated active/selection context must run under
 `bpy.context.temp_override(**kwargs)`, not the deprecated
 `bpy.ops.*(bpy.context.copy())` dict-pass form (removed in 5.x). Three unit
-cubes are joined into one mesh; the check asserts the closed-form topology
-and that only the target object remains.
+cubes are joined into a staircase; the check asserts closed-form topology,
+that only the target remains, and that the local Z span spans all three steps
+(proving every source contributed geometry).
 
 By default it runs only the correctness check (no render) — the CI smoke
 check. Pass --output to also render a still:
@@ -218,10 +219,14 @@ <h2>Source</h2>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse
 
 CUBE_SIZE = <span class="n">1.0</span>
-<span class="c"># L-shape footprint: origin, +X, -Y — open corner faces the standard -Y camera</span>
-OFFSETS = ((<span class="n">0.0</span>, <span class="n">0.0</span>), (CUBE_SIZE, <span class="n">0.0</span>), (<span class="n">0.0</span>, -CUBE_SIZE))
-EXPECT_VERTS = <span class="n">8</span> * len(OFFSETS)
-EXPECT_FACES = <span class="n">6</span> * len(OFFSETS)
+HALF = CUBE_SIZE / <span class="n">2</span>
+STEPS = <span class="n">3</span>
+<span class="c"># staircase along +X: step i sits on the previous, center at (i, 0, i+0.5) * CUBE_SIZE</span>
+EXPECT_VERTS = <span class="n">8</span> * STEPS
+EXPECT_FACES = <span class="n">6</span> * STEPS
+<span class="c"># target origin is step 0; joined local Z spans [-HALF, (STEPS-1)*CUBE_SIZE + HALF]</span>
+EXPECT_Z_LO = -HALF
+EXPECT_Z_HI = (STEPS - <span class="n">1</span>) * CUBE_SIZE + HALF
 
 
 <span class="k">def</span> build_cubes():
@@ -235,13 +240,12 @@ <h2>Source</h2>
         bm.free()
 
     objs = []
-    <span class="k">for</span> i, (x, y) <span class="k">in</span> enumerate(OFFSETS):
-        <span class="c"># each object needs its own mesh datablock so join keeps all geometry</span>
+    <span class="k">for</span> i <span class="k">in</span> range(STEPS):
         obj = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Block.</span>{i}<span class="s">&quot;</span>, me.copy())
-        obj.location = (x, y, CUBE_SIZE / <span class="n">2</span>)
+        obj.location = (i * CUBE_SIZE, <span class="n">0.0</span>, (i + <span class="n">0.5</span>) * CUBE_SIZE)
         bpy.context.collection.objects.link(obj)
         objs.append(obj)
-    bpy.data.meshes.remove(me)  <span class="c"># template only</span>
+    bpy.data.meshes.remove(me)
     <span class="k">return</span> objs
 
 
@@ -283,15 +287,23 @@ <h2>Source</h2>
               file=sys.stderr)
         <span class="k">return</span> <span class="n">5</span>
 
-    <span class="c"># sources must be gone (join consumes them) — names captured before join</span>
     still_alive = [n <span class="k">for</span> n <span class="k">in</span> source_names <span class="k">if</span> n <span class="k">in</span> bpy.data.objects]
     <span class="k">if</span> still_alive:
         print(<span class="s">f&quot;</span><span class="s">ERROR: source objects still present after join: </span>{still_alive}<span class="s">&quot;</span>,
               file=sys.stderr)
         <span class="k">return</span> <span class="n">6</span>
 
-    print(<span class="s">f&quot;</span><span class="s">blocks=</span>{len(OFFSETS)}<span class="s"> verts=</span>{got_v}<span class="s"> faces=</span>{got_f}<span class="s"> </span><span class="s">&quot;</span>
-          <span class="s">f&quot;</span><span class="s">mesh_objects=1 override=temp_override</span><span class="s">&quot;</span>)
+    <span class="c"># Z span proves every step contributed — a no-op override leaves only step 0</span>
+    zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> joined.data.vertices]
+    z_lo, z_hi = min(zs), max(zs)
+    <span class="k">if</span> abs(z_lo - EXPECT_Z_LO) &gt; <span class="n">1e-4</span> <span class="k">or</span> abs(z_hi - EXPECT_Z_HI) &gt; <span class="n">1e-4</span>:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: local z [</span>{z_lo:<span class="s">.4f</span>}<span class="s">, </span>{z_hi:<span class="s">.4f</span>}<span class="s">] != </span><span class="s">&quot;</span>
+              <span class="s">f&quot;</span><span class="s">[</span>{EXPECT_Z_LO:<span class="s">.4f</span>}<span class="s">, </span>{EXPECT_Z_HI:<span class="s">.4f</span>}<span class="s">] — join did not merge all steps</span><span class="s">&quot;</span>,
+              file=sys.stderr)
+        <span class="k">return</span> <span class="n">7</span>
+
+    print(<span class="s">f&quot;</span><span class="s">steps=</span>{STEPS}<span class="s"> verts=</span>{got_v}<span class="s"> faces=</span>{got_f}<span class="s"> </span><span class="s">&quot;</span>
+          <span class="s">f&quot;</span><span class="s">z=</span>{z_lo:<span class="s">.3f</span>}<span class="s">..</span>{z_hi:<span class="s">.3f</span>}<span class="s"> override=temp_override</span><span class="s">&quot;</span>)
     <span class="k">return</span> <span class="n">0</span>
 
 
@@ -306,12 +318,12 @@ <h2>Source</h2>
     mat = bpy.data.materials.new(<span class="s">&quot;Amber&quot;</span>)
     mat.use_nodes = <span class="k">True</span>
     bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.98</span>, <span class="n">0.42</span>, <span class="n">0.02</span>, <span class="n">1.0</span>)  <span class="c"># amber</span>
-    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.22</span>
+    bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.98</span>, <span class="n">0.38</span>, <span class="n">0.02</span>, <span class="n">1.0</span>)  <span class="c"># amber</span>
+    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.20</span>
     obj.data.materials.clear()
     obj.data.materials.append(mat)
-    <span class="c"># L-shape rests on the floor; center the footprint on the origin</span>
-    obj.location = (-CUBE_SIZE / <span class="n">2</span>, CUBE_SIZE / <span class="n">2</span>, CUBE_SIZE / <span class="n">2</span>)
+    <span class="c"># center the staircase footprint; origin is step-0 center</span>
+    obj.location = (-(STEPS - <span class="n">1</span>) * CUBE_SIZE / <span class="n">2</span>, <span class="n">0.0</span>, HALF)
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -339,7 +351,7 @@ <h2>Source</h2>
     scene.world = world
 
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, CUBE_SIZE / <span class="n">2</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, STEPS * CUBE_SIZE / <span class="n">2</span>)
     scene.collection.objects.link(aim)
 
     <span class="k">def</span> light(name, loc, energy, size, col):
@@ -355,15 +367,14 @@ <h2>Source</h2>
         lc.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
         lc.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
 
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.5</span>, -<span class="n">4.5</span>, <span class="n">5.5</span>), <span class="n">1400.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">320.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">2.0</span>), <span class="n">420.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">5.0</span>, <span class="n">6.0</span>), <span class="n">1500.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">3.0</span>), <span class="n">340.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">5.0</span>, <span class="n">2.5</span>), <span class="n">480.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>))
 
-    <span class="c"># look into the open corner of the L so both arms read</span>
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">2.8</span>, -<span class="n">3.6</span>, <span class="n">2.8</span>)
+    cam.location = (<span class="n">4.2</span>, -<span class="n">5.2</span>, <span class="n">4.0</span>)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
@@ -406,7 +417,7 @@ <h2>Source</h2>
     <span class="k">if</span> args.output:
         <span class="k">if</span> <span class="k">not</span> render_still(joined, os.path.abspath(args.output), args.engine):
             print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
-            <span class="k">return</span> <span class="n">7</span>
+            <span class="k">return</span> <span class="n">8</span>
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
 
     print(<span class="s">&quot;temp-override-join OK&quot;</span>)
diff --git a/examples/curve-bevel-arc/README.md b/examples/curve-bevel-arc/README.md
index 0dd3112..3dd2cb9 100644
--- a/examples/curve-bevel-arc/README.md
+++ b/examples/curve-bevel-arc/README.md
@@ -1,14 +1,15 @@
 # Curve Bevel Arc
 
 A runnable example that builds a beveled Bezier semicircle entirely through the
-curve data API — `splines.new('BEZIER')`, per-point `bezier_points`, and
-`bevel_depth` — so the curve renders as a tube without a prior mesh conversion.
+curve data API — `splines.new('BEZIER')`, per-point `bezier_points`,
+`bevel_depth`, and `use_fill_caps` — so the curve renders as a solid tube without
+a prior mesh conversion.
 
 **What it witnesses:** renderable curve tubes are curve datablocks, not meshes.
-The check asserts eight Bezier points, `bevel_depth == 0.12`, and that the
-depsgraph-evaluated mesh has the deterministic topology (850 verts, 840 faces
-for these resolution settings) with a Z span that rests on the floor
-(`[≈0, 2 × bevel]`).
+The check asserts eight Bezier points, `bevel_depth == 0.15`, `use_fill_caps`,
+and that the depsgraph-evaluated mesh has the deterministic topology (1044 verts,
+1028 faces for these resolution settings) with a Z span that rests on the floor
+(`[0, 2 × bevel]`) and an X span of `2 × radius + 2 × bevel`.
 
 ## Run
 
@@ -21,5 +22,5 @@ blender --background --python curve_bevel_arc.py -- --output arc.png
 blender --background --python curve_bevel_arc.py -- --output arc.png --engine cycles
 ```
 
-It exits non-zero on failure (wrong point count, bevel, topology, or Z span).
+It exits non-zero on failure (wrong point count, bevel, caps, topology, or span).
 The `blender-smoke` workflow runs the check on Blender 4.5 LTS and 5.1.
diff --git a/examples/curve-bevel-arc/curve_bevel_arc.py b/examples/curve-bevel-arc/curve_bevel_arc.py
index 07f0e06..11d1f4e 100644
--- a/examples/curve-bevel-arc/curve_bevel_arc.py
+++ b/examples/curve-bevel-arc/curve_bevel_arc.py
@@ -1,10 +1,10 @@
 """Beveled Bezier arc via the curve data API — a runnable example.
 
 Witnesses that renderable tubes are authored on `bpy.types.Curve` directly
-(`splines.new('BEZIER')`, `bezier_points`, `bevel_depth`) — not by meshing
-first or calling curve operators. The check asserts the closed-form point
-count, bevel depth, and that the depsgraph-evaluated mesh has the
-deterministic topology and Z span of a tube whose centerline sits at
+(`splines.new('BEZIER')`, `bezier_points`, `bevel_depth`, `use_fill_caps`) —
+not by meshing first or calling curve operators. The check asserts the
+closed-form point count, bevel depth, filled-cap topology, and that the
+depsgraph-evaluated mesh has a Z span of a tube whose centerline sits at
 `z = bevel_depth` (resting on the floor).
 
 By default it runs only the correctness check (no render) — the CI smoke
@@ -17,12 +17,12 @@
 
 N_POINTS = 8
 RADIUS = 1.5
-BEVEL = 0.12
-BEVEL_RES = 3
+BEVEL = 0.15
+BEVEL_RES = 4
 RES_U = 12
-# measured for the parameters above — identical on 4.4 and 5.1
-EXPECT_VERTS = 850
-EXPECT_FACES = 840
+# measured for the parameters above with use_fill_caps=True — identical on 4.4 and 5.1
+EXPECT_VERTS = 1044
+EXPECT_FACES = 1028
 
 
 def build():
@@ -32,6 +32,7 @@ def build():
     curve.bevel_depth = BEVEL
     curve.bevel_resolution = BEVEL_RES
     curve.resolution_u = RES_U
+    curve.use_fill_caps = True  # solid ends — not a hollow pipe
 
     spline = curve.splines.new('BEZIER')
     spline.bezier_points.add(N_POINTS - 1)  # one point exists already
@@ -59,6 +60,9 @@ def check(obj):
     if abs(curve.bevel_depth - BEVEL) > 1e-6:
         print(f"ERROR: bevel_depth {curve.bevel_depth} != {BEVEL}", file=sys.stderr)
         return 5
+    if not curve.use_fill_caps:
+        print("ERROR: use_fill_caps is False — ends should be capped", file=sys.stderr)
+        return 6
 
     bpy.context.view_layer.update()
     dg = bpy.context.evaluated_depsgraph_get()
@@ -69,6 +73,9 @@ def check(obj):
         got_f = len(em.polygons)
         zs = [v.co.z for v in em.vertices]
         z_lo, z_hi = min(zs), max(zs)
+        # arc spans x in [-RADIUS, +RADIUS] at the endpoints
+        xs = [v.co.x for v in em.vertices]
+        x_span = max(xs) - min(xs)
     finally:
         ev.to_mesh_clear()
 
@@ -76,19 +83,24 @@ def check(obj):
         print(f"ERROR: evaluated topology verts={got_v} faces={got_f} != "
               f"expected verts={EXPECT_VERTS} faces={EXPECT_FACES}",
               file=sys.stderr)
-        return 6
-
-    # tube diameter ≈ 2 * bevel; centerline at z=BEVEL → span [0, 2*BEVEL]
-    if z_lo < -0.02 or z_lo > 0.03:
-        print(f"ERROR: tube does not rest on floor (z_lo={z_lo:.4f})", file=sys.stderr)
         return 7
-    if abs(z_hi - 2 * BEVEL) > 0.03:
+
+    # tube diameter = 2 * bevel; centerline at z=BEVEL → span [0, 2*BEVEL]
+    if abs(z_lo) > 1e-4:
+        print(f"ERROR: tube does not rest on floor (z_lo={z_lo:.6f})", file=sys.stderr)
+        return 8
+    if abs(z_hi - 2 * BEVEL) > 1e-4:
         print(f"ERROR: tube height {z_hi:.4f} != 2*bevel={2 * BEVEL:.4f}",
               file=sys.stderr)
-        return 8
-
-    print(f"points={n} bevel={BEVEL} eval_verts={got_v} eval_faces={got_f} "
-          f"z={z_lo:.3f}..{z_hi:.3f}")
+        return 9
+    # diameter adds 2*BEVEL to the arc's 2*RADIUS span
+    expect_x_span = 2 * RADIUS + 2 * BEVEL
+    if abs(x_span - expect_x_span) > 0.05:
+        print(f"ERROR: x span {x_span:.4f} != {expect_x_span:.4f}", file=sys.stderr)
+        return 10
+
+    print(f"points={n} bevel={BEVEL} caps=True eval_verts={got_v} "
+          f"eval_faces={got_f} z={z_lo:.3f}..{z_hi:.3f} x_span={x_span:.3f}")
     return 0
 
 
@@ -101,10 +113,10 @@ def render_still(obj, path, engine):
     mat = bpy.data.materials.new("Rose")
     mat.use_nodes = True
     bsdf = mat.node_tree.nodes["Principled BSDF"]
-    bsdf.inputs["Base Color"].default_value = (0.92, 0.14, 0.42, 1.0)  # rose
-    bsdf.inputs["Roughness"].default_value = 0.28
+    bsdf.inputs["Base Color"].default_value = (0.95, 0.10, 0.38, 1.0)  # rose
+    bsdf.inputs["Roughness"].default_value = 0.24
     obj.data.materials.append(mat)
-    obj.rotation_euler = (0.0, 0.0, math.radians(-20))
+    obj.rotation_euler = (0.0, 0.0, math.radians(-18))
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -132,7 +144,7 @@ def render_still(obj, path, engine):
     scene.world = world
 
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.4, BEVEL)
+    aim.location = (0.0, 0.35, BEVEL)
     scene.collection.objects.link(aim)
 
     def light(name, loc, energy, size, col):
@@ -148,14 +160,14 @@ def light(name, loc, energy, size, col):
         lc.track_axis = 'TRACK_NEGATIVE_Z'
         lc.up_axis = 'UP_Y'
 
-    light("Key", (-3.5, -4.5, 5.5), 1400.0, 6.0, (1.0, 0.98, 0.94))
-    light("Fill", (5.0, -3.5, 2.5), 320.0, 8.0, (0.8, 0.87, 1.0))
-    light("Rim", (1.5, 4.5, 2.0), 420.0, 4.0, (1.0, 0.75, 0.45))
+    light("Key", (-3.5, -4.5, 5.5), 1500.0, 6.0, (1.0, 0.98, 0.94))
+    light("Fill", (5.0, -3.5, 2.5), 340.0, 8.0, (0.8, 0.87, 1.0))
+    light("Rim", (1.5, 4.5, 2.0), 480.0, 4.0, (1.0, 0.75, 0.45))
 
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (2.8, -4.0, 2.4)
+    cam.location = (3.0, -4.2, 2.6)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new('TRACK_TO')
@@ -195,7 +207,7 @@ def main():
     if args.output:
         if not render_still(obj, os.path.abspath(args.output), args.engine):
             print("ERROR: render produced no file", file=sys.stderr)
-            return 9
+            return 11
         print(f"rendered still {args.output}")
 
     print("curve-bevel-arc OK")
diff --git a/examples/curve-bevel-arc/preview.webp b/examples/curve-bevel-arc/preview.webp
index e154557..b8c1bcc 100644
Binary files a/examples/curve-bevel-arc/preview.webp and b/examples/curve-bevel-arc/preview.webp differ
diff --git a/examples/gallery.json b/examples/gallery.json
index f7af3e3..0681c46 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -80,8 +80,8 @@
     {
       "name": "temp-override-join",
       "dir": "examples/temp-override-join",
-      "teaches": "Join three unit cubes into one L-shaped mesh under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form.",
-      "witnessesFix": "temp_override actually applies: join consumes the sources, exactly one mesh remains, and topology is verts = 8 × blocks, faces = 6 × blocks.",
+      "teaches": "Join three unit cubes into a staircase under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form.",
+      "witnessesFix": "temp_override actually applies: join consumes the sources, exactly one mesh remains, topology is verts = 8 × steps, and local Z spans all three steps.",
       "hero": "docs/gallery/assets/temp-override-join-hero.webp",
       "preview": "examples/temp-override-join/preview.webp",
       "tags": ["operators", "context"]
@@ -89,8 +89,8 @@
     {
       "name": "gn-instance-grid",
       "dir": "examples/gn-instance-grid",
-      "teaches": "A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances — attached as a NODES modifier with no Group Input geometry.",
-      "witnessesFix": "Realized instances produce closed-form topology: eval verts = grid points × cube verts (3 × 3 × 8 = 72), and Set Material carries the accent onto the evaluated mesh.",
+      "teaches": "A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry.",
+      "witnessesFix": "Realized instances produce closed-form topology (72 verts, 54 faces), Set Material carries Lime, and the corner instance center sits at its closed-form grid coordinate.",
       "hero": "docs/gallery/assets/gn-instance-grid-hero.webp",
       "preview": "examples/gn-instance-grid/preview.webp",
       "tags": ["geometry-nodes", "instancing"]
@@ -98,8 +98,8 @@
     {
       "name": "shape-key-blend",
       "dir": "examples/shape-key-blend",
-      "teaches": "A relative shape key authored entirely through the data API — shape_key_add, per-vertex key_blocks data, and .value — read back from the depsgraph-evaluated mesh.",
-      "witnessesFix": "Shape keys do not rewrite mesh.vertices: undeformed top z stays at Basis, and evaluated z matches basis + value × (key − basis).",
+      "teaches": "A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / .value — read back from the depsgraph-evaluated mesh.",
+      "witnessesFix": "Shape keys do not rewrite mesh.vertices: every evaluated vert matches basis + value × (key − basis), including the flared top half-extent.",
       "hero": "docs/gallery/assets/shape-key-blend-hero.webp",
       "preview": "examples/shape-key-blend/preview.webp",
       "tags": ["mesh", "shape-keys"]
@@ -107,8 +107,8 @@
     {
       "name": "curve-bevel-arc",
       "dir": "examples/curve-bevel-arc",
-      "teaches": "A beveled Bezier semicircle authored on bpy.types.Curve — splines.new('BEZIER'), bezier_points, bevel_depth — so the curve renders as a tube without a prior mesh conversion.",
-      "witnessesFix": "Curve tubes are curve datablocks: eight Bezier points, bevel_depth == 0.12, and the evaluated mesh has deterministic topology (850 verts, 840 faces) resting on the floor.",
+      "teaches": "A beveled Bezier semicircle authored on bpy.types.Curve — splines.new('BEZIER'), bezier_points, bevel_depth, use_fill_caps — so the curve renders as a solid tube without a prior mesh conversion.",
+      "witnessesFix": "Curve tubes are curve datablocks: eight Bezier points, bevel_depth == 0.15, filled caps, and the evaluated mesh has deterministic topology (1044 verts, 1028 faces) resting on the floor.",
       "hero": "docs/gallery/assets/curve-bevel-arc-hero.webp",
       "preview": "examples/curve-bevel-arc/preview.webp",
       "tags": ["curves", "bevel"]
diff --git a/examples/gn-instance-grid/README.md b/examples/gn-instance-grid/README.md
index 815c153..03712a7 100644
--- a/examples/gn-instance-grid/README.md
+++ b/examples/gn-instance-grid/README.md
@@ -1,16 +1,17 @@
 # GN Instance Grid
 
 A runnable example that builds a generative Geometry Nodes tree — Mesh Grid →
-Instance on Points → Realize Instances → Transform — and attaches it as a
-`NODES` modifier, following the
+Instance on Points → Realize Instances → Transform → Set Shade Smooth — and
+attaches it as a `NODES` modifier, following the
 [`geometry-nodes-python`](../../skills/geometry-nodes-python/SKILL.md) skill. The
 tree has no Group Input: the grid and cube primitives live inside the node group.
 
 **What it witnesses:** instancing is not free geometry until you realize it. The
 check asserts the closed-form evaluated topology — verts = grid points × cube
-verts (3 × 3 × 8 = 72), faces = 9 × 6 — and that a `Set Material` node carries
-the lime accent onto the evaluated mesh. If Realize Instances is omitted, the
-evaluated mesh is empty and the counts fail.
+verts (3 × 3 × 8 = 72), faces = 9 × 6 — that a `Set Material` node carries the
+lime accent, and that the corner instance center sits at its closed-form grid
+coordinate. If Realize Instances is omitted, the evaluated mesh is empty and the
+counts fail.
 
 ## Run
 
@@ -23,5 +24,6 @@ blender --background --python gn_instance_grid.py -- --output grid.png
 blender --background --python gn_instance_grid.py -- --output grid.png --engine cycles
 ```
 
-It exits non-zero on failure (wrong carrier, topology mismatch, or missing
-material). The `blender-smoke` workflow runs the check on Blender 4.5 LTS and 5.1.
+It exits non-zero on failure (wrong carrier, topology mismatch, missing material, or
+misplaced corner). The `blender-smoke` workflow runs the check on Blender 4.5 LTS and
+5.1.
diff --git a/examples/gn-instance-grid/gn_instance_grid.py b/examples/gn-instance-grid/gn_instance_grid.py
index 58ebd73..607a16c 100644
--- a/examples/gn-instance-grid/gn_instance_grid.py
+++ b/examples/gn-instance-grid/gn_instance_grid.py
@@ -5,7 +5,8 @@
 Instances → Transform) attached as a NODES modifier, with no Group Input
 geometry. The check asserts the closed-form evaluated topology —
 verts = grid_points × cube_verts — proving instances were realized, not
-left as empty instance geometry.
+left as empty instance geometry, and that a corner instance sits at its
+closed-form grid coordinate.
 
 By default it runs only the correctness check (no render) — the CI smoke
 check. Pass --output to also render a still:
@@ -17,13 +18,17 @@
 
 GRID_X = 3
 GRID_Y = 3
-GRID_SIZE = 2.0
-CUBE_SIZE = 0.35
+GRID_SIZE = 2.4
+CUBE_SIZE = 0.42
 CUBE_VERTS = 8
 CUBE_FACES = 6
 GRID_POINTS = GRID_X * GRID_Y
 EXPECT_VERTS = GRID_POINTS * CUBE_VERTS
 EXPECT_FACES = GRID_POINTS * CUBE_FACES
+# Mesh Grid spans [-GRID_SIZE/2, +GRID_SIZE/2]; corner point at (+half, +half)
+GRID_HALF = GRID_SIZE / 2
+# after Transform lift, corner cube center is at (GRID_HALF, GRID_HALF, CUBE_SIZE/2)
+CORNER_CENTER = (GRID_HALF, GRID_HALF, CUBE_SIZE / 2)
 
 
 def build_instance_grid_tree(material=None):
@@ -49,11 +54,16 @@ def build_instance_grid_tree(material=None):
     # cubes are centered on grid points at z=0; lift so they rest on the floor
     xform.inputs["Translation"].default_value = (0.0, 0.0, CUBE_SIZE / 2)
 
+    # crisp facets — matches the other studio examples
+    shade = tree.nodes.new('GeometryNodeSetShadeSmooth')
+    shade.inputs["Shade Smooth"].default_value = False
+
     tree.links.new(grid.outputs["Mesh"], iop.inputs["Points"])
     tree.links.new(cube.outputs["Mesh"], iop.inputs["Instance"])
     tree.links.new(iop.outputs["Instances"], realize.inputs["Geometry"])
     tree.links.new(realize.outputs["Geometry"], xform.inputs["Geometry"])
-    out_socket = xform.outputs["Geometry"]
+    tree.links.new(xform.outputs["Geometry"], shade.inputs["Geometry"])
+    out_socket = shade.outputs["Geometry"]
 
     if material is not None:
         set_mat = tree.nodes.new('GeometryNodeSetMaterial')
@@ -76,8 +86,8 @@ def build():
     mat = bpy.data.materials.new("Lime")
     mat.use_nodes = True
     bsdf = mat.node_tree.nodes["Principled BSDF"]
-    bsdf.inputs["Base Color"].default_value = (0.28, 0.92, 0.08, 1.0)  # lime
-    bsdf.inputs["Roughness"].default_value = 0.24
+    bsdf.inputs["Base Color"].default_value = (0.22, 0.95, 0.06, 1.0)  # lime
+    bsdf.inputs["Roughness"].default_value = 0.22
 
     tree = build_instance_grid_tree(material=mat)
     mod = obj.modifiers.new("instance_grid", 'NODES')
@@ -98,6 +108,16 @@ def check(obj):
         got_v = len(em.vertices)
         got_f = len(em.polygons)
         mat_names = [m.name for m in em.materials if m is not None]
+        # corner instance: the 8 verts nearest CORNER_CENTER should average to it
+        corner = [v.co for v in em.vertices
+                  if (v.co.x > GRID_HALF - CUBE_SIZE and v.co.y > GRID_HALF - CUBE_SIZE)]
+        if len(corner) != CUBE_VERTS:
+            print(f"ERROR: corner instance has {len(corner)} verts, expected {CUBE_VERTS}",
+                  file=sys.stderr)
+            return 4
+        cx = sum(c.x for c in corner) / CUBE_VERTS
+        cy = sum(c.y for c in corner) / CUBE_VERTS
+        cz = sum(c.z for c in corner) / CUBE_VERTS
     finally:
         ev.to_mesh_clear()
 
@@ -105,15 +125,24 @@ def check(obj):
         print(f"ERROR: evaluated topology verts={got_v} faces={got_f} != "
               f"expected verts={EXPECT_VERTS} faces={EXPECT_FACES}",
               file=sys.stderr)
-        return 4
+        return 5
 
     if "Lime" not in mat_names:
         print(f"ERROR: Set Material did not carry Lime onto evaluated mesh "
               f"(materials={mat_names})", file=sys.stderr)
-        return 5
+        return 6
+
+    for got, exp, axis in ((cx, CORNER_CENTER[0], 'x'),
+                           (cy, CORNER_CENTER[1], 'y'),
+                           (cz, CORNER_CENTER[2], 'z')):
+        if abs(got - exp) > 1e-3:
+            print(f"ERROR: corner center {axis}={got:.4f} != {exp:.4f}",
+                  file=sys.stderr)
+            return 7
 
     print(f"grid={GRID_X}x{GRID_Y} points={GRID_POINTS} "
-          f"eval_verts={got_v} eval_faces={got_f} material=Lime")
+          f"eval_verts={got_v} eval_faces={got_f} "
+          f"corner=({cx:.2f},{cy:.2f},{cz:.2f}) material=Lime")
     return 0
 
 
@@ -149,31 +178,34 @@ def render_still(obj, path, engine):
     world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.008, 0.009, 0.012, 1.0)
     scene.world = world
 
-    def light(name, loc, energy, size, col, rot):
+    # tip the grid so depth reads; cubes already rest on the floor via the tree
+    obj.rotation_euler = (0.0, 0.0, math.radians(24))
+
+    aim = bpy.data.objects.new("Aim", None)
+    aim.location = (0.0, 0.0, CUBE_SIZE / 2)
+    scene.collection.objects.link(aim)
+
+    def light(name, loc, energy, size, col):
         ld = bpy.data.lights.new(name, 'AREA')
         ld.energy = energy
         ld.size = size
         ld.color = col
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
-        ob.rotation_euler = tuple(math.radians(a) for a in rot)
         scene.collection.objects.link(ob)
+        lc = ob.constraints.new('TRACK_TO')
+        lc.target = aim
+        lc.track_axis = 'TRACK_NEGATIVE_Z'
+        lc.up_axis = 'UP_Y'
 
-    light("Key", (-3.5, -4.5, 5.5), 1400.0, 6.0, (1.0, 0.98, 0.94), (48, 0, -35))
-    light("Fill", (5.0, -3.5, 2.5), 320.0, 8.0, (0.8, 0.87, 1.0), (65, 0, 50))
-    light("Rim", (1.5, 4.5, 2.0), 420.0, 4.0, (1.0, 0.75, 0.45), (-82, 0, 165))
-
-    # tip the grid so depth reads; cubes already rest on the floor via the tree
-    obj.rotation_euler = (0.0, 0.0, math.radians(22))
+    light("Key", (-3.5, -4.5, 5.5), 1500.0, 6.0, (1.0, 0.98, 0.94))
+    light("Fill", (5.0, -3.5, 2.5), 340.0, 8.0, (0.8, 0.87, 1.0))
+    light("Rim", (1.5, 4.5, 2.0), 480.0, 4.0, (1.0, 0.75, 0.45))
 
-    aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, CUBE_SIZE / 2)
-    scene.collection.objects.link(aim)
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 55.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    # three-quarter view so the 3x3 grid reads as depth, not a flat array
-    cam.location = (3.2, -3.8, 2.6)
+    cam.location = (3.6, -4.2, 2.8)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new('TRACK_TO')
@@ -213,7 +245,7 @@ def main():
     if args.output:
         if not render_still(obj, os.path.abspath(args.output), args.engine):
             print("ERROR: render produced no file", file=sys.stderr)
-            return 6
+            return 8
         print(f"rendered still {args.output}")
 
     print("gn-instance-grid OK")
diff --git a/examples/gn-instance-grid/preview.webp b/examples/gn-instance-grid/preview.webp
index 5fb0196..f9ce1b9 100644
Binary files a/examples/gn-instance-grid/preview.webp and b/examples/gn-instance-grid/preview.webp differ
diff --git a/examples/shape-key-blend/README.md b/examples/shape-key-blend/README.md
index d886cb9..2b05c59 100644
--- a/examples/shape-key-blend/README.md
+++ b/examples/shape-key-blend/README.md
@@ -2,14 +2,13 @@
 
 A runnable example that authors a relative shape key entirely through the data
 API — `shape_key_add`, per-vertex `key_blocks["Tall"].data[i].co`, and
-`.value` — then reads the blend back from the depsgraph-evaluated mesh.
+`.value` — then reads the blend back from the depsgraph-evaluated mesh. The Tall
+key both lifts and flares the top face, so the silhouette is a truncated pyramid.
 
 **What it witnesses:** shape keys do not rewrite `mesh.vertices`. The undeformed
-mesh stays at Basis; the closed-form blend
-`co = basis + value × (key − basis)` appears only on the evaluated mesh. The
-check asserts key names `Basis`/`Tall`, `Tall.value == 0.5`, undeformed top z
-equals the basis half-extent, and evaluated z matches
-`[−half, half + value × lift]`.
+mesh stays at Basis; every evaluated vertex matches the closed-form blend
+`co = basis + value × (key − basis)`. The check also asserts the flared top half-extent
+(`0.5 + value × flare`) so a uniform-scale mistake cannot pass.
 
 ## Run
 
@@ -22,5 +21,5 @@ blender --background --python shape_key_blend.py -- --output blend.png
 blender --background --python shape_key_blend.py -- --output blend.png --engine cycles
 ```
 
-It exits non-zero on failure (missing keys, wrong value, or evaluated z mismatch).
-The `blender-smoke` workflow runs the check on Blender 4.5 LTS and 5.1.
+It exits non-zero on failure (missing keys, wrong value, per-vert blend mismatch, or
+flare miss). The `blender-smoke` workflow runs the check on Blender 4.5 LTS and 5.1.
diff --git a/examples/shape-key-blend/preview.webp b/examples/shape-key-blend/preview.webp
index efa3ff6..1444329 100644
Binary files a/examples/shape-key-blend/preview.webp and b/examples/shape-key-blend/preview.webp differ
diff --git a/examples/shape-key-blend/shape_key_blend.py b/examples/shape-key-blend/shape_key_blend.py
index 1b49edc..baa9d5a 100644
--- a/examples/shape-key-blend/shape_key_blend.py
+++ b/examples/shape-key-blend/shape_key_blend.py
@@ -7,6 +7,9 @@
 wrong block, forgets Basis, or reads undeformed `mesh.vertices` instead of
 the evaluated mesh.
 
+The Tall key both lifts and flares the top face, so the silhouette is a
+truncated pyramid — clearly a blend, not a uniformly scaled box.
+
 By default it runs only the correctness check (no render) — the CI smoke
 check. Pass --output to also render a still:
 
@@ -16,12 +19,13 @@
 import bpy, bmesh, sys, os, math, argparse
 
 CUBE_SIZE = 1.0
-LIFT = 1.2
+LIFT = 2.0
+FLARE = 0.45  # extra half-extent on top face in XY at full key
 BLEND = 0.5
-# cube spans [-half, +half]; top verts start at +half
 HALF = CUBE_SIZE / 2
 EXPECT_TOP_Z = HALF + BLEND * LIFT
 EXPECT_BOT_Z = -HALF
+EXPECT_TOP_HALF = HALF + BLEND * FLARE  # |x| and |y| of top verts
 
 
 def build():
@@ -44,10 +48,19 @@ def build():
         co = tall.data[i].co
         if co.z > 0.0:
             co.z += LIFT
+            # flare top face outward so the blend reads as a taper, not a box
+            co.x = math.copysign(HALF + FLARE, co.x)
+            co.y = math.copysign(HALF + FLARE, co.y)
     tall.value = BLEND
     return obj
 
 
+def blended_co(basis_kb, key_kb, i, value):
+    b = basis_kb.data[i].co
+    k = key_kb.data[i].co
+    return b + value * (k - b)
+
+
 def check(obj):
     keys = obj.data.shape_keys
     if keys is None:
@@ -57,6 +70,7 @@ def check(obj):
     if names != ["Basis", "Tall"]:
         print(f"ERROR: key names {names} != ['Basis', 'Tall']", file=sys.stderr)
         return 4
+    basis = keys.key_blocks["Basis"]
     tall = keys.key_blocks["Tall"]
     if abs(tall.value - BLEND) > 1e-6:
         print(f"ERROR: Tall.value {tall.value} != {BLEND}", file=sys.stderr)
@@ -64,9 +78,11 @@ def check(obj):
 
     # undeformed mesh.vertices stay at Basis — the trap this example catches
     raw_top = max(v.co.z for v in obj.data.vertices)
-    if abs(raw_top - HALF) > 1e-4:
-        print(f"ERROR: undeformed top z {raw_top} != basis {HALF} "
-              f"(shape keys do not rewrite mesh.vertices)", file=sys.stderr)
+    raw_xy = max(max(abs(v.co.x), abs(v.co.y)) for v in obj.data.vertices)
+    if abs(raw_top - HALF) > 1e-4 or abs(raw_xy - HALF) > 1e-4:
+        print(f"ERROR: undeformed mesh not at Basis "
+              f"(top_z={raw_top}, xy={raw_xy}, expected half={HALF})",
+              file=sys.stderr)
         return 6
 
     bpy.context.view_layer.update()
@@ -74,19 +90,32 @@ def check(obj):
     ev = obj.evaluated_get(dg)
     em = ev.to_mesh()
     try:
+        # every evaluated vert must match the closed-form blend from key_blocks
+        for i, v in enumerate(em.vertices):
+            expect = blended_co(basis, tall, i, BLEND)
+            if (v.co - expect).length > 1e-4:
+                print(f"ERROR: vert {i} evaluated {tuple(v.co)} != "
+                      f"blend {tuple(expect)}", file=sys.stderr)
+                return 7
         zs = [v.co.z for v in em.vertices]
+        top_xy = [max(abs(v.co.x), abs(v.co.y)) for v in em.vertices if v.co.z > 0.0]
         top = max(zs)
         bot = min(zs)
+        flare = max(top_xy)
     finally:
         ev.to_mesh_clear()
 
     if abs(top - EXPECT_TOP_Z) > 1e-4 or abs(bot - EXPECT_BOT_Z) > 1e-4:
         print(f"ERROR: evaluated z [{bot:.4f}, {top:.4f}] != "
               f"[{EXPECT_BOT_Z:.4f}, {EXPECT_TOP_Z:.4f}]", file=sys.stderr)
-        return 7
+        return 8
+    if abs(flare - EXPECT_TOP_HALF) > 1e-4:
+        print(f"ERROR: top flare {flare:.4f} != {EXPECT_TOP_HALF:.4f}",
+              file=sys.stderr)
+        return 9
 
     print(f"keys={names} value={BLEND} eval_z={bot:.3f}..{top:.3f} "
-          f"undeformed_top={raw_top:.3f}")
+          f"top_half={flare:.3f} undeformed_top={raw_top:.3f}")
     return 0
 
 
@@ -101,13 +130,13 @@ def render_still(obj, path, engine):
     mat = bpy.data.materials.new("Violet")
     mat.use_nodes = True
     bsdf = mat.node_tree.nodes["Principled BSDF"]
-    bsdf.inputs["Base Color"].default_value = (0.48, 0.08, 0.95, 1.0)  # violet
-    bsdf.inputs["Roughness"].default_value = 0.24
+    bsdf.inputs["Base Color"].default_value = (0.52, 0.06, 0.98, 1.0)  # violet
+    bsdf.inputs["Roughness"].default_value = 0.22
     obj.data.materials.clear()
     obj.data.materials.append(mat)
     # bottom verts stay at -HALF; lift so the block rests on the floor
     obj.location = (0.0, 0.0, HALF)
-    obj.rotation_euler = (0.0, 0.0, math.radians(32))
+    obj.rotation_euler = (0.0, 0.0, math.radians(28))
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -134,9 +163,9 @@ def render_still(obj, path, engine):
     world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.008, 0.009, 0.012, 1.0)
     scene.world = world
 
-    # world-space mid-height of the blended block (bottom at 0, top at HALF+EXPECT_TOP_Z)
+    world_top = HALF + EXPECT_TOP_Z
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, (HALF + EXPECT_TOP_Z) / 2)
+    aim.location = (0.0, 0.0, world_top / 2)
     scene.collection.objects.link(aim)
 
     def light(name, loc, energy, size, col):
@@ -152,14 +181,14 @@ def light(name, loc, energy, size, col):
         lc.track_axis = 'TRACK_NEGATIVE_Z'
         lc.up_axis = 'UP_Y'
 
-    light("Key", (-3.5, -4.5, 5.5), 1400.0, 6.0, (1.0, 0.98, 0.94))
-    light("Fill", (5.0, -3.5, 2.5), 320.0, 8.0, (0.8, 0.87, 1.0))
-    light("Rim", (1.5, 4.5, 2.0), 420.0, 4.0, (1.0, 0.75, 0.45))
+    light("Key", (-3.5, -4.5, 5.5), 1500.0, 6.0, (1.0, 0.98, 0.94))
+    light("Fill", (5.0, -3.5, 2.5), 340.0, 8.0, (0.8, 0.87, 1.0))
+    light("Rim", (1.5, 4.5, 2.0), 480.0, 4.0, (1.0, 0.75, 0.45))
 
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (3.2, -5.0, 2.2)
+    cam.location = (3.6, -4.8, 2.4)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new('TRACK_TO')
@@ -199,7 +228,7 @@ def main():
     if args.output:
         if not render_still(obj, os.path.abspath(args.output), args.engine):
             print("ERROR: render produced no file", file=sys.stderr)
-            return 8
+            return 10
         print(f"rendered still {args.output}")
 
     print("shape-key-blend OK")
diff --git a/examples/temp-override-join/README.md b/examples/temp-override-join/README.md
index 063811f..6fa265b 100644
--- a/examples/temp-override-join/README.md
+++ b/examples/temp-override-join/README.md
@@ -1,6 +1,6 @@
 # Temp-Override Join
 
-A runnable example that joins three unit cubes into one L-shaped mesh using
+A runnable example that joins three unit cubes into a staircase using
 `bpy.context.temp_override`, following the
 [`prefer-temp-override-over-context-copy`](../../rules/prefer-temp-override-over-context-copy.mdc)
 rule and the [`operators`](../../skills/operators/SKILL.md) skill: operators that need a
@@ -8,10 +8,10 @@ fabricated active/selection context run under `temp_override(**kwargs)`, not the
 `bpy.context.copy()` dict-pass form removed in Blender 5.x.
 
 **What it witnesses:** `object.join` under `temp_override` actually consumes the sources.
-The check asserts the closed-form topology — verts = 8 × blocks, faces = 6 × blocks — that
-exactly one mesh object remains (the target), and that the source objects are gone. If the
-override is ignored (the 5.x failure mode of the old dict-pass path), join no-ops and the
-counts fail.
+The check asserts closed-form topology (verts = 8 × steps, faces = 6 × steps), that exactly
+one mesh remains, that the sources are gone, and that the local Z span covers all three
+steps (`[-0.5, 2.5]`). A no-op override (the 5.x failure mode of the old dict-pass path)
+leaves only step 0 and the Z span fails.
 
 ## Run
 
@@ -24,5 +24,6 @@ blender --background --python temp_override_join.py -- --output join.png
 blender --background --python temp_override_join.py -- --output join.png --engine cycles
 ```
 
-It exits non-zero on failure (wrong object count, topology mismatch, or sources still
-alive). The `blender-smoke` workflow runs the check on Blender 4.5 LTS and 5.1.
+It exits non-zero on failure (wrong object count, topology mismatch, sources still alive,
+or incomplete Z span). The `blender-smoke` workflow runs the check on Blender 4.5 LTS and
+5.1.
diff --git a/examples/temp-override-join/preview.webp b/examples/temp-override-join/preview.webp
index a76557b..e93b2e1 100644
Binary files a/examples/temp-override-join/preview.webp and b/examples/temp-override-join/preview.webp differ
diff --git a/examples/temp-override-join/temp_override_join.py b/examples/temp-override-join/temp_override_join.py
index 8d5ef24..03d033e 100644
--- a/examples/temp-override-join/temp_override_join.py
+++ b/examples/temp-override-join/temp_override_join.py
@@ -4,8 +4,9 @@
 need a fabricated active/selection context must run under
 `bpy.context.temp_override(**kwargs)`, not the deprecated
 `bpy.ops.*(bpy.context.copy())` dict-pass form (removed in 5.x). Three unit
-cubes are joined into one mesh; the check asserts the closed-form topology
-and that only the target object remains.
+cubes are joined into a staircase; the check asserts closed-form topology,
+that only the target remains, and that the local Z span spans all three steps
+(proving every source contributed geometry).
 
 By default it runs only the correctness check (no render) — the CI smoke
 check. Pass --output to also render a still:
@@ -16,10 +17,14 @@
 import bpy, bmesh, sys, os, math, argparse
 
 CUBE_SIZE = 1.0
-# L-shape footprint: origin, +X, -Y — open corner faces the standard -Y camera
-OFFSETS = ((0.0, 0.0), (CUBE_SIZE, 0.0), (0.0, -CUBE_SIZE))
-EXPECT_VERTS = 8 * len(OFFSETS)
-EXPECT_FACES = 6 * len(OFFSETS)
+HALF = CUBE_SIZE / 2
+STEPS = 3
+# staircase along +X: step i sits on the previous, center at (i, 0, i+0.5) * CUBE_SIZE
+EXPECT_VERTS = 8 * STEPS
+EXPECT_FACES = 6 * STEPS
+# target origin is step 0; joined local Z spans [-HALF, (STEPS-1)*CUBE_SIZE + HALF]
+EXPECT_Z_LO = -HALF
+EXPECT_Z_HI = (STEPS - 1) * CUBE_SIZE + HALF
 
 
 def build_cubes():
@@ -33,13 +38,12 @@ def build_cubes():
         bm.free()
 
     objs = []
-    for i, (x, y) in enumerate(OFFSETS):
-        # each object needs its own mesh datablock so join keeps all geometry
+    for i in range(STEPS):
         obj = bpy.data.objects.new(f"Block.{i}", me.copy())
-        obj.location = (x, y, CUBE_SIZE / 2)
+        obj.location = (i * CUBE_SIZE, 0.0, (i + 0.5) * CUBE_SIZE)
         bpy.context.collection.objects.link(obj)
         objs.append(obj)
-    bpy.data.meshes.remove(me)  # template only
+    bpy.data.meshes.remove(me)
     return objs
 
 
@@ -81,15 +85,23 @@ def check(joined, source_names):
               file=sys.stderr)
         return 5
 
-    # sources must be gone (join consumes them) — names captured before join
     still_alive = [n for n in source_names if n in bpy.data.objects]
     if still_alive:
         print(f"ERROR: source objects still present after join: {still_alive}",
               file=sys.stderr)
         return 6
 
-    print(f"blocks={len(OFFSETS)} verts={got_v} faces={got_f} "
-          f"mesh_objects=1 override=temp_override")
+    # Z span proves every step contributed — a no-op override leaves only step 0
+    zs = [v.co.z for v in joined.data.vertices]
+    z_lo, z_hi = min(zs), max(zs)
+    if abs(z_lo - EXPECT_Z_LO) > 1e-4 or abs(z_hi - EXPECT_Z_HI) > 1e-4:
+        print(f"ERROR: local z [{z_lo:.4f}, {z_hi:.4f}] != "
+              f"[{EXPECT_Z_LO:.4f}, {EXPECT_Z_HI:.4f}] — join did not merge all steps",
+              file=sys.stderr)
+        return 7
+
+    print(f"steps={STEPS} verts={got_v} faces={got_f} "
+          f"z={z_lo:.3f}..{z_hi:.3f} override=temp_override")
     return 0
 
 
@@ -104,12 +116,12 @@ def render_still(obj, path, engine):
     mat = bpy.data.materials.new("Amber")
     mat.use_nodes = True
     bsdf = mat.node_tree.nodes["Principled BSDF"]
-    bsdf.inputs["Base Color"].default_value = (0.98, 0.42, 0.02, 1.0)  # amber
-    bsdf.inputs["Roughness"].default_value = 0.22
+    bsdf.inputs["Base Color"].default_value = (0.98, 0.38, 0.02, 1.0)  # amber
+    bsdf.inputs["Roughness"].default_value = 0.20
     obj.data.materials.clear()
     obj.data.materials.append(mat)
-    # L-shape rests on the floor; center the footprint on the origin
-    obj.location = (-CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+    # center the staircase footprint; origin is step-0 center
+    obj.location = (-(STEPS - 1) * CUBE_SIZE / 2, 0.0, HALF)
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -137,7 +149,7 @@ def render_still(obj, path, engine):
     scene.world = world
 
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, CUBE_SIZE / 2)
+    aim.location = (0.0, 0.0, STEPS * CUBE_SIZE / 2)
     scene.collection.objects.link(aim)
 
     def light(name, loc, energy, size, col):
@@ -153,15 +165,14 @@ def light(name, loc, energy, size, col):
         lc.track_axis = 'TRACK_NEGATIVE_Z'
         lc.up_axis = 'UP_Y'
 
-    light("Key", (-3.5, -4.5, 5.5), 1400.0, 6.0, (1.0, 0.98, 0.94))
-    light("Fill", (5.0, -3.5, 2.5), 320.0, 8.0, (0.8, 0.87, 1.0))
-    light("Rim", (1.5, 4.5, 2.0), 420.0, 4.0, (1.0, 0.75, 0.45))
+    light("Key", (-4.0, -5.0, 6.0), 1500.0, 6.0, (1.0, 0.98, 0.94))
+    light("Fill", (5.0, -3.5, 3.0), 340.0, 8.0, (0.8, 0.87, 1.0))
+    light("Rim", (1.5, 5.0, 2.5), 480.0, 4.0, (1.0, 0.75, 0.45))
 
-    # look into the open corner of the L so both arms read
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (2.8, -3.6, 2.8)
+    cam.location = (4.2, -5.2, 4.0)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new('TRACK_TO')
@@ -204,7 +215,7 @@ def main():
     if args.output:
         if not render_still(joined, os.path.abspath(args.output), args.engine):
             print("ERROR: render produced no file", file=sys.stderr)
-            return 7
+            return 8
         print(f"rendered still {args.output}")
 
     print("temp-override-join OK")