diff --git a/docs/gallery/assets/gn-instance-grid-hero.webp b/docs/gallery/assets/gn-instance-grid-hero.webp
index 94337909..c3df22cf 100644
Binary files a/docs/gallery/assets/gn-instance-grid-hero.webp and b/docs/gallery/assets/gn-instance-grid-hero.webp differ
diff --git a/docs/gallery/assets/hay-bale-hero.webp b/docs/gallery/assets/hay-bale-hero.webp
index 3e87e787..9d3a74d8 100644
Binary files a/docs/gallery/assets/hay-bale-hero.webp and b/docs/gallery/assets/hay-bale-hero.webp differ
diff --git a/docs/gallery/assets/temp-override-join-hero.webp b/docs/gallery/assets/temp-override-join-hero.webp
index c1031726..262b11b5 100644
Binary files a/docs/gallery/assets/temp-override-join-hero.webp and b/docs/gallery/assets/temp-override-join-hero.webp differ
diff --git a/docs/gallery/assets/treasure-chest-hero.webp b/docs/gallery/assets/treasure-chest-hero.webp
index a1a55cf1..0872cb36 100644
Binary files a/docs/gallery/assets/treasure-chest-hero.webp and b/docs/gallery/assets/treasure-chest-hero.webp differ
diff --git a/docs/gallery/contact-sheets/gn-instance-grid-contact-sheet.webp b/docs/gallery/contact-sheets/gn-instance-grid-contact-sheet.webp
new file mode 100644
index 00000000..51ef3b36
Binary files /dev/null and b/docs/gallery/contact-sheets/gn-instance-grid-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/hay-bale-contact-sheet.webp b/docs/gallery/contact-sheets/hay-bale-contact-sheet.webp
index 6687b9eb..1e7e2b4d 100644
Binary files a/docs/gallery/contact-sheets/hay-bale-contact-sheet.webp and b/docs/gallery/contact-sheets/hay-bale-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/temp-override-join-contact-sheet.webp b/docs/gallery/contact-sheets/temp-override-join-contact-sheet.webp
index 34ca79bb..2051ca42 100644
Binary files a/docs/gallery/contact-sheets/temp-override-join-contact-sheet.webp and b/docs/gallery/contact-sheets/temp-override-join-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/treasure-chest-contact-sheet.webp b/docs/gallery/contact-sheets/treasure-chest-contact-sheet.webp
index 6ef410bc..a7f82c91 100644
Binary files a/docs/gallery/contact-sheets/treasure-chest-contact-sheet.webp and b/docs/gallery/contact-sheets/treasure-chest-contact-sheet.webp differ
diff --git a/docs/gallery/gn-instance-grid/index.html b/docs/gallery/gn-instance-grid/index.html
index aabf314f..af274bab 100644
--- a/docs/gallery/gn-instance-grid/index.html
+++ b/docs/gallery/gn-instance-grid/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gn-instance-grid-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A three-by-three grid of green instanced cubes on a dark floor." />
+  <meta property="og:image:alt" content="A three-by-three grid of green instanced cubes, each sitting on a node of a faint source-grid lattice on a dark floor." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="gn-instance-grid — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gn-instance-grid-hero.webp" />
-  <meta name="twitter:image:alt" content="A three-by-three grid of green instanced cubes on a dark floor." />
+  <meta name="twitter:image:alt" content="A three-by-three grid of green instanced cubes, each sitting on a node of a faint source-grid lattice on a dark floor." />
   <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-instance-grid</h1>
     <p>A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A three-by-three grid of green instanced cubes on a dark floor.">
-      <img src="../assets/gn-instance-grid-hero.webp" alt="A three-by-three grid of green instanced cubes on a dark floor." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A three-by-three grid of green instanced cubes, each sitting on a node of a faint source-grid lattice on a dark floor.">
+      <img src="../assets/gn-instance-grid-hero.webp" alt="A three-by-three grid of green instanced cubes, each sitting on a node of a faint source-grid lattice on a dark floor." width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
     <div class="callout"><span class="tag">witnesses</span> Realized instances produce closed-form topology (72 verts, 54 faces), Set Material carries Lime, and the corner instance center sits at its closed-form grid coordinate.</div>
@@ -490,8 +490,33 @@ <h2>Source</h2>
     <span class="c"># tip the grid so depth reads; cubes already rest on the floor via the tree</span>
     obj.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(<span class="n">24</span>))
 
+    <span class="c"># The source Mesh Grid drawn as a faint lattice on the floor, turned with</span>
+    <span class="c"># the instances, so the still shows grid points in and one cube per</span>
+    <span class="c"># point out. Render-only: the same GRID_SIZE / GRID_X / GRID_Y the tree</span>
+    <span class="c"># uses, as a wireframe 1 mm above the floor.</span>
+    lat_me = bpy.data.meshes.new(<span class="s">&quot;Lattice&quot;</span>)
+    lbm = bmesh.new()
+    <span class="k">try</span>:
+        bmesh.ops.create_grid(lbm, x_segments=GRID_X - <span class="n">1</span>, y_segments=GRID_Y - <span class="n">1</span>,
+                              size=GRID_HALF)
+        lbm.to_mesh(lat_me)
+    <span class="k">finally</span>:
+        lbm.free()
+    lat_mat = bpy.data.materials.new(<span class="s">&quot;Lattice&quot;</span>)
+    lat_mat.use_nodes = <span class="k">True</span>
+    lb = lat_mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    lb.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.30</span>, <span class="n">0.42</span>, <span class="n">0.26</span>, <span class="n">1.0</span>)
+    lb.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.6</span>
+    lat_me.materials.append(lat_mat)
+    lattice = bpy.data.objects.new(<span class="s">&quot;Lattice&quot;</span>, lat_me)
+    lattice.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.001</span>)
+    lattice.rotation_euler = obj.rotation_euler
+    wire = lattice.modifiers.new(<span class="s">&quot;lattice&quot;</span>, <span class="s">&quot;WIREFRAME&quot;</span>)
+    wire.thickness = <span class="n">0.018</span>
+    scene.collection.objects.link(lattice)
+
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, CUBE_SIZE / <span class="n">2</span>)
+    aim.location = (-<span class="n">0.12</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)
     scene.collection.objects.link(aim)
 
     <span class="k">def</span> light(name, loc, energy, size, col):
@@ -523,7 +548,9 @@ <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">3.7</span>, -<span class="n">4.3</span>, <span class="n">2.7</span>)
+    <span class="c"># Higher, so the 3 x 3 layout reads as a grid: from 2.7 m the perspective</span>
+    <span class="c"># scrambled the rows and the right column crowded the frame edge.</span>
+    cam.location = (<span class="n">3.4</span>, -<span class="n">4.6</span>, <span class="n">4.3</span>)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
@@ -584,7 +611,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-instance-grid-hero.webp" alt="A three-by-three grid of green instanced cubes on a dark floor." />
+    <img src="../assets/gn-instance-grid-hero.webp" alt="A three-by-three grid of green instanced cubes, each sitting on a node of a faint source-grid lattice on a dark floor." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/hay-bale/index.html b/docs/gallery/hay-bale/index.html
index c7e31232..e804d905 100644
--- a/docs/gallery/hay-bale/index.html
+++ b/docs/gallery/hay-bale/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/hay-bale-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A rectangular hay bale bound by two twine belts." />
+  <meta property="og:image:alt" content="A golden fibrous hay bale bound by two thin twine cords with knotted loops on top." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="hay-bale — Showcase — Blender Developer Tools" />
   <meta name="twitter:description" content="A bound hay bale whose twine belts follow the loaf&#x27;s own raycast cross-section, asserting recomputed geometry budgets, not an API contract." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/hay-bale-hero.webp" />
-  <meta name="twitter:image:alt" content="A rectangular hay bale bound by two twine belts." />
+  <meta name="twitter:image:alt" content="A golden fibrous hay bale bound by two thin twine cords with knotted loops on top." />
   <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>hay-bale</h1>
     <p>A bound hay bale whose twine belts follow the loaf&#x27;s own raycast cross-section, asserting recomputed geometry budgets, not an API contract.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A rectangular hay bale bound by two twine belts.">
-      <img src="../assets/hay-bale-hero.webp" alt="A rectangular hay bale bound by two twine belts." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A golden fibrous hay bale bound by two thin twine cords with knotted loops on top.">
+      <img src="../assets/hay-bale-hero.webp" alt="A golden fibrous hay bale bound by two thin twine cords with knotted loops on top." 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: 2012 tris, two materials with 712 hay and 304 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.921x0.530x0.409 m, zmin 0, hygiene and cross-shell z-fight 0, 5 shells, each belt wrapping under the loaf at zmin 2.6 mm, banded belt seat depth 4.0-16.8 mm over 20/20 stations on both belts, belt mirror error 0, cinch depth 14.2 mm, LOD ratios in band, convex collider 156 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z and --float-belts 16; --slack-belt 18; --skew-belt 19.</div>
@@ -288,15 +288,19 @@ <h2>How the belts are built</h2>
 <p>Every closed-form term in the loaf shaping is <strong>even in x</strong>. An odd term (<code>sin(x*24)</code>) put the two belt stations on different surface heights and left the wraps 5.4 mm out of step, which no budget could see.</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. Measurements below are identical on 4.5.11, 5.1.2 and 5.2.1 — construction uses no RNG and no version-dependent operator.</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>1700–2400</td><td>2012 on all three</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2197</td></tr><tr><td>Materials</td><td>exactly 2 distinct, ≥24 hay, ≥24 twine</td><td>2 slots, 712 hay, 304 twine</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.922, 0.530, 0.409) m ± 0.01</td><td>(0.9208, 0.5295, 0.4087)</td></tr><tr><td>Grounded zmin</td><td>within 1e-4 of 0</td><td>0.000000</td></tr><tr><td>Hygiene</td><td>loose/nonman/zero-area/doubles/n-gons/<strong>z-fight</strong> = 0</td><td>all 0</td></tr><tr><td>Shell count</td><td>exactly 5 (loaf, 2 belts, 2 loops)</td><td>5</td></tr><tr><td><strong>Belt wrap zmin</strong></td><td>each belt shell ≤ 0.006 m</td><td>0.002628 both</td></tr><tr><td><strong>Belt seat depth</strong></td><td>every station in [0.002, 0.020] m</td><td>0.00400..0.01676 over 20/20 stations, both belts</td></tr><tr><td><strong>Mirror symmetry</strong></td><td>belts and loops matched within 5e-4 m</td><td>0.000000</td></tr><tr><td><strong>Cinch depth</strong></td><td>mid-span minus waist in [0.006, 0.020] m</td><td>0.01420</td></tr><tr><td>Loaf X × Z</td><td>(0.922, 0.409) m ± 0.02</td><td>(0.9208, 0.4087)</td></tr><tr><td>Hay–twine gap</td><td>BVH surface &lt; 0.008 m</td><td>0.00002</td></tr><tr><td>Collider tris</td><td>≤ 400</td><td>156</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>156664 / 156664 / 156656 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>1700–2400</td><td>2012 on all three</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2197</td></tr><tr><td>Materials</td><td>exactly 2 distinct, ≥24 hay, ≥24 twine</td><td>2 slots, 1404 hay, 304 twine</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.922, 0.530, 0.409) m ± 0.01</td><td>(0.9208, 0.5295, 0.4087)</td></tr><tr><td>Grounded zmin</td><td>within 1e-4 of 0</td><td>0.000000</td></tr><tr><td>Hygiene</td><td>loose/nonman/zero-area/doubles/n-gons/<strong>z-fight</strong> = 0</td><td>all 0</td></tr><tr><td>Shell count</td><td>exactly 5 (loaf, 2 belts, 2 loops)</td><td>5</td></tr><tr><td><strong>Belt wrap zmin</strong></td><td>each belt shell ≤ 0.006 m</td><td>0.002846 both</td></tr><tr><td><strong>Belt seat depth</strong></td><td>every station in [0.002, 0.020] m</td><td>0.00400..0.00903 over 20/20 stations, both belts</td></tr><tr><td><strong>Mirror symmetry</strong></td><td>belts and loops matched within 5e-4 m</td><td>0.000000</td></tr><tr><td><strong>Loaf mirror</strong></td><td>every loaf vertex has an X-mirror partner within 2e-4 m</td><td>0.000071</td></tr><tr><td><strong>Cinch depth</strong></td><td>mid-span minus waist in [0.006, 0.020] m</td><td>0.01420</td></tr><tr><td>Loaf X × Z</td><td>(0.922, 0.409) m ± 0.02</td><td>(0.9208, 0.4087)</td></tr><tr><td>Hay–twine gap</td><td>BVH surface &lt; 0.008 m</td><td>0.00002</td></tr><tr><td>Collider tris</td><td>≤ 400</td><td>120</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>197504 / 197504 / 197496 bytes</td></tr></tbody></table></div>
 <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. Export byte counts differ by 8 B on 5.2.1 (glTF serializer), which is not a gated axis; every geometric figure above is identical on all three binaries.</p>
 <p>The export is deleted once its size is measured. Blender sets <code>TMPDIR</code> from its own preference, which resolves to the working directory on a stock portable build, so <code>tempfile.gettempdir()</code> is the repo root under CI and every run used to leave a <code>.glb</code> behind.</p>
 <h3>Why these budgets and not an AABB</h3>
 <p><code>zmin</code> alone cannot see a belt that stops at the bottom edge: the loaf still grounds the box. A single global hay-twine gap cannot see a wrap that hugs one side and gaps the other. A bounding box cannot see two belts 5.4 mm out of step, or a flank with no waist in it. Each of the five budgets in bold above exists because a defect got past everything else and had to be found by looking at a render.</p>
 <p>The z-fight count is taken over <strong>cross-shell</strong> face pairs, not merely over faces that share no vertex: two quads two steps apart on one flat cap share no vertex and are coplanar by construction, and counting those reported 96 pairs, none of them a hazard.</p>
+<h3>Why the loaf is triangulated along its short diagonals</h3>
+<p>The twine used to be a 16 × 24 mm band, and it read as packing tape on a parcel. Thinned to an 8 × 10 mm cord, the two belts came out 0.45 mm out of step, right against the 0.5 mm mirror budget. The loaf&#x27;s vertices were mirror-symmetric to 71 um. The belt profile is raycast from the loaf at each station, though, and the loaf&#x27;s quads are not planar: split along a fixed diagonal, the surface at -x and at +x differed by up to 5.6 mm on the same vertices. The old wide band happened to hide that.</p>
+<p>The loaf is now triangulated with <code>quad_method=&quot;SHORT_EDGE&quot;</code>. On mirror-symmetric vertices the shorter diagonal is mirror-symmetric too, and a tie only happens where a quad is planar, where either split is the same surface. The belt mirror error went back to exactly 0 and the seats to identical values at both stations. This is the surface an engine renders, so it is fixed in the mesh, not only in the sampling. Averaging the two stations&#x27; profiles was tried first and rejected: it put one belt 0.52 mm into the loaf, below the seat band, because neither station&#x27;s real surface is the mean.</p>
+<p>The loaf&#x27;s own symmetry is now asserted directly (<strong>Loaf mirror</strong>, exit 19). Every loaf vertex needs a partner at <code>(-x, y, z)</code> within <code>LOAF_MIRROR_EPS</code>. The belt budget only ever caught an odd shaping term second-hand, through the belts&#x27; extents. <code>--odd-loaf</code> adds a 2 mm odd <code>sin</code> displacement to the finished loaf and fails it. It is applied after the bevel because, put into the shaping function, even 0.3 mm of odd term flipped which edges cleared the bevel&#x27;s 50-degree selection and grew the envelope 16 mm, so the bounding box fired instead.</p>
 <h2>Falsifiers</h2>
