diff --git a/README.md b/README.md
index d6c08cfa..df9dcc9b 100644
--- a/README.md
+++ b/README.md
@@ -232,7 +232,7 @@ or expand a category below.
 <table>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/swatch-grid/"><img src="examples/swatch-grid/preview.webp" alt="Swatch grid: a three-by-two grid of shaded spheres - polished gold and brushed copper metals, red and blue plastics, an emissive orange, and a matte white - against a dark studio backdrop, rendered with EEVEE" /></a>
+<a href="examples/swatch-grid/"><img src="examples/swatch-grid/preview.webp" alt="Swatch grid: a tiered material library in a dark studio - six spheres seated in chrome collars on graphite plinths, mirror gold, brushed copper and red plastic on tall plinths behind blue plastic, a glowing orange emissive globe and matte white in front, rendered with EEVEE" /></a>
 </td>
 <td valign="middle">
 
diff --git a/docs/gallery/assets/swatch-grid-hero.webp b/docs/gallery/assets/swatch-grid-hero.webp
index 1ba348ea..2bfbc0cf 100644
Binary files a/docs/gallery/assets/swatch-grid-hero.webp and b/docs/gallery/assets/swatch-grid-hero.webp differ
diff --git a/docs/gallery/contact-sheets/swatch-grid-contact-sheet.webp b/docs/gallery/contact-sheets/swatch-grid-contact-sheet.webp
index 4f44994b..65214878 100644
Binary files a/docs/gallery/contact-sheets/swatch-grid-contact-sheet.webp and b/docs/gallery/contact-sheets/swatch-grid-contact-sheet.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 48ed8007..a7dad91c 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -343,7 +343,7 @@ <h1>Examples and Showcase</h1>
     <div class="grid" id="grid">
       <article class="card" data-tags="materials rendering">
         <a class="card-media" href="swatch-grid/" tabindex="-1" aria-hidden="true">
-          <img src="assets/swatch-grid-hero.webp" alt="Six material spheres in two rows against a dark backdrop: mirror gold, brushed copper, red, blue, flat orange emission and white." loading="lazy" decoding="async" />
+          <img src="assets/swatch-grid-hero.webp" alt="Six material spheres on graphite plinths in two tiers: mirror gold, brushed copper and red behind; blue, a glowing orange emissive globe and matte white in front." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="swatch-grid/">swatch-grid</a></h2>
diff --git a/docs/gallery/swatch-grid/index.html b/docs/gallery/swatch-grid/index.html
index 900ebed3..1959442d 100644
--- a/docs/gallery/swatch-grid/index.html
+++ b/docs/gallery/swatch-grid/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/swatch-grid-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Six material spheres in two rows against a dark backdrop: mirror gold, brushed copper, red, blue, flat orange emission and white." />
+  <meta property="og:image:alt" content="Six material spheres on graphite plinths in two tiers: mirror gold, brushed copper and red behind; blue, a glowing orange emissive globe and matte white in front." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="swatch-grid — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="Procedural Principled materials — metal and dielectric, the emission pattern, and the cross-version set_specular shim." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/swatch-grid-hero.webp" />
-  <meta name="twitter:image:alt" content="Six material spheres in two rows against a dark backdrop: mirror gold, brushed copper, red, blue, flat orange emission and white." />
+  <meta name="twitter:image:alt" content="Six material spheres on graphite plinths in two tiers: mirror gold, brushed copper and red behind; blue, a glowing orange emissive globe and matte white in front." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -268,8 +268,8 @@ <h1>swatch-grid</h1>
     <p>Procedural Principled materials — metal and dielectric, the emission pattern, and the cross-version set_specular shim.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Six material spheres in two rows against a dark backdrop: mirror gold, brushed copper, red, blue, flat orange emission and white.">
-      <img src="../assets/swatch-grid-hero.webp" alt="Six material spheres in two rows against a dark backdrop: mirror gold, brushed copper, red, blue, flat orange emission and white." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Six material spheres on graphite plinths in two tiers: mirror gold, brushed copper and red behind; blue, a glowing orange emissive globe and matte white in front.">
+      <img src="../assets/swatch-grid-hero.webp" alt="Six material spheres on graphite plinths in two tiers: mirror gold, brushed copper and red behind; blue, a glowing orange emissive globe and matte white in front." 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> EEVEE engine-id mapping: BLENDER_EEVEE on 5.x, BLENDER_EEVEE_NEXT on 4.2–4.5.</div>
@@ -278,8 +278,8 @@ <h1>swatch-grid</h1>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that renders a 3×2 grid of spheres — one material per cell — to a single PNG. It demonstrates the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/procedural-materials-and-shaders/SKILL.md"><code>procedural-materials-and-shaders</code></a> patterns end to end:</p>
-<ul><li><strong>Principled BSDF</strong> metals (gold, copper: high metallic, low roughness) and dielectrics (red/blue plastic, white rough), configured with <strong>string socket lookups</strong> and <strong>4-tuple colors</strong>.</li><li>The <strong>emission</strong> pattern (an emissive orange swatch).</li><li>The cross-version <strong><code>set_specular</code> shim</strong> (<code>Specular</code> → <code>Specular IOR Level</code>, renamed in Blender 4.0).</li></ul>
+<p>A runnable example that renders a tiered 3×2 material library — one sphere per material, each seated in a chrome collar on a graphite plinth — to a single PNG. It demonstrates the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/procedural-materials-and-shaders/SKILL.md"><code>procedural-materials-and-shaders</code></a> patterns end to end:</p>
+<ul><li><strong>Principled BSDF</strong> metals (gold, copper: high metallic, low roughness) and dielectrics (red/blue plastic, white rough), configured with <strong>string socket lookups</strong> and <strong>4-tuple colors</strong>.</li><li>The <strong>emission</strong> pattern (an emissive orange swatch, its <code>ShaderNodeEmission</code> core mixed toward a dark dielectric shell at the silhouette so it reads as a glowing globe).</li><li>The cross-version <strong><code>set_specular</code> shim</strong> (<code>Specular</code> → <code>Specular IOR Level</code>, renamed in Blender 4.0).</li></ul>
 <p>It doubles as a live proof of the <strong>EEVEE engine-id</strong> behavior: the version-branch helper resolves <code>BLENDER_EEVEE</code> on Blender 5.x and <code>BLENDER_EEVEE_NEXT</code> on 4.2–4.5, and the check witnesses the inversion for real — the <em>other</em> era&#x27;s id must be <strong>rejected</strong> by the running build (assignment raises <code>TypeError</code>) and the helper&#x27;s id accepted — so a regression in that mapping fails the example, not just the docs.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (materials + engine-id witness, no render):
@@ -295,7 +295,10 @@ <h2>Run</h2>
 # asserted; only the final pixels use Cycles.
 blender --background --python swatch_grid.py -- --output swatch.png --engine cycles --samples 16 --width 960</code></pre>
 <h2>Staging</h2>
