diff --git a/README.md b/README.md
index bf88fde0..234f4edf 100644
--- a/README.md
+++ b/README.md
@@ -393,14 +393,14 @@ the Z span matches the amplitude, and a probe vertex matches the closed-form wav
 </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: three violet blocks on a dark studio floor showing a relative Tall shape key at values 0, 0.25, and 0.5 - plain cube to lifted, flared truncated pyramid, left to right" /></a>
+<a href="examples/shape-key-blend/"><img src="examples/shape-key-blend/preview.webp" alt="Shape-key blend: three cobalt-glazed ceramic vases with an ochre band on a dark studio floor - the same vase at Tall shape-key values 0, 0.5 and 1, squat jar to amphora to flared trumpet vase, left to right, with thin pale rings of the jar's belly around the tallest" /></a>
 </td>
 <td valign="middle">
 
 ### [shape-key-blend](examples/shape-key-blend/)
 
-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
+A relative Tall shape key that turns a squat ceramic jar into a trumpet vase,
+lifting and flaring the rim — 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>
diff --git a/ROADMAP.md b/ROADMAP.md
index f5fc9641..96ef9c5f 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -223,7 +223,7 @@ not measurable by the floors (curve/GP data, no mesh hero). Re-survey after
 any example remodel.
 
 - naming (default datablock names): gltf-skin-roundtrip (3 parts), gn-sdf-remesh (`Torus`), turntable (`Suzanne`)
-- materials (multi-part, single material): armature-bend (3 parts/1 mat — vertex-color weight bands are the honest display), degenerate-bevel-weld (2/1), driver-wave (16/1, also edge90 1.0), shape-key-blend (3/1, also edge90 1.0)
+- materials (multi-part, single material): armature-bend (3 parts/1 mat — vertex-color weight bands are the honest display), degenerate-bevel-weld (2/1), driver-wave (16/1, also edge90 1.0)
 - edge90 (raw right angles, 1.0): depsgraph-export (also naming + materials), image-pixels-testcard, png-exr-alpha, temp-override-join, text-version-stamp, vse-cut-list; vse-gamma-cross at 0.92
 - reference: gallery best-modeled measure collision-hull-proxy 0.044, custom-normals-shade 0.288, vertex-weight-limit 0.150, lod-decimate-chain 0.019; calibration details in `docs/VISUAL-STYLE.md` § Asset quality
 
diff --git a/docs/gallery/asset-sheets/shape-key-blend.webp b/docs/gallery/asset-sheets/shape-key-blend.webp
new file mode 100644
index 00000000..8083d5a8
Binary files /dev/null and b/docs/gallery/asset-sheets/shape-key-blend.webp differ
diff --git a/docs/gallery/assets/shape-key-blend-hero.webp b/docs/gallery/assets/shape-key-blend-hero.webp
index 58c1bedb..9b65008f 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/contact-sheets/shape-key-blend-contact-sheet.webp b/docs/gallery/contact-sheets/shape-key-blend-contact-sheet.webp
index fbd1315a..fc98de36 100644
Binary files a/docs/gallery/contact-sheets/shape-key-blend-contact-sheet.webp and b/docs/gallery/contact-sheets/shape-key-blend-contact-sheet.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 162f151b..fc7e6271 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -464,12 +464,12 @@ <h2><a href="gn-modifier-inputs/">gn-modifier-inputs</a></h2>
       </article>
       <article class="card" data-tags="mesh shape-keys">
         <a class="card-media" href="shape-key-blend/" tabindex="-1" aria-hidden="true">
-          <img src="assets/shape-key-blend-hero.webp" alt="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." loading="lazy" decoding="async" />
+          <img src="assets/shape-key-blend-hero.webp" alt="One cobalt vase with an ochre band at shape-key values 0, 0.5 and 1: squat jar, amphora, tall trumpet vase, with pale rings of the jar&#x27;s belly around the tallest." 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 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>
+          <p class="teaches">A relative Tall shape key that turns a squat ceramic jar into a trumpet vase — lifting and flaring the rim — authored via shape_key_add / key_blocks / .value and 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 lifted, flared rim ring.</p>
           <a class="card-link" href="shape-key-blend/">View example<span class="sr-only"> shape-key-blend</span> <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 abdb0a41..220f73ed 100644
--- a/docs/gallery/shape-key-blend/index.html
+++ b/docs/gallery/shape-key-blend/index.html
@@ -4,25 +4,25 @@
   <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 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="description" content="A relative Tall shape key that turns a squat ceramic jar into a trumpet vase — lifting and flaring the rim — authored via shape_key_add / key_blocks / .value and 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 name="color-scheme" content="dark" />
   <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 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:description" content="A relative Tall shape key that turns a squat ceramic jar into a trumpet vase — lifting and flaring the rim — authored via shape_key_add / key_blocks / .value and 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 property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." />
+  <meta property="og:image:alt" content="One cobalt vase with an ochre band at shape-key values 0, 0.5 and 1: squat jar, amphora, tall trumpet vase, with pale rings of the jar&#x27;s belly around the tallest." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <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 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:description" content="A relative Tall shape key that turns a squat ceramic jar into a trumpet vase — lifting and flaring the rim — authored via shape_key_add / key_blocks / .value and 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" />
-  <meta name="twitter:image:alt" content="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." />
+  <meta name="twitter:image:alt" content="One cobalt vase with an ochre band at shape-key values 0, 0.5 and 1: squat jar, amphora, tall trumpet vase, with pale rings of the jar&#x27;s belly around the tallest." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -265,21 +265,23 @@
   </div>
   <header class="hero">
     <h1>shape-key-blend</h1>