-<p>Each breaks one stage so a <strong>named</strong> budget fails and the piece exits that code. All six proven on 4.5.11, 5.1.2 and 5.2.1.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Target budget</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>hygiene: loose vertices</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>grounded AABB zmin</td><td>16</td></tr><tr><td><code>--float-belts</code></td><td>per-belt wrap zmin</td><td>16</td></tr><tr><td><code>--slack-belt</code></td><td>banded belt seat depth</td><td>18</td></tr><tr><td><code>--skew-belt</code></td><td>belt mirror symmetry</td><td>19</td></tr></tbody></table></div>
+<p>Each breaks one stage so a <strong>named</strong> budget fails and the piece exits that code. All seven proven on 4.5.11, 5.1.2 and 5.2.1.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Target budget</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>hygiene: loose vertices</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>grounded AABB zmin</td><td>16</td></tr><tr><td><code>--float-belts</code></td><td>per-belt wrap zmin</td><td>16</td></tr><tr><td><code>--slack-belt</code></td><td>banded belt seat depth</td><td>18</td></tr><tr><td><code>--skew-belt</code></td><td>belt mirror symmetry</td><td>19</td></tr><tr><td><code>--odd-loaf</code></td><td>loaf X-mirror symmetry</td><td>19</td></tr></tbody></table></div>
 <p><code>--stray-vert</code> parks its loose vertex <strong>inside</strong> the bale: above it, the bounding-box budget (exit 8) fired first and the run proved nothing about hygiene. <code>--skew-belt</code> shifts one belt along <strong>X</strong> rather than Z for the same reason — a Z skew landed a belt face coplanar with a loaf face and tripped the z-fight budget (exit 15) instead of its target. <code>--float-belts</code> moves twine only, so the loaf still grounds the AABB and the per-belt gate has to be the thing that fires.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python hay_bale.py --
@@ -306,16 +310,19 @@ <h2>Run</h2>
 blender --background --python hay_bale.py -- --float-belts
 blender --background --python hay_bale.py -- --slack-belt
 blender --background --python hay_bale.py -- --skew-belt
+blender --background --python hay_bale.py -- --odd-loaf
 blender --background --python hay_bale.py -- --output bale.png</code></pre>
 <p>Smoke does not pass <code>--output</code> or any falsifier flag.</p>
 <h2>Shading</h2>
 <p>Decided per part, not globally. The loaf is <strong>flat</strong>-shaded: straw is a chunky matte mass and the facets read as compressed flakes. Smoothing the whole bale erased every ridge and nap in it and left a featureless pillow that read as a bar of soap. Twine is cord, so the belts and hitch loops stay smooth.</p>
 <p>The low mesh carries the form — bulge, waist, ridges, end strata — and the <strong>high mesh carries the straw</strong>: <code>LOAF_CUTS_HIGH</code> subdivision plus per-band flake offsets, moved onto the low mesh by the bake stage. A low mesh dense enough to model flakes directly would cost thousands of triangles for detail this piece already has a bake for.</p>
-<h2>Known gap</h2>
-<p>At hero scale the piece still reads as a wrapped parcel rather than as straw. The form, the binding and the hygiene are right; the surface is not. The next pass on this piece belongs in the <strong>material and bake</strong> — straw needs directional fibre and colour break-up that a 256 px tangent-space normal off a smooth high mesh cannot deliver — not in more geometry. Recorded here so the next run does not re-litigate the silhouette.</p>
+<h2>Surface</h2>
+<p>The bale used to read as a wrapped parcel: flat mustard hay, and a wide dark band for twine. The hay is now <code>straw_material</code>:</p>
+<ul><li>a dense fibre field stretched along the bale (noise with X compressed), and a weaker crossing field for the strands that lie the other way;</li><li>colour pulled between pale straw and dark tan by the fibres, with a faint green cast from low-frequency noise;</li><li>roughness and a bump from the same fibres, so every strand catches light.</li></ul>
+<p>The baked normal is chained under that bump (<code>wire_normal</code>). The twine is an 8 × 10 mm cord, and the hitch loop&#x27;s tube is sized from the same <code>TWINE_T</code>. The earlier note here, that the surface belonged to the material and bake and not to more geometry, was right. The cord was the other half of the parcel read.</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.</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 ≠ 2 distinct slots, or hay/twine faces missing</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>Hygiene: loose, non-manifold, zero-area, doubles, n-gons, or cross-shell z-fight (<code>--stray-vert</code>)</td></tr><tr><td>16</td><td>Grounded: AABB zmin (<code>--lift-z</code>), or a belt that does not wrap under (<code>--float-belts</code>)</td></tr><tr><td>17</td><td>Shell count, or hay–twine BVH gap above 8 mm</td></tr><tr><td>18</td><td>Banded belt seat depth (<code>--slack-belt</code>)</td></tr><tr><td>19</td><td>Belt mirror symmetry (<code>--skew-belt</code>), cinch depth, or loaf 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</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 hay/twine faces missing</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>Hygiene: loose, non-manifold, zero-area, doubles, n-gons, or cross-shell z-fight (<code>--stray-vert</code>)</td></tr><tr><td>16</td><td>Grounded: AABB zmin (<code>--lift-z</code>), or a belt that does not wrap under (<code>--float-belts</code>)</td></tr><tr><td>17</td><td>Shell count, or hay–twine BVH gap above 8 mm</td></tr><tr><td>18</td><td>Banded belt seat depth (<code>--slack-belt</code>)</td></tr><tr><td>19</td><td>Loaf X-mirror symmetry (<code>--odd-loaf</code>), belt mirror symmetry (<code>--skew-belt</code>), cinch depth, or loaf real-world size</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -332,7 +339,8 @@ <h2>Source</h2>
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
 DECIMATE stage so the LOD-ratio budget fails. ``--lift-z`` raises the
-mesh so the grounded-zmin hygiene budget fails.
+mesh so the grounded-zmin hygiene budget fails. ``--odd-loaf`` breaks
+the loaf&#x27;s X-mirror symmetry so the loaf-mirror budget fails.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -354,6 +362,7 @@ <h2>Source</h2>
 <span class="k">import</span> bpy
 <span class="k">from</span> mathutils <span class="k">import</span> Euler, Vector
 <span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
+<span class="k">from</span> mathutils.kdtree <span class="k">import</span> KDTree
 
 <span class="c"># Showcase lives at repo-root/showcase/, not under examples/. The framing</span>
 <span class="c"># helper is the repo&#x27;s only shared import and lives next to the examples;</span>
@@ -368,8 +377,10 @@ <h2>Source</h2>
 BALE_X = <span class="n">0.90</span>
 BALE_Y = <span class="n">0.48</span>
 BALE_Z = <span class="n">0.38</span>
-TWINE_T = <span class="n">0.016</span>
-TWINE_W = <span class="n">0.024</span>
+<span class="c"># Baling twine is a cord, not a strap. At 16 x 24 mm the wrap read as</span>
+<span class="c"># packing tape on a parcel; 8 x 10 mm reads as cord pulled into the straw.</span>
+TWINE_T = <span class="n">0.008</span>
+TWINE_W = <span class="n">0.010</span>
 TWINE_EMBED = <span class="n">0.004</span>
 BELT_XS = (-<span class="n">0.225</span>, <span class="n">0.225</span>)
 LOAF_CUTS = <span class="n">8</span>
@@ -443,6 +454,12 @@ <h2>Source</h2>
 <span class="c"># The two belts are mirror images. The odd ridge term used to put them</span>
 <span class="c"># 5.4 mm out of step, which no budget could see.</span>
 MIRROR_EPS = <span class="n">5e-4</span>
+<span class="c"># The loaf itself must be mirror-symmetric in X: every vertex has a partner</span>
+<span class="c"># at (-x, y, z) within this distance. This is the direct witness for an odd</span>
+<span class="c"># term in the shaping function; the belt extents only ever caught it</span>
+<span class="c"># second-hand. Measured worst on the finished loaf: 71 um (bevel rounding).</span>
+LOAF_MIRROR_EPS = <span class="n">2e-4</span>
+ODD_LOAF_AMP = <span class="n">0.002</span>
 
 <span class="c"># The cinch is what makes this a *bound* bale rather than a pillow, and it</span>
 <span class="c"># is the one feature no other budget here touches: measured as the loaf&#x27;s</span>
@@ -928,6 +945,8 @@ <h2>Source</h2>
         <span class="c"># waist: the cinch measured 2.2 mm and read as a crease rather than</span>
         <span class="c"># as binding.</span>
         press = <span class="n">1.0</span> - _cinch(x) / CINCH
+        <span class="c"># --odd-loaf restores the historical sin() here: the falsifier for</span>
+        <span class="c"># the loaf-mirror budget.</span>
         v.co.y += RIDGE_AMP * math.cos(x * <span class="n">24.0</span>) * (<span class="n">0.35</span> + <span class="n">0.65</span> * abs(ny)) * press
         v.co.z += (
             <span class="n">0.55</span> * RIDGE_AMP * math.cos(x * <span class="n">19.0</span>) * (<span class="n">0.35</span> + <span class="n">0.65</span> * abs(nz))
@@ -954,7 +973,7 @@ <h2>Source</h2>
 
 <span class="k">def</span> build_bale_mesh(name, bevel_offset, bevel_segments, cuts=LOAF_CUTS,
                     flake=<span class="k">False</span>, slack_belt=<span class="k">False</span>, float_belts=<span class="k">False</span>,
-                    skew_belt=<span class="k">False</span>):
+                    skew_belt=<span class="k">False</span>, odd_loaf=<span class="k">False</span>):
     bm = bmesh.new()
     hay_verts = []
     twine_faces = set()
@@ -995,6 +1014,27 @@ <h2>Source</h2>
                 clamp_overlap=<span class="k">True</span>,
             )
 
+        <span class="c"># --odd-loaf: an odd displacement on the finished loaf, applied after</span>
+        <span class="c"># the bevel. Put into the shaping function instead, even 0.3 mm of</span>
+        <span class="c"># odd term flipped which edges cleared the bevel&#x27;s 50-degree</span>
+        <span class="c"># selection and grew the envelope 16 mm, so the bounding box fired</span>
+        <span class="c"># instead of the loaf-mirror budget.</span>
+        <span class="k">if</span> odd_loaf:
+            <span class="k">for</span> v <span class="k">in</span> bm.verts:
+                v.co.y += ODD_LOAF_AMP * math.sin(v.co.x * <span class="n">24.0</span>)
+
+        <span class="c"># Triangulate the loaf along each quad&#x27;s shorter diagonal. The quads</span>
+        <span class="c"># are not planar, and left to a fixed split their diagonals are not</span>
+        <span class="c"># mirrored: the surface at -x and +x differed by up to 5.6 mm on</span>
+        <span class="c"># mirror-symmetric vertices, so a thin cord at the two stations came</span>
+        <span class="c"># out 0.45 mm out of step. On symmetric vertices the shorter</span>
+        <span class="c"># diagonal is symmetric too, and a tie only happens where the quad</span>
+        <span class="c"># is planar, where either split is the same surface. This is the</span>
+        <span class="c"># surface an engine renders, so it is fixed here, not only sampled.</span>
+        loaf_quads = [f <span class="k">for</span> f <span class="k">in</span> bm.faces <span class="k">if</span> len(f.verts) == <span class="n">4</span>]
+        <span class="k">if</span> loaf_quads:
+            bmesh.ops.triangulate(bm, faces=loaf_quads, quad_method=<span class="s">&quot;SHORT_EDGE&quot;</span>)
+
         <span class="c"># Ground and centre the LOAF first, then hang the belts on the</span>
         <span class="c"># finished surface. Placing them beforehand and shifting everything</span>
         <span class="c"># afterwards left each belt a few millimetres off the floor by a</span>
@@ -1034,7 +1074,8 @@ <h2>Source</h2>
                 (x + math.copysign(TWINE_W, x), <span class="n">0.052</span>,
                  top_z - TWINE_EMBED + TWINE_T * <span class="n">0.45</span>),
                 <span class="n">0.030</span>,
-                <span class="n">0.0062</span>,
+                <span class="c"># The loop is the same cord as the wrap: tube sized from it.</span>
+                TWINE_T * <span class="n">0.39</span>,
                 TWINE_IDX,
                 euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
                 n_major=<span class="n">12</span>,