-<p>The backdrop stands 0.16 behind the spheres, so each casts a soft contact shadow. It used to stand 1.58 behind them, and the grid floated. The world is a reflection-only sky: glossy rays see a warm overhead gradient above a dark horizon, and camera and diffuse rays see the dark stage. The mirror-finish gold otherwise reflected the near-black world and rendered as a black ball with two light-card glints. Sphere positions, materials, the camera and the six-region pixel check are unchanged; <code>verify_png</code> still reads six distinct regions on 4.5.11, 5.1.2 and 5.2.1.</p>
+<p>The swatches stand as a tiered material library on the default stage (floor, wall at y = 9, warm key, cool fill and rim, warm wedge pooling on the floor behind the display). Each sphere sits in a gunmetal collar on a bevelled graphite plinth; the back row stands on tall plinths so every sphere clears the one in front of it. A 50 mm camera looks down on the display with a <code>TRACK_TO</code> aim, which keeps the floor/wall seam above the back row.</p>
+<p>The emissive swatch used to be a bare <code>Emission</code> at strength 1.4: under the Standard view transform its red channel clipped across the whole face and it rendered as a flat orange disk. Now the same <code>ShaderNodeEmission</code> (color and strength asserted) owns the face toward the camera at strength 0.95, below clipping, and a <code>Layer Weight</code> facing ramp hands it over to a dark dielectric shell at the silhouette, so the globe has a limb. A shadowless warm point light at its center stands in for the glow it throws on its own collar, plinth and the floor; the shell is lit from inside only on back faces, so the ball itself still shows only the asserted emission.</p>
+<p>The world is a reflection-only sky: glossy rays see a warm overhead gradient above a dark horizon, and camera and diffuse rays see the dark stage. The mirror-finish gold otherwise reflects the near-black world as a black ball.</p>
+<p><code>verify_png</code> samples each swatch where the camera sees it: the sphere center is projected through the render camera (<code>world_to_camera_view</code>) rather than assumed to sit at the center of a third of the frame, so the six-region check follows the layout.</p>
 <h2>Exit codes</h2>
 <p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it. <code>10</code> is the shared framing helper.</p>
 <div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Distinct swatch colors ≠ 6 (<code>--same-base</code> lands here); also render not six distinct regions</td></tr><tr><td>4</td><td><code>--output</code> produced no file</td></tr><tr><td>5</td><td>Wrong-era EEVEE engine id was accepted</td></tr><tr><td>10</td><td>Gallery framing violation</td></tr></tbody></table></div>
@@ -312,7 +315,7 @@ <h2>Source</h2>
       </div>
       <pre><span class="s">&quot;&quot;&quot;Procedural-materials swatch grid -- a runnable BDT example.
 
-Renders a 3x2 grid of spheres, one per material, demonstrating the
+Renders a tiered 3x2 display of material spheres on plinths, one per material, demonstrating the
 `procedural-materials-and-shaders` patterns end to end: Principled BSDF (metal +
 dielectric), the emission pattern, the cross-version `set_specular` shim, string socket
 lookups, and 4-tuple colors. It also doubles as a live proof of the EEVEE engine-id fix:
@@ -383,7 +386,7 @@ <h2>Source</h2>
     <span class="k">return</span> mat, resolved
 
 