-    <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>
+    <p>A relative Tall shape key that turns a squat ceramic jar into a trumpet vase — lifting and flaring the rim — authored via shape_key_add / key_blocks / .value and read back from the depsgraph-evaluated mesh.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it.">
-      <img src="../assets/shape-key-blend-hero.webp" alt="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: One cobalt vase with an ochre band at shape-key values 0, 0.5 and 1: squat jar, amphora, tall trumpet vase, with pale rings of the jar&#x27;s belly around the tallest.">
+      <img src="../assets/shape-key-blend-hero.webp" alt="One cobalt vase with an ochre band at shape-key values 0, 0.5 and 1: squat jar, amphora, tall trumpet vase, with pale rings of the jar&#x27;s belly around the tallest." 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: every evaluated vert matches basis + value × (key − basis), including the flared top half-extent.</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 lifted, flared rim ring.</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. 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>
+<p>A runnable example that authors a relative shape key entirely through the data API — <code>shape_key_add</code>, <code>key_blocks[&quot;Tall&quot;].data</code> (bulk <code>foreach_get</code> / <code>foreach_set</code> on the key&#x27;s <code>co</code>), and <code>.value</code> — then reads the blend back from the depsgraph-evaluated mesh. The subject is a lathe-turned ceramic vase: its Basis is a squat jar, and the Tall key lifts the rim (stretching the neck), flares the lip into a trumpet, and slims the belly.</p>
+<p><strong>What it witnesses:</strong> shape keys do not rewrite <code>mesh.vertices</code>. The undeformed mesh stays at Basis (every vertex, plus the rim ring at <code>z = 1.0</code>, <code>r = 0.335</code>); every evaluated vertex matches the closed-form blend <code>co = basis + value × (key − basis)</code>. The check also pins the rim ring — lifted to <code>1.0 + value × 1.5</code> and flared to <code>0.335 + value × 0.38</code> — with the foot still on the floor, so a uniform scale or a lift without the flare cannot pass.</p>
+<h2>The render</h2>
+<p>The same vase at <code>Tall.value</code> 0, 0.5 (the checked object) and 1, left to right: squat jar, amphora, trumpet vase. The ochre band is part of the lathe profile, so it rides the key — thin on the jar&#x27;s shoulder, stretched tall and higher on the full key. Around the full-key vase, three thin pale rings are read straight from the <code>Basis</code> key block: the jar&#x27;s belly it was blended from. If the blend broke, the three vases would render as three identical jars.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python shape_key_blend.py --
@@ -291,8 +293,8 @@ <h2>Run</h2>
 blender --background --python shape_key_blend.py -- --output blend.png
 blender --background --python shape_key_blend.py -- --output blend.png --engine cycles</code></pre>
 <h2>Exit codes</h2>
-<p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it.</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>No shape keys on mesh</td></tr><tr><td>4</td><td>Key names ≠ Basis, Tall</td></tr><tr><td>5</td><td>Tall.value ≠ 0.5 (<code>--zero-blend</code> lands here)</td></tr><tr><td>6</td><td>Undeformed <code>mesh.vertices</code> not at Basis</td></tr><tr><td>7</td><td>Evaluated vert off closed-form blend</td></tr><tr><td>8</td><td>Evaluated Z span off closed form</td></tr><tr><td>9</td><td>Top flare off closed form</td></tr><tr><td>10</td><td><code>--output</code> produced no file</td></tr></tbody></table></div>
+<p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it. <code>10</code> and <code>11</code> are the shared render-path gates&#x27; own codes.</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>No shape keys on mesh</td></tr><tr><td>4</td><td>Key names ≠ Basis, Tall</td></tr><tr><td>5</td><td>Tall.value ≠ 0.5 (<code>--zero-blend</code> lands here)</td></tr><tr><td>6</td><td>Undeformed <code>mesh.vertices</code> not at Basis</td></tr><tr><td>7</td><td>Evaluated vert off closed-form blend</td></tr><tr><td>8</td><td>Evaluated Z span off closed form</td></tr><tr><td>9</td><td>Rim radius (flare) off closed form</td></tr><tr><td>10</td><td>Framing gate (<code>gallery_framing</code>, <code>--output</code> only)</td></tr><tr><td>11</td><td>Asset-quality gate (<code>gallery_asset_quality</code>, <code>--output</code> only)</td></tr><tr><td>12</td><td><code>--output</code> produced no file</td></tr></tbody></table></div>
 <p>The <code>blender-smoke</code> workflow runs the check on Blender 5.2 LTS and 4.5 LTS (5.1 on the weekly cron, the <code>needs-5.1</code> PR label, or manual dispatch). Smoke does not pass <code>--output</code> or <code>--zero-blend</code>.</p>
     </section>
     <section class="detail-section src">
@@ -304,14 +306,16 @@ <h2>Source</h2>
       <pre><span class="s">&quot;&quot;&quot;Relative shape-key blend via the data API — a runnable example.
 
 Witnesses that shape keys are authored and driven on the mesh datablock
-(`shape_key_add`, `key_blocks[&quot;Name&quot;].data[i].co`, `.value`), not through
+(`shape_key_add`, `key_blocks[&quot;Tall&quot;].data`, `.value`), not through
 operators, and that the depsgraph-evaluated mesh matches the closed-form
 relative blend: co = basis + value * (key - basis). AI often keys the
 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.
+The subject is a lathe-turned ceramic vase. Its Basis is a squat jar; the
+Tall key lifts the rim (stretching the neck), flares the lip into a
+trumpet, and slims the belly — a real morph, not a uniform scale. The
+check pins the lift and the flare at the rim ring in closed form.
 
 ``--zero-blend`` sets Tall.value to 0 and still asserts the 0.5 closed form.
 That is the falsifier (``--same-axis`` in export-preset-axis).
@@ -325,47 +329,164 @@ <h2>Source</h2>
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse
 
-CUBE_SIZE = <span class="n">1.0</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>
+SEGMENTS = <span class="n">64</span>      <span class="c"># lathe resolution around Z</span>
+H0 = <span class="n">1.0</span>           <span class="c"># Basis rim height (the lip&#x27;s top ring)</span>
+R_LIP0 = <span class="n">0.335</span>     <span class="c"># Basis rim radius</span>
+WALL = <span class="n">0.03</span>        <span class="c"># ceramic wall thickness</span>
+LIFT = <span class="n">1.5</span>         <span class="c"># Tall key: rim rises by this much</span>
+FLARE = <span class="n">0.38</span>       <span class="c"># Tall key: rim radius grows by this much</span>
+SLIM = <span class="n">0.28</span>        <span class="c"># Tall key: belly narrows by up to this fraction</span>
 BLEND = <span class="n">0.5</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(zero_blend=<span class="k">False</span>):
-    bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    me = bpy.data.meshes.new(<span class="s">&quot;Block&quot;</span>)
+EXPECT_TOP_Z = H0 + BLEND * LIFT
+EXPECT_BOT_Z = <span class="n">0.0</span>                      <span class="c"># the foot never moves</span>
+EXPECT_RIM_R = R_LIP0 + BLEND * FLARE   <span class="c"># radius of the rim ring</span>
+
+<span class="c"># Outer wall control points (radius, z) from the foot to the shoulder of the</span>
+<span class="c"># lip, Catmull-Rom interpolated. A squat, round-bellied jar.</span>
+_OUTER_CTRL = [(<span class="n">0.300</span>, <span class="n">0.080</span>), (<span class="n">0.420</span>, <span class="n">0.160</span>), (<span class="n">0.540</span>, <span class="n">0.270</span>), (<span class="n">0.605</span>, <span class="n">0.370</span>),
+               (<span class="n">0.620</span>, <span class="n">0.450</span>), (<span class="n">0.590</span>, <span class="n">0.540</span>), (<span class="n">0.500</span>, <span class="n">0.640</span>), (<span class="n">0.380</span>, <span class="n">0.720</span>),
+               (<span class="n">0.290</span>, <span class="n">0.790</span>), (<span class="n">0.262</span>, <span class="n">0.850</span>), (<span class="n">0.272</span>, <span class="n">0.910</span>), (<span class="n">0.305</span>, <span class="n">0.955</span>),
+               (<span class="n">0.345</span>, <span class="n">0.985</span>)]
+BAND = (<span class="n">0.530</span>, <span class="n">0.600</span>, <span class="n">0.014</span>)   <span class="c"># raised ochre band: z0, z1, relief</span>
+GHOST_RINGS = (<span class="n">0.22</span>, <span class="n">0.34</span>, <span class="n">0.45</span>)  <span class="c"># Basis heights drawn as the ghost</span>
+
+<span class="c"># material slots</span>
+M_GLAZE, M_BISQUE, M_GILT, M_INNER = range(<span class="n">4</span>)
+
+
+<span class="k">def</span> _smoothstep(a, b, x):
+    t = min(<span class="n">1.0</span>, max(<span class="n">0.0</span>, (x - a) / (b - a)))
+    <span class="k">return</span> t * t * (<span class="n">3.0</span> - <span class="n">2.0</span> * t)
+
+
+<span class="k">def</span> _catmull(pts, per_span=<span class="n">8</span>):
+    out = []
+    ext = [pts[<span class="n">0</span>]] + pts + [pts[-<span class="n">1</span>]]
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, len(ext) - <span class="n">2</span>):
+        p0, p1, p2, p3 = ext[i - <span class="n">1</span>], ext[i], ext[i + <span class="n">1</span>], ext[i + <span class="n">2</span>]
+        <span class="k">for</span> s <span class="k">in</span> range(per_span):
+            t = s / per_span
+            t2, t3 = t * t, t * t * t
+            out.append(tuple(<span class="n">0.5</span> * ((<span class="n">2</span> * p1[k]) + (-p0[k] + p2[k]) * t
+                                    + (<span class="n">2</span> * p0[k] - <span class="n">5</span> * p1[k] + <span class="n">4</span> * p2[k] - p3[k]) * t2
+                                    + (-p0[k] + <span class="n">3</span> * p1[k] - <span class="n">3</span> * p2[k] + p3[k]) * t3)
+                             <span class="k">for</span> k <span class="k">in</span> range(<span class="n">2</span>)))
+    out.append(pts[-<span class="n">1</span>])
+    <span class="k">return</span> out
+
+
+<span class="k">def</span> _radius_at(dense, z):
+    <span class="k">for</span> (r0, z0), (r1, z1) <span class="k">in</span> zip(dense, dense[<span class="n">1</span>:]):
+        <span class="k">if</span> z0 &lt;= z &lt;= z1:
+            <span class="k">return</span> r0 + (r1 - r0) * (z - z0) / (z1 - z0)
+    <span class="k">return</span> dense[-<span class="n">1</span>][<span class="n">0</span>] <span class="k">if</span> z &gt; dense[-<span class="n">1</span>][<span class="n">1</span>] <span class="k">else</span> dense[<span class="n">0</span>][<span class="n">0</span>]
+
+
+<span class="k">def</span> vase_profile():
+    <span class="s">&quot;&quot;&quot;Closed lathe profile [(r, z, material)] from the underside pole, up the
+    outer wall, over the lip, down the inner wall to the inner floor pole.&quot;&quot;&quot;</span>
+    dense = _catmull(_OUTER_CTRL)
+    prof = [(<span class="n">0.0</span>, <span class="n">0.0</span>, M_BISQUE), (<span class="n">0.235</span>, <span class="n">0.0</span>, M_BISQUE), (<span class="n">0.262</span>, <span class="n">0.008</span>, M_BISQUE),
+            (<span class="n">0.272</span>, <span class="n">0.030</span>, M_BISQUE), (<span class="n">0.276</span>, <span class="n">0.060</span>, M_BISQUE), (<span class="n">0.290</span>, <span class="n">0.075</span>, M_GLAZE)]
+    zs = [<span class="n">0.080</span> + i * <span class="n">0.015</span> <span class="k">for</span> i <span class="k">in</span> range(int((<span class="n">0.970</span> - <span class="n">0.080</span>) / <span class="n">0.015</span>) + <span class="n">1</span>)]
+    b0, b1, relief = BAND
+    zs = sorted(set([z <span class="k">for</span> z <span class="k">in</span> zs <span class="k">if</span> <span class="k">not</span> (b0 - <span class="n">0.012</span> &lt; z &lt; b1 + <span class="n">0.012</span>)]
+                    + [b0 - <span class="n">0.008</span>, b0, b0 + <span class="n">0.006</span>, b1 - <span class="n">0.006</span>, b1, b1 + <span class="n">0.008</span>]))
+    <span class="k">for</span> z <span class="k">in</span> zs:
+        r = _radius_at(dense, z)
+        mat = M_GLAZE
+        <span class="k">if</span> b0 &lt;= z &lt; b1:
+            mat = M_GILT
+        <span class="k">if</span> b0 + <span class="n">0.006</span> - <span class="n">1e-9</span> &lt;= z &lt;= b1 - <span class="n">0.006</span> + <span class="n">1e-9</span>:
+            r += relief
+        <span class="k">elif</span> abs(z - b0) &lt; <span class="n">1e-9</span> <span class="k">or</span> abs(z - b1) &lt; <span class="n">1e-9</span>:
+            r += relief * <span class="n">0.55</span>
+        prof.append((r, z, mat))
+    prof += [(<span class="n">0.345</span>, <span class="n">0.985</span>, M_GLAZE), (R_LIP0, H0, M_INNER), (<span class="n">0.312</span>, <span class="n">0.990</span>, M_INNER)]
+    z = <span class="n">0.975</span>
+    <span class="k">while</span> z &gt; <span class="n">0.14</span>:
+        prof.append((_radius_at(dense, z) - WALL, z, M_INNER))
+        z -= <span class="n">0.018</span>
+    prof += [(_radius_at(dense, <span class="n">0.135</span>) - WALL - <span class="n">0.03</span>, <span class="n">0.120</span>, M_INNER), (<span class="n">0.0</span>, <span class="n">0.120</span>, M_INNER)]
+    <span class="k">return</span> prof
+
+
+<span class="k">def</span> tall_offset(x, y, z):
+    <span class="s">&quot;&quot;&quot;The Tall key as a function of the Basis position: lift the neck, flare
+    the lip, slim the belly. Zero at the foot; exactly (+FLARE, +LIFT) at the
+    rim ring (u == 1).&quot;&quot;&quot;</span>
+    u = z / H0
+    r = math.hypot(x, y)
+    <span class="k">if</span> r &lt; <span class="n">1e-9</span>:
+        <span class="k">return</span> x, y, z + LIFT * _smoothstep(<span class="n">0.30</span>, <span class="n">1.0</span>, u)
+    w = <span class="n">0.0</span>
+    <span class="k">if</span> <span class="n">0.08</span> &lt; u &lt; <span class="n">0.75</span>:
+        w = math.sin(math.pi * (u - <span class="n">0.08</span>) / <span class="n">0.67</span>) ** <span class="n">2</span>
+    nr = r * (<span class="n">1.0</span> - SLIM * w) + FLARE * _smoothstep(<span class="n">0.78</span>, <span class="n">1.0</span>, u) ** <span class="n">2</span>
+    <span class="k">return</span> x / r * nr, y / r * nr, z + LIFT * _smoothstep(<span class="n">0.30</span>, <span class="n">1.0</span>, u)
+
+
+<span class="k">def</span> build_vase_mesh(name):
+    prof = vase_profile()
+    me = bpy.data.meshes.new(name)
     bm = bmesh.new()
     <span class="k">try</span>:
