diff --git a/README.md b/README.md
index c636cb13..36d9b945 100644
--- a/README.md
+++ b/README.md
@@ -112,7 +112,7 @@ Budget-conformance props. Not examples. Conventions: [`showcase/README.md`](show
   <a href="showcase/shipping-crate/"><img src="showcase/shipping-crate/preview.webp" width="24%" alt="Shipping crate: a wooden slat crate with iron corner brackets on a dark studio floor, warm wedge on the back wall" /></a>
   <a href="showcase/stone-well/"><img src="showcase/stone-well/preview.webp" width="24%" alt="Stone well: a round brick well with a shingled pyramid roof on posts, rope and bucket, on a dark studio floor" /></a>
   <a href="showcase/wooden-barrel/"><img src="showcase/wooden-barrel/preview.webp" width="24%" alt="Wooden barrel: a 20-stave wine-cask with a head of four boards, chord-lofted iron hoops, and a bung on a dark studio floor" /></a>
-  <a href="showcase/campfire/"><img src="showcase/campfire/preview.webp" width="24%" alt="Campfire: a two-course stone fire ring with a tripod of logs on a dark studio floor, warm wedge on the back wall" /></a>
+  <a href="showcase/campfire/"><img src="showcase/campfire/preview.webp" width="24%" alt="Campfire: a two-course ring of rounded fieldstones around a tripod of logs and glowing ash on a dark studio floor, warm wedge on the back wall" /></a>
   <a href="showcase/market-stall/"><img src="showcase/market-stall/preview.webp" width="24%" alt="Market stall: a timber frame with post feet, slatted counter, rafters, and a striped awning on a dark studio floor, warm wedge on the back wall" /></a>
   <a href="showcase/street-lantern/"><img src="showcase/street-lantern/preview.webp" width="24%" alt="Street lantern: an iron post with brass collars, a braced arm, and a muntined amber cage on a dark studio floor" /></a>
   <a href="showcase/treasure-chest/"><img src="showcase/treasure-chest/preview.webp" width="24%" alt="Treasure chest: a slatted wooden chest with iron bands, corner brackets, and an open lid on a dark studio floor" /></a>
@@ -132,7 +132,7 @@ Budget-conformance props. Not examples. Conventions: [`showcase/README.md`](show
   <a href="showcase/wooden-bucket/"><img src="showcase/wooden-bucket/preview.webp" width="24%" alt="Wooden bucket: a coopered pail with a three-strand rope bail through iron ear rings and chord-lofted iron hoops on a dark studio floor" /></a>
   <a href="showcase/wall-torch/"><img src="showcase/wall-torch/preview.webp" width="24%" alt="Wall torch: a dressed stone plaque with an iron sconce, wooden haft, and flame on a dark studio floor" /></a>
   <a href="showcase/tavern-stool/"><img src="showcase/tavern-stool/preview.webp" width="24%" alt="Tavern stool: a round wooden seat on turned splayed legs with stretchers and iron ferrules on a dark studio floor" /></a>
-  <a href="showcase/iron-cauldron/"><img src="showcase/iron-cauldron/preview.webp" width="24%" alt="Iron cauldron: a bulged iron pot hanging from a timber tripod on a dark studio floor" /></a>
+  <a href="showcase/iron-cauldron/"><img src="showcase/iron-cauldron/preview.webp" width="24%" alt="Iron cauldron: a round-bellied cast-iron pot hanging by its bail from a timber tripod on a dark studio floor" /></a>
   <a href="showcase/wooden-ladder/"><img src="showcase/wooden-ladder/preview.webp" width="24%" alt="Wooden ladder: a raked timber ladder with six rungs and iron shoes on a dark studio floor" /></a>
   <a href="showcase/hay-bale/"><img src="showcase/hay-bale/preview.webp" width="24%" alt="Hay bale: a bound straw bale with two sisal twine belts on a dark studio floor" /></a>
   <a href="showcase/crate-stack/"><img src="showcase/crate-stack/preview.webp" width="24%" alt="Crate stack: three slatted shipping crates stacked and yawed, each with iron corner straps and runners, on a dark studio floor" /></a>
@@ -145,7 +145,7 @@ Budget-conformance props. Not examples. Conventions: [`showcase/README.md`](show
 
 [`wooden-barrel`](showcase/wooden-barrel/) — procedural 20-stave wine-cask with boarded, croze-seated heads and chord-lofted hoops through the same pipeline. Falsifiers `--round-band` exits 18, `--one-piece-head` exits 17.
 
-[`campfire`](showcase/campfire/) — procedural cobble ring, logs, and ash through the same pipeline. Falsifier `--skip-decimate` exits 9.
+[`campfire`](showcase/campfire/) — procedural fieldstone ring, logs, and ash through the same pipeline. Falsifiers `--skip-decimate` exits 9, `--uniform-stones` exits 20.
 
 [`market-stall`](showcase/market-stall/) — procedural timber stall with striped awning and counter through the same pipeline. Falsifier `--skip-decimate` exits 9.
 
@@ -185,7 +185,7 @@ Budget-conformance props. Not examples. Conventions: [`showcase/README.md`](show
 
 [`tavern-stool`](showcase/tavern-stool/) — procedural tavern stool with turned legs, stretchers, and iron ferrules through the same pipeline. Falsifier `--skip-decimate` exits 9.
 
-[`iron-cauldron`](showcase/iron-cauldron/) — procedural hanging iron cauldron on a timber tripod through the same pipeline. Falsifier `--skip-decimate` exits 9.
+[`iron-cauldron`](showcase/iron-cauldron/) — procedural round-bellied iron cauldron on a timber tripod through the same pipeline. Falsifiers `--skip-decimate` exits 9, `--pointed-pot` exits 19.
 
 [`wooden-ladder`](showcase/wooden-ladder/) — procedural timber ladder with raked stiles, rungs, and iron shoes through the same pipeline. Falsifier `--skip-decimate` exits 9.
 
@@ -450,7 +450,7 @@ three. `--assume-distinct-names` is red only on 5.2.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/usd-export-evaluation-mode/"><img src="examples/usd-export-evaluation-mode/preview.webp" alt="USD export evaluation_mode: two steel SUBSURF cubes on a dark studio floor — left faceted viewport tessellation, right smoother render tessellation, warm wedge on the back wall" /></a>
+<a href="examples/usd-export-evaluation-mode/"><img src="examples/usd-export-evaluation-mode/preview.webp" alt="USD export evaluation_mode: two steel SUBSURF cubes resting on a dark studio floor — left faceted viewport tessellation, right smoother render tessellation, warm wedge on the back wall" /></a>
 </td>
 <td valign="middle">
 
@@ -562,7 +562,7 @@ verts = 72, faces = 54, and `Set Material` carries the lime accent.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/gn-modifier-inputs/"><img src="examples/gn-modifier-inputs/preview.webp" alt="GN modifier inputs: three cubes in teal, copper, and coral scaled to 1, 2, and 3 meters by a shared Geometry Nodes tree, proving per-modifier Scale writes land on 5.2 RNA and on 4.5 dict assignment" /></a>
+<a href="examples/gn-modifier-inputs/"><img src="examples/gn-modifier-inputs/preview.webp" alt="GN modifier inputs: three separate cubes in teal, copper, and coral scaled to 1, 2, and 3 meters by a shared Geometry Nodes tree, proving per-modifier Scale writes land on 5.2 RNA and on 4.5 dict assignment" /></a>
 </td>
 <td valign="middle">
 
diff --git a/docs/gallery/assets/campfire-hero.webp b/docs/gallery/assets/campfire-hero.webp
index 15745d09..a32c44a9 100644
Binary files a/docs/gallery/assets/campfire-hero.webp and b/docs/gallery/assets/campfire-hero.webp differ
diff --git a/docs/gallery/assets/gn-modifier-inputs-hero.webp b/docs/gallery/assets/gn-modifier-inputs-hero.webp
index 0e2494f2..e9dd8ae8 100644
Binary files a/docs/gallery/assets/gn-modifier-inputs-hero.webp and b/docs/gallery/assets/gn-modifier-inputs-hero.webp differ
diff --git a/docs/gallery/assets/iron-cauldron-hero.webp b/docs/gallery/assets/iron-cauldron-hero.webp
index 9c348e6b..34eaf7de 100644
Binary files a/docs/gallery/assets/iron-cauldron-hero.webp and b/docs/gallery/assets/iron-cauldron-hero.webp differ
diff --git a/docs/gallery/assets/usd-export-evaluation-mode-hero.webp b/docs/gallery/assets/usd-export-evaluation-mode-hero.webp
index e12e1841..1022580d 100644
Binary files a/docs/gallery/assets/usd-export-evaluation-mode-hero.webp and b/docs/gallery/assets/usd-export-evaluation-mode-hero.webp differ
diff --git a/docs/gallery/campfire/index.html b/docs/gallery/campfire/index.html
index 9f00c5df..8e5197dc 100644
--- a/docs/gallery/campfire/index.html
+++ b/docs/gallery/campfire/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/campfire-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A campfire of crossed logs in a teepee inside a ring of grey stone blocks." />
+  <meta property="og:image:alt" content="A campfire of crossed logs in a teepee, embers in the ash, inside a two-course ring of rounded grey fieldstones." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="campfire — Showcase — Blender Developer Tools" />
   <meta name="twitter:description" content="A procedural campfire through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/campfire-hero.webp" />
-  <meta name="twitter:image:alt" content="A campfire of crossed logs in a teepee inside a ring of grey stone blocks." />
+  <meta name="twitter:image:alt" content="A campfire of crossed logs in a teepee, embers in the ash, inside a two-course ring of rounded grey fieldstones." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -268,33 +268,37 @@ <h1>campfire</h1>
     <p>A procedural campfire through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A campfire of crossed logs in a teepee inside a ring of grey stone blocks.">
-      <img src="../assets/campfire-hero.webp" alt="A campfire of crossed logs in a teepee inside a ring of grey stone blocks." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A campfire of crossed logs in a teepee, embers in the ash, inside a two-course ring of rounded grey fieldstones.">
+      <img src="../assets/campfire-hero.webp" alt="A campfire of crossed logs in a teepee, embers in the ash, inside a two-course ring of rounded grey fieldstones." width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the showcase piece itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Recomputed: 2200 tris, three materials with 216 wood, 48 ash and 1304 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.807×0.808×0.404 m, LOD ratios in band, convex collider 198 tris, hygiene 0, 14 grounded bottom stones, teepee kiss 0.00001 m, course seat 0, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-stones 16; --float-logs 17; --gap-courses 18.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 2760 tris, three materials with 216 wood, 48 ash and 1416 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.802×0.802×0.404 m, LOD ratios in band, convex collider 162 tris, hygiene 0, 14 grounded bottom stones, teepee kiss 0.00034 m, course seat 0, stone variation 0.01269 m, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-stones 16; --float-logs 17; --gap-courses 18; --uniform-stones 20.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/campfire/campfire.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural campfire (two-course running-bond stone ring of 14 barrelled wedges, pit-floor cobbles, ash, a kissing log tripod that overshoots a shared apex ring, floor logs, and charcoal) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>A showcase piece, not an example. Procedural campfire (two-course running-bond ring of 14 rounded fieldstones per course, pit-floor cobbles, ash with embers, a kissing log tripod that overshoots a shared apex ring, floor logs, and charcoal) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>Courses share a Z plane; <code>--gap-courses</code> is the falsifier. Teepee axes aim at a ring of radius <code>(STICK_R * 0.55) / sin(π/N)</code> and overshoot so the caps cross; <code>--float-logs</code> inflates that ring.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>1400–3600</td><td>2200 / 2200 / 2200</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2200 / 0.2200 / 0.2200</td></tr><tr><td>Materials</td><td>exactly 3 distinct; ≥80 wood, ≥24 ash, ≥200 stone</td><td>3 slots; 216 / 48 / 1304</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(0.807, 0.808, 0.404) m ± 0.015</td><td>(0.8069, 0.8079, 0.4037), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 360</td><td>198</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>206244 / 206244 / 206236 bytes</td></tr></tbody></table></div>
-<p>Base triangles dropped from <strong>3616 to 2200</strong> in the quality pass: the old piece stacked identical boxes with a mortar gap and a teepee that met at one point. The rebuild is two seated courses plus crossing sticks; hidden overlapping volume went away.</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> guaranteed identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Stone-width jitter uses fixed seed 17. glTF byte size differs by 8 B on 5.2.1.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>1400–3600</td><td>2760 / 2760 / 2760</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.4993</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2196 / 0.2196 / 0.2196</td></tr><tr><td>Materials</td><td>exactly 3 distinct; ≥80 wood, ≥24 ash, ≥200 stone</td><td>3 slots; 216 / 48 / 1416</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(0.807, 0.808, 0.404) m ± 0.015</td><td>(0.8024, 0.8022, 0.4037), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 360</td><td>162</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>231952 / 231952 / 231944 bytes</td></tr></tbody></table></div>
+<p>Base triangles dropped from <strong>3616 to 2200</strong> in the quality pass: the old piece stacked identical boxes with a mortar gap and a teepee that met at one point. The rebuild is two seated courses plus crossing sticks; hidden overlapping volume went away. The second pass took it to <strong>2760</strong>: each stone is now a lofted, chamfered lump instead of a four-sided wedge.</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> guaranteed identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Stone-width jitter uses fixed seed 17; each stone&#x27;s shape draws from its own seeded generator. glTF byte size differs on 5.2.1.</p>
 <h3>Hygiene</h3>
 <p>Recomputed from the generated mesh, not asserted about the script.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar disjoint face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Named supports: 14 bottom stones</td><td>each <code>zmin</code> ≤ 0.001</td><td>14, stone_z 0.00000</td></tr><tr><td>Ring plan</td><td>0.807 m dia × 0.156 m high ± 0.04</td><td>0.8074 × 0.1560</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar disjoint face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Named supports: 14 bottom stones</td><td>each <code>zmin</code> ≤ 0.001</td><td>14, stone_z 0.00000</td></tr><tr><td>Ring plan</td><td>0.807 m dia × 0.176 m high ± 0.04</td><td>0.8023 × 0.1759</td></tr><tr><td><strong>Stone variation</strong> (exit 20)</td><td>per course, spread of stone outer radius, and of crown height on the top course, each ≥ 0.006 m</td><td>0.01269 (smallest spread)</td></tr></tbody></table></div>
 <h3>Joint fit and seat</h3>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Teepee kiss (BVH nearest at caps)</td><td>≤ 0.008 m</td><td>0.00001</td></tr><tr><td>Course seat (upper zmin − lower zmax)</td><td>abs ≤ 0.004 m</td><td>0.00000</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Teepee kiss (BVH nearest at caps)</td><td>≤ 0.008 m</td><td>0.00034</td></tr><tr><td>Course seat (upper zmin − lower zmax)</td><td>abs ≤ 0.004 m</td><td>0.00000</td></tr></tbody></table></div>
+<h3>Stones, wood and ash</h3>
+<p>The ring was 28 identical curved bricks: flat tops, flat faces, one height, one grey. It read as a concrete kerb. Each stone is now a chamfered octagon section lofted along its span, swelling to a seeded belly mid-stone and pinched and capped at the ends, with a seeded radial offset and outer-face wobble. Top-course stones get a seeded domed crown. The beds stay flat, and the bottom course&#x27;s crown stays at the bed height, so the upper course still seats (course seat 0.00000). The stated ring height rose from 0.156 to 0.176 m for the crowns.</p>
+<p><strong>Stone variation</strong> asserts the ring is not one stone repeated. <code>--uniform-stones</code> gives every stone the same draw — each jitter at its upper bound, so the ring keeps the envelope of its widest seeded stone and only this budget fails (exit 20, spread 0.00000).</p>
+<p>Stone is isotropic mottling, speckle and pitting with a seeded tone per stone (<code>stone-archway</code>&#x27;s recipe, reading <code>PieceTone</code>); sticks and logs carry their own tone and grain along their axis; the ash has sparse ember glow. The temp <code>.glb</code> is removed after its size is measured.</p>
 <h3>Falsifiers</h3>
-<p>Each violates one named budget. All six were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--short-stones</code></td><td>named bottom-course supports at Z=0</td><td>16</td></tr><tr><td><code>--float-logs</code></td><td>teepee kiss</td><td>17</td></tr><tr><td><code>--gap-courses</code></td><td>course seat</td><td>18</td></tr></tbody></table></div>
+<p>Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--short-stones</code></td><td>named bottom-course supports at Z=0</td><td>16</td></tr><tr><td><code>--float-logs</code></td><td>teepee kiss</td><td>17</td></tr><tr><td><code>--gap-courses</code></td><td>course seat</td><td>18</td></tr><tr><td><code>--uniform-stones</code></td><td>stone variation</td><td>20</td></tr></tbody></table></div>
 <h2>Run</h2>
 <pre><code>blender --background --python campfire.py --
 blender --background --python campfire.py -- --skip-decimate
@@ -303,11 +307,12 @@ <h2>Run</h2>
 blender --background --python campfire.py -- --short-stones
 blender --background --python campfire.py -- --float-logs
 blender --background --python campfire.py -- --gap-courses
+blender --background --python campfire.py -- --uniform-stones
 blender --background --python campfire.py -- --output campfire.png</code></pre>
 <p>Smoke passes no flags.</p>
 <h2>Exit codes</h2>
-<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</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>Mesh did not build / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 3 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named bottom stone floats</td></tr><tr><td>17</td><td>Joint fit: teepee kiss (<code>--float-logs</code>)</td></tr><tr><td>18</td><td>Seat: course gap (<code>--gap-courses</code>)</td></tr><tr><td>19</td><td>Ring diameter or height off the stated real-world size</td></tr></tbody></table></div>
+<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path. <code>15</code>–<code>19</code> are the hygiene and joint-fit family; <code>20</code> is file-local.</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>Mesh did not build / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 3 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named bottom stone floats</td></tr><tr><td>17</td><td>Joint fit: teepee kiss (<code>--float-logs</code>)</td></tr><tr><td>18</td><td>Seat: course gap (<code>--gap-courses</code>)</td></tr><tr><td>19</td><td>Ring diameter or height off the stated real-world size</td></tr><tr><td>20</td><td>Stone variation: the ring stones are identical (<code>--uniform-stones</code>)</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -369,7 +374,17 @@ <h2>Source</h2>
 R_MID = <span class="n">0.5</span> * (R_INNER + R_OUTER)
 STONE_H = <span class="n">0.078</span>
 STONE_SEED = <span class="n">17</span>
-STONE_JITTER = <span class="n">0.10</span>
+STONE_JITTER = <span class="n">0.22</span>
+<span class="c"># Each ring stone is a lofted chamfered section, not a curved brick: a</span>
+<span class="c"># seeded belly and radial offset, rounded ends pinched to END_PINCH, and</span>
+<span class="c"># (upper course only) a domed crown. Beds stay flat so the courses seat.</span>
+STONE_R_JITTER = <span class="n">0.012</span>
+STONE_BULGE = <span class="n">0.14</span>
+STONE_WOBBLE = <span class="n">0.05</span>
+STONE_DOME = <span class="n">0.020</span>
+END_PINCH = <span class="n">0.62</span>
+STONE_CHAMFER = <span class="n">0.28</span>
+STONE_VARY_MIN = <span class="n">0.006</span>
 GAP_ANG = <span class="n">0.004</span>
 N_COBBLES = <span class="n">12</span>
 COBBLE_H = <span class="n">0.016</span>
@@ -397,7 +412,7 @@ <h2>Source</h2>
 ZFIGHT_COS = <span class="n">0.998</span>
 BODY_TOL = <span class="n">0.04</span>
 RING_DIA = <span class="n">0.807</span>
-RING_H = <span class="n">0.156</span>
+RING_H = <span class="n">0.176</span>
 BBOX_TOL = <span class="n">0.015</span>
 OUTER_SIZE = (<span class="n">0.807</span>, <span class="n">0.808</span>, <span class="n">0.404</span>)
 
@@ -424,6 +439,11 @@ <h2>Source</h2>
 WOOD_IDX = <span class="n">1</span>
 ASH_IDX = <span class="n">2</span>
 
+<span class="c"># Per-piece tone jitter and wood grain frequency, as in shipping-crate.</span>
+PLANK_TONE_JITTER = <span class="n">0.25</span>
+TONE_SEED = <span class="n">29</span>
+WOOD_GRAIN_SCALE = <span class="n">45.0</span>
+
 
 <span class="k">def</span> eevee_engine_id():
     <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE&quot;</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">&quot;BLENDER_EEVEE_NEXT&quot;</span>
@@ -464,46 +484,52 @@ <h2>Source</h2>
     <span class="k">return</span> spans
 
 
-<span class="k">def</span> add_wedge(bm, a0, a1, r_in, r_out, z0, z1, mat_idx, lump=<span class="n">0.0</span>):
-    mid_z = <span class="n">0.5</span> * (z0 + z1)
-    mid_ang = <span class="n">0.5</span> * (a0 + a1)
-    layers = (
-        (z0, <span class="n">0.985</span>, <span class="n">0.0</span>),
-        (mid_z, <span class="n">1.025</span>, lump),
-        (z1, <span class="n">0.97</span>, <span class="n">0.0</span>),
-    )
+<span class="k">def</span> add_stone(bm, a0, a1, z0, z1, rng, crown, stations, mat_idx):
+    <span class="s">&quot;&quot;&quot;One ring stone: a chamfered octagon section lofted from a0 to a1.
+
+    The section&#x27;s width swells to a seeded belly mid-stone and pinches to
+    END_PINCH at the ends, which are capped, so each stone is a rounded
+    lump rather than a curved brick. The bed (z0) is flat on every stone.
+    The crown is flat at z1 on the lower course, which the upper course
+    sits on, and domed by a seeded ``crown`` on the upper course.
+    &quot;&quot;&quot;</span>
+    r_in = R_INNER + rng.uniform(-STONE_R_JITTER, STONE_R_JITTER)
+    r_out = R_OUTER + rng.uniform(-STONE_R_JITTER, STONE_R_JITTER)
+    bulge = rng.uniform(<span class="n">0.3</span>, <span class="n">1.0</span>) * STONE_BULGE
+    phase = rng.uniform(<span class="n">0.0</span>, <span class="n">2.0</span> * math.pi)
+    top = z1 + crown
     rings = []
-    <span class="k">for</span> z, r_scale, lp <span class="k">in</span> layers:
-        ring = []
-        <span class="k">for</span> ang, r <span class="k">in</span> (
-            (a0, r_in),
-            (a1, r_in),
-            (a1, r_out * r_scale),
-            (a0, r_out * r_scale),
-        ):
-            x = r * math.cos(ang)
-            y = r * math.sin(ang)
-            <span class="k">if</span> lp &gt; <span class="n">0.0</span> <span class="k">and</span> r &gt; <span class="n">0.5</span> * (r_in + r_out):
-                h = math.sin(ang * <span class="n">5.0</span> + z * <span class="n">17.0</span> + mid_ang * <span class="n">3.0</span>)
-                scale = <span class="n">1.0</span> + lp * max(-<span class="n">0.7</span>, min(<span class="n">0.7</span>, h))
-                x *= scale
-                y *= scale
-            ring.append(bm.verts.new((x, y, z)))
-        rings.append(ring)
-    verts = [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
-    <span class="k">for</span> k <span class="k">in</span> range(len(rings) - <span class="n">1</span>):
+    <span class="k">for</span> k <span class="k">in</span> range(stations):
+        t = k / (stations - <span class="n">1</span>)
+        ang = a0 + (a1 - a0) * t
+        sw = math.sin(math.pi * t)
+        pinch = END_PINCH + (<span class="n">1.0</span> - END_PINCH) * math.sqrt(sw)
+        cr = <span class="n">0.5</span> * (r_in + r_out)
+        hw = <span class="n">0.5</span> * (r_out - r_in) * pinch * (<span class="n">1.0</span> + bulge * sw)
+        lo = cr - hw
+        hi = cr + hw * (<span class="n">1.0</span> + STONE_WOBBLE * math.sin(phase + <span class="n">3.0</span> * math.pi * t))
+        zt = z0 + (top - z0) * (<span class="n">0.80</span> + <span class="n">0.20</span> * sw)
+        c = STONE_CHAMFER * min(hi - lo, zt - z0) * <span class="n">0.5</span>
+        section = (
+            (lo + c, z0), (hi - c, z0), (hi, z0 + c), (hi, zt - c),
+            (hi - c, zt), (lo + c, zt), (lo, zt - c), (lo, z0 + c),
+        )
+        ca, sa = math.cos(ang), math.sin(ang)
+        rings.append([bm.verts.new((r * ca, r * sa, z)) <span class="k">for</span> r, z <span class="k">in</span> section])
+    n = len(rings[<span class="n">0</span>])
+    <span class="k">for</span> k <span class="k">in</span> range(stations - <span class="n">1</span>):
         a, b = rings[k], rings[k + <span class="n">1</span>]
-        <span class="k">for</span> i <span class="k">in</span> range(<span class="n">4</span>):
-            j = (i + <span class="n">1</span>) % <span class="n">4</span>
-            face = bm.faces.new((a[i], a[j], b[j], b[i]))
-            face.material_index = mat_idx
-    bot = rings[<span class="n">0</span>]
-    top = rings[-<span class="n">1</span>]
-    face = bm.faces.new((bot[<span class="n">0</span>], bot[<span class="n">3</span>], bot[<span class="n">2</span>], bot[<span class="n">1</span>]))
-    face.material_index = mat_idx
-    face = bm.faces.new((top[<span class="n">0</span>], top[<span class="n">1</span>], top[<span class="n">2</span>], top[<span class="n">3</span>]))
-    face.material_index = mat_idx
-    <span class="k">return</span> verts
+        <span class="k">for</span> i <span class="k">in</span> range(n):
+            j = (i + <span class="n">1</span>) % n
+            f = bm.faces.new((a[i], a[j], b[j], b[i]))
+            f.material_index = mat_idx
+    <span class="k">for</span> ring, flip <span class="k">in</span> ((rings[<span class="n">0</span>], <span class="k">False</span>), (rings[-<span class="n">1</span>], <span class="k">True</span>)):
+        hub = bm.verts.new(sum((v.co <span class="k">for</span> v <span class="k">in</span> ring), Vector()) / n)
+        <span class="k">for</span> i <span class="k">in</span> range(n):
+            vs = (hub, ring[(i + <span class="n">1</span>) % n], ring[i])
+            f = bm.faces.new(tuple(reversed(vs)) <span class="k">if</span> flip <span class="k">else</span> vs)
+            f.material_index = mat_idx
+    <span class="k">return</span> [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
 
 
 <span class="k">def</span> add_cyl_between(bm, a, b, r0, r1, segs, mat_idx):
@@ -609,6 +635,7 @@ <h2>Source</h2>
     short_stones=<span class="k">False</span>,
     float_logs=<span class="k">False</span>,
     gap_courses=<span class="k">False</span>,
+    uniform_stones=<span class="k">False</span>,
 ):
     bm = bmesh.new()
     spans = stone_spans(N_AROUND, GAP_ANG, STONE_JITTER, STONE_SEED)
@@ -616,49 +643,28 @@ <h2>Source</h2>
     extra = COURSE_GAP <span class="k">if</span> gap_courses <span class="k">else</span> <span class="n">0.0</span>
     stone_verts = []
     <span class="k">try</span>:
+        <span class="c"># --uniform-stones gives every stone the same draw: each jitter at its</span>
+        <span class="c"># upper bound, so the stones are identical but the ring keeps the</span>
+        <span class="c"># envelope of its widest seeded stone.</span>
+        <span class="k">class</span> _Flat:
+            <span class="k">def</span> uniform(self, a, b):
+                <span class="k">return</span> b
+
+        stations = <span class="n">3</span> + bevel_segments
         <span class="k">for</span> row <span class="k">in</span> range(N_ROWS):
             z0 = z_ground + row * STONE_H + (extra <span class="k">if</span> row <span class="k">else</span> <span class="n">0.0</span>)
             z1 = z0 + STONE_H
             rot_off = (row % <span class="n">2</span>) * (math.pi / N_AROUND)
-            <span class="k">for</span> a0, a1 <span class="k">in</span> spans:
+            <span class="k">for</span> idx, (a0, a1) <span class="k">in</span> enumerate(spans):
+                rng = _Flat() <span class="k">if</span> uniform_stones <span class="k">else</span> random.Random(STONE_SEED * <span class="n">31</span> + row * <span class="n">101</span> + idx)
+                crown = STONE_DOME * rng.uniform(<span class="n">0.35</span>, <span class="n">1.0</span>) <span class="k">if</span> row == N_ROWS - <span class="n">1</span> <span class="k">else</span> <span class="n">0.0</span>
                 stone_verts.extend(
-                    add_wedge(
-                        bm,
-                        a0 + rot_off,
-                        a1 + rot_off,
-                        R_INNER,
-                        R_OUTER,
-                        z0,
-                        z1,
-                        STONE_IDX,
-                        lump=<span class="n">0.022</span>,
+                    add_stone(
+                        bm, a0 + rot_off, a1 + rot_off, z0, z1, rng, crown,
+                        stations, STONE_IDX,
                     )
                 )
 
-        <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
-            vertical = []
-            seen = set()
-            <span class="k">for</span> v <span class="k">in</span> stone_verts:
-                <span class="k">for</span> e <span class="k">in</span> v.link_edges:
-                    <span class="k">if</span> e <span class="k">in</span> seen:
-                        <span class="k">continue</span>
-                    seen.add(e)
-                    a, b = e.verts
-                    <span class="k">if</span> abs(a.co.z - b.co.z) &gt; <span class="n">0.02</span>:
-                        vertical.append(e)
-            <span class="k">if</span> vertical:
-                ret = bmesh.ops.bevel(
-                    bm,
-                    geom=vertical,
-                    offset=min(bevel_offset, <span class="n">0.008</span>),
-                    segments=bevel_segments,
-                    profile=<span class="n">0.5</span>,
-                    affect=<span class="s">&quot;EDGES&quot;</span>,
-                    clamp_overlap=<span class="k">True</span>,
-                )
-                <span class="k">for</span> f <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
-                    f.material_index = STONE_IDX
-
         add_ash_disk(bm, ASH_R, ASH_H, <span class="n">16</span>, ASH_IDX)
         rng = random.Random(STONE_SEED)
         <span class="k">for</span> i <span class="k">in</span> range(N_COBBLES):
@@ -1018,6 +1024,244 @@ <h2>Source</h2>
             bm_s.free()
 
 
+<span class="k">def</span> stone_variation(me):
+    <span class="s">&quot;&quot;&quot;Spread of the ring stones&#x27; crowns and outer radii, in metres.
+
+    Identical stones read instantly as CG. Across the stones of each
+    course, the spread (max - min) of each stone&#x27;s top and of its outer
+    radius is measured from the mesh; the smaller of the two spreads,
+    over both courses, must clear STONE_VARY_MIN.
+    &quot;&quot;&quot;</span>
+    courses = {}
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        <span class="k">if</span> mat_of(me, g) != STONE_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        <span class="k">if</span> a[<span class="n">5</span>] - a[<span class="n">2</span>] &lt; <span class="n">0.05</span>:
+            <span class="k">continue</span>
+        top = a[<span class="n">5</span>]
+        r_out = max(math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) <span class="k">for</span> i <span class="k">in</span> g)
+        row = <span class="n">0</span> <span class="k">if</span> <span class="n">0.5</span> * (a[<span class="n">2</span>] + a[<span class="n">5</span>]) &lt; STONE_H <span class="k">else</span> <span class="n">1</span>
+        courses.setdefault(row, []).append((top, r_out))
+    spreads = []
+    <span class="k">for</span> row, vals <span class="k">in</span> courses.items():
+        tops = [v[<span class="n">0</span>] <span class="k">for</span> v <span class="k">in</span> vals]
+        radii = [v[<span class="n">1</span>] <span class="k">for</span> v <span class="k">in</span> vals]
+        <span class="k">if</span> row == N_ROWS - <span class="n">1</span>:
+            spreads.append(max(tops) - min(tops))
+        spreads.append(max(radii) - min(radii))
+    <span class="k">return</span> min(spreads, default=<span class="n">0.0</span>)
+
+
+<span class="k">def</span> _long_axis(pts):
+    <span class="s">&quot;&quot;&quot;Principal axis of a point set, by power iteration on its covariance.&quot;&quot;&quot;</span>
+    c = sum(pts, Vector()) / len(pts)
+    cov = [[<span class="n">0.0</span>] * <span class="n">3</span> <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">3</span>)]
+    <span class="k">for</span> p <span class="k">in</span> pts:
+        d = p - c
+        <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>):
+            <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((<span class="n">1.0</span>, <span class="n">0.3</span>, <span class="n">0.1</span>))
+    <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">30</span>):
+        w = Vector([sum(cov[i][j] * v[j] <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>)) <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>)])
+        <span class="k">if</span> w.length &lt; <span class="n">1e-12</span>:
+            <span class="k">break</span>
+        v = w.normalized()
+    <span class="k">return</span> v
+
+
+<span class="k">def</span> paint_pieces(me):
+    <span class="s">&quot;&quot;&quot;Per-shell ``PieceTone`` and ``GrainDir`` face attributes.
+
+    Every stone, stick and log is its own shell, so each gets one tone,
+    and the wood shader runs grain along each piece&#x27;s own long axis.
+    &quot;&quot;&quot;</span>
+    tone = [<span class="n">0.5</span>] * len(me.polygons)
+    grain = [(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        pts = [me.vertices[i].co.copy() <span class="k">for</span> i <span class="k">in</span> g]
+        d = _long_axis(pts) <span class="k">if</span> len(pts) &gt; <span class="n">2</span> <span class="k">else</span> Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>))
+        t = <span class="n">0.5</span> + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        <span class="k">for</span> i <span class="k">in</span> g:
+            owner[i] = (t, tuple(d))
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        t, d = owner[poly.vertices[<span class="n">0</span>]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new(<span class="s">&quot;PieceTone&quot;</span>, <span class="s">&quot;FLOAT&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    a.data.foreach_set(<span class="s">&quot;value&quot;</span>, tone)
+    b = me.attributes.new(<span class="s">&quot;GrainDir&quot;</span>, <span class="s">&quot;FLOAT_VECTOR&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    b.data.foreach_set(<span class="s">&quot;vector&quot;</span>, [c <span class="k">for</span> v <span class="k">in</span> grain <span class="k">for</span> c <span class="k">in</span> v])
+
+
+<span class="k">def</span> _sock(sockets, identifier):
+    <span class="s">&quot;&quot;&quot;A Mix-node socket by identifier; its A/B/Result names repeat per type.&quot;&quot;&quot;</span>
+    <span class="k">return</span> next(sk <span class="k">for</span> sk <span class="k">in</span> sockets <span class="k">if</span> sk.identifier == identifier)
+
+
+<span class="k">def</span> wood_material(name):
+    <span class="s">&quot;&quot;&quot;Grain along each stick and log (``GrainDir``), tone per piece (``PieceTone``).&quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    gdir = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    gdir.attribute_name = <span class="s">&quot;GrainDir&quot;</span>
+    tone = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    tone.attribute_name = <span class="s">&quot;PieceTone&quot;</span>
+    dot = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    dot.operation = <span class="s">&quot;DOT_PRODUCT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], dot.inputs[<span class="n">0</span>])
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], dot.inputs[<span class="n">1</span>])
+    squash = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    squash.operation = <span class="s">&quot;MULTIPLY&quot;</span>
+    squash.inputs[<span class="n">1</span>].default_value = <span class="n">0.94</span>
+    nt.links.new(dot.outputs[<span class="s">&quot;Value&quot;</span>], squash.inputs[<span class="n">0</span>])
+    along = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    along.operation = <span class="s">&quot;SCALE&quot;</span>
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], along.inputs[<span class="n">0</span>])
+    nt.links.new(squash.outputs[<span class="s">&quot;Value&quot;</span>], along.inputs[<span class="s">&quot;Scale&quot;</span>])
+    grain_co = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    grain_co.operation = <span class="s">&quot;SUBTRACT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], grain_co.inputs[<span class="n">0</span>])
+    nt.links.new(along.outputs[<span class="s">&quot;Vector&quot;</span>], grain_co.inputs[<span class="n">1</span>])
+    shift = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    shift.operation = <span class="s">&quot;ADD&quot;</span>
+    nt.links.new(grain_co.outputs[<span class="s">&quot;Vector&quot;</span>], shift.inputs[<span class="n">0</span>])
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], shift.inputs[<span class="n">1</span>])
+    noise = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    noise.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = WOOD_GRAIN_SCALE
+    noise.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+    noise.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.62</span>
+    nt.links.new(shift.outputs[<span class="s">&quot;Vector&quot;</span>], noise.inputs[<span class="s">&quot;Vector&quot;</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.30</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.12</span>, <span class="n">0.052</span>, <span class="n">0.018</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.72</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.38</span>, <span class="n">0.18</span>, <span class="n">0.065</span>, <span class="n">1.0</span>)
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    gain = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    gain.operation = <span class="s">&quot;MULTIPLY_ADD&quot;</span>
+    gain.inputs[<span class="n">1</span>].default_value = <span class="n">1.1</span>
+    gain.inputs[<span class="n">2</span>].default_value = <span class="n">0.45</span>
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], gain.inputs[<span class="n">0</span>])
+    mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+    mix.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    _sock(mix.inputs, <span class="s">&quot;Factor_Float&quot;</span>).default_value = <span class="n">1.0</span>
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], _sock(mix.inputs, <span class="s">&quot;A_Color&quot;</span>))
+    nt.links.new(gain.outputs[<span class="s">&quot;Value&quot;</span>], _sock(mix.inputs, <span class="s">&quot;B_Color&quot;</span>))
+    nt.links.new(_sock(mix.outputs, <span class="s">&quot;Result_Color&quot;</span>), bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    rough = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rough.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = <span class="n">0.72</span>
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = <span class="n">0.52</span>
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], rough.inputs[<span class="s">&quot;Value&quot;</span>])
+    nt.links.new(rough.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> stone_material(name, light, dark, roughness, mottle, speck, bump):
+    <span class="s">&quot;&quot;&quot;Fieldstone: isotropic mottling, speckle and pitting, a tone per stone.
+
+    Copied from stone-archway, reading ``PieceTone`` for the per-stone
+    shade. Nothing in the pattern has a direction, so it cannot read as
+    wood grain the way stretched noise does.
+    &quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    mot = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    mot.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = mottle
+    mot.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">4.0</span>
+    mot.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.55</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], mot.inputs[<span class="s">&quot;Vector&quot;</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.32</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = dark
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.70</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = light
+    nt.links.new(mot.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    spk = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    spk.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = speck
+    spk.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">2.0</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], spk.inputs[<span class="s">&quot;Vector&quot;</span>])
+    gain = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    gain.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = <span class="n">0.82</span>
+    gain.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = <span class="n">1.12</span>
+    nt.links.new(spk.outputs[<span class="s">&quot;Fac&quot;</span>], gain.inputs[<span class="s">&quot;Value&quot;</span>])
+    mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+    mix.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    _sock(mix.inputs, <span class="s">&quot;Factor_Float&quot;</span>).default_value = <span class="n">1.0</span>
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], _sock(mix.inputs, <span class="s">&quot;A_Color&quot;</span>))
+    nt.links.new(gain.outputs[<span class="s">&quot;Result&quot;</span>], _sock(mix.inputs, <span class="s">&quot;B_Color&quot;</span>))
+    tone = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    tone.attribute_name = <span class="s">&quot;PieceTone&quot;</span>
+    shade = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    shade.operation = <span class="s">&quot;MULTIPLY_ADD&quot;</span>
+    shade.inputs[<span class="n">1</span>].default_value = <span class="n">0.8</span>
+    shade.inputs[<span class="n">2</span>].default_value = <span class="n">0.6</span>
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], shade.inputs[<span class="n">0</span>])
+    mix2 = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    mix2.data_type = <span class="s">&quot;RGBA&quot;</span>
+    mix2.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    _sock(mix2.inputs, <span class="s">&quot;Factor_Float&quot;</span>).default_value = <span class="n">1.0</span>
+    nt.links.new(_sock(mix.outputs, <span class="s">&quot;Result_Color&quot;</span>), _sock(mix2.inputs, <span class="s">&quot;A_Color&quot;</span>))
+    nt.links.new(shade.outputs[<span class="s">&quot;Value&quot;</span>], _sock(mix2.inputs, <span class="s">&quot;B_Color&quot;</span>))
+    nt.links.new(_sock(mix2.outputs, <span class="s">&quot;Result_Color&quot;</span>), bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    rough = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rough.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = roughness - <span class="n">0.06</span>
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = min(<span class="n">1.0</span>, roughness + <span class="n">0.08</span>)
+    nt.links.new(spk.outputs[<span class="s">&quot;Fac&quot;</span>], rough.inputs[<span class="s">&quot;Value&quot;</span>])
+    nt.links.new(rough.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
+    <span class="k">if</span> bump &gt; <span class="n">0.0</span>:
+        bmp = nt.nodes.new(<span class="s">&quot;ShaderNodeBump&quot;</span>)
+        bmp.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = bump
+        bmp.inputs[<span class="s">&quot;Distance&quot;</span>].default_value = <span class="n">0.002</span>
+        nt.links.new(spk.outputs[<span class="s">&quot;Fac&quot;</span>], bmp.inputs[<span class="s">&quot;Height&quot;</span>])
+        nt.links.new(bmp.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> ash_material(name):
+    <span class="s">&quot;&quot;&quot;Grey ash with a few embers: sparse orange emission from a noise threshold.&quot;&quot;&quot;</span>
+    mat = principled(name, (<span class="n">0.11</span>, <span class="n">0.105</span>, <span class="n">0.10</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.95</span>,
+                     noise_scale=<span class="n">10.0</span>, wear=(<span class="n">0.05</span>, <span class="n">0.045</span>, <span class="n">0.04</span>, <span class="n">1.0</span>))
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    hot = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    hot.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = <span class="n">28.0</span>
+    hot.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">3.0</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], hot.inputs[<span class="s">&quot;Vector&quot;</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.62</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.74</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">1.0</span>, <span class="n">0.32</span>, <span class="n">0.06</span>, <span class="n">1.0</span>)
+    nt.links.new(hot.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>], bsdf.inputs[<span class="s">&quot;Emission Color&quot;</span>])
+    bsdf.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">2.5</span>
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> campfire_materials():
+    <span class="s">&quot;&quot;&quot;(stone, wood, ash): shared by the check, the render and inspection.&quot;&quot;&quot;</span>
+    stone = stone_material(
+        <span class="s">&quot;CampfireStone&quot;</span>, (<span class="n">0.44</span>, <span class="n">0.42</span>, <span class="n">0.38</span>, <span class="n">1.0</span>), (<span class="n">0.22</span>, <span class="n">0.215</span>, <span class="n">0.20</span>, <span class="n">1.0</span>),
+        <span class="n">0.86</span>, mottle=<span class="n">6.0</span>, speck=<span class="n">160.0</span>, bump=<span class="n">0.35</span>,
+    )
+    wood = wood_material(<span class="s">&quot;CampfireWood&quot;</span>)
+    ash = ash_material(<span class="s">&quot;CampfireAsh&quot;</span>)
+    <span class="k">return</span> stone, wood, ash
+
+
 <span class="k">def</span> body_plan(me):
     groups = shells(me)
     xs, ys, z0s, z1s = [], [], [], []
@@ -1151,27 +1395,20 @@ <h2>Source</h2>
     short_stones=<span class="k">False</span>,
     float_logs=<span class="k">False</span>,
     gap_courses=<span class="k">False</span>,
+    uniform_stones=<span class="k">False</span>,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     flags = dict(
         short_stones=short_stones,
         float_logs=float_logs,
         gap_courses=gap_courses,
+        uniform_stones=uniform_stones,
     )
     low = build_campfire_mesh(<span class="s">&quot;CampfireLow&quot;</span>, <span class="n">0.006</span>, <span class="n">2</span>, **flags)
     high = build_campfire_mesh(<span class="s">&quot;CampfireHigh&quot;</span>, <span class="n">0.006</span>, <span class="n">4</span>, **flags)
-    stone = principled(
-        <span class="s">&quot;CampfireStone&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.42</span>, <span class="n">0.46</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.84</span>,
-        noise_scale=<span class="n">8.0</span>, wear=(<span class="n">0.28</span>, <span class="n">0.27</span>, <span class="n">0.24</span>, <span class="n">1.0</span>),
-    )
-    wood = principled(
-        <span class="s">&quot;CampfireWood&quot;</span>, (<span class="n">0.38</span>, <span class="n">0.18</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.62</span>,
-        noise_scale=<span class="n">6.0</span>, wear=(<span class="n">0.18</span>, <span class="n">0.09</span>, <span class="n">0.04</span>, <span class="n">1.0</span>),
-    )
-    ash = principled(
-        <span class="s">&quot;CampfireAsh&quot;</span>, (<span class="n">0.12</span>, <span class="n">0.11</span>, <span class="n">0.10</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.94</span>,
-        noise_scale=<span class="n">10.0</span>, wear=(<span class="n">0.08</span>, <span class="n">0.07</span>, <span class="n">0.06</span>, <span class="n">1.0</span>),
-    )
+    stone, wood, ash = campfire_materials()
+    paint_pieces(low.data)
+    paint_pieces(high.data)
     assign_slots(low, stone, wood, ash)
     assign_slots(high, stone, wood, ash)
     <span class="k">if</span> stray_vert:
@@ -1203,6 +1440,7 @@ <h2>Source</h2>
     sup = support_audit(low.data)
     cseat = course_seat(low.data)
     kiss = teepee_kiss(low.data)
+    vary = stone_variation(low.data)
     dia, ht = body_plan(low.data)
     print(
         <span class="s">f&quot;</span><span class="s">measured hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
@@ -1213,6 +1451,7 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">measured stones=</span>{sup[<span class="s">&#x27;stones&#x27;</span>]}<span class="s"> stone_z=</span>{sup[<span class="s">&#x27;stone_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">course_seat=</span>{cseat:<span class="s">.5f</span>}<span class="s"> kiss=</span>{kiss:<span class="s">.5f</span>}<span class="s"> body=</span>{dia:<span class="s">.4f</span>}<span class="s">x</span>{ht:<span class="s">.4f</span>}<span class="s">&quot;</span>
     )
+    print(<span class="s">f&quot;</span><span class="s">measured stone_variation=</span>{vary:<span class="s">.5f</span>}<span class="s">&quot;</span>)
 
     img, tex = setup_bake_image(low, stone)
     <span class="k">if</span> img <span class="k">is</span> <span class="k">None</span>:
@@ -1240,6 +1479,10 @@ <h2>Source</h2>
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) <span class="k">if</span> os.path.isfile(export_path) <span class="k">else</span> <span class="n">0</span>
+    <span class="c"># Blender points TMPDIR at the working directory, so the export must not</span>
+    <span class="c"># outlive the measurement.</span>
+    <span class="k">if</span> os.path.exists(export_path):
+        os.remove(export_path)
 
     print(<span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>)
     print(
@@ -1355,6 +1598,12 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">ring </span>{dia:<span class="s">.4f</span>}<span class="s">x</span>{ht:<span class="s">.4f</span>}<span class="s"> off </span>{RING_DIA}<span class="s">x</span>{RING_H}<span class="s">&quot;</span>,
             <span class="n">19</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> vary &lt; STONE_VARY_MIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">stone variation </span>{vary:<span class="s">.5f</span>}<span class="s"> &lt; </span>{STONE_VARY_MIN}<span class="s">: the ring stones are </span><span class="s">&quot;</span>
+            <span class="s">&quot;identical (--uniform-stones is the designed fail)&quot;</span>,
+            <span class="n">20</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, stone, tex, collider
 
 
@@ -1465,6 +1714,7 @@ <h2>Source</h2>
     p.add_argument(<span class="s">&quot;--short-stones&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--float-logs&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--gap-courses&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--uniform-stones&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, stone, tex, _col = check(
@@ -1474,6 +1724,7 @@ <h2>Source</h2>
         short_stones=args.short_stones,
         float_logs=args.float_logs,
         gap_courses=args.gap_courses,
+        uniform_stones=args.uniform_stones,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1498,7 +1749,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/campfire-hero.webp" alt="A campfire of crossed logs in a teepee inside a ring of grey stone blocks." />
+    <img src="../assets/campfire-hero.webp" alt="A campfire of crossed logs in a teepee, embers in the ash, inside a two-course ring of rounded grey fieldstones." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/contact-sheets/campfire-contact-sheet.webp b/docs/gallery/contact-sheets/campfire-contact-sheet.webp
index 6decf7fc..f135f628 100644
Binary files a/docs/gallery/contact-sheets/campfire-contact-sheet.webp and b/docs/gallery/contact-sheets/campfire-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/gn-modifier-inputs-contact-sheet.webp b/docs/gallery/contact-sheets/gn-modifier-inputs-contact-sheet.webp
index 7bc87258..78472ab7 100644
Binary files a/docs/gallery/contact-sheets/gn-modifier-inputs-contact-sheet.webp and b/docs/gallery/contact-sheets/gn-modifier-inputs-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/iron-cauldron-contact-sheet.webp b/docs/gallery/contact-sheets/iron-cauldron-contact-sheet.webp
index 15e3766e..6b76f5f2 100644
Binary files a/docs/gallery/contact-sheets/iron-cauldron-contact-sheet.webp and b/docs/gallery/contact-sheets/iron-cauldron-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/usd-export-evaluation-mode-contact-sheet.webp b/docs/gallery/contact-sheets/usd-export-evaluation-mode-contact-sheet.webp
index cf7014b1..96b618a3 100644
Binary files a/docs/gallery/contact-sheets/usd-export-evaluation-mode-contact-sheet.webp and b/docs/gallery/contact-sheets/usd-export-evaluation-mode-contact-sheet.webp differ
diff --git a/docs/gallery/gn-modifier-inputs/index.html b/docs/gallery/gn-modifier-inputs/index.html
index 6eb5ef2f..0f127c3d 100644
--- a/docs/gallery/gn-modifier-inputs/index.html
+++ b/docs/gallery/gn-modifier-inputs/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gn-modifier-inputs-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Three boxes stepping up in size from a small teal cube to an orange block to a large red block." />
+  <meta property="og:image:alt" content="Three separate cubes stepping up in size from left to right: a small teal cube, an orange block and a large red block." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="gn-modifier-inputs — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="Per-modifier Geometry Nodes Float inputs on a shared tree — 4.5/5.1 write mod[identifier], 5.2 writes mod.properties.inputs.Socket_1.value." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gn-modifier-inputs-hero.webp" />
-  <meta name="twitter:image:alt" content="Three boxes stepping up in size from a small teal cube to an orange block to a large red block." />
+  <meta name="twitter:image:alt" content="Three separate cubes stepping up in size from left to right: a small teal cube, an orange block and a large red block." />
   <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>gn-modifier-inputs</h1>
     <p>Per-modifier Geometry Nodes Float inputs on a shared tree — 4.5/5.1 write mod[identifier], 5.2 writes mod.properties.inputs.Socket_1.value.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three boxes stepping up in size from a small teal cube to an orange block to a large red block.">
-      <img src="../assets/gn-modifier-inputs-hero.webp" alt="Three boxes stepping up in size from a small teal cube to an orange block to a large red block." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three separate cubes stepping up in size from left to right: a small teal cube, an orange block and a large red block.">
+      <img src="../assets/gn-modifier-inputs-hero.webp" alt="Three separate cubes stepping up in size from left to right: a small teal cube, an orange block and a large red block." 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> The 5.1 dict form raises TypeError on 5.2 rather than silently no-opping; RNA properties are AttributeError on 4.5. Readback and evaluated Z-extent match written scales 1/2/3.</div>
@@ -281,6 +281,7 @@ <h1>gn-modifier-inputs</h1>
 <p>A runnable example that attaches one Geometry Nodes tree to three cubes and writes a per-modifier Float <strong>Scale</strong> input through the version-appropriate API. The tree scales a 1 m cube by that value and lifts it onto the floor. Evaluated Z-extent must match the written scale (1 / 2 / 3). That is the closed form: if the write did not land, the three cubes collapse to the socket default and the extents are no longer distinct.</p>
 <p><strong>What it witnesses:</strong> Blender 5.2 removed ID-property assignment on <code>NodesModifier</code>. <code>mod[&quot;Socket_1&quot;] = 2.0</code> raises <code>TypeError</code> rather than silently no-opping. 4.5 LTS and 5.1 still require that dict form; <code>mod.properties</code> does not exist there (<code>AttributeError</code>). 5.2+ writes <code>mod.properties.inputs.Socket_1.value</code>. After the write, the depsgraph must be updated or <code>evaluated_get</code> still sees the previous scale.</p>
 <p>Follows <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/geometry-nodes-python/SKILL.md"><code>geometry-nodes-python</code></a>.</p>
+<p>Staging: the carriers now stand 0.5 m apart (<code>XS</code>). The old spacing overlapped the 2 m and 3 m cubes by 0.2 m. The check reads only each cube&#x27;s evaluated Z extent and zmin, never X, so this is layout only. The camera looks from the front, so small to large reads left to right, and a duller finish keeps the tops from blowing out.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python gn_modifier_inputs.py --
@@ -346,8 +347,10 @@ <h2>Source</h2>
 
 CUBE_SIZE = <span class="n">1.0</span>
 SCALES = (<span class="n">1.0</span>, <span class="n">2.0</span>, <span class="n">3.0</span>)
-<span class="c"># Half-widths 0.5 / 1.0 / 1.5; keep a clear gap, keep the 3 m cube off the right edge.</span>
-XS = (-<span class="n">2.2</span>, <span class="n">0.15</span>, <span class="n">2.45</span>)
+<span class="c"># Half-widths 0.5 / 1.0 / 1.5, with 0.5 m between neighbours. The old</span>
+<span class="c"># (-2.2, 0.15, 2.45) overlapped the 2 m and 3 m cubes by 0.2 m. The check</span>
+<span class="c"># reads only Z extents, so the layout is free.</span>
+XS = (-<span class="n">2.6</span>, -<span class="n">0.6</span>, <span class="n">2.4</span>)
 COLORS = (
     (<span class="n">0.05</span>, <span class="n">0.62</span>, <span class="n">0.58</span>, <span class="n">1.0</span>),  <span class="c"># teal</span>
     (<span class="n">0.82</span>, <span class="n">0.38</span>, <span class="n">0.08</span>, <span class="n">1.0</span>),  <span class="c"># copper</span>
@@ -393,8 +396,8 @@ <h2>Source</h2>
     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 = color
-    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.28</span>
-    bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.35</span>
+    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.45</span>
+    bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.1</span>
     <span class="k">return</span> mat
 
 
@@ -603,7 +606,7 @@ <h2>Source</h2>
     scene.world = world
 
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.35</span>, <span class="n">0.0</span>, <span class="n">1.25</span>)
+    aim.location = (<span class="n">0.25</span>, <span class="n">0.0</span>, <span class="n">1.1</span>)
     scene.collection.objects.link(aim)
 
     <span class="k">def</span> light(name, loc, energy, size, col):
@@ -619,7 +622,7 @@ <h2>Source</h2>
         lc.track_axis = <span class="s">&quot;TRACK_NEGATIVE_Z&quot;</span>
         lc.up_axis = <span class="s">&quot;UP_Y&quot;</span>
 
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.8</span>, -<span class="n">5.0</span>, <span class="n">6.2</span>), <span class="n">560.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>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">5.5</span>, -<span class="n">6.0</span>, <span class="n">5.2</span>), <span class="n">380.0</span>, <span class="n">6.0</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.4</span>, -<span class="n">3.2</span>, <span class="n">2.4</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.4</span>, <span class="n">6.4</span>, <span class="n">3.8</span>), <span class="n">280.0</span>, <span class="n">3.5</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">&quot;AREA&quot;</span>)
@@ -634,7 +637,7 @@ <h2>Source</h2>
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">8.1</span>, -<span class="n">10.8</span>, <span class="n">5.05</span>)
+    cam.location = (<span class="n">1.6</span>, -<span class="n">12.4</span>, <span class="n">6.6</span>)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
@@ -718,7 +721,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/gn-modifier-inputs-hero.webp" alt="Three boxes stepping up in size from a small teal cube to an orange block to a large red block." />
+    <img src="../assets/gn-modifier-inputs-hero.webp" alt="Three separate cubes stepping up in size from left to right: a small teal cube, an orange block and a large red block." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index c4c81e67..fec5cb50 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -453,7 +453,7 @@ <h2><a href="gn-instance-grid/">gn-instance-grid</a></h2>
       </article>
       <article class="card" data-tags="geometry-nodes modifiers">
         <a class="card-media" href="gn-modifier-inputs/" tabindex="-1" aria-hidden="true">
-          <img src="assets/gn-modifier-inputs-hero.webp" alt="Three boxes stepping up in size from a small teal cube to an orange block to a large red block." loading="lazy" decoding="async" />
+          <img src="assets/gn-modifier-inputs-hero.webp" alt="Three separate cubes stepping up in size from left to right: a small teal cube, an orange block and a large red block." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="gn-modifier-inputs/">gn-modifier-inputs</a></h2>
@@ -860,7 +860,7 @@ <h2><a href="cross-version-property-delete/">cross-version-property-delete</a></
       </article>
       <article class="card" data-tags="depsgraph export">
         <a class="card-media" href="usd-export-evaluation-mode/" tabindex="-1" aria-hidden="true">
-          <img src="assets/usd-export-evaluation-mode-hero.webp" alt="Two grey spheres: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." loading="lazy" decoding="async" />
+          <img src="assets/usd-export-evaluation-mode-hero.webp" alt="Two steel balls resting on the floor: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="usd-export-evaluation-mode/">usd-export-evaluation-mode</a></h2>
@@ -937,12 +937,12 @@ <h2><a href="wooden-barrel/">wooden-barrel</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="campfire/" tabindex="-1" aria-hidden="true">
-          <img src="assets/campfire-hero.webp" alt="A campfire of crossed logs in a teepee inside a ring of grey stone blocks." loading="lazy" decoding="async" />
+          <img src="assets/campfire-hero.webp" alt="A campfire of crossed logs in a teepee, embers in the ash, inside a two-course ring of rounded grey fieldstones." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="campfire/">campfire</a></h2>
           <p class="teaches">A procedural campfire through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 2200 tris, three materials with 216 wood, 48 ash and 1304 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.807×0.808×0.404 m, LOD ratios in band, convex collider 198 tris, hygiene 0, 14 grounded bottom stones, teepee kiss 0.00001 m, course seat 0, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-stones 16; --float-logs 17; --gap-courses 18.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 2760 tris, three materials with 216 wood, 48 ash and 1416 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.802×0.802×0.404 m, LOD ratios in band, convex collider 162 tris, hygiene 0, 14 grounded bottom stones, teepee kiss 0.00034 m, course seat 0, stone variation 0.01269 m, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-stones 16; --float-logs 17; --gap-courses 18; --uniform-stones 20.</p>
           <a class="card-link" href="campfire/">View showcase piece<span class="sr-only"> campfire</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1157,12 +1157,12 @@ <h2><a href="tavern-stool/">tavern-stool</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="iron-cauldron/" tabindex="-1" aria-hidden="true">
-          <img src="assets/iron-cauldron-hero.webp" alt="A black iron cauldron hanging from a tripod of wooden poles." loading="lazy" decoding="async" />
+          <img src="assets/iron-cauldron-hero.webp" alt="A round-bellied black iron cauldron hanging by its bail from a tripod of wooden poles." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="iron-cauldron/">iron-cauldron</a></h2>
-          <p class="teaches">A procedural hanging iron cauldron with a bulged open pot, bail, and timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 3664 tris, two materials with 224 wood and 1768 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.987×0.961×0.860 m, pot–leg clearance 0.046 m, 3 coaxial ferrules at zmin 0, ferrule bite −0.00185 m, hook-bail join 0, mesh hygiene all zero, LOD ratios in band, convex collider 250 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-legs 16; --float-hook 17; --pipe-ferrule 18.</p>
+          <p class="teaches">A procedural hanging iron cauldron with a round-bellied pot, a bail threaded through flat ear rings, and a timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 3664 tris, two materials with 224 wood and 1768 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.987×0.961×0.860 m, pot–leg clearance 0.053 m, pot base radius 0.075 m, 3 coaxial ferrules at zmin 0, ferrule bite −0.00185 m, hook-bail join 0, bail threads both ear rings, mesh hygiene all zero, LOD ratios in band, convex collider 246 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-legs 16; --float-hook/--edge-on-ears 17; --pipe-ferrule 18; --pointed-pot 19.</p>
           <a class="card-link" href="iron-cauldron/">View showcase piece<span class="sr-only"> iron-cauldron</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/iron-cauldron/index.html b/docs/gallery/iron-cauldron/index.html
index ed6f5fc5..e467fa5a 100644
--- a/docs/gallery/iron-cauldron/index.html
+++ b/docs/gallery/iron-cauldron/index.html
@@ -4,25 +4,25 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>iron-cauldron — Showcase — Blender Developer Tools</title>
-  <meta name="description" content="A procedural hanging iron cauldron with a bulged open pot, bail, and timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural hanging iron cauldron with a round-bellied pot, a bail threaded through flat ear rings, and a timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/iron-cauldron/" />
   <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="iron-cauldron — Showcase — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural hanging iron cauldron with a bulged open pot, bail, and timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural hanging iron cauldron with a round-bellied pot, a bail threaded through flat ear rings, and a timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/iron-cauldron/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/iron-cauldron-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A black iron cauldron hanging from a tripod of wooden poles." />
+  <meta property="og:image:alt" content="A round-bellied black iron cauldron hanging by its bail from a tripod of wooden poles." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="iron-cauldron — Showcase — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural hanging iron cauldron with a bulged open pot, bail, and timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural hanging iron cauldron with a round-bellied pot, a bail threaded through flat ear rings, and a timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/iron-cauldron-hero.webp" />
-  <meta name="twitter:image:alt" content="A black iron cauldron hanging from a tripod of wooden poles." />
+  <meta name="twitter:image:alt" content="A round-bellied black iron cauldron hanging by its bail from a tripod of wooden poles." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -265,36 +265,40 @@
   </div>
   <header class="hero">
     <h1>iron-cauldron</h1>
-    <p>A procedural hanging iron cauldron with a bulged open pot, bail, and timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural hanging iron cauldron with a round-bellied pot, a bail threaded through flat ear rings, and a timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A black iron cauldron hanging from a tripod of wooden poles.">
-      <img src="../assets/iron-cauldron-hero.webp" alt="A black iron cauldron hanging from a tripod of wooden poles." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A round-bellied black iron cauldron hanging by its bail from a tripod of wooden poles.">
+      <img src="../assets/iron-cauldron-hero.webp" alt="A round-bellied black iron cauldron hanging by its bail from a tripod of wooden poles." width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the showcase piece itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Recomputed: 3664 tris, two materials with 224 wood and 1768 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.987×0.961×0.860 m, pot–leg clearance 0.046 m, 3 coaxial ferrules at zmin 0, ferrule bite −0.00185 m, hook-bail join 0, mesh hygiene all zero, LOD ratios in band, convex collider 250 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-legs 16; --float-hook 17; --pipe-ferrule 18.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 3664 tris, two materials with 224 wood and 1768 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.987×0.961×0.860 m, pot–leg clearance 0.053 m, pot base radius 0.075 m, 3 coaxial ferrules at zmin 0, ferrule bite −0.00185 m, hook-bail join 0, bail threads both ear rings, mesh hygiene all zero, LOD ratios in band, convex collider 246 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-legs 16; --float-hook/--edge-on-ears 17; --pipe-ferrule 18; --pointed-pot 19.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/iron-cauldron/iron_cauldron.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural hanging cauldron (lathed iron pot with a rolled rim, pipe bail through vertical ear rings, timber tripod tenoned into a turned crown, iron ferrule cups coaxial with the poles) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>A showcase piece, not an example. Procedural hanging cauldron (a round-bellied iron pot on a small flat base with a rolled rim, a pipe bail threaded through flat ear rings, timber tripod tenoned into a turned crown, iron ferrule cups coaxial with the poles) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>Ferrules are lofted along the pole axis and shifted so the downhill rim sits at Z=0. A world-Z bucket lets a leaning pole slice the lip. <code>ferrule_bite</code> is measured in that same frame, and only samples wood inside the cup&#x27;s own axis span — a pole hovering above the well cannot fake a seat.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>2800–4200</td><td>3664 / 3664 / 3664</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2200 / 0.2200 / 0.2200</td></tr><tr><td>Materials</td><td>exactly 2 distinct; ≥80 wood, ≥200 metal faces</td><td>2 slots; 224 / 1768</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(0.987, 0.961, 0.860) m ± 0.015</td><td>(0.9866, 0.9605, 0.8600), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 280</td><td>250</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>287916 / 287916 / 287904 bytes</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>2800–4200</td><td>3664 / 3664 / 3664</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2200 / 0.2200 / 0.2200</td></tr><tr><td>Materials</td><td>exactly 2 distinct; ≥80 wood, ≥200 metal faces</td><td>2 slots; 224 / 1768</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(0.987, 0.961, 0.860) m ± 0.015</td><td>(0.9866, 0.9605, 0.8600), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 280</td><td>246</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>287380 / 287380 / 287368 bytes</td></tr></tbody></table></div>
 <p>Base triangles rose from <strong>3388 to 3664</strong> in the quality pass: coaxial ferrule cups and a dual-wall lathe with a rolled rim replaced the old cone-tripod / overlapping-torus construction.</p>
 <h3>Hygiene</h3>
 <p>Recomputed from the generated mesh, not asserted about the script.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar disjoint face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Named supports: 3 ferrules</td><td>each <code>zmin</code> ≤ 1e-3</td><td>3, cup_z 0.00000</td></tr><tr><td>Pot size</td><td>0.355 m dia × 0.334 m high ± 0.04</td><td>0.3545 × 0.3340</td></tr><tr><td>Pot–leg clearance</td><td>≥ 0.04 m</td><td>0.0464</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar disjoint face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Named supports: 3 ferrules</td><td>each <code>zmin</code> ≤ 1e-3</td><td>3, cup_z 0.00000</td></tr><tr><td>Pot size</td><td>0.355 m dia × 0.334 m high ± 0.04</td><td>0.3600 × 0.3340</td></tr><tr><td><strong>Pot form</strong></td><td>base radius ≥ 0.05 m; widest point in the lower 60%</td><td>0.0750; at 0.420 of the height</td></tr><tr><td>Pot–leg clearance</td><td>≥ 0.04 m</td><td>0.0528</td></tr></tbody></table></div>
 <h3>Joint fit and seat</h3>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Hook-bail BVH gap</td><td>≤ 0.010 m</td><td>0.00000</td></tr><tr><td>Ferrule bite (pole r − inner wall, pole frame)</td><td>−0.006–0.000 m</td><td>−0.00185</td></tr></tbody></table></div>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 12 B on 5.2.1 (glTF serializer), not a gated axis.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Hook-bail BVH gap</td><td>≤ 0.010 m</td><td>0.00000</td></tr><tr><td><strong>Bail through the ears</strong></td><td>2 rings; 0 ring vertices inside the bail; bail within the hole (&lt; 0.0135 m of the ring centre)</td><td>2; 0; 0.00641</td></tr><tr><td>Ferrule bite (pole r − inner wall, pole frame)</td><td>−0.006–0.000 m</td><td>−0.00185</td></tr></tbody></table></div>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction is closed-form; the only RNG is the seeded per-pole wood tone. Export byte counts differ on 5.2.1 (glTF serializer), not a gated axis.</p>
+<h3>Pot, ears and surface</h3>
+<p>The pot was a quadratic profile from a 28 mm tip: an onion that ran to a point. It is now a superellipse belly from a 75 mm flat base out to 0.180 m at 0.42 of the height, then a rounded shoulder in to a 0.128 m mouth. The inner wall is offset along the profile&#x27;s normal, not sideways, so it keeps its thickness where the wall runs nearly flat. <strong>Pot form</strong> asserts it; <code>--pointed-pot</code> restores the old profile (base 0.028 m, widest at 0.727 of the height) and exits 19.</p>
+<p>The ear rings stood in the bail&#x27;s own XZ plane, so the bail ran through the ring&#x27;s tube rather than its hole, and its ends hung into the pot&#x27;s mouth. The rings now lie flat, bite 2 mm into the rim&#x27;s outer edge, and the bail (vertical where it passes) threads them. Past each ear the bail is mirrored about the ring, so its ends hook outward. <strong>Bail through the ears</strong> asserts it; <code>--edge-on-ears</code> restores the old rings (36 ring vertices inside the bail) and exits 17.</p>
+<p>Cast iron is near-black and rough with rust in the pores; each pole has its own tone and grain along its axis. The temp <code>.glb</code> is removed after its size is measured.</p>
 <h3>Falsifiers</h3>
-<p>Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--short-legs</code></td><td>named ferrule supports at Z=0</td><td>16</td></tr><tr><td><code>--float-hook</code></td><td>hook-bail gap</td><td>17</td></tr><tr><td><code>--pipe-ferrule</code></td><td>ferrule bite (pole starts above the well)</td><td>18</td></tr></tbody></table></div>
+<p>Each violates one named budget. All nine were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--short-legs</code></td><td>named ferrule supports at Z=0</td><td>16</td></tr><tr><td><code>--float-hook</code></td><td>hook-bail gap</td><td>17</td></tr><tr><td><code>--pipe-ferrule</code></td><td>ferrule bite (pole starts above the well)</td><td>18</td></tr><tr><td><code>--pointed-pot</code></td><td>pot form</td><td>19</td></tr><tr><td><code>--edge-on-ears</code></td><td>bail through the ears</td><td>17</td></tr></tbody></table></div>
 <h2>Run</h2>
 <pre><code>blender --background --python iron_cauldron.py --
 blender --background --python iron_cauldron.py -- --skip-decimate
@@ -303,11 +307,13 @@ <h2>Run</h2>
 blender --background --python iron_cauldron.py -- --short-legs
 blender --background --python iron_cauldron.py -- --float-hook
 blender --background --python iron_cauldron.py -- --pipe-ferrule
+blender --background --python iron_cauldron.py -- --pointed-pot
+blender --background --python iron_cauldron.py -- --edge-on-ears
 blender --background --python iron_cauldron.py -- --output cauldron.png</code></pre>
 <p>Smoke passes no flags.</p>
 <h2>Exit codes</h2>
 <p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</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>Mesh did not build / no UV layer / pot clips tripod</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 2 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named ferrule floats</td></tr><tr><td>17</td><td>Joint fit: hook-bail gap</td></tr><tr><td>18</td><td>Seat: ferrule bite band</td></tr><tr><td>19</td><td>Pot diameter or height off the stated real-world size</td></tr></tbody></table></div>
+<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>Mesh did not build / no UV layer / pot clips tripod</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 2 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named ferrule floats</td></tr><tr><td>17</td><td>Joint fit: hook-bail gap, or the bail not threading the ear rings</td></tr><tr><td>18</td><td>Seat: ferrule bite band</td></tr><tr><td>19</td><td>Pot diameter or height off the stated real-world size, or pot form (base radius, belly height)</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -332,9 +338,12 @@ <h2>Source</h2>
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named ferrule
 supports, ``--float-hook`` hook-bail joint-fit, ``--pipe-ferrule``
-ferrule-cup seat (pole starts above the well).
+ferrule-cup seat (pole starts above the well), ``--pointed-pot`` pot
+form (the old quadratic profile that ran to a point), ``--edge-on-ears``
+bail through the ears (the old rings stood in the bail&#x27;s own plane).
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
+Construction is closed-form; the only RNG is the seeded per-pole wood
+tone. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -345,6 +354,7 @@ <h2>Source</h2>
 <span class="k">import</span> argparse
 <span class="k">import</span> math
 <span class="k">import</span> os
+<span class="k">import</span> random
 <span class="k">import</span> sys
 <span class="k">import</span> tempfile
 <span class="k">import</span> traceback
@@ -368,9 +378,24 @@ <h2>Source</h2>
 POT_THICK = <span class="n">0.012</span>
 N_AROUND = <span class="n">32</span>
 N_RINGS = <span class="n">12</span>
-R_BOT = <span class="n">0.028</span>
+R_BOT = <span class="n">0.075</span>
 R_MID = <span class="n">0.185</span>
-R_TOP = <span class="n">0.148</span>
+R_TOP = <span class="n">0.128</span>
+<span class="c"># The pot is a round belly on a small flat base: a superellipse quadrant</span>
+<span class="c"># from the base (radius R_BOT) out to the belly (R_BELLY at BELLY_Z), then</span>
+<span class="c"># a circular shoulder in to the mouth (R_TOP). --pointed-pot restores the</span>
+<span class="c"># old quadratic profile, which ran from a 28 mm tip.</span>
+R_BELLY = <span class="n">0.180</span>
+BELLY_Z = <span class="n">0.42</span> * <span class="n">0.320</span>
+BELLY_P = <span class="n">2.4</span>
+N_LOWER = <span class="n">7</span>
+POINTED_R_BOT = <span class="n">0.028</span>
+POT_BASE_MIN = <span class="n">0.05</span>
+POT_BELLY_MAX = <span class="n">0.60</span>
+<span class="c"># Per-pole wood tone jitter and grain frequency, as in shipping-crate.</span>
+PLANK_TONE_JITTER = <span class="n">0.28</span>
+TONE_SEED = <span class="n">29</span>
+WOOD_GRAIN_SCALE = <span class="n">40.0</span>
 POT_Z0 = <span class="n">0.155</span>
 APEX_Z = <span class="n">0.860</span>
 TRIPOD_R = <span class="n">0.560</span>
@@ -390,6 +415,10 @@ <h2>Source</h2>
 HOOK_R = <span class="n">0.006</span>
 EAR_MAJOR = <span class="n">0.018</span>
 EAR_MINOR = <span class="n">0.0045</span>
+<span class="c"># Ear rings lie flat (hole along Z) so the bail, vertical where it passes,</span>
+<span class="c"># threads the hole. Each ring bites EAR_BITE into the rim&#x27;s outer edge.</span>
+EAR_BITE = <span class="n">0.002</span>
+RIM_OUT = <span class="n">0.018</span>
 POLE_OFFSET = math.radians(<span class="n">18.0</span>)
 
 BBOX_TOL = <span class="n">0.015</span>
@@ -696,15 +725,50 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> pot_radius(z_local):
+<span class="k">def</span> pointed_radius(z_local):
+    <span class="s">&quot;&quot;&quot;The old profile: a quadratic from a 28 mm tip (``--pointed-pot``).&quot;&quot;&quot;</span>
     t = max(<span class="n">0.0</span>, min(<span class="n">1.0</span>, z_local / POT_H))
     <span class="k">return</span> (
-        (<span class="n">1.0</span> - t) ** <span class="n">2</span> * R_BOT
+        (<span class="n">1.0</span> - t) ** <span class="n">2</span> * POINTED_R_BOT
         + <span class="n">2.0</span> * t * (<span class="n">1.0</span> - t) * (R_MID * <span class="n">1.32</span>)
         + t ** <span class="n">2</span> * R_TOP
     )
 
 
+<span class="k">def</span> pot_profile(pointed=<span class="k">False</span>):
+    <span class="s">&quot;&quot;&quot;Outer and inner (z_local, r) rings of the pot wall, base to mouth.
+
+    The inner wall is the outer offset POT_THICK along the profile&#x27;s
+    inward normal, so the wall keeps its thickness where it runs nearly
+    flat under the belly; a horizontal offset thins it to nothing there.
+    &quot;&quot;&quot;</span>
+    <span class="k">if</span> pointed:
+        zs = [POT_H * i / (N_RINGS - <span class="n">1</span>) <span class="k">for</span> i <span class="k">in</span> range(N_RINGS)]
+        outer = [(z, pointed_radius(z)) <span class="k">for</span> z <span class="k">in</span> zs]
+        <span class="k">return</span> outer, [(z, max(r - POT_THICK, <span class="n">0.014</span>)) <span class="k">for</span> z, r <span class="k">in</span> outer]
+    outer = []
+    <span class="k">for</span> k <span class="k">in</span> range(N_LOWER):
+        th = <span class="n">0.5</span> * math.pi * k / (N_LOWER - <span class="n">1</span>)
+        sn = max(<span class="n">0.0</span>, math.sin(th)) ** (<span class="n">2.0</span> / BELLY_P)
+        cs = max(<span class="n">0.0</span>, math.cos(th)) ** (<span class="n">2.0</span> / BELLY_P)
+        outer.append((BELLY_Z * (<span class="n">1.0</span> - cs), R_BOT + (R_BELLY - R_BOT) * sn))
+    n_up = N_RINGS - N_LOWER + <span class="n">1</span>
+    <span class="k">for</span> k <span class="k">in</span> range(<span class="n">1</span>, n_up):
+        th = <span class="n">0.5</span> * math.pi * k / (n_up - <span class="n">1</span>)
+        outer.append((
+            BELLY_Z + (POT_H - BELLY_Z) * math.sin(th),
+            R_TOP + (R_BELLY - R_TOP) * math.cos(th),
+        ))
+    inner = []
+    <span class="k">for</span> i, (z, r) <span class="k">in</span> enumerate(outer):
+        z0, r0 = outer[max(i - <span class="n">1</span>, <span class="n">0</span>)]
+        z1, r1 = outer[min(i + <span class="n">1</span>, len(outer) - <span class="n">1</span>)]
+        tr, tz = r1 - r0, z1 - z0
+        ln = math.hypot(tr, tz)
+        inner.append((z + POT_THICK * tr / ln, r - POT_THICK * tz / ln))
+    <span class="k">return</span> outer, inner
+
+
 <span class="k">def</span> pole_feet():
     feet = []
     <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>):
@@ -718,6 +782,8 @@ <h2>Source</h2>
     short_legs=<span class="k">False</span>,
     float_hook=<span class="k">False</span>,
     pipe_ferrule=<span class="k">False</span>,
+    pointed_pot=<span class="k">False</span>,
+    edge_on_ears=<span class="k">False</span>,
 ):
     bm = bmesh.new()
     wood_verts = []
@@ -725,7 +791,7 @@ <h2>Source</h2>
         <span class="c"># Dual-wall lathe plus a rolled rim. No overlapping torus, no</span>
         <span class="c"># extra bottom cylinder — those left a hole in the floor and a</span>
         <span class="c"># faceted lip sitting on the mouth.</span>
-        zs = [POT_H * i / (N_RINGS - <span class="n">1</span>) <span class="k">for</span> i <span class="k">in</span> range(N_RINGS)]
+        prof_out, prof_in = pot_profile(pointed_pot)
         rim = (
             (POT_H + <span class="n">0.004</span>, R_TOP + <span class="n">0.012</span>),
             (POT_H + <span class="n">0.010</span>, R_TOP + <span class="n">0.018</span>),
@@ -733,15 +799,14 @@ <h2>Source</h2>
             (POT_H + <span class="n">0.011</span>, R_TOP + <span class="n">0.006</span>),
         )
         outers, inners = [], []
-        <span class="k">for</span> z_local <span class="k">in</span> zs:
+        <span class="k">for</span> (z_local, r), (zi_local, ri) <span class="k">in</span> zip(prof_out, prof_in):
             z = POT_Z0 + z_local
-            r = pot_radius(z_local)
-            ri = max(r - POT_THICK, <span class="n">0.014</span>)
+            zi = POT_Z0 + zi_local
             oring, iring = [], []
             <span class="k">for</span> i <span class="k">in</span> range(N_AROUND):
                 a = <span class="n">2.0</span> * math.pi * i / N_AROUND
                 oring.append(bm.verts.new((r * math.cos(a), r * math.sin(a), z)))
-                iring.append(bm.verts.new((ri * math.cos(a), ri * math.sin(a), z)))
+                iring.append(bm.verts.new((ri * math.cos(a), ri * math.sin(a), zi)))
             outers.append(oring)
             inners.append(iring)
         <span class="k">for</span> z_off, r <span class="k">in</span> rim:
@@ -781,8 +846,16 @@ <h2>Source</h2>
             ibot.material_index = METAL_IDX
 
         mouth_z = POT_Z0 + POT_H
-        <span class="c"># Vertical rings (hole along Y) so the XZ bail can thread them.</span>
-        ear_x = R_TOP + <span class="n">0.008</span>
+        <span class="c"># Flat rings (hole along Z): the bail is vertical where it passes</span>
+        <span class="c"># the ear, so it threads the hole. The old rings were stood up in</span>
+        <span class="c"># the bail&#x27;s own XZ plane, so the bail ran through the ring&#x27;s tube;</span>
+        <span class="c"># --edge-on-ears restores them at the old position.</span>
+        <span class="k">if</span> edge_on_ears:
+            ear_x = R_TOP + <span class="n">0.008</span>
+            ear_euler = (math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)
+        <span class="k">else</span>:
+            ear_x = R_TOP + RIM_OUT + EAR_MAJOR + EAR_MINOR - EAR_BITE
+            ear_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)
         ear_z = mouth_z + <span class="n">0.002</span>
         <span class="k">for</span> sign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             add_torus(
@@ -793,17 +866,22 @@ <h2>Source</h2>
                 <span class="n">14</span>,
                 <span class="n">6</span>,
                 METAL_IDX,
-                euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
+                euler=ear_euler,
             )
-        <span class="c"># Semicircle through the ear holes, ends past the rings.</span>
+        <span class="c"># Semicircle through the ear holes. Past each ear the curve is</span>
+        <span class="c"># mirrored about the ear, so the ends hook outward and down instead</span>
+        <span class="c"># of hanging into the pot&#x27;s mouth.</span>
         t0 = -<span class="n">0.42</span>
         t1 = math.pi + <span class="n">0.42</span>
         bail_pts = []
         <span class="k">for</span> i <span class="k">in</span> range(BAIL_SEGS + <span class="n">1</span>):
             t = t0 + (t1 - t0) * i / BAIL_SEGS
-            bail_pts.append(
-                (ear_x * math.cos(t), <span class="n">0.0</span>, ear_z + ear_x * math.sin(t))
-            )
+            x = ear_x * math.cos(t)
+            <span class="k">if</span> t &lt; <span class="n">0.0</span>:
+                x = <span class="n">2.0</span> * ear_x - x
+            <span class="k">elif</span> t &gt; math.pi:
+                x = -<span class="n">2.0</span> * ear_x - x
+            bail_pts.append((x, <span class="n">0.0</span>, ear_z + ear_x * math.sin(t)))
         add_pipe_curve(bm, bail_pts, BAIL_R, BAIL_PIPE, METAL_IDX)
         bail_peak = Vector(bail_pts[len(bail_pts) // <span class="n">2</span>])
         hook_z = bail_peak.z + (<span class="n">0.08</span> <span class="k">if</span> float_hook <span class="k">else</span> <span class="n">0.0</span>)
@@ -928,6 +1006,131 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
+<span class="k">def</span> _long_axis(pts):
+    <span class="s">&quot;&quot;&quot;Principal axis of a point set, by power iteration on its covariance.&quot;&quot;&quot;</span>
+    c = sum(pts, Vector()) / len(pts)
+    cov = [[<span class="n">0.0</span>] * <span class="n">3</span> <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">3</span>)]
+    <span class="k">for</span> p <span class="k">in</span> pts:
+        d = p - c
+        <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>):
+            <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((<span class="n">1.0</span>, <span class="n">0.3</span>, <span class="n">0.1</span>))
+    <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">30</span>):
+        w = Vector([sum(cov[i][j] * v[j] <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>)) <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>)])
+        <span class="k">if</span> w.length &lt; <span class="n">1e-12</span>:
+            <span class="k">break</span>
+        v = w.normalized()
+    <span class="k">return</span> v
+
+
+<span class="k">def</span> paint_planks(me):
+    <span class="s">&quot;&quot;&quot;Per-shell ``PlankTone`` and ``GrainDir`` face attributes for the wood shader.
+
+    Every pole and the crown is its own shell, so each gets one tone and
+    grain running along its own long axis (along each pole).
+    &quot;&quot;&quot;</span>
+    tone = [<span class="n">0.5</span>] * len(me.polygons)
+    grain = [(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        pts = [me.vertices[i].co.copy() <span class="k">for</span> i <span class="k">in</span> g]
+        d = _long_axis(pts) <span class="k">if</span> len(pts) &gt; <span class="n">2</span> <span class="k">else</span> Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>))
+        t = <span class="n">0.5</span> + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        <span class="k">for</span> i <span class="k">in</span> g:
+            owner[i] = (t, tuple(d))
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        t, d = owner[poly.vertices[<span class="n">0</span>]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new(<span class="s">&quot;PlankTone&quot;</span>, <span class="s">&quot;FLOAT&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    a.data.foreach_set(<span class="s">&quot;value&quot;</span>, tone)
+    b = me.attributes.new(<span class="s">&quot;GrainDir&quot;</span>, <span class="s">&quot;FLOAT_VECTOR&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    b.data.foreach_set(<span class="s">&quot;vector&quot;</span>, [c <span class="k">for</span> v <span class="k">in</span> grain <span class="k">for</span> c <span class="k">in</span> v])
+
+
+<span class="k">def</span> _sock(sockets, identifier):
+    <span class="s">&quot;&quot;&quot;A Mix-node socket by identifier; its A/B/Result names repeat per type.&quot;&quot;&quot;</span>
+    <span class="k">return</span> next(sk <span class="k">for</span> sk <span class="k">in</span> sockets <span class="k">if</span> sk.identifier == identifier)
+
+
+<span class="k">def</span> wood_material(name):
+    <span class="s">&quot;&quot;&quot;Grain along each pole (``GrainDir``), tone per pole (``PlankTone``).&quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    gdir = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    gdir.attribute_name = <span class="s">&quot;GrainDir&quot;</span>
+    tone = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    tone.attribute_name = <span class="s">&quot;PlankTone&quot;</span>
+    dot = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    dot.operation = <span class="s">&quot;DOT_PRODUCT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], dot.inputs[<span class="n">0</span>])
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], dot.inputs[<span class="n">1</span>])
+    squash = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    squash.operation = <span class="s">&quot;MULTIPLY&quot;</span>
+    squash.inputs[<span class="n">1</span>].default_value = <span class="n">0.94</span>
+    nt.links.new(dot.outputs[<span class="s">&quot;Value&quot;</span>], squash.inputs[<span class="n">0</span>])
+    along = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    along.operation = <span class="s">&quot;SCALE&quot;</span>
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], along.inputs[<span class="n">0</span>])
+    nt.links.new(squash.outputs[<span class="s">&quot;Value&quot;</span>], along.inputs[<span class="s">&quot;Scale&quot;</span>])
+    grain_co = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    grain_co.operation = <span class="s">&quot;SUBTRACT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], grain_co.inputs[<span class="n">0</span>])
+    nt.links.new(along.outputs[<span class="s">&quot;Vector&quot;</span>], grain_co.inputs[<span class="n">1</span>])
+    shift = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    shift.operation = <span class="s">&quot;ADD&quot;</span>
+    nt.links.new(grain_co.outputs[<span class="s">&quot;Vector&quot;</span>], shift.inputs[<span class="n">0</span>])
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], shift.inputs[<span class="n">1</span>])
+    noise = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    noise.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = WOOD_GRAIN_SCALE
+    noise.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+    noise.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.62</span>
+    nt.links.new(shift.outputs[<span class="s">&quot;Vector&quot;</span>], noise.inputs[<span class="s">&quot;Vector&quot;</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.30</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.12</span>, <span class="n">0.052</span>, <span class="n">0.018</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.72</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.38</span>, <span class="n">0.18</span>, <span class="n">0.065</span>, <span class="n">1.0</span>)
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    gain = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    gain.operation = <span class="s">&quot;MULTIPLY_ADD&quot;</span>
+    gain.inputs[<span class="n">1</span>].default_value = <span class="n">1.1</span>
+    gain.inputs[<span class="n">2</span>].default_value = <span class="n">0.45</span>
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], gain.inputs[<span class="n">0</span>])
+    mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+    mix.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    _sock(mix.inputs, <span class="s">&quot;Factor_Float&quot;</span>).default_value = <span class="n">1.0</span>
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], _sock(mix.inputs, <span class="s">&quot;A_Color&quot;</span>))
+    nt.links.new(gain.outputs[<span class="s">&quot;Value&quot;</span>], _sock(mix.inputs, <span class="s">&quot;B_Color&quot;</span>))
+    nt.links.new(_sock(mix.outputs, <span class="s">&quot;Result_Color&quot;</span>), bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    rough = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rough.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = <span class="n">0.72</span>
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = <span class="n">0.52</span>
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], rough.inputs[<span class="s">&quot;Value&quot;</span>])
+    nt.links.new(rough.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> cauldron_materials():
+    <span class="s">&quot;&quot;&quot;(wood, iron): shared by the check, the render and inspection.
+
+    Cast iron is near-black and rough, with rust in the pores, not the
+    satin grey metal the pot first shipped with.
+    &quot;&quot;&quot;</span>
+    wood = wood_material(<span class="s">&quot;TripodWood&quot;</span>)
+    metal = principled(
+        <span class="s">&quot;CauldronIron&quot;</span>, (<span class="n">0.075</span>, <span class="n">0.072</span>, <span class="n">0.070</span>, <span class="n">1.0</span>), <span class="n">0.80</span>, <span class="n">0.58</span>,
+        noise_scale=<span class="n">22.0</span>, wear=(<span class="n">0.10</span>, <span class="n">0.055</span>, <span class="n">0.03</span>, <span class="n">1.0</span>),
+    )
+    <span class="k">return</span> wood, metal
+
+
 <span class="k">def</span> assign_slots(obj, wood, metal):
     mats = obj.data.materials
     wanted = (wood, metal)
@@ -1117,6 +1320,85 @@ <h2>Source</h2>
     <span class="k">return</span> {<span class="s">&quot;cups&quot;</span>: len(cups), <span class="s">&quot;cup_z&quot;</span>: cup_z}
 
 
+<span class="k">def</span> pot_form(me):
+    <span class="s">&quot;&quot;&quot;Base radius and belly height of the pot, from its outer wall.
+
+    The pot is the tallest wide iron shell. Its base radius is the widest
+    vertex on the lowest ring (the base centre excluded); the belly is
+    where the wall is widest, as a fraction of the pot&#x27;s height. A pot
+    that runs to a point has a base of a few millimetres.
+    &quot;&quot;&quot;</span>
+    best, best_r = <span class="k">None</span>, -<span class="n">1.0</span>
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        <span class="k">if</span> mat_of(me, g) != METAL_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        r = <span class="n">0.25</span> * ((a[<span class="n">3</span>] - a[<span class="n">0</span>]) + (a[<span class="n">4</span>] - a[<span class="n">1</span>]))
+        <span class="k">if</span> a[<span class="n">5</span>] - a[<span class="n">2</span>] &gt; <span class="n">0.20</span> <span class="k">and</span> r &gt; best_r:
+            best, best_r = (g, a), r
+    <span class="k">if</span> best <span class="k">is</span> <span class="k">None</span>:
+        <span class="k">return</span> <span class="n">0.0</span>, <span class="n">1.0</span>
+    g, a = best
+    z0 = a[<span class="n">2</span>]
+    base = max(
+        (math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) <span class="k">for</span> i <span class="k">in</span> g
+         <span class="k">if</span> me.vertices[i].co.z &lt; z0 + <span class="n">1e-4</span>),
+        default=<span class="n">0.0</span>,
+    )
+    widest = max(g, key=<span class="k">lambda</span> i: math.hypot(me.vertices[i].co.x, me.vertices[i].co.y))
+    belly = (me.vertices[widest].co.z - z0) / max(POT_H, <span class="n">1e-6</span>)
+    <span class="k">return</span> base, belly
+
+
+<span class="k">def</span> ear_threading(me):
+    <span class="s">&quot;&quot;&quot;How the bail passes the two ear rings.
+
+    The ear rings are the two small iron shells level with the mouth;
+    the bail is the iron shell spanning the pot. A ring vertex inside
+    the bail (by the nearest face&#x27;s normal) is bail running through the
+    ring&#x27;s tube; the bail must also come within the ring&#x27;s hole of its
+    centre. Returns (rings, ring verts inside the bail, worst centre gap).
+    &quot;&quot;&quot;</span>
+    rings, bail = [], <span class="k">None</span>
+    mouth = POT_Z0 + POT_H
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        <span class="k">if</span> mat_of(me, g) != METAL_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        <span class="k">if</span> max(dx, dy, dz) &lt; <span class="n">0.06</span> <span class="k">and</span> abs(<span class="n">0.5</span> * (a[<span class="n">2</span>] + a[<span class="n">5</span>]) - mouth) &lt; <span class="n">0.03</span>:
+            rings.append(g)
+        <span class="k">elif</span> dx &gt; <span class="n">0.25</span> <span class="k">and</span> dy &lt; <span class="n">0.05</span> <span class="k">and</span> a[<span class="n">2</span>] &gt; POT_Z0:
+            bail = g
+    <span class="k">if</span> bail <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> len(rings) != <span class="n">2</span>:
+        <span class="k">return</span> len(rings), <span class="n">99</span>, <span class="n">99.0</span>
+    bm_b = bmesh.new()
+    <span class="k">try</span>:
+        bm_b.from_mesh(me)
+        keep = set(bail)
+        drop = [f <span class="k">for</span> f <span class="k">in</span> bm_b.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        <span class="k">if</span> drop:
+            bmesh.ops.delete(bm_b, geom=drop, context=<span class="s">&quot;FACES&quot;</span>)
+        bm_b.normal_update()
+        tree = BVHTree.FromBMesh(bm_b)
+        inside, worst = <span class="n">0</span>, <span class="n">0.0</span>
+        <span class="k">for</span> g <span class="k">in</span> rings:
+            c = Vector()
+            <span class="k">for</span> i <span class="k">in</span> g:
+                c += me.vertices[i].co
+            c /= len(g)
+            <span class="k">for</span> i <span class="k">in</span> g:
+                p = me.vertices[i].co
+                loc, nrm, _idx, _d = tree.find_nearest(p)
+                <span class="k">if</span> loc <span class="k">is</span> <span class="k">not</span> <span class="k">None</span> <span class="k">and</span> nrm.dot(p - loc) &lt; <span class="n">0.0</span>:
+                    inside += <span class="n">1</span>
+            loc, _n, _i, d = tree.find_nearest(c)
+            worst = max(worst, d <span class="k">if</span> loc <span class="k">is</span> <span class="k">not</span> <span class="k">None</span> <span class="k">else</span> <span class="n">99.0</span>)
+        <span class="k">return</span> len(rings), inside, worst
+    <span class="k">finally</span>:
+        bm_b.free()
+
+
 <span class="k">def</span> pot_audit(me):
     groups = shells(me)
     best = <span class="k">None</span>
@@ -1363,23 +1645,22 @@ <h2>Source</h2>
     short_legs=<span class="k">False</span>,
     float_hook=<span class="k">False</span>,
     pipe_ferrule=<span class="k">False</span>,
+    pointed_pot=<span class="k">False</span>,
+    edge_on_ears=<span class="k">False</span>,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     flags = dict(
         short_legs=short_legs,
         float_hook=float_hook,
         pipe_ferrule=pipe_ferrule,
+        pointed_pot=pointed_pot,
+        edge_on_ears=edge_on_ears,
     )
     low = build_cauldron_mesh(<span class="s">&quot;CauldronLow&quot;</span>, **flags)
     high = build_cauldron_mesh(<span class="s">&quot;CauldronHigh&quot;</span>, **flags)
-    wood = principled(
-        <span class="s">&quot;TripodWood&quot;</span>, (<span class="n">0.38</span>, <span class="n">0.22</span>, <span class="n">0.09</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.58</span>,
-        noise_scale=<span class="n">6.0</span>, wear=(<span class="n">0.22</span>, <span class="n">0.12</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
-    )
-    metal = principled(
-        <span class="s">&quot;CauldronIron&quot;</span>, (<span class="n">0.10</span>, <span class="n">0.095</span>, <span class="n">0.09</span>, <span class="n">1.0</span>), <span class="n">0.92</span>, <span class="n">0.40</span>,
-        noise_scale=<span class="n">5.0</span>, wear=(<span class="n">0.18</span>, <span class="n">0.16</span>, <span class="n">0.14</span>, <span class="n">1.0</span>),
-    )
+    wood, metal = cauldron_materials()
+    paint_planks(low.data)
+    paint_planks(high.data)
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     <span class="k">if</span> stray_vert:
@@ -1441,6 +1722,10 @@ <h2>Source</h2>
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) <span class="k">if</span> os.path.isfile(export_path) <span class="k">else</span> <span class="n">0</span>
+    <span class="c"># Blender points TMPDIR at the working directory, so the export must not</span>
+    <span class="c"># outlive the measurement.</span>
+    <span class="k">if</span> os.path.exists(export_path):
+        os.remove(export_path)
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -1448,6 +1733,8 @@ <h2>Source</h2>
     pot = pot_audit(low.data)
     hj = hook_bail_join(low.data)
     bite = ferrule_bite(low.data)
+    base_r, belly = pot_form(low.data)
+    n_ears, ear_in, ear_gap = ear_threading(low.data)
 
     print(<span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>)
     print(
@@ -1476,6 +1763,8 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">pot_dia=</span>{pot[<span class="s">&#x27;dia&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> pot_h=</span>{pot[<span class="s">&#x27;height&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">hook_join=</span>{hj:<span class="s">.5f</span>}<span class="s"> ferrule_bite=</span>{bite:<span class="s">.5f</span>}<span class="s">&quot;</span>
     )
+    print(<span class="s">f&quot;</span><span class="s">measured pot_base_r=</span>{base_r:<span class="s">.4f</span>}<span class="s"> belly_at=</span>{belly:<span class="s">.3f</span>}<span class="s">&quot;</span>)
+    print(<span class="s">f&quot;</span><span class="s">measured ears=</span>{n_ears}<span class="s"> ring_verts_in_bail=</span>{ear_in}<span class="s"> ear_centre_gap=</span>{ear_gap:<span class="s">.5f</span>}<span class="s">&quot;</span>)
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
@@ -1568,6 +1857,13 @@ <h2>Source</h2>
             <span class="s">&quot;(--float-hook is the designed fail)&quot;</span>,
             <span class="n">17</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> n_ears != <span class="n">2</span> <span class="k">or</span> ear_in <span class="k">or</span> ear_gap &gt; EAR_MAJOR - EAR_MINOR:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">ears </span>{n_ears}<span class="s">: </span>{ear_in}<span class="s"> ring vertices inside the bail, bail </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span>{ear_gap:<span class="s">.5f</span>}<span class="s"> from a ring centre (hole </span>{EAR_MAJOR - EAR_MINOR:<span class="s">.4f</span>}<span class="s">) </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--edge-on-ears is the designed fail)&quot;</span>,
+            <span class="n">17</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> <span class="k">not</span> (FERRULE_BITE_MIN &lt;= bite &lt;= FERRULE_BITE_MAX):
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">ferrule bite </span>{bite:<span class="s">.5f</span>}<span class="s"> not in </span><span class="s">&quot;</span>
@@ -1585,6 +1881,13 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">pot height </span>{pot[<span class="s">&#x27;height&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_H}<span class="s">&quot;</span>,
             <span class="n">19</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> base_r &lt; POT_BASE_MIN <span class="k">or</span> belly &gt; POT_BELLY_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">pot form: base radius </span>{base_r:<span class="s">.4f</span>}<span class="s"> &lt; </span>{POT_BASE_MIN}<span class="s"> or belly at </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span>{belly:<span class="s">.3f</span>}<span class="s"> of the height &gt; </span>{POT_BELLY_MAX}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--pointed-pot is the designed fail)&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1704,6 +2007,8 @@ <h2>Source</h2>
     p.add_argument(<span class="s">&quot;--short-legs&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--float-hook&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--pipe-ferrule&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--pointed-pot&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--edge-on-ears&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1713,6 +2018,8 @@ <h2>Source</h2>
         short_legs=args.short_legs,
         float_hook=args.float_hook,
         pipe_ferrule=args.pipe_ferrule,
+        pointed_pot=args.pointed_pot,
+        edge_on_ears=args.edge_on_ears,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1737,7 +2044,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/iron-cauldron-hero.webp" alt="A black iron cauldron hanging from a tripod of wooden poles." />
+    <img src="../assets/iron-cauldron-hero.webp" alt="A round-bellied black iron cauldron hanging by its bail from a tripod of wooden poles." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/usd-export-evaluation-mode/index.html b/docs/gallery/usd-export-evaluation-mode/index.html
index a624f24e..4c01f04c 100644
--- a/docs/gallery/usd-export-evaluation-mode/index.html
+++ b/docs/gallery/usd-export-evaluation-mode/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/usd-export-evaluation-mode-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Two grey spheres: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." />
+  <meta property="og:image:alt" content="Two steel balls resting on the floor: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="usd-export-evaluation-mode — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="The USD exporter evaluation_mode chooses viewport versus render modifier quality. TESSELLATE makes the split observable; BEST_MATCH writes the cage and the mode is silent." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/usd-export-evaluation-mode-hero.webp" />
-  <meta name="twitter:image:alt" content="Two grey spheres: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." />
+  <meta name="twitter:image:alt" content="Two steel balls resting on the floor: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." />
   <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>usd-export-evaluation-mode</h1>
     <p>The USD exporter evaluation_mode chooses viewport versus render modifier quality. TESSELLATE makes the split observable; BEST_MATCH writes the cage and the mode is silent.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Two grey spheres: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right.">
-      <img src="../assets/usd-export-evaluation-mode-hero.webp" alt="Two grey spheres: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Two steel balls resting on the floor: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right.">
+      <img src="../assets/usd-export-evaluation-mode-hero.webp" alt="Two steel balls resting on the floor: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." 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> TESSELLATE+VIEWPORT writes 26/24; TESSELLATE+RENDER writes 98/96 subdivisionScheme=none; BEST_MATCH writes the 8-vert catmullClark cage. --evaluation-mode VIEWPORT and --subdivision BEST_MATCH exit 4.</div>
@@ -283,7 +283,7 @@ <h1>usd-export-evaluation-mode</h1>
 <p>The still is numeric-adjacent: left is viewport tessellation (flat-shaded L1), right is render tessellation (smoothed L2). The USDA point counts are the evidence; the two balls depict the two qualities the exporter chooses between.</p>
 <p><strong>What failure each check would catch:</strong></p>
 <ul><li>exit 3 — VIEWPORT TESSELLATE did not write the L1 closed form</li><li>exit 4 — RENDER TESSELLATE wrote viewport quality or the BEST_MATCH cage (<code>--evaluation-mode VIEWPORT</code> measured 26/24; <code>--subdivision BEST_MATCH</code> measured 8/6 <code>catmullClark</code>)</li><li>exit 5 — BEST_MATCH stopped writing the cage</li><li>exit 6 — RENDER and VIEWPORT files are identical</li></ul>
-<p>The still depicts viewport vs render tessellation of the same SUBSURF cube (flat-shaded L1 vs smoothed L2). The USDA point counts are the evidence.</p>
+<p>Staging: Catmull-Clark pulls the surface inside the 2 m cage, and level 1 and level 2 shrink by different amounts, so both balls used to hover about 0.16 m over the floor at the cage&#x27;s z = 1.0. The render path now rests each one on the floor from its own evaluated vertices (measured zmin 0.000000 for both), after the check has run.</p>
 <p>Probed on the CI Linux portables <strong>Blender 5.2.1 LTS</strong> (<code>9e2066aef7ef</code>) and <strong>Blender 4.5.13 LTS</strong> (<code>daeeeca98fb0</code>): <code>wm.usd_export</code> exists, <code>poll()</code> is true in <code>--background</code>, <code>evaluation_mode</code> is <code>{RENDER, VIEWPORT}</code>. The <code>--output</code> render path measures framing via <code>examples/gallery_framing.py</code> (exit 10 on violation).</p>
 <h2>Run</h2>
 <pre><code>blender --background --python usd_export_evaluation_mode.py --
@@ -319,6 +319,7 @@ <h2>Source</h2>
     blender --background --python usd_export_evaluation_mode.py -- --output u.png
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse, tempfile
+<span class="k">from</span> mathutils <span class="k">import</span> Vector
 
 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>
@@ -523,6 +524,19 @@ <h2>Source</h2>
     rm.render_levels = LEVEL_RD
     <span class="k">for</span> poly <span class="k">in</span> right.data.polygons:
         poly.use_smooth = <span class="k">True</span>
+    <span class="c"># Subdivision pulls the surface inside the 2 m cage, so at z = 1.0 both</span>
+    <span class="c"># ingots hovered above the floor. Rest each on z = 0 from its own</span>
+    <span class="c"># evaluated bounds (level 1 and level 2 shrink by different amounts).</span>
+    bpy.context.view_layer.update()
+    dg = bpy.context.evaluated_depsgraph_get()
+    <span class="k">for</span> ob <span class="k">in</span> (left, right):
+        ev = ob.evaluated_get(dg)
+        em = ev.to_mesh()
+        <span class="k">try</span>:
+            zmin = min((ev.matrix_world @ v.co).z <span class="k">for</span> v <span class="k">in</span> em.vertices)
+        <span class="k">finally</span>:
+            ev.to_mesh_clear()
+        ob.location.z -= zmin
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -556,12 +570,12 @@ <h2>Source</h2>
         ob.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
         scene.collection.objects.link(ob)
 
-    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">200.0</span>, <span class="n">7.0</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">46</span>, <span class="n">0</span>, -<span class="n">35</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">420.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">46</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">3.0</span>), <span class="n">180.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">62</span>, <span class="n">0</span>, <span class="n">50</span>))
     light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.5</span>, <span class="n">5.5</span>, <span class="n">4.0</span>), <span class="n">360.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>))
 
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.78</span>)
     aim.hide_render = <span class="k">True</span>
     scene.collection.objects.link(aim)
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
@@ -649,7 +663,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/usd-export-evaluation-mode-hero.webp" alt="Two grey spheres: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." />
+    <img src="../assets/usd-export-evaluation-mode-hero.webp" alt="Two steel balls resting on the floor: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/gallery.json b/examples/gallery.json
index f59c399d..474bd74a 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -139,7 +139,7 @@
       "name": "gn-modifier-inputs",
       "dir": "examples/gn-modifier-inputs",
       "teaches": "Per-modifier Geometry Nodes Float inputs on a shared tree — 4.5/5.1 write mod[identifier], 5.2 writes mod.properties.inputs.Socket_1.value.",