@@ -1115,6 +1156,86 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
+<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> _stretched_noise(nt, coord, stretch, scale, detail):
+    <span class="s">&quot;&quot;&quot;Noise sampled in object space with one axis compressed: streaks along it.&quot;&quot;&quot;</span>
+    mp = nt.nodes.new(<span class="s">&quot;ShaderNodeMapping&quot;</span>)
+    mp.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = stretch
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], mp.inputs[<span class="s">&quot;Vector&quot;</span>])
+    n = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    n.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = scale
+    n.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = detail
+    n.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.65</span>
+    nt.links.new(mp.outputs[<span class="s">&quot;Vector&quot;</span>], n.inputs[<span class="s">&quot;Vector&quot;</span>])
+    <span class="k">return</span> n
+
+
+<span class="k">def</span> straw_material(name):
+    <span class="s">&quot;&quot;&quot;Straw: fibres, colour break-up and a fibre bump, not a flat mustard.
+
+    The bale read as a wrapped parcel because its hay was one flat colour
+    with a soft noise. Straw is streaks: a dense fibre field stretched
+    along the bale, a weaker crossing field for the strands that lie the
+    other way, colour pulled between pale straw and dark tan by the fibres,
+    a faint green cast from low-frequency noise, and a bump from the same
+    fibres so every strand catches light.
+    &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>)
+    along = _stretched_noise(nt, coord, (<span class="n">0.07</span>, <span class="n">1.0</span>, <span class="n">1.0</span>), <span class="n">110.0</span>, <span class="n">6.0</span>)
+    across = _stretched_noise(nt, coord, (<span class="n">1.0</span>, <span class="n">0.09</span>, <span class="n">1.0</span>), <span class="n">90.0</span>, <span class="n">4.0</span>)
+    fib = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    fib.data_type = <span class="s">&quot;FLOAT&quot;</span>
+    _sock(fib.inputs, <span class="s">&quot;Factor_Float&quot;</span>).default_value = <span class="n">0.32</span>
+    nt.links.new(along.outputs[<span class="s">&quot;Fac&quot;</span>], _sock(fib.inputs, <span class="s">&quot;A_Float&quot;</span>))
+    nt.links.new(across.outputs[<span class="s">&quot;Fac&quot;</span>], _sock(fib.inputs, <span class="s">&quot;B_Float&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.34</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.36</span>, <span class="n">0.25</span>, <span class="n">0.075</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.66</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.88</span>, <span class="n">0.71</span>, <span class="n">0.31</span>, <span class="n">1.0</span>)
+    nt.links.new(_sock(fib.outputs, <span class="s">&quot;Result_Float&quot;</span>), ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    patch = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    patch.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = <span class="n">4.0</span>
+    patch.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>], patch.inputs[<span class="s">&quot;Vector&quot;</span>])
+    green = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    green.data_type = <span class="s">&quot;RGBA&quot;</span>
+    green.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    nt.links.new(patch.outputs[<span class="s">&quot;Fac&quot;</span>], _sock(green.inputs, <span class="s">&quot;Factor_Float&quot;</span>))
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], _sock(green.inputs, <span class="s">&quot;A_Color&quot;</span>))
+    _sock(green.inputs, <span class="s">&quot;B_Color&quot;</span>).default_value = (<span class="n">0.90</span>, <span class="n">0.95</span>, <span class="n">0.74</span>, <span class="n">1.0</span>)
+    nt.links.new(_sock(green.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.95</span>
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = <span class="n">0.70</span>
+    nt.links.new(_sock(fib.outputs, <span class="s">&quot;Result_Float&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>])
+    bump = nt.nodes.new(<span class="s">&quot;ShaderNodeBump&quot;</span>)
+    bump.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">0.65</span>
+    bump.inputs[<span class="s">&quot;Distance&quot;</span>].default_value = <span class="n">0.004</span>
+    nt.links.new(_sock(fib.outputs, <span class="s">&quot;Result_Float&quot;</span>), bump.inputs[<span class="s">&quot;Height&quot;</span>])
+    nt.links.new(bump.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> bale_materials():
+    <span class="s">&quot;&quot;&quot;(hay, twine): shared by the check, the render and inspection.&quot;&quot;&quot;</span>
+    hay = straw_material(<span class="s">&quot;BaleHay&quot;</span>)
+    twine = principled(
+        <span class="s">&quot;BaleTwine&quot;</span>, (<span class="n">0.30</span>, <span class="n">0.22</span>, <span class="n">0.11</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.62</span>,
+        noise_scale=<span class="n">60.0</span>, wear=(<span class="n">0.17</span>, <span class="n">0.12</span>, <span class="n">0.06</span>, <span class="n">1.0</span>),
+    )
+    <span class="k">return</span> hay, twine
+
+
 <span class="k">def</span> assign_slots(obj, hay, twine):
     mats = obj.data.materials
     wanted = (hay, twine)
@@ -1251,11 +1372,12 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> check(skip_decimate, lift_z=<span class="k">False</span>, stray_vert=<span class="k">False</span>, slack_belt=<span class="k">False</span>,
-          float_belts=<span class="k">False</span>, skew_belt=<span class="k">False</span>):
+          float_belts=<span class="k">False</span>, skew_belt=<span class="k">False</span>, odd_loaf=<span class="k">False</span>):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     low = build_bale_mesh(
         <span class="s">&quot;BaleLow&quot;</span>, bevel_offset=<span class="n">0.016</span>, bevel_segments=<span class="n">2</span>,
         slack_belt=slack_belt, float_belts=float_belts, skew_belt=skew_belt,
+        odd_loaf=odd_loaf,
     )
     <span class="c"># The high mesh is where the straw lives: finer subdivision plus the</span>
     <span class="c"># flake strata. bake_normal moves that detail onto the low mesh.</span>
@@ -1263,22 +1385,7 @@ <h2>Source</h2>
         <span class="s">&quot;BaleHigh&quot;</span>, bevel_offset=<span class="n">0.016</span>, bevel_segments=<span class="n">4</span>,
         cuts=LOAF_CUTS_HIGH, flake=<span class="k">True</span>,
     )
-    hay = principled(
-        <span class="s">&quot;BaleHay&quot;</span>,
-        (<span class="n">0.66</span>, <span class="n">0.52</span>, <span class="n">0.18</span>, <span class="n">1.0</span>),
-        <span class="n">0.0</span>,
-        <span class="n">0.78</span>,
-        noise_scale=<span class="n">22.0</span>,
-        wear=(<span class="n">0.48</span>, <span class="n">0.36</span>, <span class="n">0.10</span>, <span class="n">1.0</span>),
-    )
-    twine = principled(
-        <span class="s">&quot;BaleTwine&quot;</span>,
-        (<span class="n">0.22</span>, <span class="n">0.16</span>, <span class="n">0.08</span>, <span class="n">1.0</span>),
-        <span class="n">0.0</span>,
-        <span class="n">0.58</span>,
-        noise_scale=<span class="n">14.0</span>,
-        wear=(<span class="n">0.14</span>, <span class="n">0.10</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
-    )
+    hay, twine = bale_materials()
     assign_slots(low, hay, twine)
     assign_slots(high, hay, twine)
     <span class="k">if</span> lift_z:
@@ -1408,6 +1515,16 @@ <h2>Source</h2>
 
     mirror_err = max(mirror_error(belt_shells), mirror_error(loop_shells))
 
+    <span class="c"># Loaf X-symmetry, vertex by vertex.</span>
+    loaf_pts = [low.data.vertices[i].co <span class="k">for</span> i <span class="k">in</span> loaf_comp]
+    kd = KDTree(len(loaf_pts))
+    <span class="k">for</span> k, co <span class="k">in</span> enumerate(loaf_pts):
+        kd.insert(co, k)
+    kd.balance()
+    loaf_mirror = max(
+        kd.find(Vector((-co.x, co.y, co.z)))[<span class="n">2</span>] <span class="k">for</span> co <span class="k">in</span> loaf_pts
+    )
+
     <span class="c"># --- banded seat depth, per angular station --------------------------</span>
     seat_depths = []
     <span class="k">for</span> bx, st <span class="k">in</span> belt_shells:
@@ -1436,7 +1553,7 @@ <h2>Source</h2>
 
     print(
         <span class="s">f&quot;</span><span class="s">measured shells=</span>{n_shells}<span class="s"> loaf=(</span>{core_x:<span class="s">.4f</span>}<span class="s">,</span>{core_y:<span class="s">.4f</span>}<span class="s">,</span>{core_z:<span class="s">.4f</span>}<span class="s">) </span><span class="s">&quot;</span>
-        <span class="s">f&quot;</span><span class="s">mirror_err=</span>{mirror_err:<span class="s">.6f</span>}<span class="s"> zfight=</span>{zfight}<span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">mirror_err=</span>{mirror_err:<span class="s">.6f</span>}<span class="s"> loaf_mirror=</span>{loaf_mirror:<span class="s">.6f</span>}<span class="s"> zfight=</span>{zfight}<span class="s">&quot;</span>
     )
     print(
         <span class="s">f&quot;</span><span class="s">measured cinch waist=</span>{waist:<span class="s">.5f</span>}<span class="s"> midspan=</span>{midspan:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
@@ -1577,6 +1694,13 @@ <h2>Source</h2>
                 <span class="s">&quot;(--slack-belt is the designed fail)&quot;</span>,
                 <span class="n">18</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> loaf_mirror &gt; LOAF_MIRROR_EPS:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">loaf not mirror-symmetric in X: worst vertex </span>{loaf_mirror:<span class="s">.6f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">&gt; </span>{LOAF_MIRROR_EPS}<span class="s"> from its partner — an odd term in the </span><span class="s">&quot;</span>
+            <span class="s">&quot;shaping function (--odd-loaf 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">if</span> mirror_err &gt; MIRROR_EPS:
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">belts out of step by </span>{mirror_err:<span class="s">.6f</span>}<span class="s"> &gt; </span>{MIRROR_EPS}<span class="s"> — the two </span><span class="s">&quot;</span>
@@ -1602,12 +1726,17 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> wire_normal(mat, tex):
+    <span class="s">&quot;&quot;&quot;Baked normal map into the BSDF, under the fibre bump if there is one.&quot;&quot;&quot;</span>
     nt = mat.node_tree
     bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     nrm = nt.nodes.new(<span class="s">&quot;ShaderNodeNormalMap&quot;</span>)
     nrm.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">1.0</span>
     nt.links.new(tex.outputs[<span class="s">&quot;Color&quot;</span>], nrm.inputs[<span class="s">&quot;Color&quot;</span>])
-    nt.links.new(nrm.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
+    bump = next((n <span class="k">for</span> n <span class="k">in</span> nt.nodes <span class="k">if</span> n.bl_idname == <span class="s">&quot;ShaderNodeBump&quot;</span>), <span class="k">None</span>)
+    <span class="k">if</span> bump <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        nt.links.new(nrm.outputs[<span class="s">&quot;Normal&quot;</span>], bump.inputs[<span class="s">&quot;Normal&quot;</span>])
+    <span class="k">else</span>:
+        nt.links.new(nrm.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
 
 
 <span class="k">def</span> render_still(low, hay, tex, path, engine):
@@ -1753,6 +1882,12 @@ <h2>Source</h2>
         help=<span class="s">&quot;falsification: raise one belt so the two wraps stop being &quot;</span>
              <span class="s">&quot;mirror images&quot;</span>,
     )
+    p.add_argument(
+        <span class="s">&quot;--odd-loaf&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: use the odd sin() ridge term so the loaf stops &quot;</span>
+             <span class="s">&quot;being mirror-symmetric in X&quot;</span>,
+    )
     args = p.parse_args(argv)
 
     code, low, _high, hay, tex, _col = check(
@@ -1762,6 +1897,7 @@ <h2>Source</h2>
         float_belts=args.float_belts,
         slack_belt=args.slack_belt,
         skew_belt=args.skew_belt,
+        odd_loaf=args.odd_loaf,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1786,7 +1922,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/hay-bale-hero.webp" alt="A rectangular hay bale bound by two twine belts." />
+    <img src="../assets/hay-bale-hero.webp" alt="A golden fibrous hay bale bound by two thin twine cords with knotted loops on top." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index d5b8fb6c..a70fac4c 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -431,7 +431,7 @@ <h2><a href="shader-node-group/">shader-node-group</a></h2>
       </article>
       <article class="card" data-tags="operators context">
         <a class="card-media" href="temp-override-join/" tabindex="-1" aria-hidden="true">
-          <img src="assets/temp-override-join-hero.webp" alt="Three orange cubes joined into a single diagonal staircase object." loading="lazy" decoding="async" />
+          <img src="assets/temp-override-join-hero.webp" alt="Three amber cubes joined into a single diagonal staircase object, the upper steps standing on grey plinths." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="temp-override-join/">temp-override-join</a></h2>
@@ -442,7 +442,7 @@ <h2><a href="temp-override-join/">temp-override-join</a></h2>
       </article>
       <article class="card" data-tags="geometry-nodes instancing">
         <a class="card-media" href="gn-instance-grid/" tabindex="-1" aria-hidden="true">
-          <img src="assets/gn-instance-grid-hero.webp" alt="A three-by-three grid of green instanced cubes on a dark floor." loading="lazy" decoding="async" />
+          <img src="assets/gn-instance-grid-hero.webp" alt="A three-by-three grid of green instanced cubes, each sitting on a node of a faint source-grid lattice on a dark floor." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="gn-instance-grid/">gn-instance-grid</a></h2>
@@ -970,7 +970,7 @@ <h2><a href="street-lantern/">street-lantern</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="treasure-chest/" tabindex="-1" aria-hidden="true">
-          <img src="assets/treasure-chest-hero.webp" alt="An open wooden treasure chest with a vaulted lid and dark iron bands." loading="lazy" decoding="async" />
+          <img src="assets/treasure-chest-hero.webp" alt="An open grained wooden treasure chest with iron bands following its barrel-vaulted lid." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="treasure-chest/">treasure-chest</a></h2>
@@ -1179,7 +1179,7 @@ <h2><a href="wooden-ladder/">wooden-ladder</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="hay-bale/" tabindex="-1" aria-hidden="true">
-          <img src="assets/hay-bale-hero.webp" alt="A rectangular hay bale bound by two twine belts." loading="lazy" decoding="async" />
+          <img src="assets/hay-bale-hero.webp" alt="A golden fibrous hay bale bound by two thin twine cords with knotted loops on top." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="hay-bale/">hay-bale</a></h2>
diff --git a/docs/gallery/temp-override-join/index.html b/docs/gallery/temp-override-join/index.html
index e830386e..3821fa10 100644
--- a/docs/gallery/temp-override-join/index.html
+++ b/docs/gallery/temp-override-join/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/temp-override-join-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Three orange cubes joined into a single diagonal staircase object." />
+  <meta property="og:image:alt" content="Three amber cubes joined into a single diagonal staircase object, the upper steps standing on grey plinths." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="temp-override-join — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="Join three unit cubes into a staircase under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/temp-override-join-hero.webp" />
-  <meta name="twitter:image:alt" content="Three orange cubes joined into a single diagonal staircase object." />
+  <meta name="twitter:image:alt" content="Three amber cubes joined into a single diagonal staircase object, the upper steps standing on grey plinths." />
   <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>temp-override-join</h1>
     <p>Join three unit cubes into a staircase under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three orange cubes joined into a single diagonal staircase object.">
-      <img src="../assets/temp-override-join-hero.webp" alt="Three orange cubes joined into a single diagonal staircase object." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three amber cubes joined into a single diagonal staircase object, the upper steps standing on grey plinths.">
+      <img src="../assets/temp-override-join-hero.webp" alt="Three amber cubes joined into a single diagonal staircase object, the upper steps standing on grey plinths." width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
     <div class="callout"><span class="tag">witnesses</span> temp_override actually applies: join consumes the sources, exactly one mesh remains, topology is verts = 8 × steps, and local Z spans all three steps.</div>
@@ -427,6 +427,34 @@ <h2>Source</h2>
     <span class="c"># center the staircase footprint; origin is step-0 center</span>
     obj.location = (-(STEPS - <span class="n">1</span>) * CUBE_SIZE / <span class="n">2</span>, <span class="n">0.0</span>, HALF)
 
+    <span class="c"># Stepped plinths under steps 1 and up. The joined steps meet only</span>
+    <span class="c"># along an edge (the geometry the check asserts), so without support</span>
+    <span class="c"># the upper cubes hung in the air. Render-only scaffolding, slimmer</span>
+    <span class="c"># than a step and stopping 2 mm short so no face is shared.</span>
+    plinth_mat = bpy.data.materials.new(<span class="s">&quot;Plinth&quot;</span>)
+    plinth_mat.use_nodes = <span class="k">True</span>
+    pb = plinth_mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    pb.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.11</span>, <span class="n">0.115</span>, <span class="n">0.125</span>, <span class="n">1.0</span>)
+    pb.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.75</span>
+    plinths = []
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, STEPS):
+        top = i * CUBE_SIZE - <span class="n">0.002</span>
+        pme = bpy.data.meshes.new(<span class="s">f&quot;</span><span class="s">Plinth</span>{i}<span class="s">&quot;</span>)
+        pbm = bmesh.new()
+        <span class="k">try</span>:
+            bmesh.ops.create_cube(pbm, size=<span class="n">1.0</span>)
+            bmesh.ops.scale(pbm, vec=(CUBE_SIZE * <span class="n">0.86</span>, CUBE_SIZE * <span class="n">0.86</span>, top),
+                            verts=pbm.verts)
+            bmesh.ops.translate(pbm, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, top / <span class="n">2.0</span>), verts=pbm.verts)
+            pbm.to_mesh(pme)
+        <span class="k">finally</span>:
+            pbm.free()
+        pme.materials.append(plinth_mat)
+        pob = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Plinth</span>{i}<span class="s">&quot;</span>, pme)
+        pob.location = (obj.location.x + i * CUBE_SIZE, <span class="n">0.0</span>, <span class="n">0.0</span>)
+        scene.collection.objects.link(pob)
+        plinths.append(pob)
+
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -453,7 +481,7 @@ <h2>Source</h2>
     scene.world = world
 
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, STEPS * CUBE_SIZE / <span class="n">2</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, STEPS * CUBE_SIZE * <span class="n">0.4</span>)
     scene.collection.objects.link(aim)
 
     <span class="k">def</span> light(name, loc, energy, size, col):
@@ -469,14 +497,19 @@ <h2>Source</h2>
         lc.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
         lc.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
 
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">5.0</span>, <span class="n">6.0</span>), <span class="n">1500.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">3.0</span>), <span class="n">340.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">5.0</span>, <span class="n">2.5</span>), <span class="n">480.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>))
+    <span class="c"># 1500 W was tuned under the default AgX view; under Standard it lifted</span>
+    <span class="c"># the frame above the calibration luma band.</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">950.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.98</span>, <span class="n">0.94</span>))
+    <span class="c"># Fill and rim softened: at 340 / 480 they threw a hot pool onto the</span>
+    <span class="c"># floor to the right of the steps, the brightest thing in frame.</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">200.0</span>, <span class="n">8.0</span>, (<span class="n">0.8</span>, <span class="n">0.87</span>, <span class="n">1.0</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">5.0</span>, <span class="n">2.5</span>), <span class="n">220.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.75</span>, <span class="n">0.45</span>))
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">5.0</span>, -<span class="n">6.4</span>, <span class="n">4.6</span>)
+    <span class="c"># Pulled back so the plinths, which reach the floor, clear the bottom edge.</span>
+    cam.location = (<span class="n">5.7</span>, -<span class="n">7.3</span>, <span class="n">5.1</span>)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
@@ -496,6 +529,7 @@ <h2>Source</h2>
     scene.render.resolution_y = <span class="n">720</span>
     scene.render.image_settings.file_format = <span class="s">&#x27;PNG&#x27;</span>
     scene.render.filepath = path
+    scene.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>  <span class="c"># docs/VISUAL-STYLE.md</span>
     bpy.ops.render.render(write_still=<span class="k">True</span>)
     <span class="k">return</span> os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>
 
@@ -546,7 +580,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/temp-override-join-hero.webp" alt="Three orange cubes joined into a single diagonal staircase object." />
+    <img src="../assets/temp-override-join-hero.webp" alt="Three amber cubes joined into a single diagonal staircase object, the upper steps standing on grey plinths." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/treasure-chest/index.html b/docs/gallery/treasure-chest/index.html
index f798872c..5d86825f 100644
--- a/docs/gallery/treasure-chest/index.html
+++ b/docs/gallery/treasure-chest/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/treasure-chest-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="An open wooden treasure chest with a vaulted lid and dark iron bands." />
+  <meta property="og:image:alt" content="An open grained wooden treasure chest with iron bands following its barrel-vaulted lid." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="treasure-chest — Showcase — Blender Developer Tools" />
   <meta name="twitter:description" content="A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles 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/treasure-chest-hero.webp" />
-  <meta name="twitter:image:alt" content="An open wooden treasure chest with a vaulted lid and dark iron bands." />
+  <meta name="twitter:image:alt" content="An open grained wooden treasure chest with iron bands following its barrel-vaulted lid." />
   <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>treasure-chest</h1>
     <p>A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles 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: An open wooden treasure chest with a vaulted lid and dark iron bands.">
-      <img src="../assets/treasure-chest-hero.webp" alt="An open wooden treasure chest with a vaulted lid and dark iron bands." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: An open grained wooden treasure chest with iron bands following its barrel-vaulted lid.">
+      <img src="../assets/treasure-chest-hero.webp" alt="An open grained wooden treasure chest with iron bands following its barrel-vaulted lid." 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: 3852 tris, two materials with 1608 wood and 318 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.764×0.542×0.691 m, LOD ratios in band, convex collider 176 tris, non-empty glTF. Hygiene all zero, four feet at zmin 0, lid-knuckle to hinge barrel 7 mm, band-wall gap 0. --float-hinge exits 17 on the hinge join; --narrow-bands exits 18 on the band seat.</div>
@@ -284,16 +284,20 @@ <h1>treasure-chest</h1>
 <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>3600–4500</td><td>3852 / 3852 / 3852</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.2196 / 0.2196 / 0.2129</td></tr><tr><td>Materials</td><td>exactly 2 distinct; ≥200 wood, ≥80 metal faces</td><td>2 slots; 1608 / 318</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.764, 0.542, 0.691) m ± 0.015</td><td>(0.7640, 0.5423, 0.6907), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 200</td><td>176</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>288196 / 288196 / 288184 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>3600–4500</td><td>3816 / 3816 / 3816</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.2196 / 0.2196 / 0.2129</td></tr><tr><td>Materials</td><td>exactly 2 distinct; ≥200 wood, ≥80 metal faces</td><td>2 slots; 1608 / 300</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.764, 0.524, 0.696) m ± 0.015</td><td>(0.7640, 0.5237, 0.6958), zmin 0</td></tr><tr><td>Lid bands on the vault</td><td>3 bands spanning the lid; every vertex radius within 1e-4 m of the band&#x27;s inner/outer radius</td><td>3; 0.000000</td></tr><tr><td>Collider tris</td><td>≤ 200</td><td>180</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>285980 / 285980 / 285972 bytes</td></tr></tbody></table></div>
 <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: 4 feet</td><td>each <code>zmin</code> ≤ 1e-3</td><td>4, foot_z 0.00000</td></tr><tr><td>Body plan</td><td>0.74 × 0.46 m ± 0.04</td><td>0.7400 × 0.4600</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>Lid-knuckle to hinge barrel</td><td>≤ 0.020 m</td><td>0.00700</td></tr><tr><td>Band-wall BVH gap</td><td>≤ 0.008 m</td><td>0.00000</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 may differ by a few bytes across series.</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 foot supports at Z=0</td><td>16</td></tr><tr><td><code>--float-hinge</code></td><td>lid-knuckle to hinge barrel</td><td>17</td></tr><tr><td><code>--narrow-bands</code></td><td>band-wall seat</td><td>18</td></tr></tbody></table></div>