-        bmesh.ops.create_cube(bm, size=CUBE_SIZE)
+        rings = []
+        <span class="k">for</span> r, z, _m <span class="k">in</span> prof:
+            <span class="k">if</span> r == <span class="n">0.0</span>:
+                rings.append([bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, z))])
+            <span class="k">else</span>:
+                rings.append([bm.verts.new((r * math.cos(<span class="n">2</span> * math.pi * s / SEGMENTS),
+                                            r * math.sin(<span class="n">2</span> * math.pi * s / SEGMENTS), z))
+                              <span class="k">for</span> s <span class="k">in</span> range(SEGMENTS)])
+        <span class="k">for</span> i <span class="k">in</span> range(len(rings) - <span class="n">1</span>):
+            a, b, mat = rings[i], rings[i + <span class="n">1</span>], prof[i][<span class="n">2</span>]
+            <span class="k">for</span> s <span class="k">in</span> range(SEGMENTS):
+                t = (s + <span class="n">1</span>) % SEGMENTS
+                <span class="k">if</span> len(a) == <span class="n">1</span>:
+                    f = bm.faces.new((a[<span class="n">0</span>], b[s], b[t]))
+                <span class="k">elif</span> len(b) == <span class="n">1</span>:
+                    f = bm.faces.new((a[s], b[<span class="n">0</span>], a[t]))
+                <span class="k">else</span>:
+                    f = bm.faces.new((a[s], b[s], b[t], a[t]))
+                f.material_index = mat
+                f.smooth = <span class="k">True</span>
+        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
         bm.to_mesh(me)
     <span class="k">finally</span>:
         bm.free()
+    <span class="k">return</span> me
 
-    obj = bpy.data.objects.new(<span class="s">&quot;ShapeBlock&quot;</span>, me)
+
+<span class="k">def</span> build(zero_blend=<span class="k">False</span>):
+    bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
+    me = build_vase_mesh(<span class="s">&quot;Vase&quot;</span>)
+    obj = bpy.data.objects.new(<span class="s">&quot;Vase&quot;</span>, me)
     bpy.context.collection.objects.link(obj)
 
     <span class="c"># data-level shape keys — no bpy.ops.object.shape_key_*</span>
     obj.shape_key_add(name=<span class="s">&quot;Basis&quot;</span>)
     tall = obj.shape_key_add(name=<span class="s">&quot;Tall&quot;</span>)
-    <span class="k">for</span> i, _v <span class="k">in</span> enumerate(me.vertices):
-        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)
+    n = len(me.vertices)
+    co = [<span class="n">0.0</span>] * (<span class="n">3</span> * n)
+    tall.data.foreach_get(<span class="s">&quot;co&quot;</span>, co)          <span class="c"># starts as a copy of Basis</span>
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        co[<span class="n">3</span> * i:<span class="n">3</span> * i + <span class="n">3</span>] = tall_offset(*co[<span class="n">3</span> * i:<span class="n">3</span> * i + <span class="n">3</span>])
+    tall.data.foreach_set(<span class="s">&quot;co&quot;</span>, co)
     tall.value = <span class="n">0.0</span> <span class="k">if</span> zero_blend <span class="k">else</span> 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> _coords(seq):
+    flat = [<span class="n">0.0</span>] * (<span class="n">3</span> * len(seq))
+    seq.foreach_get(<span class="s">&quot;co&quot;</span>, flat)
+    <span class="k">return</span> [tuple(flat[i:i + <span class="n">3</span>]) <span class="k">for</span> i <span class="k">in</span> range(<span class="n">0</span>, len(flat), <span class="n">3</span>)]
+
+
+<span class="k">def</span> _rim(coords):
+    <span class="s">&quot;&quot;&quot;(top z, max radius of the ring at the top z).&quot;&quot;&quot;</span>
+    top = max(c[<span class="n">2</span>] <span class="k">for</span> c <span class="k">in</span> coords)
+    <span class="k">return</span> top, max(math.hypot(c[<span class="n">0</span>], c[<span class="n">1</span>]) <span class="k">for</span> c <span class="k">in</span> coords <span class="k">if</span> c[<span class="n">2</span>] &gt; top - <span class="n">1e-6</span>)
 
 
 <span class="k">def</span> check(obj):
@@ -377,18 +498,20 @@ <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)
+    basis = _coords(keys.key_blocks[<span class="s">&quot;Basis&quot;</span>].data)
+    tall_kb = keys.key_blocks[<span class="s">&quot;Tall&quot;</span>]
+    tall = _coords(tall_kb.data)
+    <span class="k">if</span> abs(tall_kb.value - BLEND) &gt; <span class="n">1e-6</span>:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: Tall.value </span>{tall_kb.value}<span class="s"> != </span>{BLEND}<span class="s">&quot;</span>, file=sys.stderr)
         <span class="k">return</span> <span class="n">5</span>
 
     <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)
-    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>,
+    raw = _coords(obj.data.vertices)
+    raw_top, raw_rim = _rim(raw)
+    worst = max(math.dist(a, b) <span class="k">for</span> a, b <span class="k">in</span> zip(raw, basis))
+    <span class="k">if</span> worst &gt; <span class="n">1e-5</span> <span class="k">or</span> abs(raw_top - H0) &gt; <span class="n">1e-4</span> <span class="k">or</span> abs(raw_rim - R_LIP0) &gt; <span class="n">1e-4</span>:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: undeformed mesh not at Basis (off by </span>{worst:<span class="s">.5f</span>}<span class="s">, </span><span class="s">&quot;</span>
+              <span class="s">f&quot;</span><span class="s">rim z=</span>{raw_top:<span class="s">.4f</span>}<span class="s"> r=</span>{raw_rim:<span class="s">.4f</span>}<span class="s">, expected </span>{H0}<span class="s">, </span>{R_LIP0}<span class="s">)</span><span class="s">&quot;</span>,
               file=sys.stderr)
         <span class="k">return</span> <span class="n">6</span>
 
@@ -397,32 +520,28 @@ <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)
+        evald = _coords(em.vertices)
     <span class="k">finally</span>:
         ev.to_mesh_clear()
 