-      "alt": "Three boxes stepping up in size from a small teal cube to an orange block to a large red block.",
+      "alt": "Three separate cubes stepping up in size from left to right: a small teal cube, an orange block and a large red block.",
       "witnessesFix": "The 5.1 dict form raises TypeError on 5.2 rather than silently no-opping; RNA properties are AttributeError on 4.5. Readback and evaluated Z-extent match written scales 1/2/3.",
       "hero": "docs/gallery/assets/gn-modifier-inputs-hero.webp",
       "preview": "examples/gn-modifier-inputs/preview.webp",
@@ -645,7 +645,7 @@
       "name": "usd-export-evaluation-mode",
       "dir": "examples/usd-export-evaluation-mode",
       "teaches": "The USD exporter evaluation_mode chooses viewport versus render modifier quality. TESSELLATE makes the split observable; BEST_MATCH writes the cage and the mode is silent.",
-      "alt": "Two grey spheres: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right.",
+      "alt": "Two steel balls resting on the floor: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right.",
       "witnessesFix": "TESSELLATE+VIEWPORT writes 26/24; TESSELLATE+RENDER writes 98/96 subdivisionScheme=none; BEST_MATCH writes the 8-vert catmullClark cage. --evaluation-mode VIEWPORT and --subdivision BEST_MATCH exit 4.",
       "hero": "docs/gallery/assets/usd-export-evaluation-mode-hero.webp",
       "preview": "examples/usd-export-evaluation-mode/preview.webp",