-<span class="k">def</span> make_emissive(name, color, strength):
+<span class="k">def</span> make_emissive(name, color, strength, shell_color=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
     nt = mat.node_tree
@@ -392,7 +395,28 @@ <h2>Source</h2>
     emis.inputs[<span class="s">&#x27;Color&#x27;</span>].default_value = color
     emis.inputs[<span class="s">&#x27;Strength&#x27;</span>].default_value = strength
     out = nt.nodes.new(<span class="s">&#x27;ShaderNodeOutputMaterial&#x27;</span>)
-    nt.links.new(emis.outputs[<span class="s">&#x27;Emission&#x27;</span>], out.inputs[<span class="s">&#x27;Surface&#x27;</span>])
+    <span class="k">if</span> shell_color <span class="k">is</span> <span class="k">None</span>:
+        nt.links.new(emis.outputs[<span class="s">&#x27;Emission&#x27;</span>], out.inputs[<span class="s">&#x27;Surface&#x27;</span>])
+        <span class="k">return</span> mat
+    <span class="c"># A glowing core inside a darker shell: the emission owns the face that</span>
+    <span class="c"># looks at the camera and hands over to a deep, matte dielectric toward</span>
+    <span class="c"># the silhouette. The sphere keeps a limb and a rim instead of rendering</span>
+    <span class="c"># as one flat disk of constant radiance, and nothing has to clip to glow.</span>
+    shell = nt.nodes.new(<span class="s">&#x27;ShaderNodeBsdfPrincipled&#x27;</span>)
+    shell.inputs[<span class="s">&#x27;Base Color&#x27;</span>].default_value = shell_color
+    shell.inputs[<span class="s">&#x27;Roughness&#x27;</span>].default_value = <span class="n">0.45</span>
+    set_specular(shell, <span class="n">0.2</span>)
+    facing = nt.nodes.new(<span class="s">&#x27;ShaderNodeLayerWeight&#x27;</span>)
+    facing.inputs[<span class="s">&#x27;Blend&#x27;</span>].default_value = <span class="n">0.8</span>
+    ramp = nt.nodes.new(<span class="s">&#x27;ShaderNodeValToRGB&#x27;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.0</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.9</span>
+    nt.links.new(facing.outputs[<span class="s">&#x27;Facing&#x27;</span>], ramp.inputs[<span class="s">&#x27;Fac&#x27;</span>])
+    mix = nt.nodes.new(<span class="s">&#x27;ShaderNodeMixShader&#x27;</span>)
+    nt.links.new(ramp.outputs[<span class="s">&#x27;Color&#x27;</span>], mix.inputs[<span class="s">&#x27;Fac&#x27;</span>])
+    nt.links.new(emis.outputs[<span class="s">&#x27;Emission&#x27;</span>], mix.inputs[<span class="n">1</span>])
+    nt.links.new(shell.outputs[<span class="s">&#x27;BSDF&#x27;</span>], mix.inputs[<span class="n">2</span>])
+    nt.links.new(mix.outputs[<span class="s">&#x27;Shader&#x27;</span>], out.inputs[<span class="s">&#x27;Surface&#x27;</span>])
     <span class="k">return</span> mat
 
 
@@ -405,96 +429,168 @@ <h2>Source</h2>
     <span class="c"># for verify_png, and a mirror finish vs a broad soft highlight does it</span>
     m, specular_socket = make_principled(<span class="s">&quot;Gold&quot;</span>, (<span class="n">1.00</span>, <span class="n">0.77</span>, <span class="n">0.34</span>, <span class="n">1</span>), <span class="n">1.0</span>, <span class="n">0.08</span>)
     mats.append(m)
-    m, _ = make_principled(<span class="s">&quot;Copper&quot;</span>, (<span class="n">0.92</span>, <span class="n">0.47</span>, <span class="n">0.36</span>, <span class="n">1</span>), <span class="n">1.0</span>, <span class="n">0.55</span>)
+    m, _ = make_principled(<span class="s">&quot;Copper&quot;</span>, (<span class="n">0.92</span>, <span class="n">0.47</span>, <span class="n">0.36</span>, <span class="n">1</span>), <span class="n">1.0</span>, <span class="n">0.62</span>)
     mats.append(m)
     m, sr = make_principled(<span class="s">&quot;RedPlastic&quot;</span>, (<span class="n">0.80</span>, <span class="n">0.05</span>, <span class="n">0.05</span>, <span class="n">1</span>), <span class="n">0.0</span>, <span class="n">0.40</span>, specular=<span class="n">0.5</span>)
     mats.append(m)
     specular_socket = specular_socket <span class="k">or</span> sr
     m, _ = make_principled(<span class="s">&quot;BluePlastic&quot;</span>, (<span class="n">0.05</span>, <span class="n">0.20</span>, <span class="n">0.80</span>, <span class="n">1</span>), <span class="n">0.0</span>, <span class="n">0.30</span>, specular=<span class="n">0.5</span>)
     mats.append(m)
-    <span class="c"># strength stays low enough that the Standard view transform keeps the</span>
-    <span class="c"># hue: at 6.0 every channel clips and the swatch reads white-yellow</span>
-    mats.append(make_emissive(<span class="s">&quot;EmissiveOrange&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.35</span>, <span class="n">0.05</span>, <span class="n">1</span>), <span class="n">1.4</span>))
+    <span class="c"># Standard does not compress highlights, so the core radiance stays under</span>
+    <span class="c"># 1.0 in every channel: at 1.4 the red channel clipped across the whole</span>
+    <span class="c"># face and the swatch read as a flat orange disk with no form</span>
+    mats.append(make_emissive(<span class="s">&quot;EmissiveOrange&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.35</span>, <span class="n">0.05</span>, <span class="n">1</span>), <span class="n">0.95</span>,
+                              shell_color=(<span class="n">0.22</span>, <span class="n">0.035</span>, <span class="n">0.006</span>, <span class="n">1</span>)))
     m, _ = make_principled(<span class="s">&quot;WhiteRough&quot;</span>, (<span class="n">0.90</span>, <span class="n">0.90</span>, <span class="n">0.92</span>, <span class="n">1</span>), <span class="n">0.0</span>, <span class="n">0.70</span>, specular=<span class="n">0.3</span>)
     mats.append(m)
     <span class="k">return</span> mats, specular_socket
 
 
+SPHERE_R = <span class="n">0.5</span>
+COL_X = (-<span class="n">1.62</span>, <span class="n">0.0</span>, <span class="n">1.62</span>)
+<span class="c"># (y, plinth height) per row: the back row stands on tall plinths so every</span>
+<span class="c"># sphere clears the one in front of it -- a tiered library display, read</span>
+<span class="c"># left to right, back row first</span>
+ROWS = ((<span class="n">1.25</span>, <span class="n">1.02</span>), (-<span class="n">0.35</span>, <span class="n">0.34</span>))
+
+
+<span class="k">def</span> make_cylinder(name, radius, height, bevel, segments=<span class="n">64</span>):
+    <span class="s">&quot;&quot;&quot;A capped cylinder standing on z=0 with bevelled rims: flat caps,
+    smooth walls, sharp cap seams, so it reads machined, not primitive.&quot;&quot;&quot;</span>
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bmesh.ops.create_cone(bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>, segments=segments,
+                              radius1=radius, radius2=radius, depth=height)
+        bmesh.ops.translate(bm, verts=bm.verts, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, height / <span class="n">2</span>))
+        bm.normal_update()
+        rims = [e <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> <span class="k">not</span> e.is_boundary <span class="k">and</span> len(e.link_faces) == <span class="n">2</span>
+                <span class="k">and</span> abs(e.link_faces[<span class="n">0</span>].normal.z) != abs(e.link_faces[<span class="n">1</span>].normal.z)]
+        bmesh.ops.bevel(bm, geom=rims, offset=bevel, segments=<span class="n">4</span>, profile=<span class="n">0.5</span>,
+                        affect=<span class="s">&#x27;EDGES&#x27;</span>)
+        bm.normal_update()
+        <span class="k">for</span> f <span class="k">in</span> bm.faces:
+            f.smooth = abs(f.normal.z) &lt; <span class="n">0.999</span>
+        <span class="k">for</span> e <span class="k">in</span> bm.edges:
+            <span class="k">if</span> len(e.link_faces) == <span class="n">2</span> <span class="k">and</span> e.link_faces[<span class="n">0</span>].smooth != e.link_faces[<span class="n">1</span>].smooth:
+                e.smooth = <span class="k">False</span>
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> me
+
+
 <span class="k">def</span> build_scene(mats):
-    xs = [-<span class="n">2.3</span>, <span class="n">0.0</span>, <span class="n">2.3</span>]
-    zs = [<span class="n">1.15</span>, -<span class="n">1.15</span>]
+    sc = bpy.context.scene
+    coll = bpy.context.collection
+    plinth_mat, _ = make_principled(<span class="s">&quot;PlinthGraphite&quot;</span>, (<span class="n">0.055</span>, <span class="n">0.056</span>, <span class="n">0.062</span>, <span class="n">1</span>), <span class="n">0.0</span>, <span class="n">0.42</span>,
+                                    specular=<span class="n">0.5</span>)
+    collar_mat, _ = make_principled(<span class="s">&quot;CollarGunmetal&quot;</span>, (<span class="n">0.30</span>, <span class="n">0.30</span>, <span class="n">0.32</span>, <span class="n">1</span>), <span class="n">1.0</span>, <span class="n">0.32</span>)
+    swatches, stands = [], []
     i = <span class="n">0</span>
-    <span class="k">for</span> r <span class="k">in</span> range(GRID_ROWS):
-        <span class="k">for</span> c <span class="k">in</span> range(GRID_COLS):
-            me = bpy.data.meshes.new(<span class="s">f&quot;</span><span class="s">S</span>{i}<span class="s">&quot;</span>)
+    <span class="k">for</span> r, (y, h) <span class="k">in</span> enumerate(ROWS):
+        <span class="k">for</span> c, x <span class="k">in</span> enumerate(COL_X):
+            plinth = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Plinth</span>{i}<span class="s">&quot;</span>, make_cylinder(<span class="s">f&quot;</span><span class="s">Plinth</span>{i}<span class="s">&quot;</span>, <span class="n">0.44</span>, h, <span class="n">0.035</span>))
+            plinth.location = (x, y, <span class="n">0.0</span>)
+            plinth.data.materials.append(plinth_mat)
+            collar = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Collar</span>{i}<span class="s">&quot;</span>, make_cylinder(<span class="s">f&quot;</span><span class="s">Collar</span>{i}<span class="s">&quot;</span>, <span class="n">0.30</span>, <span class="n">0.07</span>, <span class="n">0.02</span>))
+            collar.location = (x, y, h)
+            collar.data.materials.append(collar_mat)
+            me = bpy.data.meshes.new(<span class="s">f&quot;</span><span class="s">Swatch</span>{i}<span class="s">&quot;</span>)
             bm = bmesh.new()
             <span class="k">try</span>:
-                bmesh.ops.create_uvsphere(bm, u_segments=<span class="n">48</span>, v_segments=<span class="n">24</span>, radius=<span class="n">0.92</span>)
+                bmesh.ops.create_uvsphere(bm, u_segments=<span class="n">64</span>, v_segments=<span class="n">32</span>, radius=SPHERE_R)
                 bm.to_mesh(me)
             <span class="k">finally</span>:
                 bm.free()
             <span class="k">for</span> poly <span class="k">in</span> me.polygons:
                 poly.use_smooth = <span class="k">True</span>
-            ob = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">S</span>{i}<span class="s">&quot;</span>, me)
-            ob.location = (xs[c], <span class="n">0.0</span>, zs[r])
-            bpy.context.collection.objects.link(ob)
+            ob = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Swatch</span>{i}<span class="s">&quot;</span>, me)
+            <span class="c"># seated in the collar: the sphere rests on its rim, 0.4 in from</span>
+            <span class="c"># the equator, so it reads as mounted rather than balanced</span>
+            seat = h + <span class="n">0.07</span> + math.sqrt(SPHERE_R ** <span class="n">2</span> - <span class="n">0.26</span> ** <span class="n">2</span>)
+            ob.location = (x, y, seat)
             ob.data.materials.append(mats[i])
+            <span class="k">for</span> o <span class="k">in</span> (plinth, collar, ob):
+                coll.objects.link(o)
+            swatches.append(ob)
+            stands += [plinth, collar]
             i += <span class="n">1</span>
-    <span class="c"># ortho camera framed on the grid cells: verify_png() samples the image at</span>
-    <span class="c"># each cell center, so every sphere must stay inside its third/half of the</span>
-    <span class="c"># frame. ortho height = ortho_scale * 9/16 = 4.73 units for a grid that</span>
-    <span class="c"># spans 4.14 -- nothing clips, nothing drifts out of its cell, and the</span>
-    <span class="c"># grid fills 0.876 of the frame height (inside the Layer 1 band).</span>
-    cam_d = bpy.data.cameras.new(<span class="s">&quot;cam&quot;</span>)
-    cam_d.type = <span class="s">&#x27;ORTHO&#x27;</span>
-    cam_d.ortho_scale = <span class="n">8.4</span>
-    cam = bpy.data.objects.new(<span class="s">&quot;cam&quot;</span>, cam_d)
-    cam.location = (<span class="n">0.0</span>, -<span class="n">10.0</span>, <span class="n">0.0</span>)
-    cam.rotation_euler = (math.radians(<span class="n">90</span>), <span class="n">0</span>, <span class="n">0</span>)
-    bpy.context.collection.objects.link(cam)
-    bpy.context.scene.camera = cam
 
-    <span class="c"># dark staged backdrop behind the grid (docs/VISUAL-STYLE.md)</span>
-    wall_me = bpy.data.meshes.new(<span class="s">&quot;Wall&quot;</span>)
+    <span class="c"># default stage: floor + back wall share the studio material</span>
+    stage_me = bpy.data.meshes.new(<span class="s">&quot;Stage&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
         bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">30.0</span>)
-        bm.to_mesh(wall_me)
+        bm.to_mesh(stage_me)
     <span class="k">finally</span>:
         bm.free()
-    wmat, _ = make_principled(<span class="s">&quot;Studio&quot;</span>, (<span class="n">0.03</span>, <span class="n">0.032</span>, <span class="n">0.037</span>, <span class="n">1</span>), <span class="n">0.0</span>, <span class="n">0.7</span>)
-    wall_me.materials.append(wmat)
-    wall = bpy.data.objects.new(<span class="s">&quot;Wall&quot;</span>, wall_me)
-    <span class="c"># just behind the spheres (0.16 clear of their backs) so each casts a</span>
-    <span class="c"># soft contact shadow and reads as mounted; at y=2.5 they hung 1.58 in</span>
-    <span class="c"># front of the backdrop with nothing under them</span>
-    wall.location = (<span class="n">0.0</span>, <span class="n">1.08</span>, <span class="n">0.0</span>)
+    smat, _ = make_principled(<span class="s">&quot;Studio&quot;</span>, (<span class="n">0.03</span>, <span class="n">0.032</span>, <span class="n">0.037</span>, <span class="n">1</span>), <span class="n">0.0</span>, <span class="n">0.7</span>)
+    stage_me.materials.append(smat)
+    floor = bpy.data.objects.new(<span class="s">&quot;Floor&quot;</span>, stage_me)
+    coll.objects.link(floor)
+    wall = bpy.data.objects.new(<span class="s">&quot;Wall&quot;</span>, stage_me.copy())
+    wall.location = (<span class="n">0.0</span>, <span class="n">9.0</span>, <span class="n">0.0</span>)
     wall.rotation_euler = (math.radians(<span class="n">90</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
-    bpy.context.collection.objects.link(wall)
+    coll.objects.link(wall)
 
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    bpy.context.collection.objects.link(aim)
-    <span class="c"># warm shaped key, faint cool fill, and a warm wedge pooling on the</span>
-    <span class="c"># backdrop -- the gallery&#x27;s staged look</span>
-    <span class="k">for</span> lname, loc, energy, size, col <span class="k">in</span> [
-        (<span class="s">&quot;KeyL&quot;</span>, (-<span class="n">5</span>, -<span class="n">6</span>, <span class="n">4</span>), <span class="n">900</span>, <span class="n">5.0</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>)),
-        (<span class="s">&quot;FillL&quot;</span>, (<span class="n">5</span>, -<span class="n">6</span>, -<span class="n">2</span>), <span class="n">220</span>, <span class="n">6.0</span>, (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>)),
-        (<span class="s">&quot;WedgeL&quot;</span>, (<span class="n">2.6</span>, <span class="n">1.3</span>, <span class="n">4.4</span>), <span class="n">260</span>, <span class="n">5.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>)),
-    ]:
-        ld = bpy.data.lights.new(lname, <span class="s">&#x27;AREA&#x27;</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.45</span>, <span class="n">1.05</span>)
+    coll.objects.link(aim)
+    cam_d = bpy.data.cameras.new(<span class="s">&quot;cam&quot;</span>)
+    cam_d.lens = <span class="n">50.0</span>
+    cam = bpy.data.objects.new(<span class="s">&quot;cam&quot;</span>, cam_d)
+    cam.location = (<span class="n">0.0</span>, -<span class="n">7.7</span>, <span class="n">4.5</span>)
+    coll.objects.link(cam)
+    con = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
+    con.target = aim
+    con.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
+    con.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
+    sc.camera = cam
+
+    <span class="k">def</span> light(name, loc, energy, size, col, rot):
+        ld = bpy.data.lights.new(name, <span class="s">&#x27;AREA&#x27;</span>)
         ld.energy = energy
         ld.size = size
         ld.color = col
-        lo = bpy.data.objects.new(lname, ld)
+        lo = bpy.data.objects.new(name, ld)
         lo.location = loc
-        bpy.context.collection.objects.link(lo)
-        con = lo.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
-        con.target = aim
-        con.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
-        con.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
-    <span class="c"># the wedge aims past the spheres at the wall, not at the grid</span>
-    bpy.data.objects[<span class="s">&quot;WedgeL&quot;</span>].constraints.clear()
-    bpy.data.objects[<span class="s">&quot;WedgeL&quot;</span>].rotation_euler = (math.radians(-<span class="n">56</span>), <span class="n">0.0</span>, math.radians(<span class="n">190</span>))
+        lo.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
+        coll.objects.link(lo)
+
+    <span class="c"># warm shaped key upper left, faint cool fill low right, cool rim behind,</span>
+    <span class="c"># and the warm wedge pooling on the back wall (docs/VISUAL-STYLE.md)</span>
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.2</span>, -<span class="n">4.6</span>, <span class="n">5.6</span>), <span class="n">330.0</span>, <span class="n">5.5</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">48</span>, <span class="n">0</span>, -<span class="n">40</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">4.0</span>, <span class="n">2.2</span>), <span class="n">70.0</span>, <span class="n">9.0</span>, (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>), (<span class="n">70</span>, <span class="n">0</span>, <span class="n">52</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">4.2</span>), <span class="n">110.0</span>, <span class="n">4.0</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), (-<span class="n">52</span>, <span class="n">0</span>, <span class="n">172</span>))
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">1.0</span>, <span class="n">7.6</span>, <span class="n">3.4</span>), <span class="n">320.0</span>, <span class="n">5.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>))
+    <span class="c"># the camera looks down on the display, so the backdrop it sees is mostly</span>
+    <span class="c"># floor: the wedge pools there, just behind the back row, and stays off</span>
+    <span class="c"># the swatches themselves</span>
+    pool = bpy.data.objects.new(<span class="s">&quot;WedgePool&quot;</span>, <span class="k">None</span>)
+    pool.location = (<span class="n">0.3</span>, <span class="n">4.9</span>, <span class="n">0.0</span>)
+    coll.objects.link(pool)
+    wcon = bpy.data.objects[<span class="s">&quot;Wedge&quot;</span>].constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
+    wcon.target = pool
+    wcon.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
+    wcon.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
+
+    <span class="c"># The emissive swatch is a lamp, so it lights its own collar, plinth and</span>
+    <span class="c"># the floor around it. A shadowless point at its center stands in for</span>
+    <span class="c"># that spill (the shell is lit from inside only on back faces, so the</span>
+    <span class="c"># asserted emission is still the only thing the camera sees on the ball).</span>
+    <span class="k">for</span> ob <span class="k">in</span> swatches:
+        <span class="k">if</span> any(n.type == <span class="s">&#x27;EMISSION&#x27;</span> <span class="k">for</span> n <span class="k">in</span> ob.data.materials[<span class="n">0</span>].node_tree.nodes):
+            gd = bpy.data.lights.new(<span class="s">&quot;GlowSpill&quot;</span>, <span class="s">&#x27;POINT&#x27;</span>)
+            gd.energy = <span class="n">45.0</span>
+            gd.shadow_soft_size = <span class="n">0.45</span>
+            gd.color = (<span class="n">1.0</span>, <span class="n">0.45</span>, <span class="n">0.12</span>)
+            gd.use_shadow = <span class="k">False</span>
+            gd.specular_factor = <span class="n">0.15</span>
+            glow = bpy.data.objects.new(<span class="s">&quot;GlowSpill&quot;</span>, gd)
+            glow.location = ob.location
+            coll.objects.link(glow)
+
     world = bpy.data.worlds.new(<span class="s">&quot;W&quot;</span>)
     world.use_nodes = <span class="k">True</span>
     nt = world.node_tree
@@ -513,14 +609,15 @@ <h2>Source</h2>
     sky.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.0</span>
     sky.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.02</span>, <span class="n">0.021</span>, <span class="n">0.025</span>, <span class="n">1</span>)
     sky.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.7</span>
-    sky.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.70</span>, <span class="n">0.63</span>, <span class="n">0.55</span>, <span class="n">1</span>)
+    sky.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.50</span>, <span class="n">0.45</span>, <span class="n">0.39</span>, <span class="n">1</span>)
     nt.links.new(sep.outputs[<span class="s">&quot;Z&quot;</span>], sky.inputs[<span class="s">&quot;Fac&quot;</span>])
     pick = nt.nodes.new(<span class="s">&quot;ShaderNodeMixRGB&quot;</span>)
     pick.inputs[<span class="n">1</span>].default_value = (<span class="n">0.02</span>, <span class="n">0.021</span>, <span class="n">0.025</span>, <span class="n">1</span>)
     nt.links.new(sky.outputs[<span class="s">&quot;Color&quot;</span>], pick.inputs[<span class="n">2</span>])
     nt.links.new(path.outputs[<span class="s">&quot;Is Glossy Ray&quot;</span>], pick.inputs[<span class="n">0</span>])
     nt.links.new(pick.outputs[<span class="n">0</span>], bg.inputs[<span class="n">0</span>])
-    bpy.context.scene.world = world
+    sc.world = world
+    <span class="k">return</span> swatches, stands, [floor, wall]
 
 
 <span class="k">def</span> swatch_rgb(mat):
@@ -556,18 +653,28 @@ <h2>Source</h2>
     <span class="k">return</span> <span class="n">0</span>
 
 
-<span class="k">def</span> verify_png(path):
-    <span class="s">&quot;&quot;&quot;Honest capture: not uniformly black AND distinct swatch regions == MATERIAL_COUNT.&quot;&quot;&quot;</span>
+<span class="k">def</span> verify_png(path, scene, swatches):
+    <span class="s">&quot;&quot;&quot;Honest capture: not uniformly black AND distinct swatch regions == MATERIAL_COUNT.
+
+    Each swatch is sampled where the camera actually sees it: its center is
+    projected through the render camera, so the check follows the layout
+    rather than assuming a flat grid of image cells.&quot;&quot;&quot;</span>
+    <span class="k">from</span> bpy_extras.object_utils <span class="k">import</span> world_to_camera_view
     img = bpy.data.images.load(path)
     w, h = img.size
     arr = np.array(img.pixels[:], dtype=np.float32).reshape(h, w, <span class="n">4</span>)[..., :<span class="n">3</span>]
     gmax = float(arr.max())
-    cw, ch, ph = w // GRID_COLS, h // GRID_ROWS, <span class="n">24</span>
+    ph = max(<span class="n">4</span>, round(w * <span class="n">0.012</span>))  <span class="c"># half-size of the sampled patch, in pixels</span>
     means = []
-    <span class="k">for</span> r <span class="k">in</span> range(GRID_ROWS):
-        <span class="k">for</span> c <span class="k">in</span> range(GRID_COLS):
-            cx, cy = c * cw + cw // <span class="n">2</span>, r * ch + ch // <span class="n">2</span>
-            means.append(arr[cy - ph:cy + ph, cx - ph:cx + ph, :].reshape(-<span class="n">1</span>, <span class="n">3</span>).mean(axis=<span class="n">0</span>))
+    <span class="k">for</span> ob <span class="k">in</span> swatches:
+        <span class="c"># rows are bottom-up in bpy image pixels, as in camera-view y</span>
+        v = world_to_camera_view(scene, scene.camera, ob.matrix_world.translation)
+        cx, cy = int(v.x * w), int(v.y * h)
+        means.append(arr[cy - ph:cy + ph, cx - ph:cx + ph, :].reshape(-<span class="n">1</span>, <span class="n">3</span>).mean(axis=<span class="n">0</span>))
+    print(<span class="s">&quot;swatch patch means: &quot;</span> + <span class="s">&quot;  &quot;</span>.join(
+        <span class="s">f&quot;</span>{ob.name}<span class="s">=(</span>{m[<span class="n">0</span>]:<span class="s">.2f</span>}<span class="s">,</span>{m[<span class="n">1</span>]:<span class="s">.2f</span>}<span class="s">,</span>{m[<span class="n">2</span>]:<span class="s">.2f</span>}<span class="s">)</span><span class="s">&quot;</span> <span class="k">for</span> ob, m <span class="k">in</span> zip(swatches, means)))
+    closest = min(float(np.linalg.norm(a - b)) <span class="k">for</span> i, a <span class="k">in</span> enumerate(means) <span class="k">for</span> b <span class="k">in</span> means[i + <span class="n">1</span>:])
+    print(<span class="s">f&quot;</span><span class="s">swatch closest pair distance=</span>{closest:<span class="s">.3f</span>}<span class="s"> (distinct needs &gt; 0.10)</span><span class="s">&quot;</span>)
     kept = []
     <span class="k">for</span> cm <span class="k">in</span> means:
         <span class="k">if</span> all(np.linalg.norm(cm - k) &gt; <span class="n">0.10</span> <span class="k">for</span> k <span class="k">in</span> kept):
@@ -595,7 +702,7 @@ <h2>Source</h2>
     dcode = check_distinct_swatches(mats)
     <span class="k">if</span> dcode:
         <span class="k">return</span> dcode
-    build_scene(mats)
+    swatches, stands, stage = build_scene(mats)
 
     sc = bpy.context.scene
     <span class="c"># EEVEE engine-id proof: frame-independent, must hold even when we render with</span>
@@ -633,12 +740,12 @@ <h2>Source</h2>
     sc.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
     <span class="c"># Layer 1 framing gate (silhouette matte) — exit 10 on violation, before</span>
     <span class="c"># the beauty render so a defective composition ships no artifact.</span>
-    spheres = [o <span class="k">for</span> o <span class="k">in</span> sc.objects <span class="k">if</span> o.type == <span class="s">&quot;MESH&quot;</span> <span class="k">and</span> o.name.startswith(<span class="s">&quot;S&quot;</span>)]
-    stage = [o <span class="k">for</span> o <span class="k">in</span> sc.objects <span class="k">if</span> o.name == <span class="s">&quot;Wall&quot;</span>]
+    <span class="c"># the hero is the whole display: every swatch and the plinth it stands on</span>
+    display = swatches + stands
     fcode = gallery_framing.check_framing(
         sc, sc.camera,
-        hero=spheres,
-        elements=spheres,
+        hero=display,
+        elements=display,
         stage=stage,
     )
     <span class="k">if</span> fcode:
@@ -650,7 +757,7 @@ <h2>Source</h2>
         <span class="k">return</span> <span class="n">4</span>
     print(<span class="s">f&quot;</span><span class="s">rendered </span>{args.output}<span class="s"> with </span>{render_engine}<span class="s"> (</span>{os.path.getsize(args.output)}<span class="s"> bytes)</span><span class="s">&quot;</span>)
 
-    gmax, regions = verify_png(args.output)
+    gmax, regions = verify_png(args.output, sc, swatches)
     non_black = gmax &gt; <span class="n">0.05</span>
     regions_ok = regions == MATERIAL_COUNT
     print(<span class="s">f&quot;</span><span class="s">verify: max_pixel=</span>{gmax:<span class="s">.3f</span>}<span class="s"> non_black=</span>{non_black}<span class="s"> </span><span class="s">&quot;</span>
@@ -675,7 +782,7 @@ <h2>Source</h2>
   </main>
   <dialog class="lightbox" id="lightbox" aria-label="Full-size render">
     <button class="lightbox-close" type="button" autofocus>Close</button>
-    <img src="../assets/swatch-grid-hero.webp" alt="Six material spheres in two rows against a dark backdrop: mirror gold, brushed copper, red, blue, flat orange emission and white." />
+    <img src="../assets/swatch-grid-hero.webp" alt="Six material spheres on graphite plinths in two tiers: mirror gold, brushed copper and red behind; blue, a glowing orange emissive globe and matte white in front." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/gallery.json b/examples/gallery.json
index 3ee0006a..1ae7b6f0 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -9,7 +9,7 @@
       "name": "swatch-grid",
       "dir": "examples/swatch-grid",
       "teaches": "Procedural Principled materials — metal and dielectric, the emission pattern, and the cross-version set_specular shim.",
-      "alt": "Six material spheres in two rows against a dark backdrop: mirror gold, brushed copper, red, blue, flat orange emission and white.",
+      "alt": "Six material spheres on graphite plinths in two tiers: mirror gold, brushed copper and red behind; blue, a glowing orange emissive globe and matte white in front.",
       "witnessesFix": "EEVEE engine-id mapping: BLENDER_EEVEE on 5.x, BLENDER_EEVEE_NEXT on 4.2–4.5.",
       "hero": "docs/gallery/assets/swatch-grid-hero.webp",
       "preview": "examples/swatch-grid/preview.webp",
diff --git a/examples/swatch-grid/README.md b/examples/swatch-grid/README.md
index eb256e19..b264f9b5 100644
--- a/examples/swatch-grid/README.md
+++ b/examples/swatch-grid/README.md
@@ -1,13 +1,14 @@
 # Swatch Grid
 
-A runnable example that renders a 3×2 grid of spheres — one material per cell — to a single
-PNG. It demonstrates the [`procedural-materials-and-shaders`](../../skills/procedural-materials-and-shaders/SKILL.md)
+A runnable example that renders a tiered 3×2 material library — one sphere per material, each
+seated in a chrome collar on a graphite plinth — to a single PNG. It demonstrates the [`procedural-materials-and-shaders`](../../skills/procedural-materials-and-shaders/SKILL.md)
 patterns end to end:
 
 - **Principled BSDF** metals (gold, copper: high metallic, low roughness) and dielectrics
   (red/blue plastic, white rough), configured with **string socket lookups** and **4-tuple
   colors**.
-- The **emission** pattern (an emissive orange swatch).
+- The **emission** pattern (an emissive orange swatch, its `ShaderNodeEmission` core mixed
+  toward a dark dielectric shell at the silhouette so it reads as a glowing globe).
 - The cross-version **`set_specular` shim** (`Specular` → `Specular IOR Level`, renamed in
   Blender 4.0).
 
@@ -36,14 +37,31 @@ blender --background --python swatch_grid.py -- --output swatch.png --engine cyc
 
 ## Staging
 
-The backdrop stands 0.16 behind the spheres, so each casts a soft contact
-shadow. It used to stand 1.58 behind them, and the grid floated. The world is
-a reflection-only sky: glossy rays see a warm overhead gradient above a dark
-horizon, and camera and diffuse rays see the dark stage. The mirror-finish
-gold otherwise reflected the near-black world and rendered as a black ball
-with two light-card glints. Sphere positions, materials, the camera and the
-six-region pixel check are unchanged; `verify_png` still reads six distinct
-regions on 4.5.11, 5.1.2 and 5.2.1.
+The swatches stand as a tiered material library on the default stage (floor,
+wall at y = 9, warm key, cool fill and rim, warm wedge pooling on the floor
+behind the display). Each sphere sits in a gunmetal collar on a bevelled
+graphite plinth; the back row stands on tall plinths so every sphere clears
+the one in front of it. A 50 mm camera looks down on the display with a
+`TRACK_TO` aim, which keeps the floor/wall seam above the back row.
+
+The emissive swatch used to be a bare `Emission` at strength 1.4: under the
+Standard view transform its red channel clipped across the whole face and it
+rendered as a flat orange disk. Now the same `ShaderNodeEmission` (color and
+strength asserted) owns the face toward the camera at strength 0.95, below
+clipping, and a `Layer Weight` facing ramp hands it over to a dark dielectric
+shell at the silhouette, so the globe has a limb. A shadowless warm point
+light at its center stands in for the glow it throws on its own collar,
+plinth and the floor; the shell is lit from inside only on back faces, so the
+ball itself still shows only the asserted emission.
+
+The world is a reflection-only sky: glossy rays see a warm overhead gradient
+above a dark horizon, and camera and diffuse rays see the dark stage. The
+mirror-finish gold otherwise reflects the near-black world as a black ball.
+
+`verify_png` samples each swatch where the camera sees it: the sphere center
+is projected through the render camera (`world_to_camera_view`) rather than
+assumed to sit at the center of a third of the frame, so the six-region check
+follows the layout.
 
 ## Exit codes
 
diff --git a/examples/swatch-grid/preview.webp b/examples/swatch-grid/preview.webp
index 7c9b7962..7300b698 100644
Binary files a/examples/swatch-grid/preview.webp and b/examples/swatch-grid/preview.webp differ
diff --git a/examples/swatch-grid/swatch_grid.py b/examples/swatch-grid/swatch_grid.py
index 3224374f..f7f38a51 100644
--- a/examples/swatch-grid/swatch_grid.py
+++ b/examples/swatch-grid/swatch_grid.py
@@ -1,6 +1,6 @@
 """Procedural-materials swatch grid -- a runnable BDT example.
 
-Renders a 3x2 grid of spheres, one per material, demonstrating the
+Renders a tiered 3x2 display of material spheres on plinths, one per material, demonstrating the
 `procedural-materials-and-shaders` patterns end to end: Principled BSDF (metal +
 dielectric), the emission pattern, the cross-version `set_specular` shim, string socket
 lookups, and 4-tuple colors. It also doubles as a live proof of the EEVEE engine-id fix:
@@ -71,7 +71,7 @@ def make_principled(name, base_color, metallic, roughness, specular=None):
     return mat, resolved
 
 
-def make_emissive(name, color, strength):
+def make_emissive(name, color, strength, shell_color=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
     nt = mat.node_tree
@@ -80,7 +80,28 @@ def make_emissive(name, color, strength):
     emis.inputs['Color'].default_value = color
     emis.inputs['Strength'].default_value = strength
     out = nt.nodes.new('ShaderNodeOutputMaterial')
-    nt.links.new(emis.outputs['Emission'], out.inputs['Surface'])
+    if shell_color is None:
+        nt.links.new(emis.outputs['Emission'], out.inputs['Surface'])
+        return mat
+    # A glowing core inside a darker shell: the emission owns the face that
+    # looks at the camera and hands over to a deep, matte dielectric toward
+    # the silhouette. The sphere keeps a limb and a rim instead of rendering
+    # as one flat disk of constant radiance, and nothing has to clip to glow.
+    shell = nt.nodes.new('ShaderNodeBsdfPrincipled')
+    shell.inputs['Base Color'].default_value = shell_color
+    shell.inputs['Roughness'].default_value = 0.45
+    set_specular(shell, 0.2)
+    facing = nt.nodes.new('ShaderNodeLayerWeight')
+    facing.inputs['Blend'].default_value = 0.8
+    ramp = nt.nodes.new('ShaderNodeValToRGB')
+    ramp.color_ramp.elements[0].position = 0.0
+    ramp.color_ramp.elements[1].position = 0.9
+    nt.links.new(facing.outputs['Facing'], ramp.inputs['Fac'])
+    mix = nt.nodes.new('ShaderNodeMixShader')
+    nt.links.new(ramp.outputs['Color'], mix.inputs['Fac'])
+    nt.links.new(emis.outputs['Emission'], mix.inputs[1])
+    nt.links.new(shell.outputs['BSDF'], mix.inputs[2])
+    nt.links.new(mix.outputs['Shader'], out.inputs['Surface'])
     return mat
 
 
@@ -93,96 +114,168 @@ def build_materials():
     # for verify_png, and a mirror finish vs a broad soft highlight does it
     m, specular_socket = make_principled("Gold", (1.00, 0.77, 0.34, 1), 1.0, 0.08)
     mats.append(m)
-    m, _ = make_principled("Copper", (0.92, 0.47, 0.36, 1), 1.0, 0.55)
+    m, _ = make_principled("Copper", (0.92, 0.47, 0.36, 1), 1.0, 0.62)
     mats.append(m)
     m, sr = make_principled("RedPlastic", (0.80, 0.05, 0.05, 1), 0.0, 0.40, specular=0.5)
     mats.append(m)
     specular_socket = specular_socket or sr
     m, _ = make_principled("BluePlastic", (0.05, 0.20, 0.80, 1), 0.0, 0.30, specular=0.5)
     mats.append(m)
-    # strength stays low enough that the Standard view transform keeps the
-    # hue: at 6.0 every channel clips and the swatch reads white-yellow
-    mats.append(make_emissive("EmissiveOrange", (1.0, 0.35, 0.05, 1), 1.4))
+    # Standard does not compress highlights, so the core radiance stays under
+    # 1.0 in every channel: at 1.4 the red channel clipped across the whole
+    # face and the swatch read as a flat orange disk with no form
+    mats.append(make_emissive("EmissiveOrange", (1.0, 0.35, 0.05, 1), 0.95,
+                              shell_color=(0.22, 0.035, 0.006, 1)))
     m, _ = make_principled("WhiteRough", (0.90, 0.90, 0.92, 1), 0.0, 0.70, specular=0.3)
     mats.append(m)
     return mats, specular_socket
 
 
+SPHERE_R = 0.5
+COL_X = (-1.62, 0.0, 1.62)
+# (y, plinth height) per row: the back row stands on tall plinths so every
+# sphere clears the one in front of it -- a tiered library display, read
+# left to right, back row first
+ROWS = ((1.25, 1.02), (-0.35, 0.34))
+
+
+def make_cylinder(name, radius, height, bevel, segments=64):
+    """A capped cylinder standing on z=0 with bevelled rims: flat caps,
+    smooth walls, sharp cap seams, so it reads machined, not primitive."""
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    try:
+        bmesh.ops.create_cone(bm, cap_ends=True, cap_tris=False, segments=segments,
+                              radius1=radius, radius2=radius, depth=height)
+        bmesh.ops.translate(bm, verts=bm.verts, vec=(0.0, 0.0, height / 2))
+        bm.normal_update()
+        rims = [e for e in bm.edges if not e.is_boundary and len(e.link_faces) == 2
+                and abs(e.link_faces[0].normal.z) != abs(e.link_faces[1].normal.z)]
+        bmesh.ops.bevel(bm, geom=rims, offset=bevel, segments=4, profile=0.5,
+                        affect='EDGES')
+        bm.normal_update()
+        for f in bm.faces:
+            f.smooth = abs(f.normal.z) < 0.999
+        for e in bm.edges:
+            if len(e.link_faces) == 2 and e.link_faces[0].smooth != e.link_faces[1].smooth:
+                e.smooth = False
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    return me
+
+
 def build_scene(mats):
-    xs = [-2.3, 0.0, 2.3]
-    zs = [1.15, -1.15]
+    sc = bpy.context.scene
+    coll = bpy.context.collection
+    plinth_mat, _ = make_principled("PlinthGraphite", (0.055, 0.056, 0.062, 1), 0.0, 0.42,
+                                    specular=0.5)
+    collar_mat, _ = make_principled("CollarGunmetal", (0.30, 0.30, 0.32, 1), 1.0, 0.32)
+    swatches, stands = [], []
     i = 0
-    for r in range(GRID_ROWS):
-        for c in range(GRID_COLS):
-            me = bpy.data.meshes.new(f"S{i}")
+    for r, (y, h) in enumerate(ROWS):
+        for c, x in enumerate(COL_X):
+            plinth = bpy.data.objects.new(f"Plinth{i}", make_cylinder(f"Plinth{i}", 0.44, h, 0.035))
+            plinth.location = (x, y, 0.0)
+            plinth.data.materials.append(plinth_mat)
+            collar = bpy.data.objects.new(f"Collar{i}", make_cylinder(f"Collar{i}", 0.30, 0.07, 0.02))
+            collar.location = (x, y, h)
+            collar.data.materials.append(collar_mat)
+            me = bpy.data.meshes.new(f"Swatch{i}")
             bm = bmesh.new()
             try:
-                bmesh.ops.create_uvsphere(bm, u_segments=48, v_segments=24, radius=0.92)
+                bmesh.ops.create_uvsphere(bm, u_segments=64, v_segments=32, radius=SPHERE_R)
                 bm.to_mesh(me)
             finally:
                 bm.free()
             for poly in me.polygons:
                 poly.use_smooth = True
-            ob = bpy.data.objects.new(f"S{i}", me)
-            ob.location = (xs[c], 0.0, zs[r])
-            bpy.context.collection.objects.link(ob)
+            ob = bpy.data.objects.new(f"Swatch{i}", me)
+            # seated in the collar: the sphere rests on its rim, 0.4 in from
+            # the equator, so it reads as mounted rather than balanced
+            seat = h + 0.07 + math.sqrt(SPHERE_R ** 2 - 0.26 ** 2)
+            ob.location = (x, y, seat)
             ob.data.materials.append(mats[i])
+            for o in (plinth, collar, ob):
+                coll.objects.link(o)
+            swatches.append(ob)
+            stands += [plinth, collar]
             i += 1
-    # ortho camera framed on the grid cells: verify_png() samples the image at
-    # each cell center, so every sphere must stay inside its third/half of the
-    # frame. ortho height = ortho_scale * 9/16 = 4.73 units for a grid that
-    # spans 4.14 -- nothing clips, nothing drifts out of its cell, and the
-    # grid fills 0.876 of the frame height (inside the Layer 1 band).
-    cam_d = bpy.data.cameras.new("cam")
-    cam_d.type = 'ORTHO'
-    cam_d.ortho_scale = 8.4
-    cam = bpy.data.objects.new("cam", cam_d)
-    cam.location = (0.0, -10.0, 0.0)
-    cam.rotation_euler = (math.radians(90), 0, 0)
-    bpy.context.collection.objects.link(cam)
-    bpy.context.scene.camera = cam
 
-    # dark staged backdrop behind the grid (docs/VISUAL-STYLE.md)
-    wall_me = bpy.data.meshes.new("Wall")
+    # default stage: floor + back wall share the studio material
+    stage_me = bpy.data.meshes.new("Stage")
     bm = bmesh.new()
     try:
         bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=30.0)
-        bm.to_mesh(wall_me)
+        bm.to_mesh(stage_me)
     finally:
         bm.free()
-    wmat, _ = make_principled("Studio", (0.03, 0.032, 0.037, 1), 0.0, 0.7)
-    wall_me.materials.append(wmat)
-    wall = bpy.data.objects.new("Wall", wall_me)
-    # just behind the spheres (0.16 clear of their backs) so each casts a
-    # soft contact shadow and reads as mounted; at y=2.5 they hung 1.58 in
-    # front of the backdrop with nothing under them
-    wall.location = (0.0, 1.08, 0.0)
+    smat, _ = make_principled("Studio", (0.03, 0.032, 0.037, 1), 0.0, 0.7)
+    stage_me.materials.append(smat)
+    floor = bpy.data.objects.new("Floor", stage_me)
+    coll.objects.link(floor)
+    wall = bpy.data.objects.new("Wall", stage_me.copy())
+    wall.location = (0.0, 9.0, 0.0)
     wall.rotation_euler = (math.radians(90), 0.0, 0.0)
-    bpy.context.collection.objects.link(wall)
+    coll.objects.link(wall)
 
     aim = bpy.data.objects.new("Aim", None)
-    bpy.context.collection.objects.link(aim)
-    # warm shaped key, faint cool fill, and a warm wedge pooling on the
-    # backdrop -- the gallery's staged look
-    for lname, loc, energy, size, col in [
-        ("KeyL", (-5, -6, 4), 900, 5.0, (1.0, 0.96, 0.9)),
-        ("FillL", (5, -6, -2), 220, 6.0, (0.75, 0.85, 1.0)),
-        ("WedgeL", (2.6, 1.3, 4.4), 260, 5.0, (1.0, 0.76, 0.5)),
-    ]:
-        ld = bpy.data.lights.new(lname, 'AREA')
+    aim.location = (0.0, 0.45, 1.05)
+    coll.objects.link(aim)
+    cam_d = bpy.data.cameras.new("cam")
+    cam_d.lens = 50.0
+    cam = bpy.data.objects.new("cam", cam_d)
+    cam.location = (0.0, -7.7, 4.5)
+    coll.objects.link(cam)
+    con = cam.constraints.new('TRACK_TO')
+    con.target = aim
+    con.track_axis = 'TRACK_NEGATIVE_Z'
+    con.up_axis = 'UP_Y'
+    sc.camera = cam
+
+    def light(name, loc, energy, size, col, rot):
+        ld = bpy.data.lights.new(name, 'AREA')
         ld.energy = energy
         ld.size = size
         ld.color = col
-        lo = bpy.data.objects.new(lname, ld)
+        lo = bpy.data.objects.new(name, ld)
         lo.location = loc
-        bpy.context.collection.objects.link(lo)
-        con = lo.constraints.new('TRACK_TO')
-        con.target = aim
-        con.track_axis = 'TRACK_NEGATIVE_Z'
-        con.up_axis = 'UP_Y'
-    # the wedge aims past the spheres at the wall, not at the grid
-    bpy.data.objects["WedgeL"].constraints.clear()
-    bpy.data.objects["WedgeL"].rotation_euler = (math.radians(-56), 0.0, math.radians(190))
+        lo.rotation_euler = tuple(math.radians(a) for a in rot)
+        coll.objects.link(lo)
+
+    # warm shaped key upper left, faint cool fill low right, cool rim behind,
+    # and the warm wedge pooling on the back wall (docs/VISUAL-STYLE.md)
+    light("Key", (-4.2, -4.6, 5.6), 330.0, 5.5, (1.0, 0.96, 0.9), (48, 0, -40))
+    light("Fill", (5.0, -4.0, 2.2), 70.0, 9.0, (0.75, 0.85, 1.0), (70, 0, 52))
+    light("Rim", (1.5, 4.5, 4.2), 110.0, 4.0, (0.6, 0.78, 1.0), (-52, 0, 172))
+    light("Wedge", (1.0, 7.6, 3.4), 320.0, 5.0, (1.0, 0.76, 0.5), (0, 0, 0))
+    # the camera looks down on the display, so the backdrop it sees is mostly
+    # floor: the wedge pools there, just behind the back row, and stays off
+    # the swatches themselves
+    pool = bpy.data.objects.new("WedgePool", None)
+    pool.location = (0.3, 4.9, 0.0)
+    coll.objects.link(pool)
+    wcon = bpy.data.objects["Wedge"].constraints.new('TRACK_TO')
+    wcon.target = pool
+    wcon.track_axis = 'TRACK_NEGATIVE_Z'
+    wcon.up_axis = 'UP_Y'
+
+    # The emissive swatch is a lamp, so it lights its own collar, plinth and
+    # the floor around it. A shadowless point at its center stands in for
+    # that spill (the shell is lit from inside only on back faces, so the
+    # asserted emission is still the only thing the camera sees on the ball).
+    for ob in swatches:
+        if any(n.type == 'EMISSION' for n in ob.data.materials[0].node_tree.nodes):
+            gd = bpy.data.lights.new("GlowSpill", 'POINT')
+            gd.energy = 45.0
+            gd.shadow_soft_size = 0.45
+            gd.color = (1.0, 0.45, 0.12)
+            gd.use_shadow = False
+            gd.specular_factor = 0.15
+            glow = bpy.data.objects.new("GlowSpill", gd)
+            glow.location = ob.location
+            coll.objects.link(glow)
+
     world = bpy.data.worlds.new("W")
     world.use_nodes = True
     nt = world.node_tree
@@ -201,14 +294,15 @@ def build_scene(mats):
     sky.color_ramp.elements[0].position = 0.0
     sky.color_ramp.elements[0].color = (0.02, 0.021, 0.025, 1)
     sky.color_ramp.elements[1].position = 0.7
-    sky.color_ramp.elements[1].color = (0.70, 0.63, 0.55, 1)
+    sky.color_ramp.elements[1].color = (0.50, 0.45, 0.39, 1)
     nt.links.new(sep.outputs["Z"], sky.inputs["Fac"])
     pick = nt.nodes.new("ShaderNodeMixRGB")
     pick.inputs[1].default_value = (0.02, 0.021, 0.025, 1)
     nt.links.new(sky.outputs["Color"], pick.inputs[2])
     nt.links.new(path.outputs["Is Glossy Ray"], pick.inputs[0])
     nt.links.new(pick.outputs[0], bg.inputs[0])
-    bpy.context.scene.world = world
+    sc.world = world
+    return swatches, stands, [floor, wall]
 
 
 def swatch_rgb(mat):
@@ -244,18 +338,28 @@ def check_distinct_swatches(mats):
     return 0
 
 
-def verify_png(path):
-    """Honest capture: not uniformly black AND distinct swatch regions == MATERIAL_COUNT."""
+def verify_png(path, scene, swatches):
+    """Honest capture: not uniformly black AND distinct swatch regions == MATERIAL_COUNT.
+
+    Each swatch is sampled where the camera actually sees it: its center is
+    projected through the render camera, so the check follows the layout
+    rather than assuming a flat grid of image cells."""
+    from bpy_extras.object_utils import world_to_camera_view
     img = bpy.data.images.load(path)
     w, h = img.size
     arr = np.array(img.pixels[:], dtype=np.float32).reshape(h, w, 4)[..., :3]
     gmax = float(arr.max())
-    cw, ch, ph = w // GRID_COLS, h // GRID_ROWS, 24
+    ph = max(4, round(w * 0.012))  # half-size of the sampled patch, in pixels
     means = []
-    for r in range(GRID_ROWS):
-        for c in range(GRID_COLS):
-            cx, cy = c * cw + cw // 2, r * ch + ch // 2
-            means.append(arr[cy - ph:cy + ph, cx - ph:cx + ph, :].reshape(-1, 3).mean(axis=0))
+    for ob in swatches:
+        # rows are bottom-up in bpy image pixels, as in camera-view y
+        v = world_to_camera_view(scene, scene.camera, ob.matrix_world.translation)
+        cx, cy = int(v.x * w), int(v.y * h)
+        means.append(arr[cy - ph:cy + ph, cx - ph:cx + ph, :].reshape(-1, 3).mean(axis=0))
+    print("swatch patch means: " + "  ".join(
+        f"{ob.name}=({m[0]:.2f},{m[1]:.2f},{m[2]:.2f})" for ob, m in zip(swatches, means)))
+    closest = min(float(np.linalg.norm(a - b)) for i, a in enumerate(means) for b in means[i + 1:])
+    print(f"swatch closest pair distance={closest:.3f} (distinct needs > 0.10)")
     kept = []
     for cm in means:
         if all(np.linalg.norm(cm - k) > 0.10 for k in kept):
@@ -283,7 +387,7 @@ def main():
     dcode = check_distinct_swatches(mats)
     if dcode:
         return dcode
-    build_scene(mats)
+    swatches, stands, stage = build_scene(mats)
 
     sc = bpy.context.scene
     # EEVEE engine-id proof: frame-independent, must hold even when we render with
@@ -321,12 +425,12 @@ def main():
     sc.view_settings.view_transform = 'Standard'
     # Layer 1 framing gate (silhouette matte) — exit 10 on violation, before
     # the beauty render so a defective composition ships no artifact.
-    spheres = [o for o in sc.objects if o.type == "MESH" and o.name.startswith("S")]
-    stage = [o for o in sc.objects if o.name == "Wall"]
+    # the hero is the whole display: every swatch and the plinth it stands on
+    display = swatches + stands
     fcode = gallery_framing.check_framing(
         sc, sc.camera,
-        hero=spheres,
-        elements=spheres,
+        hero=display,
+        elements=display,
         stage=stage,
     )
     if fcode:
@@ -338,7 +442,7 @@ def main():
         return 4
     print(f"rendered {args.output} with {render_engine} ({os.path.getsize(args.output)} bytes)")
 
-    gmax, regions = verify_png(args.output)
+    gmax, regions = verify_png(args.output, sc, swatches)
     non_black = gmax > 0.05
     regions_ok = regions == MATERIAL_COUNT
     print(f"verify: max_pixel={gmax:.3f} non_black={non_black} "