+    <span class="c"># every evaluated vert must match the closed-form blend from key_blocks</span>
+    <span class="k">for</span> i, (v, b, k) <span class="k">in</span> enumerate(zip(evald, basis, tall)):
+        expect = tuple(b[j] + BLEND * (k[j] - b[j]) <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>))
+        <span class="k">if</span> math.dist(v, expect) &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>{v}<span class="s"> != blend </span>{expect}<span class="s">&quot;</span>, file=sys.stderr)
+            <span class="k">return</span> <span class="n">7</span>
+    top, rim = _rim(evald)
+    bot = min(c[<span class="n">2</span>] <span class="k">for</span> c <span class="k">in</span> evald)
     <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">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">if</span> abs(rim - EXPECT_RIM_R) &gt; <span class="n">1e-4</span>:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: rim radius </span>{rim:<span class="s">.4f</span>}<span class="s"> != </span>{EXPECT_RIM_R:<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">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>)
+    print(<span class="s">f&quot;</span><span class="s">keys=</span>{names}<span class="s"> value=</span>{BLEND}<span class="s"> verts=</span>{len(evald)}<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">rim_r=</span>{rim:<span class="s">.3f</span>}<span class="s"> undeformed_rim=</span>{raw_top:<span class="s">.3f</span>}<span class="s">/</span>{raw_rim:<span class="s">.3f</span>}<span class="s">&quot;</span>)
     <span class="k">return</span> <span class="n">0</span>
 
 
@@ -430,59 +549,112 @@ <h2>Source</h2>
     <span class="k">return</span> <span class="s">&#x27;BLENDER_EEVEE&#x27;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&#x27;BLENDER_EEVEE_NEXT&#x27;</span>
 
 
+<span class="k">def</span> _principled(name, color, rough, metal=<span class="n">0.0</span>):
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    b = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    b.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (*color, <span class="n">1.0</span>)
+    b.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = rough
+    b.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metal
+    <span class="k">return</span> mat, b
+
+
+<span class="k">def</span> _vase_materials():
+    <span class="c"># Reactive cobalt glaze: object-space noise mottles two blues so the</span>
+    <span class="c"># glaze pools darker and breaks lighter, like a real kiln glaze.</span>
+    glaze, gb = _principled(<span class="s">&quot;CobaltGlaze&quot;</span>, (<span class="n">0.03</span>, <span class="n">0.12</span>, <span class="n">0.55</span>), <span class="n">0.22</span>)
+    nt = glaze.node_tree
+    tc = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    noise = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    noise.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = <span class="n">5.0</span>
+    noise.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">3.0</span>
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.38</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.02</span>, <span class="n">0.075</span>, <span class="n">0.40</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.62</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.045</span>, <span class="n">0.17</span>, <span class="n">0.66</span>, <span class="n">1.0</span>)
+    nt.links.new(tc.outputs[<span class="s">&quot;Object&quot;</span>], noise.inputs[<span class="s">&quot;Vector&quot;</span>])
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], gb.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    bisque, _ = _principled(<span class="s">&quot;Bisque&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.30</span>, <span class="n">0.18</span>), <span class="n">0.85</span>)
+    gilt, _ = _principled(<span class="s">&quot;OchreBand&quot;</span>, (<span class="n">0.95</span>, <span class="n">0.55</span>, <span class="n">0.12</span>), <span class="n">0.35</span>)
+    inner, _ = _principled(<span class="s">&quot;CreamGlaze&quot;</span>, (<span class="n">0.80</span>, <span class="n">0.72</span>, <span class="n">0.55</span>), <span class="n">0.3</span>)
+    <span class="k">return</span> [glaze, bisque, gilt, inner]
+
+
+<span class="k">def</span> _basis_ghost(src_obj, name, loc, mat):
+    <span class="s">&quot;&quot;&quot;Contour rings of the Basis, read from the Basis key block: the squat
+    jar&#x27;s belly drawn as three thin lines around the full key.&quot;&quot;&quot;</span>
+    basis = _coords(src_obj.data.shape_keys.key_blocks[<span class="s">&quot;Basis&quot;</span>].data)
+    prof = vase_profile()
+    starts, idx = [], <span class="n">0</span>
+    <span class="k">for</span> r, _z, _m <span class="k">in</span> prof:
+        starts.append(idx)
+        idx += SEGMENTS <span class="k">if</span> r &gt; <span class="n">0.0</span> <span class="k">else</span> <span class="n">1</span>
+    apex = next(i <span class="k">for</span> i, (_r, z, _m) <span class="k">in</span> enumerate(prof) <span class="k">if</span> z == H0)
+    cu = bpy.data.curves.new(name, <span class="s">&#x27;CURVE&#x27;</span>)
+    cu.dimensions = <span class="s">&#x27;3D&#x27;</span>
+    cu.bevel_depth = <span class="n">0.006</span>
+    cu.bevel_resolution = <span class="n">2</span>
+    <span class="k">for</span> zt <span class="k">in</span> GHOST_RINGS:
+        i = min(range(<span class="n">1</span>, apex), key=<span class="k">lambda</span> k: abs(prof[k][<span class="n">1</span>] - zt))
+        sp = cu.splines.new(<span class="s">&#x27;POLY&#x27;</span>)
+        sp.points.add(SEGMENTS - <span class="n">1</span>)
+        <span class="k">for</span> s <span class="k">in</span> range(SEGMENTS):
+            sp.points[s].co = (*basis[starts[i] + s], <span class="n">1.0</span>)
+        sp.use_cyclic_u = <span class="k">True</span>
+    cu.materials.append(mat)
+    ob = bpy.data.objects.new(name, cu)
+    ob.location = loc
+    bpy.context.collection.objects.link(ob)
+    <span class="k">return</span> ob
+
+
 <span class="k">def</span> render_still(obj, path, engine):
+    <span class="c"># Shared Layer 1 gates (render path only) — see gallery_framing.py</span>
+    sys.path.insert(<span class="n">0</span>, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
+    sys.dont_write_bytecode = <span class="k">True</span>  <span class="c"># keep examples/__pycache__ out of the repo tree</span>
+    <span class="k">import</span> gallery_framing
+    <span class="k">import</span> gallery_asset_quality
+
     scene = bpy.context.scene
-    <span class="k">for</span> poly <span class="k">in</span> obj.data.polygons:
-        poly.use_smooth = <span class="k">False</span>
-    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.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.35</span>
-    obj.data.materials.clear()
-    obj.data.materials.append(mat)
-
-    <span class="c"># the still shows the blend as a progression: Basis (0), half blend, and</span>
-    <span class="c"># the checked BLEND value, left to right — one silhouette per key value,</span>
-    <span class="c"># so a failed blend is visible as three identical boxes. The two extra</span>
-    <span class="c"># blocks are render-only copies; the check already ran on `obj`.</span>
-    blocks = []
-    <span class="k">for</span> value, x <span class="k">in</span> ((<span class="n">0.0</span>, -<span class="n">1.9</span>), (BLEND / <span class="n">2</span>, <span class="n">0.0</span>), (<span class="k">None</span>, <span class="n">1.9</span>)):
+    <span class="c"># No clear() first: the mesh has no slots yet, and Mesh.materials.clear()</span>
+    <span class="c"># drops the per-face material_index the lathe build assigned.</span>
+    <span class="k">for</span> m <span class="k">in</span> _vase_materials():
+        obj.data.materials.append(m)
+
+    <span class="c"># The still is the blend as a progression, left to right: Basis (0), the</span>
+    <span class="c"># checked object at BLEND, and the full key (1). Same mesh, same key —</span>
+    <span class="c"># only Tall.value differs, so a broken blend reads as three identical</span>
+    <span class="c"># jars. The two outer vases are render-only copies; the check already</span>
+    <span class="c"># ran on `obj`.</span>
+    vases = []
+    <span class="k">for</span> value, x <span class="k">in</span> ((<span class="n">0.0</span>, -<span class="n">1.85</span>), (<span class="k">None</span>, <span class="n">0.0</span>), (<span class="n">1.0</span>, <span class="n">1.95</span>)):
         <span class="k">if</span> value <span class="k">is</span> <span class="k">None</span>:
             ob = obj
         <span class="k">else</span>:
             me = obj.data.copy()
             me.shape_keys.key_blocks[<span class="s">&quot;Tall&quot;</span>].value = value
-            ob = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">ShapeBlock_</span>{value}<span class="s">&quot;</span>, me)
+            ob = bpy.data.objects.new(<span class="s">&quot;Vase.Basis&quot;</span> <span class="k">if</span> value == <span class="n">0.0</span> <span class="k">else</span> <span class="s">&quot;Vase.Full&quot;</span>, me)
             bpy.context.collection.objects.link(ob)
-        <span class="c"># bottom verts stay at -HALF; lift so each block rests on the floor</span>
-        ob.location = (x, <span class="n">0.0</span>, HALF)
-        ob.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(<span class="n">28</span>))
-        blocks.append(ob)
-
-    <span class="c"># Endpoint cages on the checked block: its Basis and its full Tall key as</span>
-    <span class="c"># pale wireframes, so the solid visibly sits halfway between the two —</span>
-    <span class="c"># the closed-form blend the check asserts, not just &quot;a taller box&quot;.</span>
-    <span class="c"># Render-only copies with their own key value; `obj` is untouched.</span>
-    cage_mat = bpy.data.materials.new(<span class="s">&quot;Cage&quot;</span>)
-    cage_mat.use_nodes = <span class="k">True</span>
-    cbsdf = cage_mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    cbsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.92</span>, <span class="n">0.84</span>, <span class="n">1.0</span>, <span class="n">1.0</span>)
-    cbsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.4</span>
-    cages = []
-    <span class="k">for</span> end <span class="k">in</span> (<span class="n">0.0</span>, <span class="n">1.0</span>):
-        me = obj.data.copy()
-        me.materials.clear()
-        me.materials.append(cage_mat)
-        me.shape_keys.key_blocks[<span class="s">&quot;Tall&quot;</span>].value = end
-        cage = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Cage_</span>{end}<span class="s">&quot;</span>, me)
-        cage.location = obj.location
-        cage.rotation_euler = obj.rotation_euler
-        wire = cage.modifiers.new(<span class="s">&quot;cage&quot;</span>, <span class="s">&quot;WIREFRAME&quot;</span>)
-        wire.thickness = <span class="n">0.02</span>
-        wire.use_even_offset = <span class="k">True</span>
-        bpy.context.collection.objects.link(cage)
-        cages.append(cage)
+        ob.location = (x, <span class="n">0.0</span>, <span class="n">0.0</span>)
+        vases.append(ob)
+
+    <span class="c"># A faint contour cage of the Basis around the full-key vase: the squat</span>
+    <span class="c"># jar it was blended from, so the lift, flare and slimmed belly read on</span>
+    <span class="c"># the one object.</span>
+    ghost_mat = bpy.data.materials.new(<span class="s">&quot;BasisGhost&quot;</span>)
+    ghost_mat.use_nodes = <span class="k">True</span>
+    gnt = ghost_mat.node_tree
+    <span class="k">for</span> n <span class="k">in</span> list(gnt.nodes):
+        <span class="k">if</span> n.type != <span class="s">&#x27;OUTPUT_MATERIAL&#x27;</span>:
+            gnt.nodes.remove(n)
+    em = gnt.nodes.new(<span class="s">&quot;ShaderNodeEmission&quot;</span>)
+    em.inputs[<span class="s">&quot;Color&quot;</span>].default_value = (<span class="n">1.0</span>, <span class="n">0.86</span>, <span class="n">0.62</span>, <span class="n">1.0</span>)
+    em.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">0.9</span>
+    gnt.links.new(em.outputs[<span class="s">&quot;Emission&quot;</span>],
+                  next(n <span class="k">for</span> n <span class="k">in</span> gnt.nodes <span class="k">if</span> n.type == <span class="s">&#x27;OUTPUT_MATERIAL&#x27;</span>).inputs[<span class="s">&quot;Surface&quot;</span>])
+    ghost = _basis_ghost(obj, <span class="s">&quot;Vase.BasisGhost&quot;</span>, vases[<span class="n">2</span>].location, ghost_mat)
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -509,55 +681,40 @@ <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.02</span>, <span class="n">0.021</span>, <span class="n">0.025</span>, <span class="n">1.0</span>)
     scene.world = world
 
-    world_top = HALF + EXPECT_TOP_Z
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    <span class="c"># Aimed above the checked block&#x27;s middle: the full-key cage over it is</span>
-    <span class="c"># taller than any solid, and centring on the solids clipped it.</span>
-    aim.location = (<span class="n">0.35</span>, <span class="n">0.0</span>, world_top * <span class="n">0.62</span>)
+    aim.location = (<span class="n">0.05</span>, <span class="n">0.0</span>, <span class="n">1.12</span>)
     scene.collection.objects.link(aim)
 
-    <span class="k">def</span> light(name, loc, energy, size, col):
+    <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
+        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>
-
-    <span class="c"># shaped warm key, faint cool fill, cool rim, warm wedge pooling on the</span>
-    <span class="c"># back wall (docs/VISUAL-STYLE.md)</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">520.0</span>, <span class="n">4.5</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</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">110.0</span>, <span class="n">8.0</span>, (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">0.5</span>, <span class="n">4.5</span>, <span class="n">4.5</span>), <span class="n">300.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>))
-    wedge = bpy.data.lights.new(<span class="s">&quot;Wedge&quot;</span>, <span class="s">&#x27;AREA&#x27;</span>)
-    wedge.energy = <span class="n">380.0</span>
-    wedge.size = <span class="n">6.0</span>
-    wedge.color = (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>)
-    wob = bpy.data.objects.new(<span class="s">&quot;Wedge&quot;</span>, wedge)
-    wob.location = (<span class="n">2.5</span>, <span class="n">5.5</span>, <span class="n">4.0</span>)
-    wob.rotation_euler = (math.radians(-<span class="n">68</span>), <span class="n">0.0</span>, math.radians(<span class="n">190</span>))
-    scene.collection.objects.link(wob)
+
+    <span class="c"># default-stage rig per docs/VISUAL-STYLE.md</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">480.0</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="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">110.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">65</span>, <span class="n">0</span>, <span class="n">50</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.0</span>, <span class="n">4.5</span>, <span class="n">5.0</span>), <span class="n">340.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">55</span>, <span class="n">0</span>, <span class="n">175</span>))
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">1.5</span>, <span class="n">5.0</span>, <span class="n">4.0</span>), <span class="n">420.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">68</span>, <span class="n">0</span>, <span class="n">190</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)
-    <span class="c"># Pulled back so the full-key cage on the right block stays in frame.</span>
-    cam.location = (<span class="n">0.35</span>, -<span class="n">10.4</span>, <span class="n">2.5</span>)
+    <span class="c"># A little above the rims so each mouth opens into an ellipse and the</span>
+    <span class="c"># cream interior reads.</span>
+    cam.location = (<span class="n">0.05</span>, -<span class="n">8.2</span>, <span class="n">3.9</span>)
     scene.collection.objects.link(cam)
-    scene.camera = cam
-    track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
+    track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)  <span class="c"># data API, not bpy.ops</span>
     track.target = aim
     track.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
     track.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