diff --git a/examples/gn-modifier-inputs/README.md b/examples/gn-modifier-inputs/README.md
index 39cc4652..a40cc211 100644
--- a/examples/gn-modifier-inputs/README.md
+++ b/examples/gn-modifier-inputs/README.md
@@ -16,6 +16,12 @@ must be updated or `evaluated_get` still sees the previous scale.
 
 Follows [`geometry-nodes-python`](../../skills/geometry-nodes-python/SKILL.md).
 
+Staging: the carriers now stand 0.5 m apart (`XS`). The old spacing
+overlapped the 2 m and 3 m cubes by 0.2 m. The check reads only each
+cube's evaluated Z extent and zmin, never X, so this is layout only. The
+camera looks from the front, so small to large reads left to right, and a
+duller finish keeps the tops from blowing out.
+
 ## Run
 
 ```bash
diff --git a/examples/gn-modifier-inputs/gn_modifier_inputs.py b/examples/gn-modifier-inputs/gn_modifier_inputs.py
index d8f8d9d0..0d9b9df0 100644
--- a/examples/gn-modifier-inputs/gn_modifier_inputs.py
+++ b/examples/gn-modifier-inputs/gn_modifier_inputs.py
@@ -36,8 +36,10 @@
 
 CUBE_SIZE = 1.0
 SCALES = (1.0, 2.0, 3.0)
-# Half-widths 0.5 / 1.0 / 1.5; keep a clear gap, keep the 3 m cube off the right edge.
-XS = (-2.2, 0.15, 2.45)
+# Half-widths 0.5 / 1.0 / 1.5, with 0.5 m between neighbours. The old
+# (-2.2, 0.15, 2.45) overlapped the 2 m and 3 m cubes by 0.2 m. The check
+# reads only Z extents, so the layout is free.
+XS = (-2.6, -0.6, 2.4)
 COLORS = (
     (0.05, 0.62, 0.58, 1.0),  # teal
     (0.82, 0.38, 0.08, 1.0),  # copper
@@ -83,8 +85,8 @@ def make_material(name, color):
     mat.use_nodes = True
     bsdf = mat.node_tree.nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = color
-    bsdf.inputs["Roughness"].default_value = 0.28
-    bsdf.inputs["Metallic"].default_value = 0.35
+    bsdf.inputs["Roughness"].default_value = 0.45
+    bsdf.inputs["Metallic"].default_value = 0.1
     return mat
 
 
@@ -293,7 +295,7 @@ def render_still(objs, path, engine):
     scene.world = world
 
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.35, 0.0, 1.25)
+    aim.location = (0.25, 0.0, 1.1)
     scene.collection.objects.link(aim)
 
     def light(name, loc, energy, size, col):
@@ -309,7 +311,7 @@ def light(name, loc, energy, size, col):
         lc.track_axis = "TRACK_NEGATIVE_Z"
         lc.up_axis = "UP_Y"
 
-    light("Key", (-3.8, -5.0, 6.2), 560.0, 5.0, (1.0, 0.96, 0.9))
+    light("Key", (-5.5, -6.0, 5.2), 380.0, 6.0, (1.0, 0.96, 0.9))
     light("Fill", (5.4, -3.2, 2.4), 110.0, 8.0, (0.75, 0.85, 1.0))
     light("Rim", (0.4, 6.4, 3.8), 280.0, 3.5, (0.6, 0.78, 1.0))
     wedge = bpy.data.lights.new("Wedge", "AREA")
@@ -324,7 +326,7 @@ def light(name, loc, energy, size, col):
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (8.1, -10.8, 5.05)
+    cam.location = (1.6, -12.4, 6.6)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new("TRACK_TO")
diff --git a/examples/gn-modifier-inputs/preview.webp b/examples/gn-modifier-inputs/preview.webp
index ddf547f8..fdef03bb 100644
Binary files a/examples/gn-modifier-inputs/preview.webp and b/examples/gn-modifier-inputs/preview.webp differ
diff --git a/examples/usd-export-evaluation-mode/README.md b/examples/usd-export-evaluation-mode/README.md
index 8cab6331..e897bc63 100644
--- a/examples/usd-export-evaluation-mode/README.md
+++ b/examples/usd-export-evaluation-mode/README.md
@@ -26,8 +26,11 @@ between.
 - exit 5 — BEST_MATCH stopped writing the cage
 - exit 6 — RENDER and VIEWPORT files are identical
 
-The still depicts viewport vs render tessellation of the same SUBSURF cube
-(flat-shaded L1 vs smoothed L2). The USDA point counts are the evidence.
+Staging: Catmull-Clark pulls the surface inside the 2 m cage, and level 1
+and level 2 shrink by different amounts, so both balls used to hover about
+0.16 m over the floor at the cage's z = 1.0. The render path now rests each
+one on the floor from its own evaluated vertices (measured zmin 0.000000
+for both), after the check has run.
 
 Probed on the CI Linux portables **Blender 5.2.1 LTS** (`9e2066aef7ef`) and
 **Blender 4.5.13 LTS** (`daeeeca98fb0`): `wm.usd_export` exists, `poll()` is
diff --git a/examples/usd-export-evaluation-mode/preview.webp b/examples/usd-export-evaluation-mode/preview.webp
index 44bae881..f7bc0549 100644
Binary files a/examples/usd-export-evaluation-mode/preview.webp and b/examples/usd-export-evaluation-mode/preview.webp differ
diff --git a/examples/usd-export-evaluation-mode/usd_export_evaluation_mode.py b/examples/usd-export-evaluation-mode/usd_export_evaluation_mode.py
index 6e37dbbf..0d5de5f8 100644
--- a/examples/usd-export-evaluation-mode/usd_export_evaluation_mode.py
+++ b/examples/usd-export-evaluation-mode/usd_export_evaluation_mode.py
@@ -18,6 +18,7 @@
     blender --background --python usd_export_evaluation_mode.py -- --output u.png
 """
 import bpy, bmesh, sys, os, math, argparse, tempfile
+from mathutils import Vector
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 sys.dont_write_bytecode = True
@@ -222,6 +223,19 @@ def render_still(obj, path, engine):
     rm.render_levels = LEVEL_RD
     for poly in right.data.polygons:
         poly.use_smooth = True
+    # Subdivision pulls the surface inside the 2 m cage, so at z = 1.0 both
+    # ingots hovered above the floor. Rest each on z = 0 from its own
+    # evaluated bounds (level 1 and level 2 shrink by different amounts).
+    bpy.context.view_layer.update()
+    dg = bpy.context.evaluated_depsgraph_get()
+    for ob in (left, right):
+        ev = ob.evaluated_get(dg)
+        em = ev.to_mesh()
+        try:
+            zmin = min((ev.matrix_world @ v.co).z for v in em.vertices)
+        finally:
+            ev.to_mesh_clear()
+        ob.location.z -= zmin
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -255,12 +269,12 @@ def light(name, loc, energy, size, col, rot):
         ob.rotation_euler = tuple(math.radians(a) for a in rot)
         scene.collection.objects.link(ob)
 
-    light("Key", (-4.0, -5.0, 6.0), 200.0, 7.0, (1.0, 0.96, 0.9), (46, 0, -35))
+    light("Key", (-4.0, -5.0, 6.0), 420.0, 5.0, (1.0, 0.96, 0.9), (46, 0, -35))
     light("Fill", (5.0, -3.5, 3.0), 180.0, 9.0, (0.75, 0.85, 1.0), (62, 0, 50))
     light("Wedge", (2.5, 5.5, 4.0), 360.0, 6.0, (1.0, 0.76, 0.5), (-68, 0, 190))
 
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 1.0)
+    aim.location = (0.0, 0.0, 0.78)
     aim.hide_render = True
     scene.collection.objects.link(aim)
     cam_data = bpy.data.cameras.new("Cam")
diff --git a/showcase/README.md b/showcase/README.md
index 4721e1d9..dd611bd8 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -438,6 +438,25 @@ entry in `showcase/gallery.json`, and a rendered still.
   off the plate and its body through it. Size the offset from the thing
   passing through, and assert that no vertex of it lies inside the mount.
   `--sunk-rope` restores the old offset.
+- **A ring is threaded across its hole, never in its plane (exit 17).**
+  `iron-cauldron`'s ear rings stood in the bail's own plane, so the bail
+  ran through each ring's tube. Orient a ring so its hole axis follows
+  whatever passes through it at that point. Assert that no ring vertex
+  lies inside the thing passing through, by the nearest face's normal,
+  and that it passes within the hole. `--edge-on-ears` is the falsifier.
+- **A vessel has a base and a belly (exit 19).** A profile interpolated
+  from a tiny bottom radius runs to a point: the cauldron was an onion.
+  Build the belly from a stated base radius and belly height, offset the
+  inner wall along the profile's normal (a sideways offset thins the
+  wall to nothing where it runs flat), and assert the base radius and
+  where the widest ring sits. `--pointed-pot` is the falsifier.
+- **Stones are lumps, and no two match (file-local code).** A curved
+  brick with a flat top reads as a kerb. Loft a chamfered section that
+  swells mid-stone and pinches at capped ends, with seeded radial offset
+  and a crown on the top course. Keep the beds flat so courses still
+  seat. Assert the spread of stone radii (and top-course crowns) clears a
+  floor; the falsifier gives every stone the same draw at the jitter's
+  upper bound, so the envelope stays put (`--uniform-stones`).
 - **A section that carries the read is a budget (exit 19).** Where a
   cross-section is what makes a part recognisable — an axe handle is
   oval, a broom handle is round — assert it as a ratio band at a named
diff --git a/showcase/campfire/README.md b/showcase/campfire/README.md
index bd54875d..a1723304 100644
--- a/showcase/campfire/README.md
+++ b/showcase/campfire/README.md
@@ -1,7 +1,8 @@
 # Campfire
 
 A showcase piece, not an example. Procedural campfire (two-course
-running-bond stone ring of 14 barrelled wedges, pit-floor cobbles, ash,
+running-bond ring of 14 rounded fieldstones per course, pit-floor
+cobbles, ash with embers,
 a kissing log tripod that overshoots a shared apex ring, floor logs,
 and charcoal) then the shipped pipeline: unique-cell UVs, Cycles
 high-to-low normal bake, LOD chain, convex collider, Unity glTF export.
@@ -26,25 +27,28 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 1400–3600 | 2200 / 2200 / 2200 |
-| LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2200 / 0.2200 / 0.2200 |
-| Materials | exactly 3 distinct; ≥80 wood, ≥24 ash, ≥200 stone | 3 slots; 216 / 48 / 1304 |
+| Base triangles | 1400–3600 | 2760 / 2760 / 2760 |
+| LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.4993 |
+| LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2196 |
+| Materials | exactly 3 distinct; ≥80 wood, ≥24 ash, ≥200 stone | 3 slots; 216 / 48 / 1416 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.807, 0.808, 0.404) m ± 0.015 | (0.8069, 0.8079, 0.4037), zmin 0 |
-| Collider tris | ≤ 360 | 198 |
-| Export | written, size > 0 | 206244 / 206244 / 206236 bytes |
+| Outer AABB | (0.807, 0.808, 0.404) m ± 0.015 | (0.8024, 0.8022, 0.4037), zmin 0 |
+| Collider tris | ≤ 360 | 162 |
+| Export | written, size > 0 | 231952 / 231952 / 231944 bytes |
 
 Base triangles dropped from **3616 to 2200** in the quality pass: the
 old piece stacked identical boxes with a mortar gap and a teepee that
 met at one point. The rebuild is two seated courses plus crossing
-sticks; hidden overlapping volume went away.
+sticks; hidden overlapping volume went away. The second pass took it to
+**2760**: each stone is now a lofted, chamfered lump instead of a
+four-sided wedge.
 
 DECIMATE COLLAPSE triangle counts are **not** guaranteed identical across
 series — the gate is a ratio band, not an exact count. Bake pixels are
 stochastic; the gate is `has_data` plus operator `FINISHED`, not
-byte-identity. Stone-width jitter uses fixed seed 17. glTF byte size
-differs by 8 B on 5.2.1.
+byte-identity. Stone-width jitter uses fixed seed 17; each stone's
+shape draws from its own seeded generator. glTF byte size differs on
+5.2.1.
 
 ### Hygiene
 
@@ -60,18 +64,40 @@ Recomputed from the generated mesh, not asserted about the script.
 | Coplanar disjoint face pairs | 0 | 0 |
 | Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
 | Named supports: 14 bottom stones | each `zmin` ≤ 0.001 | 14, stone_z 0.00000 |
-| Ring plan | 0.807 m dia × 0.156 m high ± 0.04 | 0.8074 × 0.1560 |
+| Ring plan | 0.807 m dia × 0.176 m high ± 0.04 | 0.8023 × 0.1759 |
+| **Stone variation** (exit 20) | per course, spread of stone outer radius, and of crown height on the top course, each ≥ 0.006 m | 0.01269 (smallest spread) |
 
 ### Joint fit and seat
 
 | Axis | Declared | Measured (all three) |
 | --- | --- | --- |
-| Teepee kiss (BVH nearest at caps) | ≤ 0.008 m | 0.00001 |
+| Teepee kiss (BVH nearest at caps) | ≤ 0.008 m | 0.00034 |
 | Course seat (upper zmin − lower zmax) | abs ≤ 0.004 m | 0.00000 |
 
+### Stones, wood and ash
+
+The ring was 28 identical curved bricks: flat tops, flat faces, one
+height, one grey. It read as a concrete kerb. Each stone is now a
+chamfered octagon section lofted along its span, swelling to a seeded
+belly mid-stone and pinched and capped at the ends, with a seeded
+radial offset and outer-face wobble. Top-course stones get a seeded
+domed crown. The beds stay flat, and the bottom course's crown stays at
+the bed height, so the upper course still seats (course seat 0.00000).
+The stated ring height rose from 0.156 to 0.176 m for the crowns.
+
+**Stone variation** asserts the ring is not one stone repeated.
+`--uniform-stones` gives every stone the same draw — each jitter at its
+upper bound, so the ring keeps the envelope of its widest seeded stone
+and only this budget fails (exit 20, spread 0.00000).
+
+Stone is isotropic mottling, speckle and pitting with a seeded tone per
+stone (`stone-archway`'s recipe, reading `PieceTone`); sticks and logs
+carry their own tone and grain along their axis; the ash has sparse
+ember glow. The temp `.glb` is removed after its size is measured.
+
 ### Falsifiers
 
-Each violates one named budget. All six were run on 4.5.11, 5.1.2 and
+Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
 5.2.1 and returned the same code on each.
 
 | Flag | Budget violated | Exit |
@@ -82,6 +108,7 @@ Each violates one named budget. All six were run on 4.5.11, 5.1.2 and
 | `--short-stones` | named bottom-course supports at Z=0 | 16 |
 | `--float-logs` | teepee kiss | 17 |
 | `--gap-courses` | course seat | 18 |
+| `--uniform-stones` | stone variation | 20 |
 
 ## Run
 
@@ -93,6 +120,7 @@ blender --background --python campfire.py -- --lift-z
 blender --background --python campfire.py -- --short-stones
 blender --background --python campfire.py -- --float-logs
 blender --background --python campfire.py -- --gap-courses
+blender --background --python campfire.py -- --uniform-stones
 blender --background --python campfire.py -- --output campfire.png
 ```
 