+<h3>Lid bands</h3>
+<p>Found on the inspection sheet: the three iron bands on the vaulted lid were each eight boxes rotated about X by <code>+t</code>, with <code>t</code> the arc angle at the segment. At angle <code>t</code> the arc&#x27;s tangent in (y, z) is <code>(cos t, -sin t)</code>, which is a rotation of <code>-t</code>. Every segment sat <code>2t</code> off the tangent, and in the side orthos the bands fanned out from the lid like feathers. The same sign error tilted the front-edge band caps and the hasp. Those segment tips also set the Y envelope: the bounding box shrank 18 mm when they were fixed, so the declared outer size was re-fitted to (0.764, 0.524, 0.696).</p>
+<p>Each band is now one <code>add_arc_slab</code> on the lid&#x27;s own vault: the same angular span and segment count as the lid timber, inner radius <code>LID_BAND_BITE</code> inside the lid, outer radius <code>BAND_T</code> beyond. Caps and hasp rotate by <code>-t</code>. <code>lid_band_audit</code> un-rotates the lid about its hinge, takes each lid-iron shell&#x27;s radius from the vault axis, counts the shells spanning at least 60% of the arc, and requires every band vertex inside the band&#x27;s radial range (exit 18). The builder re-centres the whole mesh after swinging the lid, so the audit recovers that shift from the feet, which are symmetric. The rest of the low body is not: the hasp hangs from the lid down the front. <code>--lift-lid-bands</code> floats the bands 5 mm off the vault (measured 5.000 mm) while the envelope stays inside tolerance.</p>
+<p>The timber gets the per-plank tone and grain shader, and the iron gets rust wear (copied from <code>shipping-crate</code>). The temp glTF export is removed after it is measured.</p>
+<h2>Falsifiers</h2>
+<p>Each violates one named budget. All eight 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 foot supports at Z=0</td><td>16</td></tr><tr><td><code>--float-hinge</code></td><td>lid-knuckle to hinge barrel</td><td>17</td></tr><tr><td><code>--narrow-bands</code></td><td>band-wall seat</td><td>18</td></tr><tr><td><code>--lift-lid-bands</code></td><td>lid bands conform to the vault (floats them 5 mm off it)</td><td>18</td></tr></tbody></table></div>
 <h2>Run</h2>
 <pre><code>blender --background --python treasure_chest.py --
 blender --background --python treasure_chest.py -- --skip-decimate
@@ -302,11 +306,12 @@ <h2>Run</h2>
 blender --background --python treasure_chest.py -- --short-legs
 blender --background --python treasure_chest.py -- --float-hinge
 blender --background --python treasure_chest.py -- --narrow-bands
+blender --background --python treasure_chest.py -- --lift-lid-bands
 blender --background --python treasure_chest.py -- --output chest.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 ≠ 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 foot floats</td></tr><tr><td>17</td><td>Joint fit: lid-knuckle to hinge barrel</td></tr><tr><td>18</td><td>Seat: band-wall gap</td></tr><tr><td>19</td><td>Body plan 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</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 foot floats</td></tr><tr><td>17</td><td>Joint fit: lid-knuckle to hinge barrel</td></tr><tr><td>18</td><td>Seat: band-wall gap, or lid bands off the vault (<code>--lift-lid-bands</code>)</td></tr><tr><td>19</td><td>Body plan off the stated real-world size</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -325,9 +330,10 @@ <h2>Source</h2>
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named foot
 supports, ``--float-hinge`` lid-hinge joint-fit, ``--narrow-bands``
-band-wall seat.
+band-wall seat, ``--lift-lid-bands`` lid bands on the vault.
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
+Construction is closed-form; the only RNG is plank tone, seeded with
+``TONE_SEED``. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -338,6 +344,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
@@ -381,7 +388,7 @@ <h2>Source</h2>
 BODY_D = OUTER_D
 BODY_W_TOL = <span class="n">0.04</span>
 BODY_D_TOL = <span class="n">0.04</span>
-OUTER_SIZE = (<span class="n">0.764</span>, <span class="n">0.542</span>, <span class="n">0.691</span>)
+OUTER_SIZE = (<span class="n">0.764</span>, <span class="n">0.524</span>, <span class="n">0.696</span>)
 
 BASE_TRIS_MIN = <span class="n">3600</span>
 BASE_TRIS_MAX = <span class="n">4500</span>
@@ -412,6 +419,17 @@ <h2>Source</h2>
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
 
+<span class="c"># Lid bands are arc slabs on the lid&#x27;s own vault: inner radius a named bite</span>
+<span class="c"># inside the lid&#x27;s outer surface, outer radius BAND_T beyond that, over</span>
+<span class="c"># the lid&#x27;s full angular span with the lid&#x27;s own segment count.</span>
+LID_SEGS = <span class="n">10</span>
+LID_BAND_BITE = <span class="n">0.002</span>
+LID_BAND_RTOL = <span class="n">1e-4</span>
+N_LID_BANDS = <span class="n">3</span>
+PLANK_TONE_JITTER = <span class="n">0.28</span>
+TONE_SEED = <span class="n">43</span>
+LID_BAND_LIFT = <span class="n">0.005</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>
@@ -524,6 +542,7 @@ <h2>Source</h2>
 <span class="k">def</span> build_chest_mesh(
     name, bevel_offset, bevel_segments,
     short_legs=<span class="k">False</span>, float_hinge=<span class="k">False</span>, narrow_bands=<span class="k">False</span>,
+    lift_lid_bands=<span class="k">False</span>,
 ):
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -720,34 +739,34 @@ <h2>Source</h2>
                 bm, cz, a_front, a_back,
                 VAULT_R, VAULT_R + LID_T,
                 -hx + <span class="n">0.008</span>, hx - <span class="n">0.008</span>,
-                <span class="n">10</span>, WOOD_IDX,
+                LID_SEGS, WOOD_IDX,
             )
         )
 
-        n_band_seg = <span class="n">8</span>
-        bspan = (a_back - a_front) / n_band_seg
-        r_band = VAULT_R + LID_T + BAND_T / <span class="n">2.0</span> + <span class="n">0.002</span>
+        <span class="c"># Each lid band is one arc slab on the lid&#x27;s vault. It used to be</span>
+        <span class="c"># eight boxes rotated about X by +t, but at angle t the arc&#x27;s tangent</span>
+        <span class="c"># in (y, z) is (cos t, -sin t), which is a rotation of -t: every</span>
+        <span class="c"># segment sat 2t off the tangent and the bands fanned out from the</span>
+        <span class="c"># lid like feathers. --lift-lid-bands floats them off the vault.</span>
+        r_band_in = VAULT_R + LID_T - LID_BAND_BITE
         <span class="k">for</span> bx <span class="k">in</span> band_xs:
-            <span class="k">for</span> i <span class="k">in</span> range(n_band_seg):
-                tmid = a_front + (i + <span class="n">0.5</span>) * bspan
-                y = r_band * math.sin(tmid)
-                z = cz + r_band * math.cos(tmid)
-                chord = r_band * bspan + <span class="n">0.003</span>
-                lid_metal.extend(
-                    add_box(
-                        bm, (bx, y, z),
-                        (BAND_W, chord, BAND_T),
-                        METAL_IDX, euler=(tmid, <span class="n">0.0</span>, <span class="n">0.0</span>),
-                    )
+            lift = LID_BAND_LIFT <span class="k">if</span> lift_lid_bands <span class="k">else</span> <span class="n">0.0</span>
+            lid_metal.extend(
+                add_arc_slab(
+                    bm, cz, a_front, a_back, r_band_in + lift, r_band_in + lift + BAND_T,
+                    bx - BAND_W / <span class="n">2.0</span>, bx + BAND_W / <span class="n">2.0</span>, LID_SEGS, METAL_IDX,
                 )
+            )
+            <span class="c"># The cap turning down over the lid&#x27;s front edge: rotated by -t</span>
+            <span class="c"># so its thickness lies along the edge&#x27;s normal (the tangent).</span>
             tmid = a_front
-            y = r_band * math.sin(tmid)
-            z = cz + r_band * math.cos(tmid)
+            y = r_band_in * math.sin(tmid)
+            z = cz + r_band_in * math.cos(tmid)
             lid_metal.extend(
                 add_box(
                     bm, (bx, y - <span class="n">0.008</span>, z - <span class="n">0.006</span>),
                     (BAND_W, BAND_T, LID_T + <span class="n">0.016</span>),
-                    METAL_IDX, euler=(tmid, <span class="n">0.0</span>, <span class="n">0.0</span>),
+                    METAL_IDX, euler=(-tmid, <span class="n">0.0</span>, <span class="n">0.0</span>),
                 )
             )
 
@@ -759,7 +778,7 @@ <h2>Source</h2>
             add_box(
                 bm, (<span class="n">0.0</span>, y - <span class="n">0.018</span>, z - <span class="n">0.010</span>),
                 (<span class="n">0.038</span>, <span class="n">0.010</span>, <span class="n">0.055</span>),
-                METAL_IDX, euler=(tmid, <span class="n">0.0</span>, <span class="n">0.0</span>),
+                METAL_IDX, euler=(-tmid, <span class="n">0.0</span>, <span class="n">0.0</span>),
             )
         )
 