+    scene.camera = cam
 
     scene.render.engine = <span class="s">&#x27;CYCLES&#x27;</span> <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span> <span class="k">else</span> eevee_engine_id()
     <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span>:
-        scene.cycles.samples = <span class="n">32</span>
+        scene.cycles.samples = <span class="n">64</span>
     <span class="k">else</span>:
         <span class="k">try</span>:
             scene.eevee.taa_render_samples = <span class="n">64</span>
@@ -566,11 +723,24 @@ <h2>Source</h2>
     scene.render.resolution_x = <span class="n">1280</span>
     scene.render.resolution_y = <span class="n">720</span>
     scene.render.image_settings.file_format = <span class="s">&#x27;PNG&#x27;</span>
-    <span class="c"># AgX would wash the violet toward pastel grey (docs/VISUAL-STYLE.md)</span>
-    scene.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
     scene.render.filepath = path
+    <span class="c"># AgX would wash the cobalt glaze toward slate (docs/VISUAL-STYLE.md)</span>
+    scene.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
+    bpy.context.view_layer.update()
+
+    code = gallery_framing.check_framing(scene, cam, hero=vases, elements=vases + [ghost],
+                                         stage=[floor, wall])
+    <span class="k">if</span> code:
+        <span class="k">return</span> code
+    code = gallery_asset_quality.check_asset_quality(scene, cam, hero=[obj],
+                                                     stage=[floor, wall])
+    <span class="k">if</span> code:
+        <span class="k">return</span> code
     bpy.ops.render.render(write_still=<span class="k">True</span>)
-    <span class="k">return</span> os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>
+    <span class="k">if</span> <span class="k">not</span> (os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>):
+        print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
+        <span class="k">return</span> <span class="n">12</span>
+    <span class="k">return</span> <span class="n">0</span>
 
 
 <span class="k">def</span> main():
@@ -589,9 +759,9 @@ <h2>Source</h2>
         <span class="k">return</span> code
 
     <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">10</span>
+        code = render_still(obj, os.path.abspath(args.output), args.engine)
+        <span class="k">if</span> code:
+            <span class="k">return</span> code
         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>)