@@ -102,7 +130,7 @@ Smoke passes no flags.
 
 File-local. `9` is a valid check code. `10` is reserved for
 `gallery_framing.check_framing` on the `--output` path. `15`–`19` are the
-hygiene and joint-fit family.
+hygiene and joint-fit family; `20` is file-local.
 
 | Code | Meaning |
 | --- | --- |
@@ -126,3 +154,4 @@ hygiene and joint-fit family.
 | 17 | Joint fit: teepee kiss (`--float-logs`) |
 | 18 | Seat: course gap (`--gap-courses`) |
 | 19 | Ring diameter or height off the stated real-world size |
+| 20 | Stone variation: the ring stones are identical (`--uniform-stones`) |
diff --git a/showcase/campfire/campfire.py b/showcase/campfire/campfire.py
index 9711405f..e59e98da 100644
--- a/showcase/campfire/campfire.py
+++ b/showcase/campfire/campfire.py
@@ -52,7 +52,17 @@
 R_MID = 0.5 * (R_INNER + R_OUTER)
 STONE_H = 0.078
 STONE_SEED = 17
-STONE_JITTER = 0.10
+STONE_JITTER = 0.22
+# Each ring stone is a lofted chamfered section, not a curved brick: a
+# seeded belly and radial offset, rounded ends pinched to END_PINCH, and
+# (upper course only) a domed crown. Beds stay flat so the courses seat.
+STONE_R_JITTER = 0.012
+STONE_BULGE = 0.14
+STONE_WOBBLE = 0.05
+STONE_DOME = 0.020
+END_PINCH = 0.62
+STONE_CHAMFER = 0.28
+STONE_VARY_MIN = 0.006
 GAP_ANG = 0.004
 N_COBBLES = 12
 COBBLE_H = 0.016