@@ -847,11 +866,129 @@ <h2>Source</h2>
         me.update()
     <span class="k">finally</span>:
         bm.free()
+    paint_planks(me)
     obj = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(obj)
     <span class="k">return</span> obj
 
 
+<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.&quot;&quot;&quot;</span>
+    tone = [<span class="n">0.5</span>] * len(me.polygons)
+    grain = [(<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.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">1.0</span>, <span class="n">0.0</span>, <span class="n">0.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 board (``GrainDir``), tone per board (``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 = <span class="n">30.0</span>
+    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> chest_materials():
+    <span class="s">&quot;&quot;&quot;(wood, iron): shared by the check, the render and inspection.&quot;&quot;&quot;</span>
+    wood = wood_material(<span class="s">&quot;ChestWood&quot;</span>)
+    metal = principled(
+        <span class="s">&quot;ChestMetal&quot;</span>, (<span class="n">0.17</span>, <span class="n">0.165</span>, <span class="n">0.155</span>, <span class="n">1.0</span>), <span class="n">0.80</span>, <span class="n">0.46</span>,
+        noise_scale=<span class="n">18.0</span>, wear=(<span class="n">0.20</span>, <span class="n">0.085</span>, <span class="n">0.032</span>, <span class="n">1.0</span>),
+    )
+    <span class="k">return</span> wood, metal
+
+
 <span class="k">def</span> principled(name, color, metallic, roughness, noise_scale=<span class="n">0.0</span>, wear=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
@@ -1168,6 +1305,59 @@ <h2>Source</h2>
         bm_wood.free()
 
 
+<span class="k">def</span> lid_band_audit(me):
+    <span class="s">&quot;&quot;&quot;Lid bands: how many span the vault, and how true they sit on it.
+
+    Un-rotates every vertex about the hinge by -LID_ANGLE, back into the
+    frame the lid was built in, and takes each iron shell&#x27;s radius from the
+    vault axis. A lid band is an iron shell spanning at least 60% of the
+    lid&#x27;s arc; for those, every vertex radius must lie between the band&#x27;s
+    inner and outer radius. The feathered segments never span the arc, so
+    they are not bands at all.
+    &quot;&quot;&quot;</span>
+    hy = OUTER_D / <span class="n">2.0</span>
+    body_top = FOOT_H + BOTTOM + CAVITY_H
+    cz = body_top - math.sqrt(max(VAULT_R * VAULT_R - hy * hy, <span class="n">1e-6</span>))
+    a_front = math.atan2(-hy, body_top - cz)
+    a_back = math.atan2(hy, body_top - cz)
+    hinge = Vector((<span class="n">0.0</span>, hy, body_top))
+    unrot = Euler((-LID_ANGLE, <span class="n">0.0</span>, <span class="n">0.0</span>)).to_matrix()
+    r_lo = VAULT_R + LID_T - LID_BAND_BITE
+    r_hi = r_lo + BAND_T
+    <span class="c"># The builder re-centres the whole mesh on its AABB after swinging the</span>
+    <span class="c"># lid, so the hinge is no longer where it was built. The body is</span>
+    <span class="c"># symmetric about its construction centre: its own Y-centre is the shift.</span>
+    <span class="c"># The feet only: everything else low on the body includes the hasp,</span>
+    <span class="c"># which hangs from the lid down the front and is not symmetric.</span>
+    <span class="c"># Measured from the mesh&#x27;s own lowest point, so a falsifier that lifts</span>
+    <span class="c"># the whole mesh still finds the feet.</span>
+    z0 = min(v.co.z <span class="k">for</span> v <span class="k">in</span> me.vertices)
+    body_ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> me.vertices <span class="k">if</span> v.co.z &lt; z0 + FOOT_H * <span class="n">0.8</span>]
+    hinge = hinge + Vector((<span class="n">0.0</span>, <span class="n">0.5</span> * (min(body_ys) + max(body_ys)), <span class="n">0.0</span>))
+    cz_shift = hinge.y - hy
+    n = <span class="n">0</span>
+    worst = <span class="n">0.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>
+        pts = [unrot @ (me.vertices[i].co - hinge) + hinge <span class="k">for</span> i <span class="k">in</span> g]
+        <span class="c"># Lid iron only: above the body, around the vault&#x27;s own radius.</span>
+        <span class="k">if</span> min(p.z <span class="k">for</span> p <span class="k">in</span> pts) &lt; body_top - <span class="n">0.01</span>:
+            <span class="k">continue</span>
+        mean_r = sum(math.hypot(p.y, p.z - cz) <span class="k">for</span> p <span class="k">in</span> pts) / len(pts)
+        <span class="k">if</span> <span class="k">not</span> (VAULT_R &lt; mean_r &lt; VAULT_R + LID_T + <span class="n">0.05</span>):
+            <span class="k">continue</span>
+        pts = [Vector((p.x, p.y - cz_shift, p.z)) <span class="k">for</span> p <span class="k">in</span> pts]
+        angs = [math.atan2(p.y, p.z - cz) <span class="k">for</span> p <span class="k">in</span> pts]
+        <span class="k">if</span> max(angs) - min(angs) &lt; <span class="n">0.6</span> * (a_back - a_front):
+            <span class="k">continue</span>
+        n += <span class="n">1</span>
+        <span class="k">for</span> p <span class="k">in</span> pts:
+            r = math.hypot(p.y, p.z - cz)
+            worst = max(worst, r_lo - r, r - r_hi)
+    <span class="k">return</span> {<span class="s">&quot;bands&quot;</span>: n, <span class="s">&quot;worst&quot;</span>: max(worst, <span class="n">0.0</span>)}
+
+
 <span class="k">def</span> add_stray_vert(me):
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -1270,21 +1460,16 @@ <h2>Source</h2>
 <span class="k">def</span> check(
     skip_decimate, lift_z=<span class="k">False</span>, stray_vert=<span class="k">False</span>,
     short_legs=<span class="k">False</span>, float_hinge=<span class="k">False</span>, narrow_bands=<span class="k">False</span>,
+    lift_lid_bands=<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_hinge=float_hinge, narrow_bands=narrow_bands,
+        lift_lid_bands=lift_lid_bands,
     )
     low = build_chest_mesh(<span class="s">&quot;ChestLow&quot;</span>, <span class="n">0.003</span>, <span class="n">2</span>, **flags)
     high = build_chest_mesh(<span class="s">&quot;ChestHigh&quot;</span>, <span class="n">0.003</span>, <span class="n">4</span>, **flags)
-    wood = principled(
-        <span class="s">&quot;ChestWood&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.18</span>, <span class="n">0.06</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.54</span>,
-        noise_scale=<span class="n">6.5</span>, wear=(<span class="n">0.22</span>, <span class="n">0.10</span>, <span class="n">0.04</span>, <span class="n">1.0</span>),
-    )
-    metal = principled(
-        <span class="s">&quot;ChestMetal&quot;</span>, (<span class="n">0.18</span>, <span class="n">0.19</span>, <span class="n">0.22</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.32</span>,
-        noise_scale=<span class="n">5.0</span>, wear=(<span class="n">0.08</span>, <span class="n">0.08</span>, <span class="n">0.09</span>, <span class="n">1.0</span>),
-    )
+    wood, metal = chest_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     <span class="k">if</span> stray_vert:
@@ -1338,6 +1523,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 its own temp preference, which on a portable</span>
+    <span class="c"># build is the working directory, so the export must not outlive this.</span>
+    <span class="k">if</span> os.path.isfile(export_path):
+        os.remove(export_path)
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -1345,6 +1534,8 @@ <h2>Source</h2>
     body = body_audit(low.data)
     hj = hinge_join(low.data)
     bg = band_wall_gap(low.data)
+    lb = lid_band_audit(low.data)
+    print(<span class="s">f&quot;</span><span class="s">measured lid_bands=</span>{lb[<span class="s">&#x27;bands&#x27;</span>]}<span class="s"> lid_band_worst=</span>{lb[<span class="s">&#x27;worst&#x27;</span>]:<span class="s">.6f</span>}<span class="s">&quot;</span>)
 
     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(
@@ -1471,6 +1662,13 @@ <h2>Source</h2>
             <span class="s">&quot;(--narrow-bands is the designed fail)&quot;</span>,
             <span class="n">18</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> lb[<span class="s">&quot;bands&quot;</span>] != N_LID_BANDS <span class="k">or</span> lb[<span class="s">&quot;worst&quot;</span>] &gt; LID_BAND_RTOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">lid bands: </span>{lb[<span class="s">&#x27;bands&#x27;</span>]}<span class="s"> of </span>{N_LID_BANDS}<span class="s"> span the vault, worst </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">radial excursion </span>{lb[<span class="s">&#x27;worst&#x27;</span>]:<span class="s">.6f</span>}<span class="s"> &gt; </span>{LID_BAND_RTOL}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--lift-lid-bands is the designed fail)&quot;</span>,
+            <span class="n">18</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> abs(body[<span class="s">&quot;w&quot;</span>] - BODY_W) &gt; BODY_W_TOL:
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">body width </span>{body[<span class="s">&#x27;w&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_W}<span class="s">&quot;</span>,
@@ -1600,6 +1798,7 @@ <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-hinge&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--narrow-bands&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--lift-lid-bands&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1609,6 +1808,7 @@ <h2>Source</h2>
         short_legs=args.short_legs,
         float_hinge=args.float_hinge,
         narrow_bands=args.narrow_bands,
+        lift_lid_bands=args.lift_lid_bands,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1633,7 +1833,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/treasure-chest-hero.webp" alt="An open wooden treasure chest with a vaulted lid and dark iron bands." />
+    <img src="../assets/treasure-chest-hero.webp" alt="An open grained wooden treasure chest with iron bands following its barrel-vaulted lid." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/gallery.json b/examples/gallery.json
index b9a58fbf..4d043d9a 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -113,7 +113,7 @@
       "name": "temp-override-join",
       "dir": "examples/temp-override-join",
       "teaches": "Join three unit cubes into a staircase under bpy.context.temp_override — the supported replacement for the removed context.copy() dict-pass form.",
-      "alt": "Three orange cubes joined into a single diagonal staircase object.",
+      "alt": "Three amber cubes joined into a single diagonal staircase object, the upper steps standing on grey plinths.",
       "witnessesFix": "temp_override actually applies: join consumes the sources, exactly one mesh remains, topology is verts = 8 × steps, and local Z spans all three steps.",
       "hero": "docs/gallery/assets/temp-override-join-hero.webp",
       "preview": "examples/temp-override-join/preview.webp",
@@ -126,7 +126,7 @@
       "name": "gn-instance-grid",
       "dir": "examples/gn-instance-grid",
       "teaches": "A generative Geometry Nodes tree — Mesh Grid → Instance on Points → Realize Instances → Set Shade Smooth — attached as a NODES modifier with no Group Input geometry.",
-      "alt": "A three-by-three grid of green instanced cubes on a dark floor.",
+      "alt": "A three-by-three grid of green instanced cubes, each sitting on a node of a faint source-grid lattice on a dark floor.",
       "witnessesFix": "Realized instances produce closed-form topology (72 verts, 54 faces), Set Material carries Lime, and the corner instance center sits at its closed-form grid coordinate.",
       "hero": "docs/gallery/assets/gn-instance-grid-hero.webp",
       "preview": "examples/gn-instance-grid/preview.webp",
diff --git a/examples/gn-instance-grid/gn_instance_grid.py b/examples/gn-instance-grid/gn_instance_grid.py
index ba9ffa23..a37bd862 100644
--- a/examples/gn-instance-grid/gn_instance_grid.py
+++ b/examples/gn-instance-grid/gn_instance_grid.py
@@ -187,8 +187,33 @@ def render_still(obj, path, engine):
     # tip the grid so depth reads; cubes already rest on the floor via the tree
     obj.rotation_euler = (0.0, 0.0, math.radians(24))
 
+    # The source Mesh Grid drawn as a faint lattice on the floor, turned with
+    # the instances, so the still shows grid points in and one cube per
+    # point out. Render-only: the same GRID_SIZE / GRID_X / GRID_Y the tree
+    # uses, as a wireframe 1 mm above the floor.
+    lat_me = bpy.data.meshes.new("Lattice")
+    lbm = bmesh.new()
+    try:
+        bmesh.ops.create_grid(lbm, x_segments=GRID_X - 1, y_segments=GRID_Y - 1,
+                              size=GRID_HALF)
+        lbm.to_mesh(lat_me)
+    finally:
+        lbm.free()
+    lat_mat = bpy.data.materials.new("Lattice")
+    lat_mat.use_nodes = True
+    lb = lat_mat.node_tree.nodes["Principled BSDF"]
+    lb.inputs["Base Color"].default_value = (0.30, 0.42, 0.26, 1.0)
+    lb.inputs["Roughness"].default_value = 0.6
+    lat_me.materials.append(lat_mat)
+    lattice = bpy.data.objects.new("Lattice", lat_me)
+    lattice.location = (0.0, 0.0, 0.001)
+    lattice.rotation_euler = obj.rotation_euler
+    wire = lattice.modifiers.new("lattice", "WIREFRAME")
+    wire.thickness = 0.018
+    scene.collection.objects.link(lattice)
+
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, CUBE_SIZE / 2)
+    aim.location = (-0.12, 0.0, 0.0)
     scene.collection.objects.link(aim)
 
     def light(name, loc, energy, size, col):
@@ -220,7 +245,9 @@ 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 = (3.7, -4.3, 2.7)
+    # Higher, so the 3 x 3 layout reads as a grid: from 2.7 m the perspective
+    # scrambled the rows and the right column crowded the frame edge.
+    cam.location = (3.4, -4.6, 4.3)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new('TRACK_TO')
diff --git a/examples/gn-instance-grid/preview.webp b/examples/gn-instance-grid/preview.webp
index 6bf4e1b4..5c5616a5 100644
Binary files a/examples/gn-instance-grid/preview.webp and b/examples/gn-instance-grid/preview.webp differ
diff --git a/examples/temp-override-join/preview.webp b/examples/temp-override-join/preview.webp
index b5234a56..9d59cf02 100644
Binary files a/examples/temp-override-join/preview.webp and b/examples/temp-override-join/preview.webp differ
diff --git a/examples/temp-override-join/temp_override_join.py b/examples/temp-override-join/temp_override_join.py
index f178d896..55830aaa 100644
--- a/examples/temp-override-join/temp_override_join.py
+++ b/examples/temp-override-join/temp_override_join.py
@@ -124,6 +124,34 @@ def render_still(obj, path, engine):
     # center the staircase footprint; origin is step-0 center
     obj.location = (-(STEPS - 1) * CUBE_SIZE / 2, 0.0, HALF)
 
+    # Stepped plinths under steps 1 and up. The joined steps meet only
+    # along an edge (the geometry the check asserts), so without support
+    # the upper cubes hung in the air. Render-only scaffolding, slimmer
+    # than a step and stopping 2 mm short so no face is shared.
+    plinth_mat = bpy.data.materials.new("Plinth")
+    plinth_mat.use_nodes = True
+    pb = plinth_mat.node_tree.nodes["Principled BSDF"]
+    pb.inputs["Base Color"].default_value = (0.11, 0.115, 0.125, 1.0)
+    pb.inputs["Roughness"].default_value = 0.75
+    plinths = []
+    for i in range(1, STEPS):
+        top = i * CUBE_SIZE - 0.002
+        pme = bpy.data.meshes.new(f"Plinth{i}")
+        pbm = bmesh.new()
+        try:
+            bmesh.ops.create_cube(pbm, size=1.0)
+            bmesh.ops.scale(pbm, vec=(CUBE_SIZE * 0.86, CUBE_SIZE * 0.86, top),
+                            verts=pbm.verts)
+            bmesh.ops.translate(pbm, vec=(0.0, 0.0, top / 2.0), verts=pbm.verts)
+            pbm.to_mesh(pme)
+        finally:
+            pbm.free()
+        pme.materials.append(plinth_mat)
+        pob = bpy.data.objects.new(f"Plinth{i}", pme)
+        pob.location = (obj.location.x + i * CUBE_SIZE, 0.0, 0.0)
+        scene.collection.objects.link(pob)
+        plinths.append(pob)
+
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
     try:
@@ -150,7 +178,7 @@ def render_still(obj, path, engine):
     scene.world = world
 
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, STEPS * CUBE_SIZE / 2)
+    aim.location = (0.0, 0.0, STEPS * CUBE_SIZE * 0.4)
     scene.collection.objects.link(aim)
 
     def light(name, loc, energy, size, col):
@@ -166,14 +194,19 @@ def light(name, loc, energy, size, col):
         lc.track_axis = 'TRACK_NEGATIVE_Z'
         lc.up_axis = 'UP_Y'
 
-    light("Key", (-4.0, -5.0, 6.0), 1500.0, 6.0, (1.0, 0.98, 0.94))
-    light("Fill", (5.0, -3.5, 3.0), 340.0, 8.0, (0.8, 0.87, 1.0))
-    light("Rim", (1.5, 5.0, 2.5), 480.0, 4.0, (1.0, 0.75, 0.45))
+    # 1500 W was tuned under the default AgX view; under Standard it lifted
+    # the frame above the calibration luma band.
+    light("Key", (-4.0, -5.0, 6.0), 950.0, 6.0, (1.0, 0.98, 0.94))
+    # Fill and rim softened: at 340 / 480 they threw a hot pool onto the
+    # floor to the right of the steps, the brightest thing in frame.
+    light("Fill", (5.0, -3.5, 3.0), 200.0, 8.0, (0.8, 0.87, 1.0))
+    light("Rim", (1.5, 5.0, 2.5), 220.0, 4.0, (1.0, 0.75, 0.45))
 
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (5.0, -6.4, 4.6)
+    # Pulled back so the plinths, which reach the floor, clear the bottom edge.
+    cam.location = (5.7, -7.3, 5.1)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new('TRACK_TO')
@@ -193,6 +226,7 @@ def light(name, loc, energy, size, col):
     scene.render.resolution_y = 720
     scene.render.image_settings.file_format = 'PNG'
     scene.render.filepath = path
+    scene.view_settings.view_transform = 'Standard'  # docs/VISUAL-STYLE.md
     bpy.ops.render.render(write_still=True)
     return os.path.exists(path) and os.path.getsize(path) > 0
 
diff --git a/showcase/README.md b/showcase/README.md
index f2f1f9a9..42d244a6 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -56,7 +56,9 @@ entry in `showcase/gallery.json`, and a rendered still.
   (exit 18). `--pile-rocks` draws scattered stones together so they
   interpenetrate (file-local code; `terrain-scatter` uses 20).
   `--straddle-handle` mounts a fixture across a board gap (file-local
-  code; `shipping-crate` uses 20).
+  code; `shipping-crate` uses 20). `--odd-loaf` breaks a body's own
+  mirror symmetry (exit 19). `--lift-lid-bands` floats bands off a
+  curved host (exit 18).
   `--sharp-iron` skips a chamfer pass so the edge-treatment budget fails
   (file-local code; `crate-stack` uses 21).
   A budget with no falsifier witnesses nothing:
@@ -361,6 +363,26 @@ entry in `showcase/gallery.json`, and a rendered still.
   A falsifier that only skips the relaxation proves nothing if the parts
   happen to miss anyway; `terrain-scatter`'s `--pile-rocks` also draws
   the scatter inward so collisions are guaranteed.
+- **Assert a body's symmetry on the body (exit 19).** Where mirrored
+  parts are hung on a body, the body itself must be mirror-symmetric:
+  give every vertex a partner at its mirror position within a named
+  epsilon (a KD-tree lookup). A budget on the hung parts sees an odd
+  shaping term only second-hand. **Triangulate non-planar quads along
+  their short diagonals** before raycasting a body or shipping it: a
+  fixed split is not mirror-symmetric, and `hay-bale` sampled surfaces
+  5.6 mm apart at mirrored stations on vertices that matched to 71 um.
+  Apply an odd-term falsifier *after* any angle-selected bevel, or the
+  asymmetry changes which edges the bevel picks and the bounding box
+  fires first.
+- **Bands on a curved host are built on the host's arc (exit 18).** A
+  band on a vault, drum or hoop is one slab on the host's own radius
+  function, with the host's segment count, not a chain of boxes rotated
+  per segment. Rotating a box to a circle's tangent at angle `t` about X
+  needs `-t` when the arc is parameterised as `(sin t, cos t)`, and
+  `treasure-chest`'s `+t` fanned every segment out like feathers. Assert
+  the band radially in the host's construction frame, un-rotating any
+  hinge swing and undoing any re-centring from a part known to be
+  symmetric.
 - **A fixture is mounted on a member, not across a gap (file-local
   code).** Handles, hinges, hasps and plates screwed to planked faces
   must land on one board. A height fixed as a fraction of the frame lands
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 531b64fc..8abe35bd 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -89,7 +89,7 @@
       "name": "treasure-chest",
       "dir": "showcase/treasure-chest",
       "teaches": "A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "An open wooden treasure chest with a vaulted lid and dark iron bands.",
+      "alt": "An open grained wooden treasure chest with iron bands following its barrel-vaulted lid.",
       "witnessesFix": "Recomputed: 3852 tris, two materials with 1608 wood and 318 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.764×0.542×0.691 m, LOD ratios in band, convex collider 176 tris, non-empty glTF. Hygiene all zero, four feet at zmin 0, lid-knuckle to hinge barrel 7 mm, band-wall gap 0. --float-hinge exits 17 on the hinge join; --narrow-bands exits 18 on the band seat.",
       "hero": "docs/gallery/assets/treasure-chest-hero.webp",
       "preview": "showcase/treasure-chest/preview.webp",
@@ -339,7 +339,7 @@
       "name": "hay-bale",
       "dir": "showcase/hay-bale",
       "teaches": "A bound hay bale whose twine belts follow the loaf's own raycast cross-section, asserting recomputed geometry budgets, not an API contract.",
-      "alt": "A rectangular hay bale bound by two twine belts.",
+      "alt": "A golden fibrous hay bale bound by two thin twine cords with knotted loops on top.",
       "witnessesFix": "Recomputed: 2012 tris, two materials with 712 hay and 304 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.921x0.530x0.409 m, zmin 0, hygiene and cross-shell z-fight 0, 5 shells, each belt wrapping under the loaf at zmin 2.6 mm, banded belt seat depth 4.0-16.8 mm over 20/20 stations on both belts, belt mirror error 0, cinch depth 14.2 mm, LOD ratios in band, convex collider 156 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z and --float-belts 16; --slack-belt 18; --skew-belt 19.",
       "hero": "docs/gallery/assets/hay-bale-hero.webp",
       "preview": "showcase/hay-bale/preview.webp",
diff --git a/showcase/hay-bale/README.md b/showcase/hay-bale/README.md
index feb9f605..e1782e94 100644
--- a/showcase/hay-bale/README.md
+++ b/showcase/hay-bale/README.md
@@ -52,20 +52,21 @@ RNG and no version-dependent operator.
 | Base triangles | 1700–2400 | 2012 on all three |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 |
 | LOD2 ratio | 0.10–0.35 of base | 0.2197 |
-| Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 712 hay, 304 twine |
+| Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 1404 hay, 304 twine |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
 | Outer AABB | (0.922, 0.530, 0.409) m ± 0.01 | (0.9208, 0.5295, 0.4087) |
 | Grounded zmin | within 1e-4 of 0 | 0.000000 |
 | Hygiene | loose/nonman/zero-area/doubles/n-gons/**z-fight** = 0 | all 0 |
 | Shell count | exactly 5 (loaf, 2 belts, 2 loops) | 5 |
-| **Belt wrap zmin** | each belt shell ≤ 0.006 m | 0.002628 both |
-| **Belt seat depth** | every station in [0.002, 0.020] m | 0.00400..0.01676 over 20/20 stations, both belts |
+| **Belt wrap zmin** | each belt shell ≤ 0.006 m | 0.002846 both |
+| **Belt seat depth** | every station in [0.002, 0.020] m | 0.00400..0.00903 over 20/20 stations, both belts |
 | **Mirror symmetry** | belts and loops matched within 5e-4 m | 0.000000 |
+| **Loaf mirror** | every loaf vertex has an X-mirror partner within 2e-4 m | 0.000071 |
 | **Cinch depth** | mid-span minus waist in [0.006, 0.020] m | 0.01420 |
 | Loaf X × Z | (0.922, 0.409) m ± 0.02 | (0.9208, 0.4087) |
 | Hay–twine gap | BVH surface < 0.008 m | 0.00002 |
-| Collider tris | ≤ 400 | 156 |
-| Export | written, size > 0 | 156664 / 156664 / 156656 bytes |
+| Collider tris | ≤ 400 | 120 |
+| Export | written, size > 0 | 197504 / 197504 / 197496 bytes |
 
 DECIMATE COLLAPSE triangle counts are **not** guaranteed identical
 across series — the gate is a ratio band, not an exact count. Bake
@@ -93,10 +94,39 @@ over faces that share no vertex: two quads two steps apart on one flat
 cap share no vertex and are coplanar by construction, and counting those
 reported 96 pairs, none of them a hazard.
 
+### Why the loaf is triangulated along its short diagonals
+
+The twine used to be a 16 × 24 mm band, and it read as packing tape on a
+parcel. Thinned to an 8 × 10 mm cord, the two belts came out 0.45 mm out
+of step, right against the 0.5 mm mirror budget. The loaf's vertices
+were mirror-symmetric to 71 um. The belt profile is raycast from the
+loaf at each station, though, and the loaf's quads are not planar: split
+along a fixed diagonal, the surface at -x and at +x differed by up to
+5.6 mm on the same vertices. The old wide band happened to hide that.
+
+The loaf is now triangulated with `quad_method="SHORT_EDGE"`. On
+mirror-symmetric vertices the shorter diagonal is mirror-symmetric too,
+and a tie only happens where a quad is planar, where either split is the
+same surface. The belt mirror error went back to exactly 0 and the seats
+to identical values at both stations. This is the surface an engine
+renders, so it is fixed in the mesh, not only in the sampling. Averaging
+the two stations' profiles was tried first and rejected: it put one belt
+0.52 mm into the loaf, below the seat band, because neither station's
+real surface is the mean.
+
+The loaf's own symmetry is now asserted directly (**Loaf mirror**,
+exit 19). Every loaf vertex needs a partner at `(-x, y, z)` within
+`LOAF_MIRROR_EPS`. The belt budget only ever caught an odd shaping term
+second-hand, through the belts' extents. `--odd-loaf` adds a 2 mm odd
+`sin` displacement to the finished loaf and fails it. It is applied
+after the bevel because, put into the shaping function, even 0.3 mm of
+odd term flipped which edges cleared the bevel's 50-degree selection
+and grew the envelope 16 mm, so the bounding box fired instead.
+
 ## Falsifiers
 
 Each breaks one stage so a **named** budget fails and the piece exits
-that code. All six proven on 4.5.11, 5.1.2 and 5.2.1.
+that code. All seven proven on 4.5.11, 5.1.2 and 5.2.1.
 
 | Flag | Target budget | Exit |
 | --- | --- | --- |
@@ -106,6 +136,7 @@ that code. All six proven on 4.5.11, 5.1.2 and 5.2.1.
 | `--float-belts` | per-belt wrap zmin | 16 |
 | `--slack-belt` | banded belt seat depth | 18 |
 | `--skew-belt` | belt mirror symmetry | 19 |
+| `--odd-loaf` | loaf X-mirror symmetry | 19 |
 
 `--stray-vert` parks its loose vertex **inside** the bale: above it, the
 bounding-box budget (exit 8) fired first and the run proved nothing
@@ -125,6 +156,7 @@ blender --background --python hay_bale.py -- --lift-z
 blender --background --python hay_bale.py -- --float-belts
 blender --background --python hay_bale.py -- --slack-belt
 blender --background --python hay_bale.py -- --skew-belt
+blender --background --python hay_bale.py -- --odd-loaf
 blender --background --python hay_bale.py -- --output bale.png
 ```
 
@@ -144,15 +176,22 @@ per-band flake offsets, moved onto the low mesh by the bake stage. A low
 mesh dense enough to model flakes directly would cost thousands of
 triangles for detail this piece already has a bake for.
 
-## Known gap
+## Surface
+
+The bale used to read as a wrapped parcel: flat mustard hay, and a wide
+dark band for twine. The hay is now `straw_material`:
+- a dense fibre field stretched along the bale (noise with X compressed),
+  and a weaker crossing field for the strands that lie the other way;
+- colour pulled between pale straw and dark tan by the fibres, with a
+  faint green cast from low-frequency noise;
+- roughness and a bump from the same fibres, so every strand catches
+  light.
 
-At hero scale the piece still reads as a wrapped parcel rather than as
-straw. The form, the binding and the hygiene are right; the surface is
-not. The next pass on this piece belongs in the **material and bake**
-— straw needs directional fibre and colour break-up that a 256 px
-tangent-space normal off a smooth high mesh cannot deliver — not in more
-geometry. Recorded here so the next run does not re-litigate the
-silhouette.
+The baked normal is chained under that bump (`wire_normal`). The twine
+is an 8 × 10 mm cord, and the hitch loop's tube is sized from the same
+`TWINE_T`. The earlier note here, that the surface belonged to the
+material and bake and not to more geometry, was right. The cord was the
+other half of the parcel read.
 
 ## Exit codes
 
@@ -180,4 +219,4 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 16 | Grounded: AABB zmin (`--lift-z`), or a belt that does not wrap under (`--float-belts`) |
 | 17 | Shell count, or hay–twine BVH gap above 8 mm |
 | 18 | Banded belt seat depth (`--slack-belt`) |
-| 19 | Belt mirror symmetry (`--skew-belt`), cinch depth, or loaf real-world size |
+| 19 | Loaf X-mirror symmetry (`--odd-loaf`), belt mirror symmetry (`--skew-belt`), cinch depth, or loaf real-world size |
diff --git a/showcase/hay-bale/hay_bale.py b/showcase/hay-bale/hay_bale.py
index 1ede9837..093ff2ab 100644
--- a/showcase/hay-bale/hay_bale.py
+++ b/showcase/hay-bale/hay_bale.py
@@ -7,7 +7,8 @@
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
 DECIMATE stage so the LOD-ratio budget fails. ``--lift-z`` raises the
-mesh so the grounded-zmin hygiene budget fails.
+mesh so the grounded-zmin hygiene budget fails. ``--odd-loaf`` breaks
+the loaf's X-mirror symmetry so the loaf-mirror budget fails.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -29,6 +30,7 @@
 import bpy
 from mathutils import Euler, Vector
 from mathutils.bvhtree import BVHTree
+from mathutils.kdtree import KDTree
 
 # Showcase lives at repo-root/showcase/, not under examples/. The framing
 # helper is the repo's only shared import and lives next to the examples;
@@ -43,8 +45,10 @@
 BALE_X = 0.90
 BALE_Y = 0.48
 BALE_Z = 0.38
-TWINE_T = 0.016
-TWINE_W = 0.024
+# Baling twine is a cord, not a strap. At 16 x 24 mm the wrap read as
+# packing tape on a parcel; 8 x 10 mm reads as cord pulled into the straw.
+TWINE_T = 0.008
+TWINE_W = 0.010
 TWINE_EMBED = 0.004
 BELT_XS = (-0.225, 0.225)
 LOAF_CUTS = 8
@@ -118,6 +122,12 @@
 # The two belts are mirror images. The odd ridge term used to put them
 # 5.4 mm out of step, which no budget could see.
 MIRROR_EPS = 5e-4
+# The loaf itself must be mirror-symmetric in X: every vertex has a partner
+# at (-x, y, z) within this distance. This is the direct witness for an odd
+# term in the shaping function; the belt extents only ever caught it
+# second-hand. Measured worst on the finished loaf: 71 um (bevel rounding).
+LOAF_MIRROR_EPS = 2e-4
+ODD_LOAF_AMP = 0.002
 
 # The cinch is what makes this a *bound* bale rather than a pillow, and it
 # is the one feature no other budget here touches: measured as the loaf's
@@ -603,6 +613,8 @@ def _shape_loaf(verts, flake=False):
         # waist: the cinch measured 2.2 mm and read as a crease rather than
         # as binding.
         press = 1.0 - _cinch(x) / CINCH
+        # --odd-loaf restores the historical sin() here: the falsifier for
+        # the loaf-mirror budget.
         v.co.y += RIDGE_AMP * math.cos(x * 24.0) * (0.35 + 0.65 * abs(ny)) * press
         v.co.z += (
             0.55 * RIDGE_AMP * math.cos(x * 19.0) * (0.35 + 0.65 * abs(nz))
@@ -629,7 +641,7 @@ def _shape_loaf(verts, flake=False):
 
 def build_bale_mesh(name, bevel_offset, bevel_segments, cuts=LOAF_CUTS,
                     flake=False, slack_belt=False, float_belts=False,
-                    skew_belt=False):
+                    skew_belt=False, odd_loaf=False):
     bm = bmesh.new()
     hay_verts = []
     twine_faces = set()
@@ -670,6 +682,27 @@ def build_bale_mesh(name, bevel_offset, bevel_segments, cuts=LOAF_CUTS,
                 clamp_overlap=True,
             )
 
+        # --odd-loaf: an odd displacement on the finished loaf, applied after
+        # the bevel. Put into the shaping function instead, even 0.3 mm of
+        # odd term flipped which edges cleared the bevel's 50-degree
+        # selection and grew the envelope 16 mm, so the bounding box fired
+        # instead of the loaf-mirror budget.
+        if odd_loaf:
+            for v in bm.verts:
+                v.co.y += ODD_LOAF_AMP * math.sin(v.co.x * 24.0)
+
+        # Triangulate the loaf along each quad's shorter diagonal. The quads
+        # are not planar, and left to a fixed split their diagonals are not
+        # mirrored: the surface at -x and +x differed by up to 5.6 mm on
+        # mirror-symmetric vertices, so a thin cord at the two stations came
+        # out 0.45 mm out of step. On symmetric vertices the shorter
+        # diagonal is symmetric too, and a tie only happens where the quad
+        # is planar, where either split is the same surface. This is the
+        # surface an engine renders, so it is fixed here, not only sampled.
+        loaf_quads = [f for f in bm.faces if len(f.verts) == 4]
+        if loaf_quads:
+            bmesh.ops.triangulate(bm, faces=loaf_quads, quad_method="SHORT_EDGE")
+
         # Ground and centre the LOAF first, then hang the belts on the
         # finished surface. Placing them beforehand and shifting everything
         # afterwards left each belt a few millimetres off the floor by a
@@ -709,7 +742,8 @@ def build_bale_mesh(name, bevel_offset, bevel_segments, cuts=LOAF_CUTS,
                 (x + math.copysign(TWINE_W, x), 0.052,
                  top_z - TWINE_EMBED + TWINE_T * 0.45),
                 0.030,
-                0.0062,
+                # The loop is the same cord as the wrap: tube sized from it.
+                TWINE_T * 0.39,
                 TWINE_IDX,
                 euler=(0.0, 0.0, 0.0),
                 n_major=12,
@@ -790,6 +824,86 @@ def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     return mat
 
 
+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 _stretched_noise(nt, coord, stretch, scale, detail):
+    """Noise sampled in object space with one axis compressed: streaks along it."""
+    mp = nt.nodes.new("ShaderNodeMapping")
+    mp.inputs["Scale"].default_value = stretch
+    nt.links.new(coord.outputs["Object"], mp.inputs["Vector"])
+    n = nt.nodes.new("ShaderNodeTexNoise")
+    n.inputs["Scale"].default_value = scale
+    n.inputs["Detail"].default_value = detail
+    n.inputs["Roughness"].default_value = 0.65
+    nt.links.new(mp.outputs["Vector"], n.inputs["Vector"])
+    return n
+
+
+def straw_material(name):
+    """Straw: fibres, colour break-up and a fibre bump, not a flat mustard.
+
+    The bale read as a wrapped parcel because its hay was one flat colour
+    with a soft noise. Straw is streaks: a dense fibre field stretched
+    along the bale, a weaker crossing field for the strands that lie the
+    other way, colour pulled between pale straw and dark tan by the fibres,
+    a faint green cast from low-frequency noise, and a bump from the same
+    fibres so every strand catches light.
+    """
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    along = _stretched_noise(nt, coord, (0.07, 1.0, 1.0), 110.0, 6.0)
+    across = _stretched_noise(nt, coord, (1.0, 0.09, 1.0), 90.0, 4.0)
+    fib = nt.nodes.new("ShaderNodeMix")
+    fib.data_type = "FLOAT"
+    _sock(fib.inputs, "Factor_Float").default_value = 0.32
+    nt.links.new(along.outputs["Fac"], _sock(fib.inputs, "A_Float"))
+    nt.links.new(across.outputs["Fac"], _sock(fib.inputs, "B_Float"))
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.34
+    ramp.color_ramp.elements[0].color = (0.36, 0.25, 0.075, 1.0)
+    ramp.color_ramp.elements[1].position = 0.66
+    ramp.color_ramp.elements[1].color = (0.88, 0.71, 0.31, 1.0)
+    nt.links.new(_sock(fib.outputs, "Result_Float"), ramp.inputs["Fac"])
+    patch = nt.nodes.new("ShaderNodeTexNoise")
+    patch.inputs["Scale"].default_value = 4.0
+    patch.inputs["Detail"].default_value = 2.0
+    nt.links.new(coord.outputs["Object"], patch.inputs["Vector"])
+    green = nt.nodes.new("ShaderNodeMix")
+    green.data_type = "RGBA"
+    green.blend_type = "MULTIPLY"
+    nt.links.new(patch.outputs["Fac"], _sock(green.inputs, "Factor_Float"))
+    nt.links.new(ramp.outputs["Color"], _sock(green.inputs, "A_Color"))
+    _sock(green.inputs, "B_Color").default_value = (0.90, 0.95, 0.74, 1.0)
+    nt.links.new(_sock(green.outputs, "Result_Color"), bsdf.inputs["Base Color"])
+    rough = nt.nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = 0.95
+    rough.inputs["To Max"].default_value = 0.70
+    nt.links.new(_sock(fib.outputs, "Result_Float"), rough.inputs["Value"])
+    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
+    bump = nt.nodes.new("ShaderNodeBump")
+    bump.inputs["Strength"].default_value = 0.65
+    bump.inputs["Distance"].default_value = 0.004
+    nt.links.new(_sock(fib.outputs, "Result_Float"), bump.inputs["Height"])
+    nt.links.new(bump.outputs["Normal"], bsdf.inputs["Normal"])
+    return mat
+
+
+def bale_materials():
+    """(hay, twine): shared by the check, the render and inspection."""
+    hay = straw_material("BaleHay")
+    twine = principled(
+        "BaleTwine", (0.30, 0.22, 0.11, 1.0), 0.0, 0.62,
+        noise_scale=60.0, wear=(0.17, 0.12, 0.06, 1.0),
+    )
+    return hay, twine
+
+
 def assign_slots(obj, hay, twine):
     mats = obj.data.materials
     wanted = (hay, twine)
@@ -926,11 +1040,12 @@ def export_unity(path, objects):
 
 
 def check(skip_decimate, lift_z=False, stray_vert=False, slack_belt=False,
-          float_belts=False, skew_belt=False):
+          float_belts=False, skew_belt=False, odd_loaf=False):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     low = build_bale_mesh(
         "BaleLow", bevel_offset=0.016, bevel_segments=2,
         slack_belt=slack_belt, float_belts=float_belts, skew_belt=skew_belt,
+        odd_loaf=odd_loaf,
     )
     # The high mesh is where the straw lives: finer subdivision plus the
     # flake strata. bake_normal moves that detail onto the low mesh.
@@ -938,22 +1053,7 @@ def check(skip_decimate, lift_z=False, stray_vert=False, slack_belt=False,
         "BaleHigh", bevel_offset=0.016, bevel_segments=4,
         cuts=LOAF_CUTS_HIGH, flake=True,
     )
-    hay = principled(
-        "BaleHay",
-        (0.66, 0.52, 0.18, 1.0),
-        0.0,
-        0.78,
-        noise_scale=22.0,
-        wear=(0.48, 0.36, 0.10, 1.0),
-    )
-    twine = principled(
-        "BaleTwine",
-        (0.22, 0.16, 0.08, 1.0),
-        0.0,
-        0.58,
-        noise_scale=14.0,
-        wear=(0.14, 0.10, 0.05, 1.0),
-    )
+    hay, twine = bale_materials()
     assign_slots(low, hay, twine)
     assign_slots(high, hay, twine)
     if lift_z:
@@ -1083,6 +1183,16 @@ def mirror_error(pairs):
 
     mirror_err = max(mirror_error(belt_shells), mirror_error(loop_shells))
 
+    # Loaf X-symmetry, vertex by vertex.
+    loaf_pts = [low.data.vertices[i].co for i in loaf_comp]
+    kd = KDTree(len(loaf_pts))
+    for k, co in enumerate(loaf_pts):
+        kd.insert(co, k)
+    kd.balance()
+    loaf_mirror = max(
+        kd.find(Vector((-co.x, co.y, co.z)))[2] for co in loaf_pts
+    )
+
     # --- banded seat depth, per angular station --------------------------
     seat_depths = []
     for bx, st in belt_shells:
@@ -1111,7 +1221,7 @@ def half_y_at(x0, half_window):
 
     print(
         f"measured shells={n_shells} loaf=({core_x:.4f},{core_y:.4f},{core_z:.4f}) "
-        f"mirror_err={mirror_err:.6f} zfight={zfight}"
+        f"mirror_err={mirror_err:.6f} loaf_mirror={loaf_mirror:.6f} zfight={zfight}"
     )
     print(
         f"measured cinch waist={waist:.5f} midspan={midspan:.5f} "
@@ -1252,6 +1362,13 @@ def half_y_at(x0, half_window):
                 "(--slack-belt is the designed fail)",
                 18,
             ), None, None, None, None, None
+    if loaf_mirror > LOAF_MIRROR_EPS:
+        return fail(
+            f"loaf not mirror-symmetric in X: worst vertex {loaf_mirror:.6f} "
+            f"> {LOAF_MIRROR_EPS} from its partner — an odd term in the "
+            "shaping function (--odd-loaf is the designed fail)",
+            19,
+        ), None, None, None, None, None
     if mirror_err > MIRROR_EPS:
         return fail(
             f"belts out of step by {mirror_err:.6f} > {MIRROR_EPS} — the two "
@@ -1277,12 +1394,17 @@ def half_y_at(x0, half_window):
 
 
 def wire_normal(mat, tex):
+    """Baked normal map into the BSDF, under the fibre bump if there is one."""
     nt = mat.node_tree
     bsdf = nt.nodes["Principled BSDF"]
     nrm = nt.nodes.new("ShaderNodeNormalMap")
     nrm.inputs["Strength"].default_value = 1.0
     nt.links.new(tex.outputs["Color"], nrm.inputs["Color"])
-    nt.links.new(nrm.outputs["Normal"], bsdf.inputs["Normal"])
+    bump = next((n for n in nt.nodes if n.bl_idname == "ShaderNodeBump"), None)
+    if bump is not None:
+        nt.links.new(nrm.outputs["Normal"], bump.inputs["Normal"])
+    else:
+        nt.links.new(nrm.outputs["Normal"], bsdf.inputs["Normal"])
 
 
 def render_still(low, hay, tex, path, engine):
@@ -1428,6 +1550,12 @@ def main():
         help="falsification: raise one belt so the two wraps stop being "
              "mirror images",
     )
+    p.add_argument(
+        "--odd-loaf",
+        action="store_true",
+        help="falsification: use the odd sin() ridge term so the loaf stops "
+             "being mirror-symmetric in X",
+    )
     args = p.parse_args(argv)
 
     code, low, _high, hay, tex, _col = check(
@@ -1437,6 +1565,7 @@ def main():
         float_belts=args.float_belts,
         slack_belt=args.slack_belt,
         skew_belt=args.skew_belt,
+        odd_loaf=args.odd_loaf,
     )
     if code:
         return code
diff --git a/showcase/hay-bale/preview.webp b/showcase/hay-bale/preview.webp
index bedb19fb..97dfd3ec 100644
Binary files a/showcase/hay-bale/preview.webp and b/showcase/hay-bale/preview.webp differ
diff --git a/showcase/treasure-chest/README.md b/showcase/treasure-chest/README.md
index 87d9bf43..3b0d1030 100644
--- a/showcase/treasure-chest/README.md
+++ b/showcase/treasure-chest/README.md
@@ -27,14 +27,15 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 3600–4500 | 3852 / 3852 / 3852 |
+| Base triangles | 3600–4500 | 3816 / 3816 / 3816 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
 | LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2129 |
-| Materials | exactly 2 distinct; ≥200 wood, ≥80 metal faces | 2 slots; 1608 / 318 |
+| Materials | exactly 2 distinct; ≥200 wood, ≥80 metal faces | 2 slots; 1608 / 300 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.764, 0.542, 0.691) m ± 0.015 | (0.7640, 0.5423, 0.6907), zmin 0 |
-| Collider tris | ≤ 200 | 176 |
-| Export | written, size > 0 | 288196 / 288196 / 288184 bytes |
+| Outer AABB | (0.764, 0.524, 0.696) m ± 0.015 | (0.7640, 0.5237, 0.6958), zmin 0 |
+| Lid bands on the vault | 3 bands spanning the lid; every vertex radius within 1e-4 m of the band's inner/outer radius | 3; 0.000000 |
+| Collider tris | ≤ 200 | 180 |
+| Export | written, size > 0 | 285980 / 285980 / 285972 bytes |
 
 ### Hygiene
 
@@ -65,9 +66,38 @@ stochastic; the gate is `has_data` plus operator `FINISHED`, not
 byte-identity. Construction uses no RNG. Export byte counts may differ
 by a few bytes across series.
 
-### Falsifiers
-
-Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
+### Lid bands
+
+Found on the inspection sheet: the three iron bands on the vaulted lid
+were each eight boxes rotated about X by `+t`, with `t` the arc angle at
+the segment. At angle `t` the arc's tangent in (y, z) is
+`(cos t, -sin t)`, which is a rotation of `-t`. Every segment sat `2t`
+off the tangent, and in the side orthos the bands fanned out from the
+lid like feathers. The same sign error tilted the front-edge band caps
+and the hasp. Those segment tips also set the Y envelope: the bounding
+box shrank 18 mm when they were fixed, so the declared outer size was
+re-fitted to (0.764, 0.524, 0.696).
+
+Each band is now one `add_arc_slab` on the lid's own vault: the same
+angular span and segment count as the lid timber, inner radius
+`LID_BAND_BITE` inside the lid, outer radius `BAND_T` beyond. Caps and
+hasp rotate by `-t`. `lid_band_audit` un-rotates the lid about its
+hinge, takes each lid-iron shell's radius from the vault axis, counts
+the shells spanning at least 60% of the arc, and requires every band
+vertex inside the band's radial range (exit 18). The builder re-centres
+the whole mesh after swinging the lid, so the audit recovers that shift
+from the feet, which are symmetric. The rest of the low body is not: the
+hasp hangs from the lid down the front. `--lift-lid-bands` floats the
+bands 5 mm off the vault (measured 5.000 mm) while the envelope stays
+inside tolerance.
+
+The timber gets the per-plank tone and grain shader, and the iron gets
+rust wear (copied from `shipping-crate`). The temp glTF export is
+removed after it is measured.
+
+## Falsifiers
+
+Each violates one named budget. All eight were run on 4.5.11, 5.1.2 and
 5.2.1 and returned the same code on each.
 
 | Flag | Budget violated | Exit |
@@ -78,6 +108,7 @@ Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
 | `--short-legs` | named foot supports at Z=0 | 16 |
 | `--float-hinge` | lid-knuckle to hinge barrel | 17 |
 | `--narrow-bands` | band-wall seat | 18 |
+| `--lift-lid-bands` | lid bands conform to the vault (floats them 5 mm off it) | 18 |
 
 ## Run
 
@@ -89,6 +120,7 @@ blender --background --python treasure_chest.py -- --lift-z
 blender --background --python treasure_chest.py -- --short-legs
 blender --background --python treasure_chest.py -- --float-hinge
 blender --background --python treasure_chest.py -- --narrow-bands
+blender --background --python treasure_chest.py -- --lift-lid-bands
 blender --background --python treasure_chest.py -- --output chest.png
 ```
 
@@ -120,5 +152,5 @@ hygiene and joint-fit family.
 | 15 | Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight |
 | 16 | Not grounded: bounding box `zmin` off 0, or a named foot floats |
 | 17 | Joint fit: lid-knuckle to hinge barrel |
-| 18 | Seat: band-wall gap |
+| 18 | Seat: band-wall gap, or lid bands off the vault (`--lift-lid-bands`) |
 | 19 | Body plan off the stated real-world size |
diff --git a/showcase/treasure-chest/preview.webp b/showcase/treasure-chest/preview.webp
index 51be3b28..4c92ec53 100644
Binary files a/showcase/treasure-chest/preview.webp and b/showcase/treasure-chest/preview.webp differ
diff --git a/showcase/treasure-chest/treasure_chest.py b/showcase/treasure-chest/treasure_chest.py
index e28a6ee3..f5f9c33e 100644
--- a/showcase/treasure-chest/treasure_chest.py
+++ b/showcase/treasure-chest/treasure_chest.py
@@ -9,9 +9,10 @@
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named foot
 supports, ``--float-hinge`` lid-hinge joint-fit, ``--narrow-bands``
-band-wall seat.
+band-wall seat, ``--lift-lid-bands`` lid bands on the vault.
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
+Construction is closed-form; the only RNG is plank tone, seeded with
+``TONE_SEED``. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -22,6 +23,7 @@
 import argparse
 import math
 import os
+import random
 import sys
 import tempfile
 import traceback
@@ -65,7 +67,7 @@
 BODY_D = OUTER_D
 BODY_W_TOL = 0.04
 BODY_D_TOL = 0.04
-OUTER_SIZE = (0.764, 0.542, 0.691)
+OUTER_SIZE = (0.764, 0.524, 0.696)
 
 BASE_TRIS_MIN = 3600
 BASE_TRIS_MAX = 4500
@@ -96,6 +98,17 @@
 WOOD_IDX = 0
 METAL_IDX = 1
 
+# Lid bands are arc slabs on the lid's own vault: inner radius a named bite
+# inside the lid's outer surface, outer radius BAND_T beyond that, over
+# the lid's full angular span with the lid's own segment count.
+LID_SEGS = 10
+LID_BAND_BITE = 0.002
+LID_BAND_RTOL = 1e-4
+N_LID_BANDS = 3
+PLANK_TONE_JITTER = 0.28
+TONE_SEED = 43
+LID_BAND_LIFT = 0.005
+
 
 def eevee_engine_id():
     return "BLENDER_EEVEE" if bpy.app.version >= (5, 0, 0) else "BLENDER_EEVEE_NEXT"
@@ -208,6 +221,7 @@ def pack_uvs(bm, margin=0.08):
 def build_chest_mesh(
     name, bevel_offset, bevel_segments,
     short_legs=False, float_hinge=False, narrow_bands=False,
+    lift_lid_bands=False,
 ):
     bm = bmesh.new()
     try:
@@ -404,34 +418,34 @@ def build_chest_mesh(
                 bm, cz, a_front, a_back,
                 VAULT_R, VAULT_R + LID_T,
                 -hx + 0.008, hx - 0.008,
-                10, WOOD_IDX,
+                LID_SEGS, WOOD_IDX,
             )
         )
 
-        n_band_seg = 8
-        bspan = (a_back - a_front) / n_band_seg
-        r_band = VAULT_R + LID_T + BAND_T / 2.0 + 0.002
+        # Each lid band is one arc slab on the lid's vault. It used to be
+        # eight boxes rotated about X by +t, but at angle t the arc's tangent
+        # in (y, z) is (cos t, -sin t), which is a rotation of -t: every
+        # segment sat 2t off the tangent and the bands fanned out from the
+        # lid like feathers. --lift-lid-bands floats them off the vault.
+        r_band_in = VAULT_R + LID_T - LID_BAND_BITE
         for bx in band_xs:
-            for i in range(n_band_seg):
-                tmid = a_front + (i + 0.5) * bspan
-                y = r_band * math.sin(tmid)
-                z = cz + r_band * math.cos(tmid)
-                chord = r_band * bspan + 0.003
-                lid_metal.extend(
-                    add_box(
-                        bm, (bx, y, z),
-                        (BAND_W, chord, BAND_T),
-                        METAL_IDX, euler=(tmid, 0.0, 0.0),
-                    )
+            lift = LID_BAND_LIFT if lift_lid_bands else 0.0
+            lid_metal.extend(
+                add_arc_slab(
+                    bm, cz, a_front, a_back, r_band_in + lift, r_band_in + lift + BAND_T,
+                    bx - BAND_W / 2.0, bx + BAND_W / 2.0, LID_SEGS, METAL_IDX,
                 )
+            )
+            # The cap turning down over the lid's front edge: rotated by -t
+            # so its thickness lies along the edge's normal (the tangent).
             tmid = a_front
-            y = r_band * math.sin(tmid)
-            z = cz + r_band * math.cos(tmid)
+            y = r_band_in * math.sin(tmid)
+            z = cz + r_band_in * math.cos(tmid)
             lid_metal.extend(
                 add_box(
                     bm, (bx, y - 0.008, z - 0.006),
                     (BAND_W, BAND_T, LID_T + 0.016),
-                    METAL_IDX, euler=(tmid, 0.0, 0.0),
+                    METAL_IDX, euler=(-tmid, 0.0, 0.0),
                 )
             )
 
@@ -443,7 +457,7 @@ def build_chest_mesh(
             add_box(
                 bm, (0.0, y - 0.018, z - 0.010),
                 (0.038, 0.010, 0.055),
-                METAL_IDX, euler=(tmid, 0.0, 0.0),
+                METAL_IDX, euler=(-tmid, 0.0, 0.0),
             )
         )
 
@@ -531,11 +545,129 @@ def build_chest_mesh(
         me.update()
     finally:
         bm.free()
+    paint_planks(me)
     obj = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(obj)
     return obj
 
 
+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."""
+    tone = [0.5] * len(me.polygons)
+    grain = [(1.0, 0.0, 0.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((1.0, 0.0, 0.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 board (``GrainDir``), tone per board (``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 = 30.0
+    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 chest_materials():
+    """(wood, iron): shared by the check, the render and inspection."""
+    wood = wood_material("ChestWood")
+    metal = principled(
+        "ChestMetal", (0.17, 0.165, 0.155, 1.0), 0.80, 0.46,
+        noise_scale=18.0, wear=(0.20, 0.085, 0.032, 1.0),
+    )
+    return wood, metal
+
+
 def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
@@ -852,6 +984,59 @@ def band_wall_gap(me):
         bm_wood.free()
 
 
+def lid_band_audit(me):
+    """Lid bands: how many span the vault, and how true they sit on it.
+
+    Un-rotates every vertex about the hinge by -LID_ANGLE, back into the
+    frame the lid was built in, and takes each iron shell's radius from the
+    vault axis. A lid band is an iron shell spanning at least 60% of the
+    lid's arc; for those, every vertex radius must lie between the band's
+    inner and outer radius. The feathered segments never span the arc, so
+    they are not bands at all.
+    """
+    hy = OUTER_D / 2.0
+    body_top = FOOT_H + BOTTOM + CAVITY_H
+    cz = body_top - math.sqrt(max(VAULT_R * VAULT_R - hy * hy, 1e-6))
+    a_front = math.atan2(-hy, body_top - cz)
+    a_back = math.atan2(hy, body_top - cz)
+    hinge = Vector((0.0, hy, body_top))
+    unrot = Euler((-LID_ANGLE, 0.0, 0.0)).to_matrix()
+    r_lo = VAULT_R + LID_T - LID_BAND_BITE
+    r_hi = r_lo + BAND_T
+    # The builder re-centres the whole mesh on its AABB after swinging the
+    # lid, so the hinge is no longer where it was built. The body is
+    # symmetric about its construction centre: its own Y-centre is the shift.
+    # The feet only: everything else low on the body includes the hasp,
+    # which hangs from the lid down the front and is not symmetric.
+    # Measured from the mesh's own lowest point, so a falsifier that lifts
+    # the whole mesh still finds the feet.
+    z0 = min(v.co.z for v in me.vertices)
+    body_ys = [v.co.y for v in me.vertices if v.co.z < z0 + FOOT_H * 0.8]
+    hinge = hinge + Vector((0.0, 0.5 * (min(body_ys) + max(body_ys)), 0.0))
+    cz_shift = hinge.y - hy
+    n = 0
+    worst = 0.0
+    for g in shells(me):
+        if mat_of(me, g) != METAL_IDX:
+            continue
+        pts = [unrot @ (me.vertices[i].co - hinge) + hinge for i in g]
+        # Lid iron only: above the body, around the vault's own radius.
+        if min(p.z for p in pts) < body_top - 0.01:
+            continue
+        mean_r = sum(math.hypot(p.y, p.z - cz) for p in pts) / len(pts)
+        if not (VAULT_R < mean_r < VAULT_R + LID_T + 0.05):
+            continue
+        pts = [Vector((p.x, p.y - cz_shift, p.z)) for p in pts]
+        angs = [math.atan2(p.y, p.z - cz) for p in pts]
+        if max(angs) - min(angs) < 0.6 * (a_back - a_front):
+            continue
+        n += 1
+        for p in pts:
+            r = math.hypot(p.y, p.z - cz)
+            worst = max(worst, r_lo - r, r - r_hi)
+    return {"bands": n, "worst": max(worst, 0.0)}
+
+
 def add_stray_vert(me):
     bm = bmesh.new()
     try:
@@ -954,21 +1139,16 @@ def export_unity(path, objects):
 def check(
     skip_decimate, lift_z=False, stray_vert=False,
     short_legs=False, float_hinge=False, narrow_bands=False,
+    lift_lid_bands=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     flags = dict(
         short_legs=short_legs, float_hinge=float_hinge, narrow_bands=narrow_bands,
+        lift_lid_bands=lift_lid_bands,
     )
     low = build_chest_mesh("ChestLow", 0.003, 2, **flags)
     high = build_chest_mesh("ChestHigh", 0.003, 4, **flags)
-    wood = principled(
-        "ChestWood", (0.40, 0.18, 0.06, 1.0), 0.0, 0.54,
-        noise_scale=6.5, wear=(0.22, 0.10, 0.04, 1.0),
-    )
-    metal = principled(
-        "ChestMetal", (0.18, 0.19, 0.22, 1.0), 1.0, 0.32,
-        noise_scale=5.0, wear=(0.08, 0.08, 0.09, 1.0),
-    )
+    wood, metal = chest_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     if stray_vert:
@@ -1022,6 +1202,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 its own temp preference, which on a portable
+    # build is the working directory, so the export must not outlive this.
+    if os.path.isfile(export_path):
+        os.remove(export_path)
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -1029,6 +1213,8 @@ def check(
     body = body_audit(low.data)
     hj = hinge_join(low.data)
     bg = band_wall_gap(low.data)
+    lb = lid_band_audit(low.data)
+    print(f"measured lid_bands={lb['bands']} lid_band_worst={lb['worst']:.6f}")
 
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
@@ -1155,6 +1341,13 @@ def check(
             "(--narrow-bands is the designed fail)",
             18,
         ), None, None, None, None, None
+    if lb["bands"] != N_LID_BANDS or lb["worst"] > LID_BAND_RTOL:
+        return fail(
+            f"lid bands: {lb['bands']} of {N_LID_BANDS} span the vault, worst "
+            f"radial excursion {lb['worst']:.6f} > {LID_BAND_RTOL} "
+            "(--lift-lid-bands is the designed fail)",
+            18,
+        ), None, None, None, None, None
     if abs(body["w"] - BODY_W) > BODY_W_TOL:
         return fail(
             f"body width {body['w']:.4f} off {BODY_W}",
@@ -1284,6 +1477,7 @@ def main():
     p.add_argument("--short-legs", action="store_true")
     p.add_argument("--float-hinge", action="store_true")
     p.add_argument("--narrow-bands", action="store_true")
+    p.add_argument("--lift-lid-bands", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1293,6 +1487,7 @@ def main():
         short_legs=args.short_legs,
         float_hinge=args.float_hinge,
         narrow_bands=args.narrow_bands,
+        lift_lid_bands=args.lift_lid_bands,
     )
     if code:
         return code