@@ -608,7 +778,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/shape-key-blend-hero.webp" alt="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." />
+    <img src="../assets/shape-key-blend-hero.webp" alt="One cobalt vase with an ochre band at shape-key values 0, 0.5 and 1: squat jar, amphora, tall trumpet vase, with pale rings of the jar&#x27;s belly around the tallest." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/gallery.json b/examples/gallery.json
index 4a695b7a..5d52991b 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -151,9 +151,9 @@
     {
       "name": "shape-key-blend",
       "dir": "examples/shape-key-blend",
-      "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.",
-      "alt": "Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it.",
-      "witnessesFix": "Shape keys do not rewrite mesh.vertices: every evaluated vert matches basis + value × (key − basis), including the flared top half-extent.",
+      "teaches": "A relative Tall shape key that turns a squat ceramic jar into a trumpet vase — lifting and flaring the rim — authored via shape_key_add / key_blocks / .value and read back from the depsgraph-evaluated mesh.",
+      "alt": "One cobalt vase with an ochre band at shape-key values 0, 0.5 and 1: squat jar, amphora, tall trumpet vase, with pale rings of the jar's belly around the tallest.",
+      "witnessesFix": "Shape keys do not rewrite mesh.vertices: every evaluated vert matches basis + value × (key − basis), including the lifted, flared rim ring.",
       "hero": "docs/gallery/assets/shape-key-blend-hero.webp",
       "preview": "examples/shape-key-blend/preview.webp",
       "tags": [
diff --git a/examples/shape-key-blend/README.md b/examples/shape-key-blend/README.md
index 729b6349..8ece2c88 100644
--- a/examples/shape-key-blend/README.md
+++ b/examples/shape-key-blend/README.md
@@ -1,14 +1,27 @@
 # Shape-Key Blend
 
 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. The Tall
-key both lifts and flares the top face, so the silhouette is a truncated pyramid.
+API — `shape_key_add`, `key_blocks["Tall"].data` (bulk `foreach_get` /
+`foreach_set` on the key's `co`), and `.value` — then reads the blend back from
+the depsgraph-evaluated mesh. The subject is a lathe-turned ceramic vase: its
+Basis is a squat jar, and the Tall key lifts the rim (stretching the neck),
+flares the lip into a trumpet, and slims the belly.
 
 **What it witnesses:** shape keys do not rewrite `mesh.vertices`. The undeformed
-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.
+mesh stays at Basis (every vertex, plus the rim ring at `z = 1.0`, `r = 0.335`);
+every evaluated vertex matches the closed-form blend
+`co = basis + value × (key − basis)`. The check also pins the rim ring — lifted
+to `1.0 + value × 1.5` and flared to `0.335 + value × 0.38` — with the foot
+still on the floor, so a uniform scale or a lift without the flare cannot pass.
+
+## The render
+
+The same vase at `Tall.value` 0, 0.5 (the checked object) and 1, left to right:
+squat jar, amphora, trumpet vase. The ochre band is part of the lathe profile,
+so it rides the key — thin on the jar's shoulder, stretched tall and higher on
+the full key. Around the full-key vase, three thin pale rings are read straight
+from the `Basis` key block: the jar's belly it was blended from. If the blend
+broke, the three vases would render as three identical jars.
 
 ## Run
 
@@ -27,7 +40,7 @@ blender --background --python shape_key_blend.py -- --output blend.png --engine
 ## Exit codes
 
 Per-script sequential checks. `9` is a valid check code; there is no rule
-against it.
+against it. `10` and `11` are the shared render-path gates' own codes.
 
 | Code | Meaning |
 | --- | --- |
@@ -40,8 +53,10 @@ against it.
 | 6 | Undeformed `mesh.vertices` not at Basis |
 | 7 | Evaluated vert off closed-form blend |
 | 8 | Evaluated Z span off closed form |
-| 9 | Top flare off closed form |
-| 10 | `--output` produced no file |
+| 9 | Rim radius (flare) off closed form |
+| 10 | Framing gate (`gallery_framing`, `--output` only) |
+| 11 | Asset-quality gate (`gallery_asset_quality`, `--output` only) |
+| 12 | `--output` produced no file |
 
 The `blender-smoke` workflow runs the check on Blender 5.2 LTS and 4.5 LTS
 (5.1 on the weekly cron, the `needs-5.1` PR label, or manual dispatch).
diff --git a/examples/shape-key-blend/preview.webp b/examples/shape-key-blend/preview.webp
index 3b93d3bd..c6f7c946 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 5e72729c..4232b1cf 100644
--- a/examples/shape-key-blend/shape_key_blend.py
+++ b/examples/shape-key-blend/shape_key_blend.py
@@ -1,14 +1,16 @@
 """Relative shape-key blend via the data API — a runnable example.
 
 Witnesses that shape keys are authored and driven on the mesh datablock
-(`shape_key_add`, `key_blocks["Name"].data[i].co`, `.value`), not through
+(`shape_key_add`, `key_blocks["Tall"].data`, `.value`), not through
 operators, and that the depsgraph-evaluated mesh matches the closed-form
 relative blend: co = basis + value * (key - basis). AI often keys the
 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.
+The subject is a lathe-turned ceramic vase. Its Basis is a squat jar; the
+Tall key lifts the rim (stretching the neck), flares the lip into a
+trumpet, and slims the belly — a real morph, not a uniform scale. The
+check pins the lift and the flare at the rim ring in closed form.
 
 ``--zero-blend`` sets Tall.value to 0 and still asserts the 0.5 closed form.
 That is the falsifier (``--same-axis`` in export-preset-axis).
@@ -22,47 +24,164 @@
 """
 import bpy, bmesh, sys, os, math, argparse
 
-CUBE_SIZE = 1.0
-LIFT = 2.0
-FLARE = 0.45  # extra half-extent on top face in XY at full key
+SEGMENTS = 64      # lathe resolution around Z
+H0 = 1.0           # Basis rim height (the lip's top ring)
+R_LIP0 = 0.335     # Basis rim radius
+WALL = 0.03        # ceramic wall thickness
+LIFT = 1.5         # Tall key: rim rises by this much
+FLARE = 0.38       # Tall key: rim radius grows by this much
+SLIM = 0.28        # Tall key: belly narrows by up to this fraction
 BLEND = 0.5
-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(zero_blend=False):
-    bpy.ops.wm.read_factory_settings(use_empty=True)
-    me = bpy.data.meshes.new("Block")
+EXPECT_TOP_Z = H0 + BLEND * LIFT
+EXPECT_BOT_Z = 0.0                      # the foot never moves
+EXPECT_RIM_R = R_LIP0 + BLEND * FLARE   # radius of the rim ring
+
+# Outer wall control points (radius, z) from the foot to the shoulder of the
+# lip, Catmull-Rom interpolated. A squat, round-bellied jar.
+_OUTER_CTRL = [(0.300, 0.080), (0.420, 0.160), (0.540, 0.270), (0.605, 0.370),
+               (0.620, 0.450), (0.590, 0.540), (0.500, 0.640), (0.380, 0.720),
+               (0.290, 0.790), (0.262, 0.850), (0.272, 0.910), (0.305, 0.955),
+               (0.345, 0.985)]
+BAND = (0.530, 0.600, 0.014)   # raised ochre band: z0, z1, relief
+GHOST_RINGS = (0.22, 0.34, 0.45)  # Basis heights drawn as the ghost
+
+# material slots
+M_GLAZE, M_BISQUE, M_GILT, M_INNER = range(4)
+
+
+def _smoothstep(a, b, x):
+    t = min(1.0, max(0.0, (x - a) / (b - a)))
+    return t * t * (3.0 - 2.0 * t)
+
+
+def _catmull(pts, per_span=8):
+    out = []
+    ext = [pts[0]] + pts + [pts[-1]]
+    for i in range(1, len(ext) - 2):
+        p0, p1, p2, p3 = ext[i - 1], ext[i], ext[i + 1], ext[i + 2]
+        for s in range(per_span):
+            t = s / per_span
+            t2, t3 = t * t, t * t * t
+            out.append(tuple(0.5 * ((2 * p1[k]) + (-p0[k] + p2[k]) * t
+                                    + (2 * p0[k] - 5 * p1[k] + 4 * p2[k] - p3[k]) * t2
+                                    + (-p0[k] + 3 * p1[k] - 3 * p2[k] + p3[k]) * t3)
+                             for k in range(2)))
+    out.append(pts[-1])
+    return out
+
+
+def _radius_at(dense, z):
+    for (r0, z0), (r1, z1) in zip(dense, dense[1:]):
+        if z0 <= z <= z1:
+            return r0 + (r1 - r0) * (z - z0) / (z1 - z0)
+    return dense[-1][0] if z > dense[-1][1] else dense[0][0]
+
+
+def vase_profile():
+    """Closed lathe profile [(r, z, material)] from the underside pole, up the
+    outer wall, over the lip, down the inner wall to the inner floor pole."""
+    dense = _catmull(_OUTER_CTRL)
+    prof = [(0.0, 0.0, M_BISQUE), (0.235, 0.0, M_BISQUE), (0.262, 0.008, M_BISQUE),
+            (0.272, 0.030, M_BISQUE), (0.276, 0.060, M_BISQUE), (0.290, 0.075, M_GLAZE)]
+    zs = [0.080 + i * 0.015 for i in range(int((0.970 - 0.080) / 0.015) + 1)]
+    b0, b1, relief = BAND
+    zs = sorted(set([z for z in zs if not (b0 - 0.012 < z < b1 + 0.012)]
+                    + [b0 - 0.008, b0, b0 + 0.006, b1 - 0.006, b1, b1 + 0.008]))
+    for z in zs:
+        r = _radius_at(dense, z)
+        mat = M_GLAZE
+        if b0 <= z < b1:
+            mat = M_GILT
+        if b0 + 0.006 - 1e-9 <= z <= b1 - 0.006 + 1e-9:
+            r += relief
+        elif abs(z - b0) < 1e-9 or abs(z - b1) < 1e-9:
+            r += relief * 0.55
+        prof.append((r, z, mat))
+    prof += [(0.345, 0.985, M_GLAZE), (R_LIP0, H0, M_INNER), (0.312, 0.990, M_INNER)]
+    z = 0.975
+    while z > 0.14:
+        prof.append((_radius_at(dense, z) - WALL, z, M_INNER))
+        z -= 0.018
+    prof += [(_radius_at(dense, 0.135) - WALL - 0.03, 0.120, M_INNER), (0.0, 0.120, M_INNER)]
+    return prof
+
+
+def tall_offset(x, y, z):
+    """The Tall key as a function of the Basis position: lift the neck, flare
+    the lip, slim the belly. Zero at the foot; exactly (+FLARE, +LIFT) at the
+    rim ring (u == 1)."""
+    u = z / H0
+    r = math.hypot(x, y)
+    if r < 1e-9:
+        return x, y, z + LIFT * _smoothstep(0.30, 1.0, u)
+    w = 0.0
+    if 0.08 < u < 0.75:
+        w = math.sin(math.pi * (u - 0.08) / 0.67) ** 2
+    nr = r * (1.0 - SLIM * w) + FLARE * _smoothstep(0.78, 1.0, u) ** 2
+    return x / r * nr, y / r * nr, z + LIFT * _smoothstep(0.30, 1.0, u)
+
+
+def build_vase_mesh(name):
+    prof = vase_profile()
+    me = bpy.data.meshes.new(name)
     bm = bmesh.new()
     try:
-        bmesh.ops.create_cube(bm, size=CUBE_SIZE)
+        rings = []
+        for r, z, _m in prof:
+            if r == 0.0:
+                rings.append([bm.verts.new((0.0, 0.0, z))])
+            else:
+                rings.append([bm.verts.new((r * math.cos(2 * math.pi * s / SEGMENTS),
+                                            r * math.sin(2 * math.pi * s / SEGMENTS), z))
+                              for s in range(SEGMENTS)])
+        for i in range(len(rings) - 1):
+            a, b, mat = rings[i], rings[i + 1], prof[i][2]
+            for s in range(SEGMENTS):
+                t = (s + 1) % SEGMENTS
+                if len(a) == 1:
+                    f = bm.faces.new((a[0], b[s], b[t]))
+                elif len(b) == 1:
+                    f = bm.faces.new((a[s], b[0], a[t]))
+                else:
+                    f = bm.faces.new((a[s], b[s], b[t], a[t]))
+                f.material_index = mat
+                f.smooth = True
+        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
         bm.to_mesh(me)
     finally:
         bm.free()
+    return me
 
-    obj = bpy.data.objects.new("ShapeBlock", me)
+
+def build(zero_blend=False):
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+    me = build_vase_mesh("Vase")
+    obj = bpy.data.objects.new("Vase", me)
     bpy.context.collection.objects.link(obj)
 
     # data-level shape keys — no bpy.ops.object.shape_key_*
     obj.shape_key_add(name="Basis")
     tall = obj.shape_key_add(name="Tall")
-    for i, _v in enumerate(me.vertices):
-        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)
+    n = len(me.vertices)
+    co = [0.0] * (3 * n)
+    tall.data.foreach_get("co", co)          # starts as a copy of Basis
+    for i in range(n):
+        co[3 * i:3 * i + 3] = tall_offset(*co[3 * i:3 * i + 3])
+    tall.data.foreach_set("co", co)
     tall.value = 0.0 if zero_blend else 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 _coords(seq):
+    flat = [0.0] * (3 * len(seq))
+    seq.foreach_get("co", flat)
+    return [tuple(flat[i:i + 3]) for i in range(0, len(flat), 3)]
+
+
+def _rim(coords):
+    """(top z, max radius of the ring at the top z)."""
+    top = max(c[2] for c in coords)
+    return top, max(math.hypot(c[0], c[1]) for c in coords if c[2] > top - 1e-6)
 
 
 def check(obj):
@@ -74,18 +193,20 @@ 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)
+    basis = _coords(keys.key_blocks["Basis"].data)
+    tall_kb = keys.key_blocks["Tall"]
+    tall = _coords(tall_kb.data)
+    if abs(tall_kb.value - BLEND) > 1e-6:
+        print(f"ERROR: Tall.value {tall_kb.value} != {BLEND}", file=sys.stderr)
         return 5
 
     # undeformed mesh.vertices stay at Basis — the trap this example catches
-    raw_top = max(v.co.z for v in obj.data.vertices)
-    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})",
+    raw = _coords(obj.data.vertices)
+    raw_top, raw_rim = _rim(raw)
+    worst = max(math.dist(a, b) for a, b in zip(raw, basis))
+    if worst > 1e-5 or abs(raw_top - H0) > 1e-4 or abs(raw_rim - R_LIP0) > 1e-4:
+        print(f"ERROR: undeformed mesh not at Basis (off by {worst:.5f}, "
+              f"rim z={raw_top:.4f} r={raw_rim:.4f}, expected {H0}, {R_LIP0})",
               file=sys.stderr)
         return 6
 