@@ -80,7 +90,7 @@
 ZFIGHT_COS = 0.998
 BODY_TOL = 0.04
 RING_DIA = 0.807
-RING_H = 0.156
+RING_H = 0.176
 BBOX_TOL = 0.015
 OUTER_SIZE = (0.807, 0.808, 0.404)
 
@@ -107,6 +117,11 @@
 WOOD_IDX = 1
 ASH_IDX = 2
 
+# Per-piece tone jitter and wood grain frequency, as in shipping-crate.
+PLANK_TONE_JITTER = 0.25
+TONE_SEED = 29
+WOOD_GRAIN_SCALE = 45.0
+
 
 def eevee_engine_id():
     return "BLENDER_EEVEE" if bpy.app.version >= (5, 0, 0) else "BLENDER_EEVEE_NEXT"
@@ -147,46 +162,52 @@ def stone_spans(n, gap_ang, jitter, seed):
     return spans
 
 
-def add_wedge(bm, a0, a1, r_in, r_out, z0, z1, mat_idx, lump=0.0):
-    mid_z = 0.5 * (z0 + z1)
-    mid_ang = 0.5 * (a0 + a1)
-    layers = (
-        (z0, 0.985, 0.0),
-        (mid_z, 1.025, lump),
-        (z1, 0.97, 0.0),
-    )
+def add_stone(bm, a0, a1, z0, z1, rng, crown, stations, mat_idx):
+    """One ring stone: a chamfered octagon section lofted from a0 to a1.
+
+    The section's width swells to a seeded belly mid-stone and pinches to
+    END_PINCH at the ends, which are capped, so each stone is a rounded
+    lump rather than a curved brick. The bed (z0) is flat on every stone.
+    The crown is flat at z1 on the lower course, which the upper course
+    sits on, and domed by a seeded ``crown`` on the upper course.
+    """
+    r_in = R_INNER + rng.uniform(-STONE_R_JITTER, STONE_R_JITTER)
+    r_out = R_OUTER + rng.uniform(-STONE_R_JITTER, STONE_R_JITTER)
+    bulge = rng.uniform(0.3, 1.0) * STONE_BULGE
+    phase = rng.uniform(0.0, 2.0 * math.pi)
+    top = z1 + crown
     rings = []
-    for z, r_scale, lp in layers:
-        ring = []
-        for ang, r in (
-            (a0, r_in),
-            (a1, r_in),
-            (a1, r_out * r_scale),
-            (a0, r_out * r_scale),
-        ):
-            x = r * math.cos(ang)
-            y = r * math.sin(ang)
-            if lp > 0.0 and r > 0.5 * (r_in + r_out):
-                h = math.sin(ang * 5.0 + z * 17.0 + mid_ang * 3.0)
-                scale = 1.0 + lp * max(-0.7, min(0.7, h))
-                x *= scale
-                y *= scale
-            ring.append(bm.verts.new((x, y, z)))
-        rings.append(ring)
-    verts = [v for ring in rings for v in ring]
-    for k in range(len(rings) - 1):
+    for k in range(stations):
+        t = k / (stations - 1)
+        ang = a0 + (a1 - a0) * t
+        sw = math.sin(math.pi * t)
+        pinch = END_PINCH + (1.0 - END_PINCH) * math.sqrt(sw)
+        cr = 0.5 * (r_in + r_out)
+        hw = 0.5 * (r_out - r_in) * pinch * (1.0 + bulge * sw)
+        lo = cr - hw
+        hi = cr + hw * (1.0 + STONE_WOBBLE * math.sin(phase + 3.0 * math.pi * t))
+        zt = z0 + (top - z0) * (0.80 + 0.20 * sw)
+        c = STONE_CHAMFER * min(hi - lo, zt - z0) * 0.5
+        section = (
+            (lo + c, z0), (hi - c, z0), (hi, z0 + c), (hi, zt - c),
+            (hi - c, zt), (lo + c, zt), (lo, zt - c), (lo, z0 + c),
+        )
+        ca, sa = math.cos(ang), math.sin(ang)
+        rings.append([bm.verts.new((r * ca, r * sa, z)) for r, z in section])
+    n = len(rings[0])
+    for k in range(stations - 1):
         a, b = rings[k], rings[k + 1]
-        for i in range(4):
-            j = (i + 1) % 4
-            face = bm.faces.new((a[i], a[j], b[j], b[i]))
-            face.material_index = mat_idx
-    bot = rings[0]
-    top = rings[-1]
-    face = bm.faces.new((bot[0], bot[3], bot[2], bot[1]))
-    face.material_index = mat_idx
-    face = bm.faces.new((top[0], top[1], top[2], top[3]))
-    face.material_index = mat_idx
-    return verts
+        for i in range(n):
+            j = (i + 1) % n
+            f = bm.faces.new((a[i], a[j], b[j], b[i]))
+            f.material_index = mat_idx
+    for ring, flip in ((rings[0], False), (rings[-1], True)):
+        hub = bm.verts.new(sum((v.co for v in ring), Vector()) / n)
+        for i in range(n):
+            vs = (hub, ring[(i + 1) % n], ring[i])
+            f = bm.faces.new(tuple(reversed(vs)) if flip else vs)
+            f.material_index = mat_idx
+    return [v for ring in rings for v in ring]
 
 
 def add_cyl_between(bm, a, b, r0, r1, segs, mat_idx):
@@ -292,6 +313,7 @@ def build_campfire_mesh(
     short_stones=False,
     float_logs=False,
     gap_courses=False,
+    uniform_stones=False,
 ):
     bm = bmesh.new()
     spans = stone_spans(N_AROUND, GAP_ANG, STONE_JITTER, STONE_SEED)