@@ -94,32 +215,28 @@ 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)
+        evald = _coords(em.vertices)
     finally:
         ev.to_mesh_clear()
 
+    # every evaluated vert must match the closed-form blend from key_blocks
+    for i, (v, b, k) in enumerate(zip(evald, basis, tall)):
+        expect = tuple(b[j] + BLEND * (k[j] - b[j]) for j in range(3))
+        if math.dist(v, expect) > 1e-4:
+            print(f"ERROR: vert {i} evaluated {v} != blend {expect}", file=sys.stderr)
+            return 7
+    top, rim = _rim(evald)
+    bot = min(c[2] for c in evald)
     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 8
-    if abs(flare - EXPECT_TOP_HALF) > 1e-4:
-        print(f"ERROR: top flare {flare:.4f} != {EXPECT_TOP_HALF:.4f}",
-              file=sys.stderr)
+    if abs(rim - EXPECT_RIM_R) > 1e-4:
+        print(f"ERROR: rim radius {rim:.4f} != {EXPECT_RIM_R:.4f}", file=sys.stderr)
         return 9
 
-    print(f"keys={names} value={BLEND} eval_z={bot:.3f}..{top:.3f} "
-          f"top_half={flare:.3f} undeformed_top={raw_top:.3f}")
+    print(f"keys={names} value={BLEND} verts={len(evald)} eval_z={bot:.3f}..{top:.3f} "
+          f"rim_r={rim:.3f} undeformed_rim={raw_top:.3f}/{raw_rim:.3f}")
     return 0
 
 
@@ -127,59 +244,112 @@ def eevee_engine_id():
     return 'BLENDER_EEVEE' if bpy.app.version >= (5, 0, 0) else 'BLENDER_EEVEE_NEXT'
 
 
+def _principled(name, color, rough, metal=0.0):
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    b = mat.node_tree.nodes["Principled BSDF"]
+    b.inputs["Base Color"].default_value = (*color, 1.0)
+    b.inputs["Roughness"].default_value = rough
+    b.inputs["Metallic"].default_value = metal
+    return mat, b
+
+
+def _vase_materials():
+    # Reactive cobalt glaze: object-space noise mottles two blues so the
+    # glaze pools darker and breaks lighter, like a real kiln glaze.
+    glaze, gb = _principled("CobaltGlaze", (0.03, 0.12, 0.55), 0.22)
+    nt = glaze.node_tree
+    tc = nt.nodes.new("ShaderNodeTexCoord")
+    noise = nt.nodes.new("ShaderNodeTexNoise")
+    noise.inputs["Scale"].default_value = 5.0
+    noise.inputs["Detail"].default_value = 3.0
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.38
+    ramp.color_ramp.elements[0].color = (0.02, 0.075, 0.40, 1.0)
+    ramp.color_ramp.elements[1].position = 0.62
+    ramp.color_ramp.elements[1].color = (0.045, 0.17, 0.66, 1.0)
+    nt.links.new(tc.outputs["Object"], noise.inputs["Vector"])
+    nt.links.new(noise.outputs["Fac"], ramp.inputs["Fac"])
+    nt.links.new(ramp.outputs["Color"], gb.inputs["Base Color"])
+    bisque, _ = _principled("Bisque", (0.55, 0.30, 0.18), 0.85)
+    gilt, _ = _principled("OchreBand", (0.95, 0.55, 0.12), 0.35)
+    inner, _ = _principled("CreamGlaze", (0.80, 0.72, 0.55), 0.3)
+    return [glaze, bisque, gilt, inner]
+
+
+def _basis_ghost(src_obj, name, loc, mat):
+    """Contour rings of the Basis, read from the Basis key block: the squat
+    jar's belly drawn as three thin lines around the full key."""
+    basis = _coords(src_obj.data.shape_keys.key_blocks["Basis"].data)
+    prof = vase_profile()
+    starts, idx = [], 0
+    for r, _z, _m in prof:
+        starts.append(idx)
+        idx += SEGMENTS if r > 0.0 else 1
+    apex = next(i for i, (_r, z, _m) in enumerate(prof) if z == H0)
+    cu = bpy.data.curves.new(name, 'CURVE')
+    cu.dimensions = '3D'
+    cu.bevel_depth = 0.006
+    cu.bevel_resolution = 2
+    for zt in GHOST_RINGS:
+        i = min(range(1, apex), key=lambda k: abs(prof[k][1] - zt))
+        sp = cu.splines.new('POLY')
+        sp.points.add(SEGMENTS - 1)
+        for s in range(SEGMENTS):
+            sp.points[s].co = (*basis[starts[i] + s], 1.0)
+        sp.use_cyclic_u = True
+    cu.materials.append(mat)
+    ob = bpy.data.objects.new(name, cu)
+    ob.location = loc
+    bpy.context.collection.objects.link(ob)
+    return ob
+
+
 def render_still(obj, path, engine):
+    # Shared Layer 1 gates (render path only) — see gallery_framing.py
+    sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
+    sys.dont_write_bytecode = True  # keep examples/__pycache__ out of the repo tree
+    import gallery_framing
+    import gallery_asset_quality
+
     scene = bpy.context.scene
-    for poly in obj.data.polygons:
-        poly.use_smooth = False
-    mat = bpy.data.materials.new("Violet")
-    mat.use_nodes = True
-    bsdf = mat.node_tree.nodes["Principled BSDF"]
-    bsdf.inputs["Base Color"].default_value = (0.52, 0.06, 0.98, 1.0)  # violet
-    bsdf.inputs["Roughness"].default_value = 0.35
-    obj.data.materials.clear()
-    obj.data.materials.append(mat)
-
-    # the still shows the blend as a progression: Basis (0), half blend, and
-    # the checked BLEND value, left to right — one silhouette per key value,
-    # so a failed blend is visible as three identical boxes. The two extra
-    # blocks are render-only copies; the check already ran on `obj`.
-    blocks = []
-    for value, x in ((0.0, -1.9), (BLEND / 2, 0.0), (None, 1.9)):
+    # No clear() first: the mesh has no slots yet, and Mesh.materials.clear()
+    # drops the per-face material_index the lathe build assigned.
+    for m in _vase_materials():
+        obj.data.materials.append(m)
+
+    # The still is the blend as a progression, left to right: Basis (0), the
+    # checked object at BLEND, and the full key (1). Same mesh, same key —
+    # only Tall.value differs, so a broken blend reads as three identical
+    # jars. The two outer vases are render-only copies; the check already
+    # ran on `obj`.
+    vases = []
+    for value, x in ((0.0, -1.85), (None, 0.0), (1.0, 1.95)):
         if value is None:
             ob = obj
         else:
             me = obj.data.copy()
             me.shape_keys.key_blocks["Tall"].value = value
-            ob = bpy.data.objects.new(f"ShapeBlock_{value}", me)
+            ob = bpy.data.objects.new("Vase.Basis" if value == 0.0 else "Vase.Full", me)
             bpy.context.collection.objects.link(ob)
-        # bottom verts stay at -HALF; lift so each block rests on the floor
-        ob.location = (x, 0.0, HALF)
-        ob.rotation_euler = (0.0, 0.0, math.radians(28))
-        blocks.append(ob)
-
-    # Endpoint cages on the checked block: its Basis and its full Tall key as
-    # pale wireframes, so the solid visibly sits halfway between the two —
-    # the closed-form blend the check asserts, not just "a taller box".
-    # Render-only copies with their own key value; `obj` is untouched.
-    cage_mat = bpy.data.materials.new("Cage")
-    cage_mat.use_nodes = True
-    cbsdf = cage_mat.node_tree.nodes["Principled BSDF"]
-    cbsdf.inputs["Base Color"].default_value = (0.92, 0.84, 1.0, 1.0)
-    cbsdf.inputs["Roughness"].default_value = 0.4
-    cages = []
-    for end in (0.0, 1.0):
-        me = obj.data.copy()
-        me.materials.clear()
-        me.materials.append(cage_mat)
-        me.shape_keys.key_blocks["Tall"].value = end
-        cage = bpy.data.objects.new(f"Cage_{end}", me)
-        cage.location = obj.location
-        cage.rotation_euler = obj.rotation_euler
-        wire = cage.modifiers.new("cage", "WIREFRAME")
-        wire.thickness = 0.02
-        wire.use_even_offset = True
-        bpy.context.collection.objects.link(cage)
-        cages.append(cage)
+        ob.location = (x, 0.0, 0.0)
+        vases.append(ob)
+
+    # A faint contour cage of the Basis around the full-key vase: the squat
+    # jar it was blended from, so the lift, flare and slimmed belly read on
+    # the one object.
+    ghost_mat = bpy.data.materials.new("BasisGhost")
+    ghost_mat.use_nodes = True
+    gnt = ghost_mat.node_tree
+    for n in list(gnt.nodes):
+        if n.type != 'OUTPUT_MATERIAL':
+            gnt.nodes.remove(n)
+    em = gnt.nodes.new("ShaderNodeEmission")
+    em.inputs["Color"].default_value = (1.0, 0.86, 0.62, 1.0)
+    em.inputs["Strength"].default_value = 0.9
+    gnt.links.new(em.outputs["Emission"],
+                  next(n for n in gnt.nodes if n.type == 'OUTPUT_MATERIAL').inputs["Surface"])
+    ghost = _basis_ghost(obj, "Vase.BasisGhost", vases[2].location, ghost_mat)
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -206,55 +376,40 @@ def render_still(obj, path, engine):
     world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.02, 0.021, 0.025, 1.0)
     scene.world = world
 
-    world_top = HALF + EXPECT_TOP_Z
     aim = bpy.data.objects.new("Aim", None)
-    # Aimed above the checked block's middle: the full-key cage over it is
-    # taller than any solid, and centring on the solids clipped it.
-    aim.location = (0.35, 0.0, world_top * 0.62)
+    aim.location = (0.05, 0.0, 1.12)
     scene.collection.objects.link(aim)
 
-    def light(name, loc, energy, size, col):
+    def light(name, loc, energy, size, col, rot):
         ld = bpy.data.lights.new(name, 'AREA')
-        ld.energy = energy
-        ld.size = size
-        ld.color = col
+        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'
-
-    # shaped warm key, faint cool fill, cool rim, warm wedge pooling on the
-    # back wall (docs/VISUAL-STYLE.md)
-    light("Key", (-3.5, -4.5, 5.5), 520.0, 4.5, (1.0, 0.96, 0.9))
-    light("Fill", (5.0, -3.5, 2.5), 110.0, 8.0, (0.75, 0.85, 1.0))
-    light("Rim", (0.5, 4.5, 4.5), 300.0, 4.0, (0.6, 0.78, 1.0))
-    wedge = bpy.data.lights.new("Wedge", 'AREA')
-    wedge.energy = 380.0
-    wedge.size = 6.0
-    wedge.color = (1.0, 0.76, 0.5)
-    wob = bpy.data.objects.new("Wedge", wedge)
-    wob.location = (2.5, 5.5, 4.0)
-    wob.rotation_euler = (math.radians(-68), 0.0, math.radians(190))
-    scene.collection.objects.link(wob)
+
+    # default-stage rig per docs/VISUAL-STYLE.md
+    light("Key", (-4.0, -5.0, 6.0), 480.0, 5.0, (1.0, 0.96, 0.9), (48, 0, -35))
+    light("Fill", (5.0, -3.5, 2.5), 110.0, 9.0, (0.75, 0.85, 1.0), (65, 0, 50))
+    light("Rim", (1.0, 4.5, 5.0), 340.0, 4.0, (0.6, 0.78, 1.0), (-55, 0, 175))
+    light("Wedge", (1.5, 5.0, 4.0), 420.0, 6.0, (1.0, 0.76, 0.5), (-68, 0, 190))
 
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    # Pulled back so the full-key cage on the right block stays in frame.
-    cam.location = (0.35, -10.4, 2.5)
+    # A little above the rims so each mouth opens into an ellipse and the
+    # cream interior reads.
+    cam.location = (0.05, -8.2, 3.9)
     scene.collection.objects.link(cam)
-    scene.camera = cam
-    track = cam.constraints.new('TRACK_TO')
+    track = cam.constraints.new('TRACK_TO')  # data API, not bpy.ops
     track.target = aim
     track.track_axis = 'TRACK_NEGATIVE_Z'
     track.up_axis = 'UP_Y'
+    scene.camera = cam
 
     scene.render.engine = 'CYCLES' if engine == 'cycles' else eevee_engine_id()
     if engine == 'cycles':
-        scene.cycles.samples = 32
+        scene.cycles.samples = 64
     else:
         try:
             scene.eevee.taa_render_samples = 64
@@ -263,11 +418,24 @@ def light(name, loc, energy, size, col):
     scene.render.resolution_x = 1280
     scene.render.resolution_y = 720
     scene.render.image_settings.file_format = 'PNG'
-    # AgX would wash the violet toward pastel grey (docs/VISUAL-STYLE.md)
-    scene.view_settings.view_transform = 'Standard'
     scene.render.filepath = path
+    # AgX would wash the cobalt glaze toward slate (docs/VISUAL-STYLE.md)
+    scene.view_settings.view_transform = 'Standard'
+    bpy.context.view_layer.update()
+
+    code = gallery_framing.check_framing(scene, cam, hero=vases, elements=vases + [ghost],
+                                         stage=[floor, wall])
+    if code:
+        return code
+    code = gallery_asset_quality.check_asset_quality(scene, cam, hero=[obj],
+                                                     stage=[floor, wall])
+    if code:
+        return code
     bpy.ops.render.render(write_still=True)
-    return os.path.exists(path) and os.path.getsize(path) > 0
+    if not (os.path.exists(path) and os.path.getsize(path) > 0):
+        print("ERROR: render produced no file", file=sys.stderr)
+        return 12
+    return 0
 
 
 def main():
@@ -286,9 +454,9 @@ def main():
         return code
 
     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 10
+        code = render_still(obj, os.path.abspath(args.output), args.engine)
+        if code:
+            return code
         print(f"rendered still {args.output}")
 
     print("shape-key-blend OK")
diff --git a/scripts/asset_sheet.py b/scripts/asset_sheet.py
index 8e4b8a9b..d9c4e2e1 100644
--- a/scripts/asset_sheet.py
+++ b/scripts/asset_sheet.py
@@ -74,6 +74,7 @@
     "degenerate-bevel-weld": (r"^CaseSafe\.", None),
     "mesh-hygiene-audit": (r"^Valve\.", None),
     "gltf-export-roundtrip": (r"^Crate\.Authored$", None),
+    "shape-key-blend": (r"^Vase$", None),
 }
 
 _REF_LINE = re.compile(r"Asset-sheet gate.*?reference set — currently (.+?) — rendered", re.S)