@@ -299,49 +321,28 @@ def build_campfire_mesh(
     extra = COURSE_GAP if gap_courses else 0.0
     stone_verts = []
     try:
+        # --uniform-stones gives every stone the same draw: each jitter at its
+        # upper bound, so the stones are identical but the ring keeps the
+        # envelope of its widest seeded stone.
+        class _Flat:
+            def uniform(self, a, b):
+                return b
+
+        stations = 3 + bevel_segments
         for row in range(N_ROWS):
             z0 = z_ground + row * STONE_H + (extra if row else 0.0)
             z1 = z0 + STONE_H
             rot_off = (row % 2) * (math.pi / N_AROUND)
-            for a0, a1 in spans:
+            for idx, (a0, a1) in enumerate(spans):
+                rng = _Flat() if uniform_stones else random.Random(STONE_SEED * 31 + row * 101 + idx)
+                crown = STONE_DOME * rng.uniform(0.35, 1.0) if row == N_ROWS - 1 else 0.0
                 stone_verts.extend(
-                    add_wedge(
-                        bm,
-                        a0 + rot_off,
-                        a1 + rot_off,
-                        R_INNER,
-                        R_OUTER,
-                        z0,
-                        z1,
-                        STONE_IDX,
-                        lump=0.022,
+                    add_stone(
+                        bm, a0 + rot_off, a1 + rot_off, z0, z1, rng, crown,
+                        stations, STONE_IDX,
                     )
                 )
 
-        if bevel_offset > 0.0:
-            vertical = []
-            seen = set()
-            for v in stone_verts:
-                for e in v.link_edges:
-                    if e in seen:
-                        continue
-                    seen.add(e)
-                    a, b = e.verts
-                    if abs(a.co.z - b.co.z) > 0.02:
-                        vertical.append(e)
-            if vertical:
-                ret = bmesh.ops.bevel(
-                    bm,
-                    geom=vertical,
-                    offset=min(bevel_offset, 0.008),
-                    segments=bevel_segments,
-                    profile=0.5,
-                    affect="EDGES",
-                    clamp_overlap=True,
-                )
-                for f in ret.get("faces") or []:
-                    f.material_index = STONE_IDX
-
         add_ash_disk(bm, ASH_R, ASH_H, 16, ASH_IDX)
         rng = random.Random(STONE_SEED)
         for i in range(N_COBBLES):
@@ -701,6 +702,244 @@ def teepee_kiss(me):
             bm_s.free()
 
 
+def stone_variation(me):
+    """Spread of the ring stones' crowns and outer radii, in metres.
+
+    Identical stones read instantly as CG. Across the stones of each
+    course, the spread (max - min) of each stone's top and of its outer
+    radius is measured from the mesh; the smaller of the two spreads,
+    over both courses, must clear STONE_VARY_MIN.
+    """
+    courses = {}
+    for g in shells(me):
+        if mat_of(me, g) != STONE_IDX:
+            continue
+        a = shell_aabb(me, g)
+        if a[5] - a[2] < 0.05:
+            continue
+        top = a[5]
+        r_out = max(math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) for i in g)
+        row = 0 if 0.5 * (a[2] + a[5]) < STONE_H else 1
+        courses.setdefault(row, []).append((top, r_out))
+    spreads = []
+    for row, vals in courses.items():
+        tops = [v[0] for v in vals]
+        radii = [v[1] for v in vals]
+        if row == N_ROWS - 1:
+            spreads.append(max(tops) - min(tops))
+        spreads.append(max(radii) - min(radii))
+    return min(spreads, default=0.0)
+
+
+def _long_axis(pts):
+    """Principal axis of a point set, by power iteration on its covariance."""
+    c = sum(pts, Vector()) / len(pts)
+    cov = [[0.0] * 3 for _ in range(3)]
+    for p in pts:
+        d = p - c
+        for i in range(3):
+            for j in range(3):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((1.0, 0.3, 0.1))
+    for _ in range(30):
+        w = Vector([sum(cov[i][j] * v[j] for j in range(3)) for i in range(3)])
+        if w.length < 1e-12:
+            break
+        v = w.normalized()
+    return v
+
+
+def paint_pieces(me):
+    """Per-shell ``PieceTone`` and ``GrainDir`` face attributes.
+
+    Every stone, stick and log is its own shell, so each gets one tone,
+    and the wood shader runs grain along each piece's own long axis.
+    """
+    tone = [0.5] * len(me.polygons)
+    grain = [(0.0, 0.0, 1.0)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    for g in shells(me):
+        pts = [me.vertices[i].co.copy() for i in g]
+        d = _long_axis(pts) if len(pts) > 2 else Vector((0.0, 0.0, 1.0))
+        t = 0.5 + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        for i in g:
+            owner[i] = (t, tuple(d))
+    for poly in me.polygons:
+        t, d = owner[poly.vertices[0]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new("PieceTone", "FLOAT", "FACE")
+    a.data.foreach_set("value", tone)
+    b = me.attributes.new("GrainDir", "FLOAT_VECTOR", "FACE")
+    b.data.foreach_set("vector", [c for v in grain for c in v])
+
+
+def _sock(sockets, identifier):
+    """A Mix-node socket by identifier; its A/B/Result names repeat per type."""
+    return next(sk for sk in sockets if sk.identifier == identifier)
+
+
+def wood_material(name):
+    """Grain along each stick and log (``GrainDir``), tone per piece (``PieceTone``)."""
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    gdir = nt.nodes.new("ShaderNodeAttribute")
+    gdir.attribute_name = "GrainDir"
+    tone = nt.nodes.new("ShaderNodeAttribute")
+    tone.attribute_name = "PieceTone"
+    dot = nt.nodes.new("ShaderNodeVectorMath")
+    dot.operation = "DOT_PRODUCT"
+    nt.links.new(coord.outputs["Object"], dot.inputs[0])
+    nt.links.new(gdir.outputs["Vector"], dot.inputs[1])
+    squash = nt.nodes.new("ShaderNodeMath")
+    squash.operation = "MULTIPLY"
+    squash.inputs[1].default_value = 0.94
+    nt.links.new(dot.outputs["Value"], squash.inputs[0])
+    along = nt.nodes.new("ShaderNodeVectorMath")
+    along.operation = "SCALE"
+    nt.links.new(gdir.outputs["Vector"], along.inputs[0])
+    nt.links.new(squash.outputs["Value"], along.inputs["Scale"])
+    grain_co = nt.nodes.new("ShaderNodeVectorMath")
+    grain_co.operation = "SUBTRACT"
+    nt.links.new(coord.outputs["Object"], grain_co.inputs[0])
+    nt.links.new(along.outputs["Vector"], grain_co.inputs[1])
+    shift = nt.nodes.new("ShaderNodeVectorMath")
+    shift.operation = "ADD"
+    nt.links.new(grain_co.outputs["Vector"], shift.inputs[0])
+    nt.links.new(tone.outputs["Fac"], shift.inputs[1])
+    noise = nt.nodes.new("ShaderNodeTexNoise")
+    noise.inputs["Scale"].default_value = WOOD_GRAIN_SCALE
+    noise.inputs["Detail"].default_value = 6.0
+    noise.inputs["Roughness"].default_value = 0.62
+    nt.links.new(shift.outputs["Vector"], noise.inputs["Vector"])
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.30
+    ramp.color_ramp.elements[0].color = (0.12, 0.052, 0.018, 1.0)
+    ramp.color_ramp.elements[1].position = 0.72
+    ramp.color_ramp.elements[1].color = (0.38, 0.18, 0.065, 1.0)
+    nt.links.new(noise.outputs["Fac"], ramp.inputs["Fac"])
+    gain = nt.nodes.new("ShaderNodeMath")
+    gain.operation = "MULTIPLY_ADD"
+    gain.inputs[1].default_value = 1.1
+    gain.inputs[2].default_value = 0.45
+    nt.links.new(tone.outputs["Fac"], gain.inputs[0])
+    mix = nt.nodes.new("ShaderNodeMix")
+    mix.data_type = "RGBA"
+    mix.blend_type = "MULTIPLY"
+    _sock(mix.inputs, "Factor_Float").default_value = 1.0
+    nt.links.new(ramp.outputs["Color"], _sock(mix.inputs, "A_Color"))
+    nt.links.new(gain.outputs["Value"], _sock(mix.inputs, "B_Color"))
+    nt.links.new(_sock(mix.outputs, "Result_Color"), bsdf.inputs["Base Color"])
+    rough = nt.nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = 0.72
+    rough.inputs["To Max"].default_value = 0.52
+    nt.links.new(noise.outputs["Fac"], rough.inputs["Value"])
+    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
+    return mat
+
+
+def stone_material(name, light, dark, roughness, mottle, speck, bump):
+    """Fieldstone: isotropic mottling, speckle and pitting, a tone per stone.
+
+    Copied from stone-archway, reading ``PieceTone`` for the per-stone
+    shade. Nothing in the pattern has a direction, so it cannot read as
+    wood grain the way stretched noise does.
+    """
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    mot = nt.nodes.new("ShaderNodeTexNoise")
+    mot.inputs["Scale"].default_value = mottle
+    mot.inputs["Detail"].default_value = 4.0
+    mot.inputs["Roughness"].default_value = 0.55
+    nt.links.new(coord.outputs["Object"], mot.inputs["Vector"])
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.32
+    ramp.color_ramp.elements[0].color = dark
+    ramp.color_ramp.elements[1].position = 0.70
+    ramp.color_ramp.elements[1].color = light
+    nt.links.new(mot.outputs["Fac"], ramp.inputs["Fac"])
+    spk = nt.nodes.new("ShaderNodeTexNoise")
+    spk.inputs["Scale"].default_value = speck
+    spk.inputs["Detail"].default_value = 2.0
+    nt.links.new(coord.outputs["Object"], spk.inputs["Vector"])
+    gain = nt.nodes.new("ShaderNodeMapRange")
+    gain.inputs["To Min"].default_value = 0.82
+    gain.inputs["To Max"].default_value = 1.12
+    nt.links.new(spk.outputs["Fac"], gain.inputs["Value"])
+    mix = nt.nodes.new("ShaderNodeMix")
+    mix.data_type = "RGBA"
+    mix.blend_type = "MULTIPLY"
+    _sock(mix.inputs, "Factor_Float").default_value = 1.0
+    nt.links.new(ramp.outputs["Color"], _sock(mix.inputs, "A_Color"))
+    nt.links.new(gain.outputs["Result"], _sock(mix.inputs, "B_Color"))
+    tone = nt.nodes.new("ShaderNodeAttribute")
+    tone.attribute_name = "PieceTone"
+    shade = nt.nodes.new("ShaderNodeMath")
+    shade.operation = "MULTIPLY_ADD"
+    shade.inputs[1].default_value = 0.8
+    shade.inputs[2].default_value = 0.6
+    nt.links.new(tone.outputs["Fac"], shade.inputs[0])
+    mix2 = nt.nodes.new("ShaderNodeMix")
+    mix2.data_type = "RGBA"
+    mix2.blend_type = "MULTIPLY"
+    _sock(mix2.inputs, "Factor_Float").default_value = 1.0
+    nt.links.new(_sock(mix.outputs, "Result_Color"), _sock(mix2.inputs, "A_Color"))
+    nt.links.new(shade.outputs["Value"], _sock(mix2.inputs, "B_Color"))
+    nt.links.new(_sock(mix2.outputs, "Result_Color"), bsdf.inputs["Base Color"])
+    rough = nt.nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = roughness - 0.06
+    rough.inputs["To Max"].default_value = min(1.0, roughness + 0.08)
+    nt.links.new(spk.outputs["Fac"], rough.inputs["Value"])
+    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
+    if bump > 0.0:
+        bmp = nt.nodes.new("ShaderNodeBump")
+        bmp.inputs["Strength"].default_value = bump
+        bmp.inputs["Distance"].default_value = 0.002
+        nt.links.new(spk.outputs["Fac"], bmp.inputs["Height"])
+        nt.links.new(bmp.outputs["Normal"], bsdf.inputs["Normal"])
+    return mat
+
+
+def ash_material(name):
+    """Grey ash with a few embers: sparse orange emission from a noise threshold."""
+    mat = principled(name, (0.11, 0.105, 0.10, 1.0), 0.0, 0.95,
+                     noise_scale=10.0, wear=(0.05, 0.045, 0.04, 1.0))
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    hot = nt.nodes.new("ShaderNodeTexNoise")
+    hot.inputs["Scale"].default_value = 28.0
+    hot.inputs["Detail"].default_value = 3.0
+    nt.links.new(coord.outputs["Object"], hot.inputs["Vector"])
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.62
+    ramp.color_ramp.elements[0].color = (0.0, 0.0, 0.0, 1.0)
+    ramp.color_ramp.elements[1].position = 0.74
+    ramp.color_ramp.elements[1].color = (1.0, 0.32, 0.06, 1.0)
+    nt.links.new(hot.outputs["Fac"], ramp.inputs["Fac"])
+    nt.links.new(ramp.outputs["Color"], bsdf.inputs["Emission Color"])
+    bsdf.inputs["Emission Strength"].default_value = 2.5
+    return mat
+
+
+def campfire_materials():
+    """(stone, wood, ash): shared by the check, the render and inspection."""
+    stone = stone_material(
+        "CampfireStone", (0.44, 0.42, 0.38, 1.0), (0.22, 0.215, 0.20, 1.0),
+        0.86, mottle=6.0, speck=160.0, bump=0.35,
+    )
+    wood = wood_material("CampfireWood")
+    ash = ash_material("CampfireAsh")
+    return stone, wood, ash
+
+
 def body_plan(me):
     groups = shells(me)
     xs, ys, z0s, z1s = [], [], [], []
@@ -834,27 +1073,20 @@ def check(
     short_stones=False,
     float_logs=False,
     gap_courses=False,
+    uniform_stones=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     flags = dict(
         short_stones=short_stones,
         float_logs=float_logs,
         gap_courses=gap_courses,
+        uniform_stones=uniform_stones,
     )
     low = build_campfire_mesh("CampfireLow", 0.006, 2, **flags)
     high = build_campfire_mesh("CampfireHigh", 0.006, 4, **flags)
-    stone = principled(
-        "CampfireStone", (0.40, 0.42, 0.46, 1.0), 0.0, 0.84,
-        noise_scale=8.0, wear=(0.28, 0.27, 0.24, 1.0),
-    )
-    wood = principled(
-        "CampfireWood", (0.38, 0.18, 0.07, 1.0), 0.0, 0.62,
-        noise_scale=6.0, wear=(0.18, 0.09, 0.04, 1.0),
-    )
-    ash = principled(
-        "CampfireAsh", (0.12, 0.11, 0.10, 1.0), 0.0, 0.94,
-        noise_scale=10.0, wear=(0.08, 0.07, 0.06, 1.0),
-    )
+    stone, wood, ash = campfire_materials()
+    paint_pieces(low.data)
+    paint_pieces(high.data)
     assign_slots(low, stone, wood, ash)
     assign_slots(high, stone, wood, ash)
     if stray_vert:
@@ -886,6 +1118,7 @@ def check(
     sup = support_audit(low.data)
     cseat = course_seat(low.data)
     kiss = teepee_kiss(low.data)
+    vary = stone_variation(low.data)
     dia, ht = body_plan(low.data)
     print(
         f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
@@ -896,6 +1129,7 @@ def check(
         f"measured stones={sup['stones']} stone_z={sup['stone_z']:.5f} "
         f"course_seat={cseat:.5f} kiss={kiss:.5f} body={dia:.4f}x{ht:.4f}"
     )
+    print(f"measured stone_variation={vary:.5f}")
 
     img, tex = setup_bake_image(low, stone)
     if img is None:
@@ -923,6 +1157,10 @@ def check(
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
+    # Blender points TMPDIR at the working directory, so the export must not
+    # outlive the measurement.
+    if os.path.exists(export_path):
+        os.remove(export_path)
 
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
@@ -1038,6 +1276,12 @@ def check(
             f"ring {dia:.4f}x{ht:.4f} off {RING_DIA}x{RING_H}",
             19,
         ), None, None, None, None, None
+    if vary < STONE_VARY_MIN:
+        return fail(
+            f"stone variation {vary:.5f} < {STONE_VARY_MIN}: the ring stones are "
+            "identical (--uniform-stones is the designed fail)",
+            20,
+        ), None, None, None, None, None
     return 0, low, high, stone, tex, collider
 
 
@@ -1148,6 +1392,7 @@ def main():
     p.add_argument("--short-stones", action="store_true")
     p.add_argument("--float-logs", action="store_true")
     p.add_argument("--gap-courses", action="store_true")
+    p.add_argument("--uniform-stones", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, stone, tex, _col = check(
@@ -1157,6 +1402,7 @@ def main():
         short_stones=args.short_stones,
         float_logs=args.float_logs,
         gap_courses=args.gap_courses,
+        uniform_stones=args.uniform_stones,
     )
     if code:
         return code
diff --git a/showcase/campfire/preview.webp b/showcase/campfire/preview.webp
index 307046ab..f306c783 100644
Binary files a/showcase/campfire/preview.webp and b/showcase/campfire/preview.webp differ
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 07ed49d1..7f03954c 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -49,8 +49,8 @@
       "name": "campfire",
       "dir": "showcase/campfire",
       "teaches": "A procedural campfire through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "A campfire of crossed logs in a teepee inside a ring of grey stone blocks.",
-      "witnessesFix": "Recomputed: 2200 tris, three materials with 216 wood, 48 ash and 1304 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.807×0.808×0.404 m, LOD ratios in band, convex collider 198 tris, hygiene 0, 14 grounded bottom stones, teepee kiss 0.00001 m, course seat 0, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-stones 16; --float-logs 17; --gap-courses 18.",
+      "alt": "A campfire of crossed logs in a teepee, embers in the ash, inside a two-course ring of rounded grey fieldstones.",
+      "witnessesFix": "Recomputed: 2760 tris, three materials with 216 wood, 48 ash and 1416 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.802×0.802×0.404 m, LOD ratios in band, convex collider 162 tris, hygiene 0, 14 grounded bottom stones, teepee kiss 0.00034 m, course seat 0, stone variation 0.01269 m, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-stones 16; --float-logs 17; --gap-courses 18; --uniform-stones 20.",
       "hero": "docs/gallery/assets/campfire-hero.webp",
       "preview": "showcase/campfire/preview.webp",
       "tags": [
@@ -312,9 +312,9 @@
     {
       "name": "iron-cauldron",
       "dir": "showcase/iron-cauldron",
-      "teaches": "A procedural hanging iron cauldron with a bulged open pot, bail, and timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "A black iron cauldron hanging from a tripod of wooden poles.",
-      "witnessesFix": "Recomputed: 3664 tris, two materials with 224 wood and 1768 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.987×0.961×0.860 m, pot–leg clearance 0.046 m, 3 coaxial ferrules at zmin 0, ferrule bite −0.00185 m, hook-bail join 0, mesh hygiene all zero, LOD ratios in band, convex collider 250 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-legs 16; --float-hook 17; --pipe-ferrule 18.",
+      "teaches": "A procedural hanging iron cauldron with a round-bellied pot, a bail threaded through flat ear rings, and a timber tripod through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "alt": "A round-bellied black iron cauldron hanging by its bail from a tripod of wooden poles.",
+      "witnessesFix": "Recomputed: 3664 tris, two materials with 224 wood and 1768 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.987×0.961×0.860 m, pot–leg clearance 0.053 m, pot base radius 0.075 m, 3 coaxial ferrules at zmin 0, ferrule bite −0.00185 m, hook-bail join 0, bail threads both ear rings, mesh hygiene all zero, LOD ratios in band, convex collider 246 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-legs 16; --float-hook/--edge-on-ears 17; --pipe-ferrule 18; --pointed-pot 19.",
       "hero": "docs/gallery/assets/iron-cauldron-hero.webp",
       "preview": "showcase/iron-cauldron/preview.webp",
       "tags": [
diff --git a/showcase/iron-cauldron/README.md b/showcase/iron-cauldron/README.md
index 9a77d25b..3b7a320c 100644
--- a/showcase/iron-cauldron/README.md
+++ b/showcase/iron-cauldron/README.md
@@ -1,7 +1,8 @@
 # Iron cauldron
 
-A showcase piece, not an example. Procedural hanging cauldron (lathed
-iron pot with a rolled rim, pipe bail through vertical ear rings, timber
+A showcase piece, not an example. Procedural hanging cauldron (a
+round-bellied iron pot on a small flat base with a rolled rim, a pipe
+bail threaded through flat ear rings, timber
 tripod tenoned into a turned crown, iron ferrule cups coaxial with the
 poles) then the shipped pipeline: unique-cell UVs, Cycles high-to-low
 normal bake, LOD chain, convex collider, Unity glTF export.
@@ -34,8 +35,8 @@ materials, UVs, evaluated LOD, collider, or export file.
 | Materials | exactly 2 distinct; ≥80 wood, ≥200 metal faces | 2 slots; 224 / 1768 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
 | Outer AABB | (0.987, 0.961, 0.860) m ± 0.015 | (0.9866, 0.9605, 0.8600), zmin 0 |
-| Collider tris | ≤ 280 | 250 |
-| Export | written, size > 0 | 287916 / 287916 / 287904 bytes |
+| Collider tris | ≤ 280 | 246 |
+| Export | written, size > 0 | 287380 / 287380 / 287368 bytes |
 
 Base triangles rose from **3388 to 3664** in the quality pass: coaxial
 ferrule cups and a dual-wall lathe with a rolled rim replaced the old
@@ -55,25 +56,50 @@ Recomputed from the generated mesh, not asserted about the script.
 | Coplanar disjoint face pairs | 0 | 0 |
 | Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
 | Named supports: 3 ferrules | each `zmin` ≤ 1e-3 | 3, cup_z 0.00000 |
-| Pot size | 0.355 m dia × 0.334 m high ± 0.04 | 0.3545 × 0.3340 |
-| Pot–leg clearance | ≥ 0.04 m | 0.0464 |
+| Pot size | 0.355 m dia × 0.334 m high ± 0.04 | 0.3600 × 0.3340 |
+| **Pot form** | base radius ≥ 0.05 m; widest point in the lower 60% | 0.0750; at 0.420 of the height |
+| Pot–leg clearance | ≥ 0.04 m | 0.0528 |
 
 ### Joint fit and seat
 
 | Axis | Declared | Measured (all three) |
 | --- | --- | --- |
 | Hook-bail BVH gap | ≤ 0.010 m | 0.00000 |
+| **Bail through the ears** | 2 rings; 0 ring vertices inside the bail; bail within the hole (< 0.0135 m of the ring centre) | 2; 0; 0.00641 |
 | Ferrule bite (pole r − inner wall, pole frame) | −0.006–0.000 m | −0.00185 |
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
 the gate is a ratio band, not an exact count. Bake pixels are
 stochastic; the gate is `has_data` plus operator `FINISHED`, not
-byte-identity. Construction uses no RNG. Export byte counts differ by
-12 B on 5.2.1 (glTF serializer), not a gated axis.
+byte-identity. Construction is closed-form; the only RNG is the seeded
+per-pole wood tone. Export byte counts differ on 5.2.1 (glTF
+serializer), not a gated axis.
+
+### Pot, ears and surface
+
+The pot was a quadratic profile from a 28 mm tip: an onion that ran to a
+point. It is now a superellipse belly from a 75 mm flat base out to
+0.180 m at 0.42 of the height, then a rounded shoulder in to a 0.128 m
+mouth. The inner wall is offset along the profile's normal, not
+sideways, so it keeps its thickness where the wall runs nearly flat.
+**Pot form** asserts it; `--pointed-pot` restores the old profile (base
+0.028 m, widest at 0.727 of the height) and exits 19.
+
+The ear rings stood in the bail's own XZ plane, so the bail ran through
+the ring's tube rather than its hole, and its ends hung into the pot's
+mouth. The rings now lie flat, bite 2 mm into the rim's outer edge, and
+the bail (vertical where it passes) threads them. Past each ear the bail
+is mirrored about the ring, so its ends hook outward. **Bail through the
+ears** asserts it; `--edge-on-ears` restores the old rings (36 ring
+vertices inside the bail) and exits 17.
+
+Cast iron is near-black and rough with rust in the pores; each pole has
+its own tone and grain along its axis. The temp `.glb` is removed after
+its size is measured.
 
 ### Falsifiers
 
-Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
+Each violates one named budget. All nine were run on 4.5.11, 5.1.2 and
 5.2.1 and returned the same code on each.
 
 | Flag | Budget violated | Exit |
@@ -84,6 +110,8 @@ Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
 | `--short-legs` | named ferrule supports at Z=0 | 16 |
 | `--float-hook` | hook-bail gap | 17 |
 | `--pipe-ferrule` | ferrule bite (pole starts above the well) | 18 |
+| `--pointed-pot` | pot form | 19 |
+| `--edge-on-ears` | bail through the ears | 17 |
 
 ## Run
 
@@ -95,6 +123,8 @@ blender --background --python iron_cauldron.py -- --lift-z
 blender --background --python iron_cauldron.py -- --short-legs
 blender --background --python iron_cauldron.py -- --float-hook
 blender --background --python iron_cauldron.py -- --pipe-ferrule
+blender --background --python iron_cauldron.py -- --pointed-pot
+blender --background --python iron_cauldron.py -- --edge-on-ears
 blender --background --python iron_cauldron.py -- --output cauldron.png
 ```
 
@@ -125,6 +155,6 @@ hygiene and joint-fit family.
 | 14 | `--output` produced no file |
 | 15 | Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight |
 | 16 | Not grounded: bounding box `zmin` off 0, or a named ferrule floats |
-| 17 | Joint fit: hook-bail gap |
+| 17 | Joint fit: hook-bail gap, or the bail not threading the ear rings |
 | 18 | Seat: ferrule bite band |
-| 19 | Pot diameter or height off the stated real-world size |
+| 19 | Pot diameter or height off the stated real-world size, or pot form (base radius, belly height) |
diff --git a/showcase/iron-cauldron/iron_cauldron.py b/showcase/iron-cauldron/iron_cauldron.py
index 6e1a5a83..f87ecd7e 100644
--- a/showcase/iron-cauldron/iron_cauldron.py
+++ b/showcase/iron-cauldron/iron_cauldron.py
@@ -15,9 +15,12 @@
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named ferrule
 supports, ``--float-hook`` hook-bail joint-fit, ``--pipe-ferrule``
-ferrule-cup seat (pole starts above the well).
+ferrule-cup seat (pole starts above the well), ``--pointed-pot`` pot
+form (the old quadratic profile that ran to a point), ``--edge-on-ears``
+bail through the ears (the old rings stood in the bail's own plane).
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
+Construction is closed-form; the only RNG is the seeded per-pole wood
+tone. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -28,6 +31,7 @@
 import argparse
 import math
 import os
+import random
 import sys
 import tempfile
 import traceback
@@ -51,9 +55,24 @@
 POT_THICK = 0.012
 N_AROUND = 32
 N_RINGS = 12
-R_BOT = 0.028
+R_BOT = 0.075
 R_MID = 0.185
-R_TOP = 0.148
+R_TOP = 0.128
+# The pot is a round belly on a small flat base: a superellipse quadrant
+# from the base (radius R_BOT) out to the belly (R_BELLY at BELLY_Z), then
+# a circular shoulder in to the mouth (R_TOP). --pointed-pot restores the
+# old quadratic profile, which ran from a 28 mm tip.
+R_BELLY = 0.180
+BELLY_Z = 0.42 * 0.320
+BELLY_P = 2.4
+N_LOWER = 7
+POINTED_R_BOT = 0.028
+POT_BASE_MIN = 0.05
+POT_BELLY_MAX = 0.60
+# Per-pole wood tone jitter and grain frequency, as in shipping-crate.
+PLANK_TONE_JITTER = 0.28
+TONE_SEED = 29
+WOOD_GRAIN_SCALE = 40.0
 POT_Z0 = 0.155
 APEX_Z = 0.860
 TRIPOD_R = 0.560
@@ -73,6 +92,10 @@
 HOOK_R = 0.006
 EAR_MAJOR = 0.018
 EAR_MINOR = 0.0045
+# Ear rings lie flat (hole along Z) so the bail, vertical where it passes,
+# threads the hole. Each ring bites EAR_BITE into the rim's outer edge.
+EAR_BITE = 0.002
+RIM_OUT = 0.018
 POLE_OFFSET = math.radians(18.0)
 
 BBOX_TOL = 0.015
@@ -379,15 +402,50 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def pot_radius(z_local):
+def pointed_radius(z_local):
+    """The old profile: a quadratic from a 28 mm tip (``--pointed-pot``)."""
     t = max(0.0, min(1.0, z_local / POT_H))
     return (
-        (1.0 - t) ** 2 * R_BOT
+        (1.0 - t) ** 2 * POINTED_R_BOT
         + 2.0 * t * (1.0 - t) * (R_MID * 1.32)
         + t ** 2 * R_TOP
     )
 
 
+def pot_profile(pointed=False):
+    """Outer and inner (z_local, r) rings of the pot wall, base to mouth.
+
+    The inner wall is the outer offset POT_THICK along the profile's
+    inward normal, so the wall keeps its thickness where it runs nearly
+    flat under the belly; a horizontal offset thins it to nothing there.
+    """
+    if pointed:
+        zs = [POT_H * i / (N_RINGS - 1) for i in range(N_RINGS)]
+        outer = [(z, pointed_radius(z)) for z in zs]
+        return outer, [(z, max(r - POT_THICK, 0.014)) for z, r in outer]
+    outer = []
+    for k in range(N_LOWER):
+        th = 0.5 * math.pi * k / (N_LOWER - 1)
+        sn = max(0.0, math.sin(th)) ** (2.0 / BELLY_P)
+        cs = max(0.0, math.cos(th)) ** (2.0 / BELLY_P)
+        outer.append((BELLY_Z * (1.0 - cs), R_BOT + (R_BELLY - R_BOT) * sn))
+    n_up = N_RINGS - N_LOWER + 1
+    for k in range(1, n_up):
+        th = 0.5 * math.pi * k / (n_up - 1)
+        outer.append((
+            BELLY_Z + (POT_H - BELLY_Z) * math.sin(th),
+            R_TOP + (R_BELLY - R_TOP) * math.cos(th),
+        ))
+    inner = []
+    for i, (z, r) in enumerate(outer):
+        z0, r0 = outer[max(i - 1, 0)]
+        z1, r1 = outer[min(i + 1, len(outer) - 1)]
+        tr, tz = r1 - r0, z1 - z0
+        ln = math.hypot(tr, tz)
+        inner.append((z + POT_THICK * tr / ln, r - POT_THICK * tz / ln))
+    return outer, inner
+
+
 def pole_feet():
     feet = []
     for i in range(3):
@@ -401,6 +459,8 @@ def build_cauldron_mesh(
     short_legs=False,
     float_hook=False,
     pipe_ferrule=False,
+    pointed_pot=False,
+    edge_on_ears=False,
 ):
     bm = bmesh.new()
     wood_verts = []
@@ -408,7 +468,7 @@ def build_cauldron_mesh(
         # Dual-wall lathe plus a rolled rim. No overlapping torus, no
         # extra bottom cylinder — those left a hole in the floor and a
         # faceted lip sitting on the mouth.
-        zs = [POT_H * i / (N_RINGS - 1) for i in range(N_RINGS)]
+        prof_out, prof_in = pot_profile(pointed_pot)
         rim = (
             (POT_H + 0.004, R_TOP + 0.012),
             (POT_H + 0.010, R_TOP + 0.018),
@@ -416,15 +476,14 @@ def build_cauldron_mesh(
             (POT_H + 0.011, R_TOP + 0.006),
         )
         outers, inners = [], []
-        for z_local in zs:
+        for (z_local, r), (zi_local, ri) in zip(prof_out, prof_in):
             z = POT_Z0 + z_local
-            r = pot_radius(z_local)
-            ri = max(r - POT_THICK, 0.014)
+            zi = POT_Z0 + zi_local
             oring, iring = [], []
             for i in range(N_AROUND):
                 a = 2.0 * math.pi * i / N_AROUND
                 oring.append(bm.verts.new((r * math.cos(a), r * math.sin(a), z)))
-                iring.append(bm.verts.new((ri * math.cos(a), ri * math.sin(a), z)))
+                iring.append(bm.verts.new((ri * math.cos(a), ri * math.sin(a), zi)))
             outers.append(oring)
             inners.append(iring)
         for z_off, r in rim:
@@ -464,8 +523,16 @@ def build_cauldron_mesh(
             ibot.material_index = METAL_IDX
 
         mouth_z = POT_Z0 + POT_H
-        # Vertical rings (hole along Y) so the XZ bail can thread them.
-        ear_x = R_TOP + 0.008
+        # Flat rings (hole along Z): the bail is vertical where it passes
+        # the ear, so it threads the hole. The old rings were stood up in
+        # the bail's own XZ plane, so the bail ran through the ring's tube;
+        # --edge-on-ears restores them at the old position.
+        if edge_on_ears:
+            ear_x = R_TOP + 0.008
+            ear_euler = (math.pi / 2.0, 0.0, 0.0)
+        else:
+            ear_x = R_TOP + RIM_OUT + EAR_MAJOR + EAR_MINOR - EAR_BITE
+            ear_euler = (0.0, 0.0, 0.0)
         ear_z = mouth_z + 0.002
         for sign in (-1.0, 1.0):
             add_torus(
@@ -476,17 +543,22 @@ def build_cauldron_mesh(
                 14,
                 6,
                 METAL_IDX,
-                euler=(math.pi / 2.0, 0.0, 0.0),
+                euler=ear_euler,
             )
-        # Semicircle through the ear holes, ends past the rings.
+        # Semicircle through the ear holes. Past each ear the curve is
+        # mirrored about the ear, so the ends hook outward and down instead
+        # of hanging into the pot's mouth.
         t0 = -0.42
         t1 = math.pi + 0.42
         bail_pts = []
         for i in range(BAIL_SEGS + 1):
             t = t0 + (t1 - t0) * i / BAIL_SEGS
-            bail_pts.append(
-                (ear_x * math.cos(t), 0.0, ear_z + ear_x * math.sin(t))
-            )
+            x = ear_x * math.cos(t)
+            if t < 0.0:
+                x = 2.0 * ear_x - x
+            elif t > math.pi:
+                x = -2.0 * ear_x - x
+            bail_pts.append((x, 0.0, ear_z + ear_x * math.sin(t)))
         add_pipe_curve(bm, bail_pts, BAIL_R, BAIL_PIPE, METAL_IDX)
         bail_peak = Vector(bail_pts[len(bail_pts) // 2])
         hook_z = bail_peak.z + (0.08 if float_hook else 0.0)
@@ -611,6 +683,131 @@ def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     return mat
 
 
+def _long_axis(pts):
+    """Principal axis of a point set, by power iteration on its covariance."""
+    c = sum(pts, Vector()) / len(pts)
+    cov = [[0.0] * 3 for _ in range(3)]
+    for p in pts:
+        d = p - c
+        for i in range(3):
+            for j in range(3):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((1.0, 0.3, 0.1))
+    for _ in range(30):
+        w = Vector([sum(cov[i][j] * v[j] for j in range(3)) for i in range(3)])
+        if w.length < 1e-12:
+            break
+        v = w.normalized()
+    return v
+
+
+def paint_planks(me):
+    """Per-shell ``PlankTone`` and ``GrainDir`` face attributes for the wood shader.
+
+    Every pole and the crown is its own shell, so each gets one tone and
+    grain running along its own long axis (along each pole).
+    """
+    tone = [0.5] * len(me.polygons)
+    grain = [(0.0, 0.0, 1.0)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    for g in shells(me):
+        pts = [me.vertices[i].co.copy() for i in g]
+        d = _long_axis(pts) if len(pts) > 2 else Vector((0.0, 0.0, 1.0))
+        t = 0.5 + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        for i in g:
+            owner[i] = (t, tuple(d))
+    for poly in me.polygons:
+        t, d = owner[poly.vertices[0]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new("PlankTone", "FLOAT", "FACE")
+    a.data.foreach_set("value", tone)
+    b = me.attributes.new("GrainDir", "FLOAT_VECTOR", "FACE")
+    b.data.foreach_set("vector", [c for v in grain for c in v])
+
+
+def _sock(sockets, identifier):
+    """A Mix-node socket by identifier; its A/B/Result names repeat per type."""
+    return next(sk for sk in sockets if sk.identifier == identifier)
+
+
+def wood_material(name):
+    """Grain along each pole (``GrainDir``), tone per pole (``PlankTone``)."""
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    gdir = nt.nodes.new("ShaderNodeAttribute")
+    gdir.attribute_name = "GrainDir"
+    tone = nt.nodes.new("ShaderNodeAttribute")
+    tone.attribute_name = "PlankTone"
+    dot = nt.nodes.new("ShaderNodeVectorMath")
+    dot.operation = "DOT_PRODUCT"
+    nt.links.new(coord.outputs["Object"], dot.inputs[0])
+    nt.links.new(gdir.outputs["Vector"], dot.inputs[1])
+    squash = nt.nodes.new("ShaderNodeMath")
+    squash.operation = "MULTIPLY"
+    squash.inputs[1].default_value = 0.94
+    nt.links.new(dot.outputs["Value"], squash.inputs[0])
+    along = nt.nodes.new("ShaderNodeVectorMath")
+    along.operation = "SCALE"
+    nt.links.new(gdir.outputs["Vector"], along.inputs[0])
+    nt.links.new(squash.outputs["Value"], along.inputs["Scale"])
+    grain_co = nt.nodes.new("ShaderNodeVectorMath")
+    grain_co.operation = "SUBTRACT"
+    nt.links.new(coord.outputs["Object"], grain_co.inputs[0])
+    nt.links.new(along.outputs["Vector"], grain_co.inputs[1])
+    shift = nt.nodes.new("ShaderNodeVectorMath")
+    shift.operation = "ADD"
+    nt.links.new(grain_co.outputs["Vector"], shift.inputs[0])
+    nt.links.new(tone.outputs["Fac"], shift.inputs[1])
+    noise = nt.nodes.new("ShaderNodeTexNoise")
+    noise.inputs["Scale"].default_value = WOOD_GRAIN_SCALE
+    noise.inputs["Detail"].default_value = 6.0
+    noise.inputs["Roughness"].default_value = 0.62
+    nt.links.new(shift.outputs["Vector"], noise.inputs["Vector"])
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.30
+    ramp.color_ramp.elements[0].color = (0.12, 0.052, 0.018, 1.0)
+    ramp.color_ramp.elements[1].position = 0.72
+    ramp.color_ramp.elements[1].color = (0.38, 0.18, 0.065, 1.0)
+    nt.links.new(noise.outputs["Fac"], ramp.inputs["Fac"])
+    gain = nt.nodes.new("ShaderNodeMath")
+    gain.operation = "MULTIPLY_ADD"
+    gain.inputs[1].default_value = 1.1
+    gain.inputs[2].default_value = 0.45
+    nt.links.new(tone.outputs["Fac"], gain.inputs[0])
+    mix = nt.nodes.new("ShaderNodeMix")
+    mix.data_type = "RGBA"
+    mix.blend_type = "MULTIPLY"
+    _sock(mix.inputs, "Factor_Float").default_value = 1.0
+    nt.links.new(ramp.outputs["Color"], _sock(mix.inputs, "A_Color"))
+    nt.links.new(gain.outputs["Value"], _sock(mix.inputs, "B_Color"))
+    nt.links.new(_sock(mix.outputs, "Result_Color"), bsdf.inputs["Base Color"])
+    rough = nt.nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = 0.72
+    rough.inputs["To Max"].default_value = 0.52
+    nt.links.new(noise.outputs["Fac"], rough.inputs["Value"])
+    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
+    return mat
+
+
+def cauldron_materials():
+    """(wood, iron): shared by the check, the render and inspection.
+
+    Cast iron is near-black and rough, with rust in the pores, not the
+    satin grey metal the pot first shipped with.
+    """
+    wood = wood_material("TripodWood")
+    metal = principled(
+        "CauldronIron", (0.075, 0.072, 0.070, 1.0), 0.80, 0.58,
+        noise_scale=22.0, wear=(0.10, 0.055, 0.03, 1.0),
+    )
+    return wood, metal
+
+
 def assign_slots(obj, wood, metal):
     mats = obj.data.materials
     wanted = (wood, metal)
@@ -800,6 +997,85 @@ def support_audit(me):
     return {"cups": len(cups), "cup_z": cup_z}
 
 
+def pot_form(me):
+    """Base radius and belly height of the pot, from its outer wall.
+
+    The pot is the tallest wide iron shell. Its base radius is the widest
+    vertex on the lowest ring (the base centre excluded); the belly is
+    where the wall is widest, as a fraction of the pot's height. A pot
+    that runs to a point has a base of a few millimetres.
+    """
+    best, best_r = None, -1.0
+    for g in shells(me):
+        if mat_of(me, g) != METAL_IDX:
+            continue
+        a = shell_aabb(me, g)
+        r = 0.25 * ((a[3] - a[0]) + (a[4] - a[1]))
+        if a[5] - a[2] > 0.20 and r > best_r:
+            best, best_r = (g, a), r
+    if best is None:
+        return 0.0, 1.0
+    g, a = best
+    z0 = a[2]
+    base = max(
+        (math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) for i in g
+         if me.vertices[i].co.z < z0 + 1e-4),
+        default=0.0,
+    )
+    widest = max(g, key=lambda i: math.hypot(me.vertices[i].co.x, me.vertices[i].co.y))
+    belly = (me.vertices[widest].co.z - z0) / max(POT_H, 1e-6)
+    return base, belly
+
+
+def ear_threading(me):
+    """How the bail passes the two ear rings.
+
+    The ear rings are the two small iron shells level with the mouth;
+    the bail is the iron shell spanning the pot. A ring vertex inside
+    the bail (by the nearest face's normal) is bail running through the
+    ring's tube; the bail must also come within the ring's hole of its
+    centre. Returns (rings, ring verts inside the bail, worst centre gap).
+    """
+    rings, bail = [], None
+    mouth = POT_Z0 + POT_H
+    for g in shells(me):
+        if mat_of(me, g) != METAL_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        if max(dx, dy, dz) < 0.06 and abs(0.5 * (a[2] + a[5]) - mouth) < 0.03:
+            rings.append(g)
+        elif dx > 0.25 and dy < 0.05 and a[2] > POT_Z0:
+            bail = g
+    if bail is None or len(rings) != 2:
+        return len(rings), 99, 99.0
+    bm_b = bmesh.new()
+    try:
+        bm_b.from_mesh(me)
+        keep = set(bail)
+        drop = [f for f in bm_b.faces if not all(v.index in keep for v in f.verts)]
+        if drop:
+            bmesh.ops.delete(bm_b, geom=drop, context="FACES")
+        bm_b.normal_update()
+        tree = BVHTree.FromBMesh(bm_b)
+        inside, worst = 0, 0.0
+        for g in rings:
+            c = Vector()
+            for i in g:
+                c += me.vertices[i].co
+            c /= len(g)
+            for i in g:
+                p = me.vertices[i].co
+                loc, nrm, _idx, _d = tree.find_nearest(p)
+                if loc is not None and nrm.dot(p - loc) < 0.0:
+                    inside += 1
+            loc, _n, _i, d = tree.find_nearest(c)
+            worst = max(worst, d if loc is not None else 99.0)
+        return len(rings), inside, worst
+    finally:
+        bm_b.free()
+
+
 def pot_audit(me):
     groups = shells(me)
     best = None
@@ -1046,23 +1322,22 @@ def check(
     short_legs=False,
     float_hook=False,
     pipe_ferrule=False,
+    pointed_pot=False,
+    edge_on_ears=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     flags = dict(
         short_legs=short_legs,
         float_hook=float_hook,
         pipe_ferrule=pipe_ferrule,
+        pointed_pot=pointed_pot,
+        edge_on_ears=edge_on_ears,
     )
     low = build_cauldron_mesh("CauldronLow", **flags)
     high = build_cauldron_mesh("CauldronHigh", **flags)
-    wood = principled(
-        "TripodWood", (0.38, 0.22, 0.09, 1.0), 0.0, 0.58,
-        noise_scale=6.0, wear=(0.22, 0.12, 0.05, 1.0),
-    )
-    metal = principled(
-        "CauldronIron", (0.10, 0.095, 0.09, 1.0), 0.92, 0.40,
-        noise_scale=5.0, wear=(0.18, 0.16, 0.14, 1.0),
-    )
+    wood, metal = cauldron_materials()
+    paint_planks(low.data)
+    paint_planks(high.data)
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     if stray_vert:
@@ -1124,6 +1399,10 @@ def check(
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
+    # Blender points TMPDIR at the working directory, so the export must not
+    # outlive the measurement.
+    if os.path.exists(export_path):
+        os.remove(export_path)
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -1131,6 +1410,8 @@ def check(
     pot = pot_audit(low.data)
     hj = hook_bail_join(low.data)
     bite = ferrule_bite(low.data)
+    base_r, belly = pot_form(low.data)
+    n_ears, ear_in, ear_gap = ear_threading(low.data)
 
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
@@ -1159,6 +1440,8 @@ def check(
         f"pot_dia={pot['dia']:.4f} pot_h={pot['height']:.4f} "
         f"hook_join={hj:.5f} ferrule_bite={bite:.5f}"
     )
+    print(f"measured pot_base_r={base_r:.4f} belly_at={belly:.3f}")
+    print(f"measured ears={n_ears} ring_verts_in_bail={ear_in} ear_centre_gap={ear_gap:.5f}")
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -1251,6 +1534,13 @@ def check(
             "(--float-hook is the designed fail)",
             17,
         ), None, None, None, None, None
+    if n_ears != 2 or ear_in or ear_gap > EAR_MAJOR - EAR_MINOR:
+        return fail(
+            f"ears {n_ears}: {ear_in} ring vertices inside the bail, bail "
+            f"{ear_gap:.5f} from a ring centre (hole {EAR_MAJOR - EAR_MINOR:.4f}) "
+            "(--edge-on-ears is the designed fail)",
+            17,
+        ), None, None, None, None, None
     if not (FERRULE_BITE_MIN <= bite <= FERRULE_BITE_MAX):
         return fail(
             f"ferrule bite {bite:.5f} not in "
@@ -1268,6 +1558,13 @@ def check(
             f"pot height {pot['height']:.4f} off {BODY_H}",
             19,
         ), None, None, None, None, None
+    if base_r < POT_BASE_MIN or belly > POT_BELLY_MAX:
+        return fail(
+            f"pot form: base radius {base_r:.4f} < {POT_BASE_MIN} or belly at "
+            f"{belly:.3f} of the height > {POT_BELLY_MAX} "
+            "(--pointed-pot is the designed fail)",
+            19,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -1387,6 +1684,8 @@ def main():
     p.add_argument("--short-legs", action="store_true")
     p.add_argument("--float-hook", action="store_true")
     p.add_argument("--pipe-ferrule", action="store_true")
+    p.add_argument("--pointed-pot", action="store_true")
+    p.add_argument("--edge-on-ears", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1396,6 +1695,8 @@ def main():
         short_legs=args.short_legs,
         float_hook=args.float_hook,
         pipe_ferrule=args.pipe_ferrule,
+        pointed_pot=args.pointed_pot,
+        edge_on_ears=args.edge_on_ears,
     )
     if code:
         return code
diff --git a/showcase/iron-cauldron/preview.webp b/showcase/iron-cauldron/preview.webp
index e10ba3f0..2fff0c11 100644
Binary files a/showcase/iron-cauldron/preview.webp and b/showcase/iron-cauldron/preview.webp differ