diff --git a/docs/gallery/anvil/index.html b/docs/gallery/anvil/index.html
index c730f27..da9f14a 100644
--- a/docs/gallery/anvil/index.html
+++ b/docs/gallery/anvil/index.html
@@ -253,7 +253,7 @@ <h1>anvil</h1>
       <img src="../assets/anvil-hero.webp" alt="anvil render" width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Recomputed: 1052 tris, two materials with 102 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.750×0.406×0.690 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 134 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 1696 tris, two materials with 274 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.746×0.410×0.682 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 162 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/anvil/anvil.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
@@ -264,7 +264,7 @@ <h1>anvil</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>
-<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 980–1140 | 1052 / 1052 / 1052 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2186 / 0.2186 / 0.2110 | | Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 102 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.750, 0.406, 0.690) m ± 0.01 | (0.7500, 0.4060, 0.6900), zmin 0 | | Collider tris | ≤ 180 | 134 | | Export | written, size &gt; 0 | 84092 / 84092 / 84088 bytes |</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 1620–1780 | 1696 / 1696 / 1696 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2193 / 0.2193 / 0.2182 | | Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 274 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.746, 0.410, 0.682) m ± 0.01 | (0.7460, 0.4095, 0.6820), zmin 0 | | Collider tris | ≤ 180 | 162 | | Export | written, size &gt; 0 | 130852 / 130852 / 130840 bytes |</p>
 <p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 4 B on 5.2.1 (glTF serializer), not a gated axis.</p>
 <p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. That is the named budget the falsifier violates.</p>
 <h2>Run</h2>
@@ -333,9 +333,9 @@ <h2>Source</h2>
 HEEL_L = <span class="n">0.11</span>
 
 BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">0.750</span>, <span class="n">0.406</span>, <span class="n">0.690</span>)
-BASE_TRIS_MIN = <span class="n">980</span>
-BASE_TRIS_MAX = <span class="n">1140</span>
+OUTER_SIZE = (<span class="n">0.746</span>, <span class="n">0.410</span>, <span class="n">0.682</span>)
+BASE_TRIS_MIN = <span class="n">1620</span>
+BASE_TRIS_MAX = <span class="n">1780</span>
 LOD1_RATIO_MIN = <span class="n">0.32</span>
 LOD1_RATIO_MAX = <span class="n">0.62</span>
 LOD2_RATIO_MIN = <span class="n">0.10</span>
@@ -461,6 +461,37 @@ <h2>Source</h2>
     <span class="k">return</span> verts
 
 
+<span class="k">def</span> add_rim(bm, loc, major, minor, mat_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">14</span>
+    n_minor = <span class="n">7</span>
+    rings = []
+    <span class="k">for</span> i <span class="k">in</span> range(n_major):
+        u = i * (<span class="n">2.0</span> * math.pi / n_major)
+        ring = []
+        <span class="k">for</span> j <span class="k">in</span> range(n_minor):
+            v = j * (<span class="n">2.0</span> * math.pi / n_minor)
+            x = (major + minor * math.cos(v)) * math.cos(u)
+            y = (major + minor * math.cos(v)) * math.sin(u)
+            z = minor * math.sin(v)
+            ring.append(bm.verts.new((x, y, z)))
+        rings.append(ring)
+    bm.verts.ensure_lookup_table()
+    <span class="k">for</span> i <span class="k">in</span> range(n_major):
+        i2 = (i + <span class="n">1</span>) % n_major
+        <span class="k">for</span> j <span class="k">in</span> range(n_minor):
+            j2 = (j + <span class="n">1</span>) % n_minor
+            face = bm.faces.new(
+                (rings[i][j], rings[i2][j], rings[i2][j2], rings[i][j2])
+            )
+            face.material_index = mat_idx
+    verts = [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
+    rot = Euler(euler).to_matrix()
+    origin = Vector(loc)
+    <span class="k">for</span> v <span class="k">in</span> verts:
+        v.co = rot @ v.co + origin
+    <span class="k">return</span> verts
+
+
 <span class="k">def</span> pack_uvs(bm, margin=<span class="n">0.08</span>):
     uv = bm.loops.layers.uv.new(<span class="s">&quot;UVMap&quot;</span>)
     faces = list(bm.faces)
@@ -511,17 +542,23 @@ <h2>Source</h2>
         metal = []
 
         wood.extend(
-            add_cyl(
-                bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, STUMP_H / <span class="n">2.0</span>), STUMP_R, STUMP_H, <span class="n">14</span>, WOOD_IDX,
+            add_cone(
+                bm,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, STUMP_H / <span class="n">2.0</span>),
+                STUMP_R + <span class="n">0.010</span>,
+                STUMP_R - <span class="n">0.018</span>,
+                STUMP_H,
+                <span class="n">20</span>,
+                WOOD_IDX,
             )
         )
         wood.extend(
             add_cyl(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, STUMP_H + <span class="n">0.012</span>),
-                STUMP_R - <span class="n">0.012</span>,
-                <span class="n">0.024</span>,
-                <span class="n">14</span>,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, STUMP_H + <span class="n">0.010</span>),
+                STUMP_R - <span class="n">0.022</span>,
+                <span class="n">0.020</span>,
+                <span class="n">20</span>,
                 WOOD_IDX,
             )
         )
@@ -540,44 +577,45 @@ <h2>Source</h2>
             <span class="k">for</span> f <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
                 f.material_index = WOOD_IDX
 
-        <span class="k">for</span> z <span class="k">in</span> (<span class="n">0.055</span>, STUMP_H - <span class="n">0.055</span>):
+        <span class="k">for</span> z <span class="k">in</span> (<span class="n">0.048</span>, STUMP_H - <span class="n">0.042</span>):
             metal.extend(
-                add_cyl(
-                    bm,
-                    (<span class="n">0.0</span>, <span class="n">0.0</span>, z),
-                    STUMP_R + <span class="n">0.008</span>,
-                    <span class="n">0.028</span>,
-                    <span class="n">16</span>,
-                    METAL_IDX,
-                )
+                add_rim(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, z), STUMP_R + <span class="n">0.004</span>, <span class="n">0.011</span>, METAL_IDX)
             )
 
         z0 = STUMP_H
         metal.extend(
             add_box(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, z0 + <span class="n">0.028</span>),
-                (FOOT_L, FOOT_W, <span class="n">0.056</span>),
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, z0 + <span class="n">0.024</span>),
+                (<span class="n">0.38</span>, <span class="n">0.168</span>, <span class="n">0.048</span>),
+                METAL_IDX,
+            )
+        )
+        metal.extend(
+            add_box(
+                bm,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, z0 + <span class="n">0.066</span>),
+                (<span class="n">0.30</span>, <span class="n">0.132</span>, <span class="n">0.038</span>),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_box(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, z0 + <span class="n">0.056</span> + BODY_H / <span class="n">2.0</span>),
-                (WAIST_L, WAIST_W, BODY_H),
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, z0 + <span class="n">0.148</span>),
+                (<span class="n">0.176</span>, <span class="n">0.070</span>, <span class="n">0.130</span>),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_box(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, z0 + <span class="n">0.056</span> + BODY_H + <span class="n">0.028</span>),
-                (FACE_L * <span class="n">0.90</span>, FACE_W * <span class="n">0.88</span>, <span class="n">0.056</span>),
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, z0 + <span class="n">0.248</span>),
+                (<span class="n">0.34</span>, <span class="n">0.112</span>, <span class="n">0.052</span>),
                 METAL_IDX,
             )
         )
-        face_z = z0 + <span class="n">0.056</span> + BODY_H + <span class="n">0.056</span> + FACE_T / <span class="n">2.0</span>
+        face_z = z0 + <span class="n">0.248</span> + <span class="n">0.026</span> + FACE_T / <span class="n">2.0</span>
         metal.extend(
             add_box(
                 bm,
@@ -587,15 +625,15 @@ <h2>Source</h2>
             )
         )
 
-        horn_z = face_z - <span class="n">0.018</span>
+        horn_z = face_z - <span class="n">0.012</span>
         metal.extend(
             add_cone(
                 bm,
-                (FACE_L / <span class="n">2.0</span> + HORN_L / <span class="n">2.0</span> - <span class="n">0.02</span>, <span class="n">0.0</span>, horn_z),
-                <span class="n">0.052</span>,
-                <span class="n">0.016</span>,
+                (FACE_L / <span class="n">2.0</span> + HORN_L / <span class="n">2.0</span> - <span class="n">0.028</span>, <span class="n">0.0</span>, horn_z),
+                <span class="n">0.056</span>,
+                <span class="n">0.014</span>,
                 HORN_L,
-                <span class="n">12</span>,
+                <span class="n">16</span>,
                 METAL_IDX,
                 euler=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
             )
@@ -603,34 +641,34 @@ <h2>Source</h2>
         metal.extend(
             add_box(
                 bm,
-                (FACE_L / <span class="n">2.0</span> - <span class="n">0.01</span>, <span class="n">0.0</span>, horn_z - <span class="n">0.028</span>),
-                (<span class="n">0.09</span>, FACE_W * <span class="n">0.92</span>, <span class="n">0.040</span>),
+                (FACE_L / <span class="n">2.0</span> - <span class="n">0.018</span>, <span class="n">0.0</span>, horn_z - <span class="n">0.018</span>),
+                (<span class="n">0.10</span>, FACE_W * <span class="n">0.90</span>, <span class="n">0.048</span>),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_box(
                 bm,
-                (-FACE_L / <span class="n">2.0</span> - HEEL_L / <span class="n">2.0</span> + <span class="n">0.02</span>, <span class="n">0.0</span>, face_z - <span class="n">0.008</span>),
-                (HEEL_L, FACE_W * <span class="n">0.92</span>, FACE_T * <span class="n">0.82</span>),
+                (-FACE_L / <span class="n">2.0</span> - HEEL_L / <span class="n">2.0</span> + <span class="n">0.016</span>, <span class="n">0.0</span>, face_z - <span class="n">0.006</span>),
+                (HEEL_L, FACE_W * <span class="n">0.90</span>, FACE_T * <span class="n">0.78</span>),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_box(
                 bm,
-                (FACE_L * <span class="n">0.22</span>, <span class="n">0.0</span>, face_z + FACE_T / <span class="n">2.0</span> - <span class="n">0.006</span>),
-                (<span class="n">0.034</span>, <span class="n">0.034</span>, <span class="n">0.014</span>),
+                (FACE_L * <span class="n">0.18</span>, <span class="n">0.0</span>, face_z + FACE_T / <span class="n">2.0</span> - <span class="n">0.005</span>),
+                (<span class="n">0.032</span>, <span class="n">0.032</span>, <span class="n">0.012</span>),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_cyl(
                 bm,
-                (FACE_L * <span class="n">0.32</span>, <span class="n">0.0</span>, face_z + FACE_T / <span class="n">2.0</span> - <span class="n">0.004</span>),
+                (FACE_L * <span class="n">0.30</span>, <span class="n">0.0</span>, face_z + FACE_T / <span class="n">2.0</span> - <span class="n">0.004</span>),
                 <span class="n">0.009</span>,
                 <span class="n">0.012</span>,
-                <span class="n">8</span>,
+                <span class="n">10</span>,
                 METAL_IDX,
             )
         )
@@ -808,7 +846,7 @@ <h2>Source</h2>
     low = build_anvil_mesh(<span class="s">&quot;AnvilLow&quot;</span>, bevel_offset=<span class="n">0.005</span>, bevel_segments=<span class="n">2</span>)
     high = build_anvil_mesh(<span class="s">&quot;AnvilHigh&quot;</span>, bevel_offset=<span class="n">0.005</span>, bevel_segments=<span class="n">4</span>)
     wood = principled(<span class="s">&quot;AnvilStump&quot;</span>, (<span class="n">0.34</span>, <span class="n">0.18</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.62</span>)
-    metal = principled(<span class="s">&quot;AnvilSteel&quot;</span>, (<span class="n">0.18</span>, <span class="n">0.185</span>, <span class="n">0.195</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.24</span>)
+    metal = principled(<span class="s">&quot;AnvilSteel&quot;</span>, (<span class="n">0.44</span>, <span class="n">0.45</span>, <span class="n">0.47</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.30</span>)
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -957,7 +995,7 @@ <h2>Source</h2>
             ob.hide_render = <span class="k">True</span>
             ob.hide_viewport = <span class="k">True</span>
 
-    low.rotation_euler.z = math.radians(-<span class="n">22.0</span>)
+    low.rotation_euler.z = math.radians(-<span class="n">8.0</span>)
     low.rotation_euler.x = math.radians(<span class="n">0.0</span>)
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
@@ -1004,10 +1042,10 @@ <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">1.36</span>, -<span class="n">1.68</span>, <span class="n">0.93</span>)
+    cam.location = (<span class="n">0.70</span>, -<span class="n">2.20</span>, <span class="n">1.08</span>)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.36</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.40</span>)
     scene.collection.objects.link(aim)
     con = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     con.target = aim
diff --git a/docs/gallery/assets/anvil-hero.webp b/docs/gallery/assets/anvil-hero.webp
index 0a706f6..3caed77 100644
Binary files a/docs/gallery/assets/anvil-hero.webp and b/docs/gallery/assets/anvil-hero.webp differ
diff --git a/docs/gallery/assets/hand-pump-hero.webp b/docs/gallery/assets/hand-pump-hero.webp
index 4902358..aaa9171 100644
Binary files a/docs/gallery/assets/hand-pump-hero.webp and b/docs/gallery/assets/hand-pump-hero.webp differ
diff --git a/docs/gallery/assets/signpost-hero.webp b/docs/gallery/assets/signpost-hero.webp
index 0d00ef7..b2727e0 100644
Binary files a/docs/gallery/assets/signpost-hero.webp and b/docs/gallery/assets/signpost-hero.webp differ
diff --git a/docs/gallery/assets/water-trough-hero.webp b/docs/gallery/assets/water-trough-hero.webp
index 58a2d57..2395fd8 100644
Binary files a/docs/gallery/assets/water-trough-hero.webp and b/docs/gallery/assets/water-trough-hero.webp differ
diff --git a/docs/gallery/hand-pump/index.html b/docs/gallery/hand-pump/index.html
index 3b395d2..e1c27d2 100644
--- a/docs/gallery/hand-pump/index.html
+++ b/docs/gallery/hand-pump/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>hand-pump — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural village hand pump through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural village hand pump with a gooseneck through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/hand-pump/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="hand-pump — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural village hand pump through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural village hand pump with a gooseneck through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/hand-pump/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/hand-pump-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="hand-pump — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural village hand pump through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural village hand pump with a gooseneck 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/hand-pump-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,25 +246,25 @@
   </div>
   <header class="hero">
     <h1>hand-pump</h1>
-    <p>A procedural village hand pump through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural village hand pump with a gooseneck 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="Zoom hand-pump render">
       <img src="../assets/hand-pump-hero.webp" alt="hand-pump render" width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Recomputed: 616 tris, two materials with 96 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.567×0.366×1.027 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 118 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 1164 tris, two materials with 222 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.610×0.364×1.049 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 110 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/hand-pump/hand_pump.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural cast-iron village hand pump (wooden plinth, column, spout, handle, wooden grip) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>A showcase piece, not an example. Procedural cast-iron village hand pump (stacked wooden plinth, two-diameter column, gooseneck spout, pump head, forked handle, wooden grip) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 540–700 | 616 / 616 / 616 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2175 / 0.2175 / 0.2143 | | Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 96 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.567, 0.366, 1.027) m ± 0.01 | (0.5668, 0.3660, 1.0271), zmin 0 | | Collider tris | ≤ 160 | 118 | | Export | written, size &gt; 0 | 52764 / 52764 / 52756 bytes |</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 1080–1240 | 1164 / 1164 / 1164 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2199 / 0.2199 / 0.2148 | | Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 222 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.610, 0.364, 1.049) m ± 0.01 | (0.6100, 0.3639, 1.0491), zmin 0 | | Collider tris | ≤ 160 | 110 | | Export | written, size &gt; 0 | 85944 / 85944 / 85936 bytes |</p>
 <p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 8 B on 5.2.1 (glTF serializer), not a gated axis.</p>
 <p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. That is the named budget the falsifier violates.</p>
 <h2>Run</h2>
@@ -319,19 +319,18 @@ <h2>Source</h2>
 sys.dont_write_bytecode = <span class="k">True</span>
 <span class="k">import</span> gallery_framing  <span class="c"># noqa: E402</span>
 
-PLINTH_XY = <span class="n">0.30</span>
-PLINTH_H = <span class="n">0.072</span>
+PLINTH_XY = <span class="n">0.34</span>
+PLINTH_H = <span class="n">0.090</span>
 COL_R = <span class="n">0.050</span>
 COL_H = <span class="n">0.78</span>
-COL_SEGS = <span class="n">12</span>
-SPOUT_Z = <span class="n">0.42</span>
-SPOUT_L = <span class="n">0.16</span>
-HANDLE_LIFT = <span class="n">0.20</span>
+COL_SEGS = <span class="n">16</span>
+SPOUT_Z = <span class="n">0.46</span>
+HANDLE_LIFT = <span class="n">0.18</span>
 
 BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">0.567</span>, <span class="n">0.366</span>, <span class="n">1.027</span>)
-BASE_TRIS_MIN = <span class="n">540</span>
-BASE_TRIS_MAX = <span class="n">700</span>
+OUTER_SIZE = (<span class="n">0.610</span>, <span class="n">0.364</span>, <span class="n">1.049</span>)
+BASE_TRIS_MIN = <span class="n">1080</span>
+BASE_TRIS_MAX = <span class="n">1240</span>
 LOD1_RATIO_MIN = <span class="n">0.32</span>
 LOD1_RATIO_MAX = <span class="n">0.62</span>
 LOD2_RATIO_MIN = <span class="n">0.10</span>
@@ -415,6 +414,26 @@ <h2>Source</h2>
     )
 
 
+<span class="k">def</span> add_cyl_between(bm, a, b, radius, segments, mat_idx):
+    a = Vector(a)
+    b = Vector(b)
+    delta = b - a
+    length = delta.length
+    <span class="k">if</span> length &lt; <span class="n">1e-8</span>:
+        <span class="k">return</span> []
+    quat = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)).rotation_difference(delta.normalized())
+    eul = quat.to_euler(<span class="s">&quot;XYZ&quot;</span>)
+    <span class="k">return</span> add_cyl(
+        bm,
+        ((a + b) * <span class="n">0.5</span>),
+        radius,
+        length,
+        segments,
+        mat_idx,
+        euler=(eul.x, eul.y, eul.z),
+    )
+
+
 <span class="k">def</span> add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
     geo = bmesh.ops.create_cone(
         bm,
@@ -545,27 +564,37 @@ <h2>Source</h2>
     <span class="k">try</span>:
         wood = []
         metal = []
-        col_z = PLINTH_H + COL_H / <span class="n">2.0</span>
-        top_z = PLINTH_H + COL_H
+        slab_h = <span class="n">0.050</span>
+        cap_h = <span class="n">0.040</span>
+        top_z = slab_h + cap_h + COL_H
 
         wood.extend(
             add_box(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, PLINTH_H / <span class="n">2.0</span>),
-                (PLINTH_XY, PLINTH_XY, PLINTH_H),
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, slab_h / <span class="n">2.0</span>),
+                (PLINTH_XY, PLINTH_XY, slab_h),
                 WOOD_IDX,
             )
         )
-        grip_end = Vector((-<span class="n">0.36</span>, <span class="n">0.10</span>, top_z - <span class="n">0.04</span> + HANDLE_LIFT))
+        wood.extend(
+            add_box(
+                bm,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, slab_h + cap_h / <span class="n">2.0</span>),
+                (<span class="n">0.26</span>, <span class="n">0.26</span>, cap_h),
+                WOOD_IDX,
+            )
+        )
+        pivot = Vector((<span class="n">0.0</span>, COL_R + <span class="n">0.030</span>, top_z - <span class="n">0.018</span>))
+        grip_end = Vector((-<span class="n">0.38</span>, pivot.y + <span class="n">0.02</span>, pivot.z + HANDLE_LIFT))
         wood.extend(
             add_cyl(
                 bm,
                 (grip_end.x, grip_end.y, grip_end.z),
-                <span class="n">0.016</span>,
-                <span class="n">0.11</span>,
-                <span class="n">8</span>,
+                <span class="n">0.018</span>,
+                <span class="n">0.12</span>,
+                <span class="n">10</span>,
                 WOOD_IDX,
-                euler=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.25</span>),
+                euler=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
             )
         )
 
@@ -583,87 +612,133 @@ <h2>Source</h2>
             <span class="k">for</span> f <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
                 f.material_index = WOOD_IDX
 
+        plinth_top = slab_h + cap_h
         metal.extend(
             add_cyl(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, PLINTH_H + <span class="n">0.014</span>),
-                <span class="n">0.092</span>,
-                <span class="n">0.028</span>,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, plinth_top + <span class="n">0.016</span>),
+                <span class="n">0.095</span>,
+                <span class="n">0.032</span>,
                 COL_SEGS,
                 METAL_IDX,
             )
         )
+        lower_h = <span class="n">0.40</span>
         metal.extend(
             add_cyl(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, col_z),
-                COL_R,
-                COL_H,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, plinth_top + lower_h / <span class="n">2.0</span>),
+                <span class="n">0.062</span>,
+                lower_h,
                 COL_SEGS,
                 METAL_IDX,
             )
         )
+        joint_z = plinth_top + lower_h
         metal.extend(
             add_cyl(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, PLINTH_H + COL_H * <span class="n">0.42</span>),
-                COL_R + <span class="n">0.010</span>,
-                <span class="n">0.032</span>,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, joint_z),
+                <span class="n">0.078</span>,
+                <span class="n">0.026</span>,
                 COL_SEGS,
                 METAL_IDX,
             )
         )
+        upper_h = <span class="n">0.36</span>
         metal.extend(
-            add_cone(
+            add_cyl(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, top_z + <span class="n">0.028</span>),
-                <span class="n">0.058</span>,
-                <span class="n">0.018</span>,
-                <span class="n">0.056</span>,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, joint_z + upper_h / <span class="n">2.0</span>),
+                <span class="n">0.046</span>,
+                upper_h,
                 COL_SEGS,
                 METAL_IDX,
             )
         )
-        spout_y = -(COL_R + SPOUT_L / <span class="n">2.0</span>)
+        metal.extend(
+            add_box(
+                bm,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, top_z + <span class="n">0.012</span>),
+                (<span class="n">0.10</span>, <span class="n">0.10</span>, <span class="n">0.085</span>),
+                METAL_IDX,
+            )
+        )
         metal.extend(
             add_cyl(
                 bm,
-                (<span class="n">0.0</span>, spout_y, SPOUT_Z),
-                <span class="n">0.022</span>,
-                SPOUT_L,
-                <span class="n">10</span>,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, top_z + <span class="n">0.068</span>),
+                <span class="n">0.034</span>,
+                <span class="n">0.036</span>,
+                COL_SEGS,
                 METAL_IDX,
-                euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
             )
         )
+
+        arc_r = <span class="n">0.13</span>
+        origin_y = -(<span class="n">0.046</span>)
+        origin_z = SPOUT_Z
+        n_arc = <span class="n">7</span>
+        last = <span class="k">None</span>
+        <span class="k">for</span> i <span class="k">in</span> range(n_arc):
+            t0 = (i / n_arc) * (math.pi / <span class="n">2.0</span>)
+            t1 = ((i + <span class="n">1</span>) / n_arc) * (math.pi / <span class="n">2.0</span>)
+            p0 = (
+                <span class="n">0.0</span>,
+                origin_y - arc_r * math.sin(t0),
+                origin_z - arc_r * (<span class="n">1.0</span> - math.cos(t0)),
+            )
+            p1 = (
+                <span class="n">0.0</span>,
+                origin_y - arc_r * math.sin(t1),
+                origin_z - arc_r * (<span class="n">1.0</span> - math.cos(t1)),
+            )
+            metal.extend(add_cyl_between(bm, p0, p1, <span class="n">0.018</span>, <span class="n">10</span>, METAL_IDX))
+            last = p1
         metal.extend(
             add_cyl(
                 bm,
-                (<span class="n">0.0</span>, spout_y - SPOUT_L / <span class="n">2.0</span> + <span class="n">0.012</span>, SPOUT_Z - <span class="n">0.045</span>),
-                <span class="n">0.018</span>,
-                <span class="n">0.090</span>,
+                (<span class="n">0.0</span>, last[<span class="n">1</span>], last[<span class="n">2</span>] - <span class="n">0.028</span>),
+                <span class="n">0.016</span>,
+                <span class="n">0.056</span>,
                 <span class="n">10</span>,
                 METAL_IDX,
             )
         )
-        pivot = Vector((<span class="n">0.0</span>, COL_R + <span class="n">0.018</span>, top_z - <span class="n">0.055</span>))
+
+        metal.extend(
+            add_box(
+                bm,
+                (<span class="n">0.028</span>, pivot.y, pivot.z),
+                (<span class="n">0.022</span>, <span class="n">0.048</span>, <span class="n">0.050</span>),
+                METAL_IDX,
+            )
+        )
+        metal.extend(
+            add_box(
+                bm,
+                (-<span class="n">0.028</span>, pivot.y, pivot.z),
+                (<span class="n">0.022</span>, <span class="n">0.048</span>, <span class="n">0.050</span>),
+                METAL_IDX,
+            )
+        )
         metal.extend(
             add_cyl(
                 bm,
-                (pivot.x, pivot.y, pivot.z),
-                <span class="n">0.016</span>,
-                <span class="n">0.055</span>,
-                <span class="n">8</span>,
+                (<span class="n">0.0</span>, pivot.y, pivot.z),
+                <span class="n">0.012</span>,
+                <span class="n">0.072</span>,
+                <span class="n">10</span>,
                 METAL_IDX,
-                euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
+                euler=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
             )
         )
         metal.extend(
             add_oriented_box(
                 bm,
                 (pivot.x, pivot.y, pivot.z),
-                (grip_end.x + <span class="n">0.04</span>, grip_end.y, grip_end.z),
-                (<span class="n">0.022</span>, <span class="n">0.018</span>),
+                (grip_end.x + <span class="n">0.03</span>, grip_end.y, grip_end.z),
+                (<span class="n">0.020</span>, <span class="n">0.016</span>),
                 METAL_IDX,
             )
         )
@@ -841,7 +916,7 @@ <h2>Source</h2>
     low = build_hand_pump_mesh(<span class="s">&quot;HandPumpLow&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">2</span>)
     high = build_hand_pump_mesh(<span class="s">&quot;HandPumpHigh&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">4</span>)
     wood = principled(<span class="s">&quot;HandPumpWood&quot;</span>, (<span class="n">0.36</span>, <span class="n">0.19</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.60</span>)
-    metal = principled(<span class="s">&quot;HandPumpIron&quot;</span>, (<span class="n">0.16</span>, <span class="n">0.155</span>, <span class="n">0.15</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.42</span>)
+    metal = principled(<span class="s">&quot;HandPumpIron&quot;</span>, (<span class="n">0.22</span>, <span class="n">0.21</span>, <span class="n">0.20</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.35</span>)
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -992,7 +1067,7 @@ <h2>Source</h2>
             ob.hide_render = <span class="k">True</span>
             ob.hide_viewport = <span class="k">True</span>
 
-    low.rotation_euler.z = math.radians(-<span class="n">28.0</span>)
+    low.rotation_euler.z = math.radians(-<span class="n">36.0</span>)
     low.rotation_euler.x = math.radians(<span class="n">0.0</span>)
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
@@ -1039,10 +1114,10 @@ <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">2.05</span>, -<span class="n">2.54</span>, <span class="n">0.97</span>)
+    cam.location = (<span class="n">2.15</span>, -<span class="n">2.35</span>, <span class="n">1.08</span>)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.42</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.52</span>)
     scene.collection.objects.link(aim)
     con = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     con.target = aim
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 5cc46c3..e56f61b 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -1035,18 +1035,18 @@ <h2><a href="wheelbarrow/">wheelbarrow</a></h2>
         <div class="card-body">
           <h2><a href="anvil/">anvil</a></h2>
           <p class="teaches">A procedural blacksmith anvil on a timber stump through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 1052 tris, two materials with 102 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.750×0.406×0.690 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 134 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 1696 tris, two materials with 274 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.746×0.410×0.682 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 162 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
           <a class="card-link" href="anvil/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="water-trough/" aria-label="water-trough example detail page">
-          <img src="assets/water-trough-hero.webp" alt="water-trough — A procedural staved water trough through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
+          <img src="assets/water-trough-hero.webp" alt="water-trough — A procedural staved water trough with water through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="water-trough/">water-trough</a></h2>
-          <p class="teaches">A procedural staved water trough through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 4008 tris, two materials with 168 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.136×0.482×0.470 m, LOD ratios in band, convex collider 108 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural staved water trough with water through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 4776 tris, three materials with 168 metal and 60 water faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.162×0.528×0.488 m, LOD ratios in band, convex collider 128 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
           <a class="card-link" href="water-trough/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1074,12 +1074,12 @@ <h2><a href="grindstone/">grindstone</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="hand-pump/" aria-label="hand-pump example detail page">
-          <img src="assets/hand-pump-hero.webp" alt="hand-pump — A procedural village hand pump through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
+          <img src="assets/hand-pump-hero.webp" alt="hand-pump — A procedural village hand pump with a gooseneck through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="hand-pump/">hand-pump</a></h2>
-          <p class="teaches">A procedural village hand pump through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 616 tris, two materials with 96 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.567×0.366×1.027 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 118 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural village hand pump with a gooseneck through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 1164 tris, two materials with 222 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.610×0.364×1.049 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 110 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
           <a class="card-link" href="hand-pump/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1090,7 +1090,7 @@ <h2><a href="hand-pump/">hand-pump</a></h2>
         <div class="card-body">
           <h2><a href="signpost/">signpost</a></h2>
           <p class="teaches">A procedural timber fingerboard signpost through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 388 tris, three materials with 66 metal and 22 board faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.162×0.147×1.575 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 92 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 504 tris, three materials with 66 metal and 24 board faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.368×0.201×1.566 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 56 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
           <a class="card-link" href="signpost/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/signpost/index.html b/docs/gallery/signpost/index.html
index 62aa1cf..9ee0871 100644
--- a/docs/gallery/signpost/index.html
+++ b/docs/gallery/signpost/index.html
@@ -253,18 +253,18 @@ <h1>signpost</h1>
       <img src="../assets/signpost-hero.webp" alt="signpost render" width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Recomputed: 388 tris, three materials with 66 metal and 22 board faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.162×0.147×1.575 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 92 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 504 tris, three materials with 66 metal and 24 board faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.368×0.201×1.566 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 56 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/signpost/signpost.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural timber fingerboard signpost (square post, pyramidal cap, two painted boards, iron shoe and straps) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>A showcase piece, not an example. Procedural timber fingerboard signpost (square post, collar and pyramidal cap, two painted planks with diamond tips, iron shoe and straps) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 320–460 | 388 / 388 / 388 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2165 / 0.2165 / 0.1804 | | Materials | exactly 3 distinct, ≥24 metal and ≥12 board faces | 3 slots, 66 metal, 22 board | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.162, 0.147, 1.575) m ± 0.01 | (1.1620, 0.1474, 1.5750), zmin 0 | | Collider tris | ≤ 140 | 92 | | Export | written, size &gt; 0 | 40124 / 40124 / 40112 bytes |</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 430–580 | 504 / 504 / 504 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2183 / 0.2183 / 0.1746 | | Materials | exactly 3 distinct, ≥24 metal and ≥12 board faces | 3 slots, 66 metal, 24 board | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.368, 0.201, 1.566) m ± 0.01 | (1.3679, 0.2014, 1.5660), zmin 0 | | Collider tris | ≤ 140 | 56 | | Export | written, size &gt; 0 | 45164 / 45164 / 45152 bytes |</p>
 <p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 12 B on 5.2.1 (glTF serializer), not a gated axis.</p>
 <p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. That is the named budget the falsifier violates.</p>
 <h2>Run</h2>
@@ -319,20 +319,20 @@ <h2>Source</h2>
 sys.dont_write_bytecode = <span class="k">True</span>
 <span class="k">import</span> gallery_framing  <span class="c"># noqa: E402</span>
 
-POST_W = <span class="n">0.110</span>
+POST_W = <span class="n">0.118</span>
 POST_H = <span class="n">1.48</span>
-CAP_H = <span class="n">0.095</span>
+CAP_H = <span class="n">0.058</span>
 SHOE_H = <span class="n">0.048</span>
 SHOE_SCALE = <span class="n">1.34</span>
-BOARD_Y = <span class="n">0.072</span>
-BOARD_ZTH = <span class="n">0.046</span>
-BOARD_A = (<span class="n">1.24</span>, <span class="n">0.52</span>, <span class="n">1.0</span>)
-BOARD_B = (<span class="n">1.02</span>, <span class="n">0.44</span>, -<span class="n">1.0</span>)
+BOARD_T = <span class="n">0.028</span>
+BOARD_H = <span class="n">0.112</span>
+BOARD_A = (<span class="n">1.24</span>, <span class="n">0.62</span>, <span class="n">1.0</span>, <span class="n">0.12</span>)
+BOARD_B = (<span class="n">1.00</span>, <span class="n">0.54</span>, -<span class="n">1.0</span>, -<span class="n">0.18</span>)
 
 BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">1.162</span>, <span class="n">0.147</span>, <span class="n">1.575</span>)
-BASE_TRIS_MIN = <span class="n">320</span>
-BASE_TRIS_MAX = <span class="n">460</span>
+OUTER_SIZE = (<span class="n">1.368</span>, <span class="n">0.201</span>, <span class="n">1.566</span>)
+BASE_TRIS_MIN = <span class="n">430</span>
+BASE_TRIS_MAX = <span class="n">580</span>
 LOD1_RATIO_MIN = <span class="n">0.32</span>
 LOD1_RATIO_MAX = <span class="n">0.62</span>
 LOD2_RATIO_MIN = <span class="n">0.10</span>
@@ -559,12 +559,20 @@ <h2>Source</h2>
                 WOOD_IDX,
             )
         )
+        wood.extend(
+            add_box(
+                bm,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, POST_H + <span class="n">0.014</span>),
+                (POST_W * <span class="n">1.16</span>, POST_W * <span class="n">1.16</span>, <span class="n">0.028</span>),
+                WOOD_IDX,
+            )
+        )
         wood.extend(
             add_cone(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, POST_H + CAP_H / <span class="n">2.0</span>),
-                POST_W * <span class="n">0.78</span>,
-                <span class="n">0.012</span>,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, POST_H + <span class="n">0.028</span> + CAP_H / <span class="n">2.0</span>),
+                POST_W * <span class="n">0.72</span>,
+                <span class="n">0.008</span>,
                 CAP_H,
                 <span class="n">4</span>,
                 WOOD_IDX,
@@ -586,50 +594,53 @@ <h2>Source</h2>
             <span class="k">for</span> f <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
                 f.material_index = WOOD_IDX
 
-        <span class="k">for</span> z, length, sign <span class="k">in</span> (BOARD_A, BOARD_B):
-            cx = sign * (half + length / <span class="n">2.0</span> - <span class="n">0.018</span>)
+        <span class="k">for</span> z, length, sign, yaw <span class="k">in</span> (BOARD_A, BOARD_B):
+            eul = Euler((<span class="n">0.0</span>, <span class="n">0.0</span>, yaw))
+            rot = eul.to_matrix()
+            inner = Vector((sign * (half - <span class="n">0.016</span>), <span class="n">0.0</span>, z))
+            center = inner + rot @ Vector((sign * length / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
             boards.extend(
                 add_box(
                     bm,
-                    (cx, <span class="n">0.0</span>, z),
-                    (length, BOARD_Y, BOARD_ZTH),
+                    (center.x, center.y, center.z),
+                    (length, BOARD_T, BOARD_H),
                     BOARD_IDX,
+                    euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, yaw),
                 )
             )
-            tip_x = cx + sign * (length / <span class="n">2.0</span> + <span class="n">0.028</span>)
+            tip = inner + rot @ Vector((sign * (length + <span class="n">0.004</span>), <span class="n">0.0</span>, <span class="n">0.0</span>))
             boards.extend(
-                add_cone(
+                add_box(
                     bm,
-                    (tip_x, <span class="n">0.0</span>, z),
-                    <span class="n">0.052</span>,
-                    <span class="n">0.004</span>,
-                    <span class="n">0.072</span>,
-                    <span class="n">3</span>,
+                    (tip.x, tip.y, tip.z),
+                    (<span class="n">0.088</span>, BOARD_T, <span class="n">0.088</span>),
                     BOARD_IDX,
-                    euler=(<span class="n">0.0</span>, sign * math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
+                    euler=(<span class="n">0.0</span>, math.pi / <span class="n">4.0</span>, yaw),
                 )
             )
+            t = <span class="n">0.012</span>
+            h = BOARD_H + <span class="n">0.024</span>
             metal.extend(
                 add_box(
                     bm,
-                    (sign * (half + <span class="n">0.010</span>), <span class="n">0.0</span>, z),
-                    (<span class="n">0.020</span>, BOARD_Y + <span class="n">0.016</span>, BOARD_ZTH + <span class="n">0.018</span>),
+                    (sign * (half + t / <span class="n">2.0</span>), <span class="n">0.0</span>, z),
+                    (t, POST_W * <span class="n">0.94</span>, h),
                     METAL_IDX,
                 )
             )
             metal.extend(
                 add_box(
                     bm,
-                    (<span class="n">0.0</span>, half + <span class="n">0.010</span>, z),
-                    (POST_W * <span class="n">0.92</span>, <span class="n">0.014</span>, BOARD_ZTH * <span class="n">1.15</span>),
+                    (<span class="n">0.0</span>, half + t / <span class="n">2.0</span>, z),
+                    (POST_W * <span class="n">0.94</span>, t, h),
                     METAL_IDX,
                 )
             )
             metal.extend(
                 add_box(
                     bm,
-                    (<span class="n">0.0</span>, -(half + <span class="n">0.010</span>), z),
-                    (POST_W * <span class="n">0.92</span>, <span class="n">0.014</span>, BOARD_ZTH * <span class="n">1.15</span>),
+                    (<span class="n">0.0</span>, -(half + t / <span class="n">2.0</span>), z),
+                    (POST_W * <span class="n">0.94</span>, t, h),
                     METAL_IDX,
                 )
             )
@@ -817,7 +828,7 @@ <h2>Source</h2>
     low = build_signpost_mesh(<span class="s">&quot;SignpostLow&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">2</span>)
     high = build_signpost_mesh(<span class="s">&quot;SignpostHigh&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">4</span>)
     wood = principled(<span class="s">&quot;SignpostWood&quot;</span>, (<span class="n">0.34</span>, <span class="n">0.18</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.62</span>)
-    board = principled(<span class="s">&quot;SignpostBoard&quot;</span>, (<span class="n">0.72</span>, <span class="n">0.58</span>, <span class="n">0.28</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.55</span>)
+    board = principled(<span class="s">&quot;SignpostBoard&quot;</span>, (<span class="n">0.76</span>, <span class="n">0.58</span>, <span class="n">0.22</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.52</span>)
     metal = principled(<span class="s">&quot;SignpostIron&quot;</span>, (<span class="n">0.14</span>, <span class="n">0.145</span>, <span class="n">0.155</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.38</span>)
     assign_slots(low, wood, board, metal)
     assign_slots(high, wood, board, metal)
@@ -974,7 +985,7 @@ <h2>Source</h2>
             ob.hide_render = <span class="k">True</span>
             ob.hide_viewport = <span class="k">True</span>
 
-    low.rotation_euler.z = math.radians(-<span class="n">18.0</span>)
+    low.rotation_euler.z = math.radians(-<span class="n">12.0</span>)
     low.rotation_euler.x = math.radians(<span class="n">0.0</span>)
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
@@ -1021,10 +1032,10 @@ <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.06</span>, -<span class="n">4.02</span>, <span class="n">1.38</span>)
+    cam.location = (<span class="n">2.80</span>, -<span class="n">3.40</span>, <span class="n">1.35</span>)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.78</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.82</span>)
     scene.collection.objects.link(aim)
     con = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     con.target = aim
diff --git a/docs/gallery/water-trough/index.html b/docs/gallery/water-trough/index.html
index a8618d7..5f9fc4d 100644
--- a/docs/gallery/water-trough/index.html
+++ b/docs/gallery/water-trough/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>water-trough — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural staved water trough through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural staved water trough with water through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/water-trough/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="water-trough — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural staved water trough through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural staved water trough with water through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/water-trough/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/water-trough-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="water-trough — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural staved water trough through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural staved water trough with water 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/water-trough-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,25 +246,25 @@
   </div>
   <header class="hero">
     <h1>water-trough</h1>
-    <p>A procedural staved water trough through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural staved water trough with water 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="Zoom water-trough render">
       <img src="../assets/water-trough-hero.webp" alt="water-trough render" width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Recomputed: 4008 tris, two materials with 168 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.136×0.482×0.470 m, LOD ratios in band, convex collider 108 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 4776 tris, three materials with 168 metal and 60 water faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.162×0.528×0.488 m, LOD ratios in band, convex collider 128 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/water-trough/water_trough.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural staved water trough on a timber stand (U-staves, end boards, iron straps, trestle legs) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>A showcase piece, not an example. Procedural staved water trough on a timber stand (U-staves, solid end-caps, water, iron straps, trestle legs) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 3880–4140 | 4008 / 4008 / 4008 | | 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.2196 | | Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 168 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.136, 0.482, 0.470) m ± 0.01 | (1.1360, 0.4820, 0.4701), zmin 0 | | Collider tris | ≤ 150 | 108 | | Export | written, size &gt; 0 | 292484 / 292484 / 292468 bytes |</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 4650–4900 | 4776 / 4776 / 4776 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2198 / 0.2198 / 0.2198 | | Materials | exactly 3 distinct, ≥24 metal and ≥6 water faces | 3 slots, 168 metal, 60 water | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.162, 0.528, 0.488) m ± 0.01 | (1.1620, 0.5280, 0.4883), zmin 0 | | Collider tris | ≤ 150 | 128 | | Export | written, size &gt; 0 | 348208 / 348208 / 348192 bytes |</p>
 <p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series in general — the gate is a ratio band, not an exact count. On this piece LOD2 happened to match on 4.5.11, 5.1.2, and 5.2.1. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
 <p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. That is the named budget the falsifier violates.</p>
 <h2>Run</h2>
@@ -274,7 +274,7 @@ <h2>Run</h2>
 <p>Smoke does not pass <code>--output</code> or <code>--skip-decimate</code>.</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>
-<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or wood/metal faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file |</p>
+<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 3 distinct slots, or wood/metal/water faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -285,8 +285,9 @@ <h2>Source</h2>
       <pre><span class="s">&quot;&quot;&quot;Game-ready wooden water trough — a showcase piece, not an example.
 
 Asserts budget conformance of a procedural staved trough on a timber
-stand (U-staves, end boards, iron straps, trestle legs) after composing
-shipped pipeline pieces: bmesh construction, UVs, two materials,
+stand (U-staves, solid end-caps, water, iron straps, trestle legs)
+after composing shipped pipeline pieces: bmesh construction, UVs, three
+materials,
 high-to-low normal bake, LOD chain, convex collider, Unity glTF export.
 
 Budgets are declared below and recomputed from the generated result.
@@ -326,16 +327,16 @@ <h2>Source</h2>
 A_SPAN = <span class="n">1.42</span>
 
 BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">1.136</span>, <span class="n">0.482</span>, <span class="n">0.470</span>)
-BASE_TRIS_MIN = <span class="n">3880</span>
-BASE_TRIS_MAX = <span class="n">4140</span>
+OUTER_SIZE = (<span class="n">1.162</span>, <span class="n">0.528</span>, <span class="n">0.488</span>)
+BASE_TRIS_MIN = <span class="n">4650</span>
+BASE_TRIS_MAX = <span class="n">4900</span>
 LOD1_RATIO_MIN = <span class="n">0.32</span>
 LOD1_RATIO_MAX = <span class="n">0.62</span>
 LOD2_RATIO_MIN = <span class="n">0.10</span>
 LOD2_RATIO_MAX = <span class="n">0.35</span>
 LOD1_TARGET = <span class="n">0.50</span>
 LOD2_TARGET = <span class="n">0.22</span>
-MATERIAL_COUNT = <span class="n">2</span>
+MATERIAL_COUNT = <span class="n">3</span>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
 COLLIDER_TRIS_MAX = <span class="n">150</span>
@@ -343,9 +344,11 @@ <h2>Source</h2>
 CAGE_EXTRUSION = <span class="n">0.08</span>
 METAL_FACES_MIN = <span class="n">24</span>
 WOOD_FACES_MIN = <span class="n">24</span>
+WATER_FACES_MIN = <span class="n">6</span>
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
+WATER_IDX = <span class="n">2</span>
 
 
 <span class="k">def</span> eevee_engine_id():
@@ -505,14 +508,14 @@ <h2>Source</h2>
         zc = <span class="n">0.30</span> + TRAY_R
         cx = <span class="n">0.0</span>
 
-        <span class="k">def</span> pt(a, x):
+        <span class="k">def</span> pt(a, x, radius=TRAY_R):
             <span class="k">return</span> (
                 x,
-                TRAY_R * math.sin(a),
-                zc - TRAY_R * math.cos(a),
+                radius * math.sin(a),
+                zc - radius * math.cos(a),
             )
 
-        gap = <span class="n">0.10</span>
+        gap = <span class="n">0.16</span>
         <span class="k">for</span> i <span class="k">in</span> range(N_STAVES):
             t0 = i / N_STAVES
             t1 = (i + (<span class="n">1.0</span> - gap)) / N_STAVES
@@ -529,39 +532,58 @@ <h2>Source</h2>
                     euler=(mid, <span class="n">0.0</span>, <span class="n">0.0</span>),
                 )
             )
-            <span class="k">for</span> xend <span class="k">in</span> (cx + TRAY_L / <span class="n">2.0</span> + <span class="n">0.014</span>, cx - TRAY_L / <span class="n">2.0</span> - <span class="n">0.014</span>):
+
+        n_end = <span class="n">11</span>
+        end_r = TRAY_R + STAVE_T * <span class="n">0.15</span>
+        <span class="k">for</span> xend <span class="k">in</span> (cx + TRAY_L / <span class="n">2.0</span> + <span class="n">0.020</span>, cx - TRAY_L / <span class="n">2.0</span> - <span class="n">0.020</span>):
+            <span class="k">for</span> i <span class="k">in</span> range(n_end):
+                t0 = i / n_end
+                t1 = (i + <span class="n">1.0</span>) / n_end
+                a0 = -A_SPAN + <span class="n">2.0</span> * A_SPAN * t0
+                a1 = -A_SPAN + <span class="n">2.0</span> * A_SPAN * t1
+                mid = <span class="n">0.5</span> * (a0 + a1)
+                chord = end_r * abs(a1 - a0) * <span class="n">1.18</span>
                 wood.extend(
                     add_box(
                         bm,
-                        pt(mid, xend),
-                        (<span class="n">0.028</span>, chord * <span class="n">1.02</span>, STAVE_T * <span class="n">1.05</span>),
+                        pt(mid, xend, end_r),
+                        (<span class="n">0.042</span>, chord, STAVE_T * <span class="n">1.45</span>),
                         WOOD_IDX,
                         euler=(mid, <span class="n">0.0</span>, <span class="n">0.0</span>),
                     )
                 )
 
-        <span class="k">for</span> sx <span class="k">in</span> (-TRAY_L * <span class="n">0.32</span>, TRAY_L * <span class="n">0.32</span>):
+        <span class="k">for</span> a_lip <span class="k">in</span> (-A_SPAN, A_SPAN):
+            wood.extend(
+                add_box(
+                    bm,
+                    pt(a_lip, cx),
+                    (TRAY_L + <span class="n">0.050</span>, <span class="n">0.034</span>, <span class="n">0.030</span>),
+                    WOOD_IDX,
+                    euler=(a_lip, <span class="n">0.0</span>, <span class="n">0.0</span>),
+                )
+            )
+
+        <span class="k">for</span> sx <span class="k">in</span> (-TRAY_L * <span class="n">0.30</span>, TRAY_L * <span class="n">0.30</span>):
             <span class="k">for</span> ysign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-                top = (sx, ysign * <span class="n">0.12</span>, zc - TRAY_R - <span class="n">0.02</span>)
-                bot = (sx, ysign * <span class="n">0.22</span>, <span class="n">0.02</span>)
+                top = (sx, ysign * <span class="n">0.10</span>, zc - TRAY_R - <span class="n">0.035</span>)
+                bot = (sx, ysign * <span class="n">0.24</span>, <span class="n">0.024</span>)
                 wood.extend(
-                    add_oriented_box(bm, top, bot, (<span class="n">0.036</span>, <span class="n">0.036</span>), WOOD_IDX)
+                    add_oriented_box(bm, top, bot, (<span class="n">0.050</span>, <span class="n">0.036</span>), WOOD_IDX)
                 )
             wood.extend(
-                add_oriented_box(
+                add_box(
                     bm,
-                    (sx, -<span class="n">0.16</span>, <span class="n">0.13</span>),
-                    (sx, <span class="n">0.16</span>, <span class="n">0.13</span>),
-                    (<span class="n">0.028</span>, <span class="n">0.028</span>),
+                    (sx, <span class="n">0.0</span>, <span class="n">0.115</span>),
+                    (<span class="n">0.044</span>, <span class="n">0.38</span>, <span class="n">0.030</span>),
                     WOOD_IDX,
                 )
             )
         wood.extend(
-            add_oriented_box(
+            add_box(
                 bm,
-                (-TRAY_L * <span class="n">0.32</span>, <span class="n">0.0</span>, <span class="n">0.13</span>),
-                (TRAY_L * <span class="n">0.32</span>, <span class="n">0.0</span>, <span class="n">0.13</span>),
-                (<span class="n">0.028</span>, <span class="n">0.028</span>),
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.115</span>),
+                (TRAY_L * <span class="n">0.62</span>, <span class="n">0.044</span>, <span class="n">0.030</span>),
                 WOOD_IDX,
             )
         )
@@ -597,17 +619,41 @@ <h2>Source</h2>
                 metal.extend(
                     add_oriented_box(bm, p0, p1, (<span class="n">0.020</span>, <span class="n">0.010</span>), METAL_IDX)
                 )
-        <span class="k">for</span> sx <span class="k">in</span> (-TRAY_L * <span class="n">0.32</span>, TRAY_L * <span class="n">0.32</span>):
+        <span class="k">for</span> sx <span class="k">in</span> (-TRAY_L * <span class="n">0.30</span>, TRAY_L * <span class="n">0.30</span>):
             <span class="k">for</span> ysign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
                 metal.extend(
                     add_box(
                         bm,
-                        (sx, ysign * <span class="n">0.22</span>, <span class="n">0.012</span>),
-                        (<span class="n">0.050</span>, <span class="n">0.042</span>, <span class="n">0.022</span>),
+                        (sx, ysign * <span class="n">0.24</span>, <span class="n">0.012</span>),
+                        (<span class="n">0.056</span>, <span class="n">0.048</span>, <span class="n">0.024</span>),
                         METAL_IDX,
                     )
                 )
 
+        n_w = <span class="n">9</span>
+        wr = TRAY_R - STAVE_T * <span class="n">0.60</span>
+        span = A_SPAN * <span class="n">0.90</span>
+        <span class="k">for</span> i <span class="k">in</span> range(n_w):
+            t0 = i / n_w
+            t1 = (i + <span class="n">1.0</span>) / n_w
+            a0 = -span + <span class="n">2.0</span> * span * t0
+            a1 = -span + <span class="n">2.0</span> * span * t1
+            mid = <span class="n">0.5</span> * (a0 + a1)
+            chord = wr * abs(a1 - a0) * <span class="n">1.16</span>
+            add_box(
+                bm,
+                pt(mid, cx, wr),
+                (TRAY_L * <span class="n">0.84</span>, chord, <span class="n">0.018</span>),
+                WATER_IDX,
+                euler=(mid, <span class="n">0.0</span>, <span class="n">0.0</span>),
+            )
+        add_box(
+            bm,
+            (cx, <span class="n">0.0</span>, zc - TRAY_R * <span class="n">0.28</span>),
+            (TRAY_L * <span class="n">0.84</span>, TRAY_R * <span class="n">1.50</span>, <span class="n">0.010</span>),
+            WATER_IDX,
+        )
+
         xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> bm.verts]
         ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> bm.verts]
         zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> bm.verts]
@@ -647,9 +693,9 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
-<span class="k">def</span> assign_slots(obj, wood, metal):
+<span class="k">def</span> assign_slots(obj, wood, metal, water):
     mats = obj.data.materials
-    wanted = (wood, metal)
+    wanted = (wood, metal, water)
     <span class="k">for</span> i, mat <span class="k">in</span> enumerate(wanted):
         <span class="k">if</span> i &lt; len(mats):
             mats[i] = mat
@@ -782,8 +828,9 @@ <h2>Source</h2>
     high = build_trough_mesh(<span class="s">&quot;TroughHigh&quot;</span>, bevel_offset=<span class="n">0.005</span>, bevel_segments=<span class="n">4</span>)
     wood = principled(<span class="s">&quot;TroughWood&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.22</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>)
     metal = principled(<span class="s">&quot;TroughIron&quot;</span>, (<span class="n">0.10</span>, <span class="n">0.105</span>, <span class="n">0.12</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.30</span>)
-    assign_slots(low, wood, metal)
-    assign_slots(high, wood, metal)
+    water = principled(<span class="s">&quot;TroughWater&quot;</span>, (<span class="n">0.05</span>, <span class="n">0.13</span>, <span class="n">0.14</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.14</span>)
+    assign_slots(low, wood, metal, water)
+    assign_slots(high, wood, metal, water)
 
     <span class="k">if</span> low.data <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> len(low.data.polygons) &lt; <span class="n">6</span>:
         <span class="k">return</span> fail(<span class="s">&quot;trough mesh did not build&quot;</span>, <span class="n">3</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>
@@ -867,6 +914,11 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">wood faces </span>{idx_counts.get(WOOD_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{WOOD_FACES_MIN}<span class="s">&quot;</span>,
             <span class="n">5</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> idx_counts.get(WATER_IDX, <span class="n">0</span>) &lt; WATER_FACES_MIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">water faces </span>{idx_counts.get(WATER_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{WATER_FACES_MIN}<span class="s">&quot;</span>,
+            <span class="n">5</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> u0 &lt; -UV_EPS <span class="k">or</span> v0 &lt; -UV_EPS <span class="k">or</span> u1 &gt; <span class="n">1.0</span> + UV_EPS <span class="k">or</span> v1 &gt; <span class="n">1.0</span> + UV_EPS:
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">UVs outside 0..1: (</span>{u0:<span class="s">.4f</span>}<span class="s">,</span>{v0:<span class="s">.4f</span>}<span class="s">)-(</span>{u1:<span class="s">.4f</span>}<span class="s">,</span>{v1:<span class="s">.4f</span>}<span class="s">)</span><span class="s">&quot;</span>,
@@ -930,7 +982,7 @@ <h2>Source</h2>
             ob.hide_render = <span class="k">True</span>
             ob.hide_viewport = <span class="k">True</span>
 
-    low.rotation_euler.z = math.radians(-<span class="n">16.0</span>)
+    low.rotation_euler.z = math.radians(-<span class="n">90.0</span>)
     low.rotation_euler.x = math.radians(<span class="n">0.0</span>)
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
@@ -977,10 +1029,10 @@ <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">1.43</span>, -<span class="n">1.73</span>, <span class="n">0.88</span>)
+    cam.location = (<span class="n">1.05</span>, -<span class="n">2.00</span>, <span class="n">1.22</span>)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.26</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.22</span>)
     scene.collection.objects.link(aim)
     con = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     con.target = aim
diff --git a/showcase/anvil/README.md b/showcase/anvil/README.md
index 2672e89..7ff1616 100644
--- a/showcase/anvil/README.md
+++ b/showcase/anvil/README.md
@@ -21,14 +21,14 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 980–1140 | 1052 / 1052 / 1052 |
+| Base triangles | 1620–1780 | 1696 / 1696 / 1696 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2186 / 0.2186 / 0.2110 |
-| Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 102 metal |
+| LOD2 ratio | 0.10–0.35 of base | 0.2193 / 0.2193 / 0.2182 |
+| Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 274 metal |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.750, 0.406, 0.690) m ± 0.01 | (0.7500, 0.4060, 0.6900), zmin 0 |
-| Collider tris | ≤ 180 | 134 |
-| Export | written, size > 0 | 84092 / 84092 / 84088 bytes |
+| Outer AABB | (0.746, 0.410, 0.682) m ± 0.01 | (0.7460, 0.4095, 0.6820), zmin 0 |
+| Collider tris | ≤ 180 | 162 |
+| Export | written, size > 0 | 130852 / 130852 / 130840 bytes |
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an
diff --git a/showcase/anvil/anvil.py b/showcase/anvil/anvil.py
index f7a3deb..09d01c1 100644
--- a/showcase/anvil/anvil.py
+++ b/showcase/anvil/anvil.py
@@ -49,9 +49,9 @@
 HEEL_L = 0.11
 
 BBOX_TOL = 0.01
-OUTER_SIZE = (0.750, 0.406, 0.690)
-BASE_TRIS_MIN = 980
-BASE_TRIS_MAX = 1140
+OUTER_SIZE = (0.746, 0.410, 0.682)
+BASE_TRIS_MIN = 1620
+BASE_TRIS_MAX = 1780
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -177,6 +177,37 @@ def add_cone(bm, loc, radius1, radius2, depth, segments, mat_idx, euler=(0.0, 0.
     return verts
 
 
+def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0)):
+    n_major = 14
+    n_minor = 7
+    rings = []
+    for i in range(n_major):
+        u = i * (2.0 * math.pi / n_major)
+        ring = []
+        for j in range(n_minor):
+            v = j * (2.0 * math.pi / n_minor)
+            x = (major + minor * math.cos(v)) * math.cos(u)
+            y = (major + minor * math.cos(v)) * math.sin(u)
+            z = minor * math.sin(v)
+            ring.append(bm.verts.new((x, y, z)))
+        rings.append(ring)
+    bm.verts.ensure_lookup_table()
+    for i in range(n_major):
+        i2 = (i + 1) % n_major
+        for j in range(n_minor):
+            j2 = (j + 1) % n_minor
+            face = bm.faces.new(
+                (rings[i][j], rings[i2][j], rings[i2][j2], rings[i][j2])
+            )
+            face.material_index = mat_idx
+    verts = [v for ring in rings for v in ring]
+    rot = Euler(euler).to_matrix()
+    origin = Vector(loc)
+    for v in verts:
+        v.co = rot @ v.co + origin
+    return verts
+
+
 def pack_uvs(bm, margin=0.08):
     uv = bm.loops.layers.uv.new("UVMap")
     faces = list(bm.faces)
@@ -227,17 +258,23 @@ def build_anvil_mesh(name, bevel_offset, bevel_segments):
         metal = []
 
         wood.extend(
-            add_cyl(
-                bm, (0.0, 0.0, STUMP_H / 2.0), STUMP_R, STUMP_H, 14, WOOD_IDX,
+            add_cone(
+                bm,
+                (0.0, 0.0, STUMP_H / 2.0),
+                STUMP_R + 0.010,
+                STUMP_R - 0.018,
+                STUMP_H,
+                20,
+                WOOD_IDX,
             )
         )
         wood.extend(
             add_cyl(
                 bm,
-                (0.0, 0.0, STUMP_H + 0.012),
-                STUMP_R - 0.012,
-                0.024,
-                14,
+                (0.0, 0.0, STUMP_H + 0.010),
+                STUMP_R - 0.022,
+                0.020,
+                20,
                 WOOD_IDX,
             )
         )
@@ -256,44 +293,45 @@ def build_anvil_mesh(name, bevel_offset, bevel_segments):
             for f in ret.get("faces") or []:
                 f.material_index = WOOD_IDX
 
-        for z in (0.055, STUMP_H - 0.055):
+        for z in (0.048, STUMP_H - 0.042):
             metal.extend(
-                add_cyl(
-                    bm,
-                    (0.0, 0.0, z),
-                    STUMP_R + 0.008,
-                    0.028,
-                    16,
-                    METAL_IDX,
-                )
+                add_rim(bm, (0.0, 0.0, z), STUMP_R + 0.004, 0.011, METAL_IDX)
             )
 
         z0 = STUMP_H
         metal.extend(
             add_box(
                 bm,
-                (0.0, 0.0, z0 + 0.028),
-                (FOOT_L, FOOT_W, 0.056),
+                (0.0, 0.0, z0 + 0.024),
+                (0.38, 0.168, 0.048),
+                METAL_IDX,
+            )
+        )
+        metal.extend(
+            add_box(
+                bm,
+                (0.0, 0.0, z0 + 0.066),
+                (0.30, 0.132, 0.038),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_box(
                 bm,
-                (0.0, 0.0, z0 + 0.056 + BODY_H / 2.0),
-                (WAIST_L, WAIST_W, BODY_H),
+                (0.0, 0.0, z0 + 0.148),
+                (0.176, 0.070, 0.130),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_box(
                 bm,
-                (0.0, 0.0, z0 + 0.056 + BODY_H + 0.028),
-                (FACE_L * 0.90, FACE_W * 0.88, 0.056),
+                (0.0, 0.0, z0 + 0.248),
+                (0.34, 0.112, 0.052),
                 METAL_IDX,
             )
         )
-        face_z = z0 + 0.056 + BODY_H + 0.056 + FACE_T / 2.0
+        face_z = z0 + 0.248 + 0.026 + FACE_T / 2.0
         metal.extend(
             add_box(
                 bm,
@@ -303,15 +341,15 @@ def build_anvil_mesh(name, bevel_offset, bevel_segments):
             )
         )
 
-        horn_z = face_z - 0.018
+        horn_z = face_z - 0.012
         metal.extend(
             add_cone(
                 bm,
-                (FACE_L / 2.0 + HORN_L / 2.0 - 0.02, 0.0, horn_z),
-                0.052,
-                0.016,
+                (FACE_L / 2.0 + HORN_L / 2.0 - 0.028, 0.0, horn_z),
+                0.056,
+                0.014,
                 HORN_L,
-                12,
+                16,
                 METAL_IDX,
                 euler=(0.0, math.pi / 2.0, 0.0),
             )
@@ -319,34 +357,34 @@ def build_anvil_mesh(name, bevel_offset, bevel_segments):
         metal.extend(
             add_box(
                 bm,
-                (FACE_L / 2.0 - 0.01, 0.0, horn_z - 0.028),
-                (0.09, FACE_W * 0.92, 0.040),
+                (FACE_L / 2.0 - 0.018, 0.0, horn_z - 0.018),
+                (0.10, FACE_W * 0.90, 0.048),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_box(
                 bm,
-                (-FACE_L / 2.0 - HEEL_L / 2.0 + 0.02, 0.0, face_z - 0.008),
-                (HEEL_L, FACE_W * 0.92, FACE_T * 0.82),
+                (-FACE_L / 2.0 - HEEL_L / 2.0 + 0.016, 0.0, face_z - 0.006),
+                (HEEL_L, FACE_W * 0.90, FACE_T * 0.78),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_box(
                 bm,
-                (FACE_L * 0.22, 0.0, face_z + FACE_T / 2.0 - 0.006),
-                (0.034, 0.034, 0.014),
+                (FACE_L * 0.18, 0.0, face_z + FACE_T / 2.0 - 0.005),
+                (0.032, 0.032, 0.012),
                 METAL_IDX,
             )
         )
         metal.extend(
             add_cyl(
                 bm,
-                (FACE_L * 0.32, 0.0, face_z + FACE_T / 2.0 - 0.004),
+                (FACE_L * 0.30, 0.0, face_z + FACE_T / 2.0 - 0.004),
                 0.009,
                 0.012,
-                8,
+                10,
                 METAL_IDX,
             )
         )
@@ -524,7 +562,7 @@ def check(skip_decimate):
     low = build_anvil_mesh("AnvilLow", bevel_offset=0.005, bevel_segments=2)
     high = build_anvil_mesh("AnvilHigh", bevel_offset=0.005, bevel_segments=4)
     wood = principled("AnvilStump", (0.34, 0.18, 0.07, 1.0), 0.0, 0.62)
-    metal = principled("AnvilSteel", (0.18, 0.185, 0.195, 1.0), 1.0, 0.24)
+    metal = principled("AnvilSteel", (0.44, 0.45, 0.47, 1.0), 1.0, 0.30)
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -673,7 +711,7 @@ def render_still(low, wood, tex, path, engine):
             ob.hide_render = True
             ob.hide_viewport = True
 
-    low.rotation_euler.z = math.radians(-22.0)
+    low.rotation_euler.z = math.radians(-8.0)
     low.rotation_euler.x = math.radians(0.0)
 
     floor_me = bpy.data.meshes.new("Floor")
@@ -720,10 +758,10 @@ def light(name, loc, energy, size, col, rot):
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (1.36, -1.68, 0.93)
+    cam.location = (0.70, -2.20, 1.08)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.36)
+    aim.location = (0.0, 0.0, 0.40)
     scene.collection.objects.link(aim)
     con = cam.constraints.new("TRACK_TO")
     con.target = aim
diff --git a/showcase/anvil/preview.webp b/showcase/anvil/preview.webp
index 883d6b7..c13722b 100644
Binary files a/showcase/anvil/preview.webp and b/showcase/anvil/preview.webp differ
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 923a9c9..3b0c5d7 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -165,7 +165,7 @@
       "name": "anvil",
       "dir": "showcase/anvil",
       "teaches": "A procedural blacksmith anvil on a timber stump through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 1052 tris, two materials with 102 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.750×0.406×0.690 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 134 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "witnessesFix": "Recomputed: 1696 tris, two materials with 274 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.746×0.410×0.682 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 162 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
       "hero": "docs/gallery/assets/anvil-hero.webp",
       "preview": "showcase/anvil/preview.webp",
       "tags": [
@@ -176,8 +176,8 @@
     {
       "name": "water-trough",
       "dir": "showcase/water-trough",
-      "teaches": "A procedural staved water trough through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 4008 tris, two materials with 168 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.136×0.482×0.470 m, LOD ratios in band, convex collider 108 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural staved water trough with water through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 4776 tris, three materials with 168 metal and 60 water faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.162×0.528×0.488 m, LOD ratios in band, convex collider 128 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
       "hero": "docs/gallery/assets/water-trough-hero.webp",
       "preview": "showcase/water-trough/preview.webp",
       "tags": [
@@ -212,8 +212,8 @@
     {
       "name": "hand-pump",
       "dir": "showcase/hand-pump",
-      "teaches": "A procedural village hand pump through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 616 tris, two materials with 96 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.567×0.366×1.027 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 118 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural village hand pump with a gooseneck through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 1164 tris, two materials with 222 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.610×0.364×1.049 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 110 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
       "hero": "docs/gallery/assets/hand-pump-hero.webp",
       "preview": "showcase/hand-pump/preview.webp",
       "tags": [
@@ -225,7 +225,7 @@
       "name": "signpost",
       "dir": "showcase/signpost",
       "teaches": "A procedural timber fingerboard signpost through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 388 tris, three materials with 66 metal and 22 board faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.162×0.147×1.575 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 92 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "witnessesFix": "Recomputed: 504 tris, three materials with 66 metal and 24 board faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.368×0.201×1.566 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 56 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
       "hero": "docs/gallery/assets/signpost-hero.webp",
       "preview": "showcase/signpost/preview.webp",
       "tags": [
diff --git a/showcase/hand-pump/README.md b/showcase/hand-pump/README.md
index bde86e1..a57e62d 100644
--- a/showcase/hand-pump/README.md
+++ b/showcase/hand-pump/README.md
@@ -1,8 +1,9 @@
 # Hand pump
 
 A showcase piece, not an example. Procedural cast-iron village hand
-pump (wooden plinth, column, spout, handle, wooden grip) then the
-shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD
+pump (stacked wooden plinth, two-diameter column, gooseneck spout,
+pump head, forked handle, wooden grip) then the shipped pipeline:
+unique-cell UVs, Cycles high-to-low normal bake, LOD
 chain, convex collider, Unity glTF export.
 
 It asserts **budget conformance** of the generated result. It does not
@@ -21,14 +22,14 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 540–700 | 616 / 616 / 616 |
+| Base triangles | 1080–1240 | 1164 / 1164 / 1164 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2175 / 0.2175 / 0.2143 |
-| Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 96 metal |
+| LOD2 ratio | 0.10–0.35 of base | 0.2199 / 0.2199 / 0.2148 |
+| Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 222 metal |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.567, 0.366, 1.027) m ± 0.01 | (0.5668, 0.3660, 1.0271), zmin 0 |
-| Collider tris | ≤ 160 | 118 |
-| Export | written, size > 0 | 52764 / 52764 / 52756 bytes |
+| Outer AABB | (0.610, 0.364, 1.049) m ± 0.01 | (0.6100, 0.3639, 1.0491), zmin 0 |
+| Collider tris | ≤ 160 | 110 |
+| Export | written, size > 0 | 85944 / 85944 / 85936 bytes |
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an
diff --git a/showcase/hand-pump/hand_pump.py b/showcase/hand-pump/hand_pump.py
index e8fc8e4..a4f72c6 100644
--- a/showcase/hand-pump/hand_pump.py
+++ b/showcase/hand-pump/hand_pump.py
@@ -35,19 +35,18 @@
 sys.dont_write_bytecode = True
 import gallery_framing  # noqa: E402
 
-PLINTH_XY = 0.30
-PLINTH_H = 0.072
+PLINTH_XY = 0.34
+PLINTH_H = 0.090
 COL_R = 0.050
 COL_H = 0.78
-COL_SEGS = 12
-SPOUT_Z = 0.42
-SPOUT_L = 0.16
-HANDLE_LIFT = 0.20
+COL_SEGS = 16
+SPOUT_Z = 0.46
+HANDLE_LIFT = 0.18
 
 BBOX_TOL = 0.01
-OUTER_SIZE = (0.567, 0.366, 1.027)
-BASE_TRIS_MIN = 540
-BASE_TRIS_MAX = 700
+OUTER_SIZE = (0.610, 0.364, 1.049)
+BASE_TRIS_MIN = 1080
+BASE_TRIS_MAX = 1240
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -131,6 +130,26 @@ def add_oriented_box(bm, a, b, scale_xy, mat_idx):
     )
 
 
+def add_cyl_between(bm, a, b, radius, segments, mat_idx):
+    a = Vector(a)
+    b = Vector(b)
+    delta = b - a
+    length = delta.length
+    if length < 1e-8:
+        return []
+    quat = Vector((0.0, 0.0, 1.0)).rotation_difference(delta.normalized())
+    eul = quat.to_euler("XYZ")
+    return add_cyl(
+        bm,
+        ((a + b) * 0.5),
+        radius,
+        length,
+        segments,
+        mat_idx,
+        euler=(eul.x, eul.y, eul.z),
+    )
+
+
 def add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
     geo = bmesh.ops.create_cone(
         bm,
@@ -261,27 +280,37 @@ def build_hand_pump_mesh(name, bevel_offset, bevel_segments):
     try:
         wood = []
         metal = []
-        col_z = PLINTH_H + COL_H / 2.0
-        top_z = PLINTH_H + COL_H
+        slab_h = 0.050
+        cap_h = 0.040
+        top_z = slab_h + cap_h + COL_H
 
         wood.extend(
             add_box(
                 bm,
-                (0.0, 0.0, PLINTH_H / 2.0),
-                (PLINTH_XY, PLINTH_XY, PLINTH_H),
+                (0.0, 0.0, slab_h / 2.0),
+                (PLINTH_XY, PLINTH_XY, slab_h),
                 WOOD_IDX,
             )
         )
-        grip_end = Vector((-0.36, 0.10, top_z - 0.04 + HANDLE_LIFT))
+        wood.extend(
+            add_box(
+                bm,
+                (0.0, 0.0, slab_h + cap_h / 2.0),
+                (0.26, 0.26, cap_h),
+                WOOD_IDX,
+            )
+        )
+        pivot = Vector((0.0, COL_R + 0.030, top_z - 0.018))
+        grip_end = Vector((-0.38, pivot.y + 0.02, pivot.z + HANDLE_LIFT))
         wood.extend(
             add_cyl(
                 bm,
                 (grip_end.x, grip_end.y, grip_end.z),
-                0.016,
-                0.11,
-                8,
+                0.018,
+                0.12,
+                10,
                 WOOD_IDX,
-                euler=(0.0, math.pi / 2.0, 0.25),
+                euler=(0.0, math.pi / 2.0, 0.0),
             )
         )
 
@@ -299,87 +328,133 @@ def build_hand_pump_mesh(name, bevel_offset, bevel_segments):
             for f in ret.get("faces") or []:
                 f.material_index = WOOD_IDX
 
+        plinth_top = slab_h + cap_h
         metal.extend(
             add_cyl(
                 bm,
-                (0.0, 0.0, PLINTH_H + 0.014),
-                0.092,
-                0.028,
+                (0.0, 0.0, plinth_top + 0.016),
+                0.095,
+                0.032,
                 COL_SEGS,
                 METAL_IDX,
             )
         )
+        lower_h = 0.40
         metal.extend(
             add_cyl(
                 bm,
-                (0.0, 0.0, col_z),
-                COL_R,
-                COL_H,
+                (0.0, 0.0, plinth_top + lower_h / 2.0),
+                0.062,
+                lower_h,
                 COL_SEGS,
                 METAL_IDX,
             )
         )
+        joint_z = plinth_top + lower_h
         metal.extend(
             add_cyl(
                 bm,
-                (0.0, 0.0, PLINTH_H + COL_H * 0.42),
-                COL_R + 0.010,
-                0.032,
+                (0.0, 0.0, joint_z),
+                0.078,
+                0.026,
                 COL_SEGS,
                 METAL_IDX,
             )
         )
+        upper_h = 0.36
         metal.extend(
-            add_cone(
+            add_cyl(
                 bm,
-                (0.0, 0.0, top_z + 0.028),
-                0.058,
-                0.018,
-                0.056,
+                (0.0, 0.0, joint_z + upper_h / 2.0),
+                0.046,
+                upper_h,
                 COL_SEGS,
                 METAL_IDX,
             )
         )
-        spout_y = -(COL_R + SPOUT_L / 2.0)
+        metal.extend(
+            add_box(
+                bm,
+                (0.0, 0.0, top_z + 0.012),
+                (0.10, 0.10, 0.085),
+                METAL_IDX,
+            )
+        )
         metal.extend(
             add_cyl(
                 bm,
-                (0.0, spout_y, SPOUT_Z),
-                0.022,
-                SPOUT_L,
-                10,
+                (0.0, 0.0, top_z + 0.068),
+                0.034,
+                0.036,
+                COL_SEGS,
                 METAL_IDX,
-                euler=(math.pi / 2.0, 0.0, 0.0),
             )
         )
+
+        arc_r = 0.13
+        origin_y = -(0.046)
+        origin_z = SPOUT_Z
+        n_arc = 7
+        last = None
+        for i in range(n_arc):
+            t0 = (i / n_arc) * (math.pi / 2.0)
+            t1 = ((i + 1) / n_arc) * (math.pi / 2.0)
+            p0 = (
+                0.0,
+                origin_y - arc_r * math.sin(t0),
+                origin_z - arc_r * (1.0 - math.cos(t0)),
+            )
+            p1 = (
+                0.0,
+                origin_y - arc_r * math.sin(t1),
+                origin_z - arc_r * (1.0 - math.cos(t1)),
+            )
+            metal.extend(add_cyl_between(bm, p0, p1, 0.018, 10, METAL_IDX))
+            last = p1
         metal.extend(
             add_cyl(
                 bm,
-                (0.0, spout_y - SPOUT_L / 2.0 + 0.012, SPOUT_Z - 0.045),
-                0.018,
-                0.090,
+                (0.0, last[1], last[2] - 0.028),
+                0.016,
+                0.056,
                 10,
                 METAL_IDX,
             )
         )
-        pivot = Vector((0.0, COL_R + 0.018, top_z - 0.055))
+
+        metal.extend(
+            add_box(
+                bm,
+                (0.028, pivot.y, pivot.z),
+                (0.022, 0.048, 0.050),
+                METAL_IDX,
+            )
+        )
+        metal.extend(
+            add_box(
+                bm,
+                (-0.028, pivot.y, pivot.z),
+                (0.022, 0.048, 0.050),
+                METAL_IDX,
+            )
+        )
         metal.extend(
             add_cyl(
                 bm,
-                (pivot.x, pivot.y, pivot.z),
-                0.016,
-                0.055,
-                8,
+                (0.0, pivot.y, pivot.z),
+                0.012,
+                0.072,
+                10,
                 METAL_IDX,
-                euler=(math.pi / 2.0, 0.0, 0.0),
+                euler=(0.0, math.pi / 2.0, 0.0),
             )
         )
         metal.extend(
             add_oriented_box(
                 bm,
                 (pivot.x, pivot.y, pivot.z),
-                (grip_end.x + 0.04, grip_end.y, grip_end.z),
-                (0.022, 0.018),
+                (grip_end.x + 0.03, grip_end.y, grip_end.z),
+                (0.020, 0.016),
                 METAL_IDX,
             )
         )
@@ -557,7 +632,7 @@ def check(skip_decimate):
     low = build_hand_pump_mesh("HandPumpLow", bevel_offset=0.004, bevel_segments=2)
     high = build_hand_pump_mesh("HandPumpHigh", bevel_offset=0.004, bevel_segments=4)
     wood = principled("HandPumpWood", (0.36, 0.19, 0.07, 1.0), 0.0, 0.60)
-    metal = principled("HandPumpIron", (0.16, 0.155, 0.15, 1.0), 1.0, 0.42)
+    metal = principled("HandPumpIron", (0.22, 0.21, 0.20, 1.0), 1.0, 0.35)
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -708,7 +783,7 @@ def render_still(low, wood, tex, path, engine):
             ob.hide_render = True
             ob.hide_viewport = True
 
-    low.rotation_euler.z = math.radians(-28.0)
+    low.rotation_euler.z = math.radians(-36.0)
     low.rotation_euler.x = math.radians(0.0)
 
     floor_me = bpy.data.meshes.new("Floor")
@@ -755,10 +830,10 @@ def light(name, loc, energy, size, col, rot):
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (2.05, -2.54, 0.97)
+    cam.location = (2.15, -2.35, 1.08)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.42)
+    aim.location = (0.0, 0.0, 0.52)
     scene.collection.objects.link(aim)
     con = cam.constraints.new("TRACK_TO")
     con.target = aim
diff --git a/showcase/hand-pump/preview.webp b/showcase/hand-pump/preview.webp
index bef66e3..89d748c 100644
Binary files a/showcase/hand-pump/preview.webp and b/showcase/hand-pump/preview.webp differ
diff --git a/showcase/signpost/README.md b/showcase/signpost/README.md
index 98ff19e..6a66060 100644
--- a/showcase/signpost/README.md
+++ b/showcase/signpost/README.md
@@ -1,9 +1,10 @@
 # Signpost
 
 A showcase piece, not an example. Procedural timber fingerboard
-signpost (square post, pyramidal cap, two painted boards, iron shoe
-and straps) then the shipped pipeline: unique-cell UVs, Cycles
-high-to-low normal bake, LOD chain, convex collider, Unity glTF export.
+signpost (square post, collar and pyramidal cap, two painted planks
+with diamond tips, iron shoe and straps) then the shipped pipeline:
+unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex
+collider, Unity glTF export.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -21,14 +22,14 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 320–460 | 388 / 388 / 388 |
+| Base triangles | 430–580 | 504 / 504 / 504 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2165 / 0.2165 / 0.1804 |
-| Materials | exactly 3 distinct, ≥24 metal and ≥12 board faces | 3 slots, 66 metal, 22 board |
+| LOD2 ratio | 0.10–0.35 of base | 0.2183 / 0.2183 / 0.1746 |
+| Materials | exactly 3 distinct, ≥24 metal and ≥12 board faces | 3 slots, 66 metal, 24 board |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.162, 0.147, 1.575) m ± 0.01 | (1.1620, 0.1474, 1.5750), zmin 0 |
-| Collider tris | ≤ 140 | 92 |
-| Export | written, size > 0 | 40124 / 40124 / 40112 bytes |
+| Outer AABB | (1.368, 0.201, 1.566) m ± 0.01 | (1.3679, 0.2014, 1.5660), zmin 0 |
+| Collider tris | ≤ 140 | 56 |
+| Export | written, size > 0 | 45164 / 45164 / 45152 bytes |
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an
diff --git a/showcase/signpost/preview.webp b/showcase/signpost/preview.webp
index 24ccfce..266e72f 100644
Binary files a/showcase/signpost/preview.webp and b/showcase/signpost/preview.webp differ
diff --git a/showcase/signpost/signpost.py b/showcase/signpost/signpost.py
index 80c8b70..82e6702 100644
--- a/showcase/signpost/signpost.py
+++ b/showcase/signpost/signpost.py
@@ -35,20 +35,20 @@
 sys.dont_write_bytecode = True
 import gallery_framing  # noqa: E402
 
-POST_W = 0.110
+POST_W = 0.118
 POST_H = 1.48
-CAP_H = 0.095
+CAP_H = 0.058
 SHOE_H = 0.048
 SHOE_SCALE = 1.34
-BOARD_Y = 0.072
-BOARD_ZTH = 0.046
-BOARD_A = (1.24, 0.52, 1.0)
-BOARD_B = (1.02, 0.44, -1.0)
+BOARD_T = 0.028
+BOARD_H = 0.112
+BOARD_A = (1.24, 0.62, 1.0, 0.12)
+BOARD_B = (1.00, 0.54, -1.0, -0.18)
 
 BBOX_TOL = 0.01
-OUTER_SIZE = (1.162, 0.147, 1.575)
-BASE_TRIS_MIN = 320
-BASE_TRIS_MAX = 460
+OUTER_SIZE = (1.368, 0.201, 1.566)
+BASE_TRIS_MIN = 430
+BASE_TRIS_MAX = 580
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -275,12 +275,20 @@ def build_signpost_mesh(name, bevel_offset, bevel_segments):
                 WOOD_IDX,
             )
         )
+        wood.extend(
+            add_box(
+                bm,
+                (0.0, 0.0, POST_H + 0.014),
+                (POST_W * 1.16, POST_W * 1.16, 0.028),
+                WOOD_IDX,
+            )
+        )
         wood.extend(
             add_cone(
                 bm,
-                (0.0, 0.0, POST_H + CAP_H / 2.0),
-                POST_W * 0.78,
-                0.012,
+                (0.0, 0.0, POST_H + 0.028 + CAP_H / 2.0),
+                POST_W * 0.72,
+                0.008,
                 CAP_H,
                 4,
                 WOOD_IDX,
@@ -302,50 +310,53 @@ def build_signpost_mesh(name, bevel_offset, bevel_segments):
             for f in ret.get("faces") or []:
                 f.material_index = WOOD_IDX
 
-        for z, length, sign in (BOARD_A, BOARD_B):
-            cx = sign * (half + length / 2.0 - 0.018)
+        for z, length, sign, yaw in (BOARD_A, BOARD_B):
+            eul = Euler((0.0, 0.0, yaw))
+            rot = eul.to_matrix()
+            inner = Vector((sign * (half - 0.016), 0.0, z))
+            center = inner + rot @ Vector((sign * length / 2.0, 0.0, 0.0))
             boards.extend(
                 add_box(
                     bm,
-                    (cx, 0.0, z),
-                    (length, BOARD_Y, BOARD_ZTH),
+                    (center.x, center.y, center.z),
+                    (length, BOARD_T, BOARD_H),
                     BOARD_IDX,
+                    euler=(0.0, 0.0, yaw),
                 )
             )
-            tip_x = cx + sign * (length / 2.0 + 0.028)
+            tip = inner + rot @ Vector((sign * (length + 0.004), 0.0, 0.0))
             boards.extend(
-                add_cone(
+                add_box(
                     bm,
-                    (tip_x, 0.0, z),
-                    0.052,
-                    0.004,
-                    0.072,
-                    3,
+                    (tip.x, tip.y, tip.z),
+                    (0.088, BOARD_T, 0.088),
                     BOARD_IDX,
-                    euler=(0.0, sign * math.pi / 2.0, 0.0),
+                    euler=(0.0, math.pi / 4.0, yaw),
                 )
             )
+            t = 0.012
+            h = BOARD_H + 0.024
             metal.extend(
                 add_box(
                     bm,
-                    (sign * (half + 0.010), 0.0, z),
-                    (0.020, BOARD_Y + 0.016, BOARD_ZTH + 0.018),
+                    (sign * (half + t / 2.0), 0.0, z),
+                    (t, POST_W * 0.94, h),
                     METAL_IDX,
                 )
             )
             metal.extend(
                 add_box(
                     bm,
-                    (0.0, half + 0.010, z),
-                    (POST_W * 0.92, 0.014, BOARD_ZTH * 1.15),
+                    (0.0, half + t / 2.0, z),
+                    (POST_W * 0.94, t, h),
                     METAL_IDX,
                 )
             )
             metal.extend(
                 add_box(
                     bm,
-                    (0.0, -(half + 0.010), z),
-                    (POST_W * 0.92, 0.014, BOARD_ZTH * 1.15),
+                    (0.0, -(half + t / 2.0), z),
+                    (POST_W * 0.94, t, h),
                     METAL_IDX,
                 )
             )
@@ -533,7 +544,7 @@ def check(skip_decimate):
     low = build_signpost_mesh("SignpostLow", bevel_offset=0.004, bevel_segments=2)
     high = build_signpost_mesh("SignpostHigh", bevel_offset=0.004, bevel_segments=4)
     wood = principled("SignpostWood", (0.34, 0.18, 0.07, 1.0), 0.0, 0.62)
-    board = principled("SignpostBoard", (0.72, 0.58, 0.28, 1.0), 0.0, 0.55)
+    board = principled("SignpostBoard", (0.76, 0.58, 0.22, 1.0), 0.0, 0.52)
     metal = principled("SignpostIron", (0.14, 0.145, 0.155, 1.0), 1.0, 0.38)
     assign_slots(low, wood, board, metal)
     assign_slots(high, wood, board, metal)
@@ -690,7 +701,7 @@ def render_still(low, wood, tex, path, engine):
             ob.hide_render = True
             ob.hide_viewport = True
 
-    low.rotation_euler.z = math.radians(-18.0)
+    low.rotation_euler.z = math.radians(-12.0)
     low.rotation_euler.x = math.radians(0.0)
 
     floor_me = bpy.data.meshes.new("Floor")
@@ -737,10 +748,10 @@ def light(name, loc, energy, size, col, rot):
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (3.06, -4.02, 1.38)
+    cam.location = (2.80, -3.40, 1.35)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.78)
+    aim.location = (0.0, 0.0, 0.82)
     scene.collection.objects.link(aim)
     con = cam.constraints.new("TRACK_TO")
     con.target = aim
diff --git a/showcase/water-trough/README.md b/showcase/water-trough/README.md
index 9611149..a3d4109 100644
--- a/showcase/water-trough/README.md
+++ b/showcase/water-trough/README.md
@@ -1,9 +1,9 @@
 # Water trough
 
 A showcase piece, not an example. Procedural staved water trough on a
-timber stand (U-staves, end boards, iron straps, trestle legs) then the
-shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD
-chain, convex collider, Unity glTF export.
+timber stand (U-staves, solid end-caps, water, iron straps, trestle
+legs) then the shipped pipeline: unique-cell UVs, Cycles high-to-low
+normal bake, LOD chain, convex collider, Unity glTF export.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -21,14 +21,14 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 3880–4140 | 4008 / 4008 / 4008 |
+| Base triangles | 4650–4900 | 4776 / 4776 / 4776 |
 | 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.2196 |
-| Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 168 metal |
+| LOD2 ratio | 0.10–0.35 of base | 0.2198 / 0.2198 / 0.2198 |
+| Materials | exactly 3 distinct, ≥24 metal and ≥6 water faces | 3 slots, 168 metal, 60 water |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.136, 0.482, 0.470) m ± 0.01 | (1.1360, 0.4820, 0.4701), zmin 0 |
-| Collider tris | ≤ 150 | 108 |
-| Export | written, size > 0 | 292484 / 292484 / 292468 bytes |
+| Outer AABB | (1.162, 0.528, 0.488) m ± 0.01 | (1.1620, 0.5280, 0.4883), zmin 0 |
+| Collider tris | ≤ 150 | 128 |
+| Export | written, size > 0 | 348208 / 348208 / 348192 bytes |
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series
 in general — the gate is a ratio band, not an exact count. On this
@@ -62,7 +62,7 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 2 | argparse / usage |
 | 3 | Mesh did not build / no UV layer |
 | 4 | Base triangle count outside range |
-| 5 | Material count ≠ 2 distinct slots, or wood/metal faces missing |
+| 5 | Material count ≠ 3 distinct slots, or wood/metal/water faces missing |
 | 6 | UVs outside 0..1 |
 | 7 | UV AABB overlap above tolerance |
 | 8 | World AABB off declared outer size |
diff --git a/showcase/water-trough/preview.webp b/showcase/water-trough/preview.webp
index 00ba9f1..bdf1492 100644
Binary files a/showcase/water-trough/preview.webp and b/showcase/water-trough/preview.webp differ
diff --git a/showcase/water-trough/water_trough.py b/showcase/water-trough/water_trough.py
index e1bdb8a..aea988b 100644
--- a/showcase/water-trough/water_trough.py
+++ b/showcase/water-trough/water_trough.py
@@ -1,8 +1,9 @@
 """Game-ready wooden water trough — a showcase piece, not an example.
 
 Asserts budget conformance of a procedural staved trough on a timber
-stand (U-staves, end boards, iron straps, trestle legs) after composing
-shipped pipeline pieces: bmesh construction, UVs, two materials,
+stand (U-staves, solid end-caps, water, iron straps, trestle legs)
+after composing shipped pipeline pieces: bmesh construction, UVs, three
+materials,
 high-to-low normal bake, LOD chain, convex collider, Unity glTF export.
 
 Budgets are declared below and recomputed from the generated result.
@@ -42,16 +43,16 @@
 A_SPAN = 1.42
 
 BBOX_TOL = 0.01
-OUTER_SIZE = (1.136, 0.482, 0.470)
-BASE_TRIS_MIN = 3880
-BASE_TRIS_MAX = 4140
+OUTER_SIZE = (1.162, 0.528, 0.488)
+BASE_TRIS_MIN = 4650
+BASE_TRIS_MAX = 4900
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
 LOD2_RATIO_MAX = 0.35
 LOD1_TARGET = 0.50
 LOD2_TARGET = 0.22
-MATERIAL_COUNT = 2
+MATERIAL_COUNT = 3
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
 COLLIDER_TRIS_MAX = 150
@@ -59,9 +60,11 @@
 CAGE_EXTRUSION = 0.08
 METAL_FACES_MIN = 24
 WOOD_FACES_MIN = 24
+WATER_FACES_MIN = 6
 
 WOOD_IDX = 0
 METAL_IDX = 1
+WATER_IDX = 2
 
 
 def eevee_engine_id():
@@ -221,14 +224,14 @@ def build_trough_mesh(name, bevel_offset, bevel_segments):
         zc = 0.30 + TRAY_R
         cx = 0.0
 
-        def pt(a, x):
+        def pt(a, x, radius=TRAY_R):
             return (
                 x,
-                TRAY_R * math.sin(a),
-                zc - TRAY_R * math.cos(a),
+                radius * math.sin(a),
+                zc - radius * math.cos(a),
             )
 
-        gap = 0.10
+        gap = 0.16
         for i in range(N_STAVES):
             t0 = i / N_STAVES
             t1 = (i + (1.0 - gap)) / N_STAVES
@@ -245,39 +248,58 @@ def pt(a, x):
                     euler=(mid, 0.0, 0.0),
                 )
             )
-            for xend in (cx + TRAY_L / 2.0 + 0.014, cx - TRAY_L / 2.0 - 0.014):
+
+        n_end = 11
+        end_r = TRAY_R + STAVE_T * 0.15
+        for xend in (cx + TRAY_L / 2.0 + 0.020, cx - TRAY_L / 2.0 - 0.020):
+            for i in range(n_end):
+                t0 = i / n_end
+                t1 = (i + 1.0) / n_end
+                a0 = -A_SPAN + 2.0 * A_SPAN * t0
+                a1 = -A_SPAN + 2.0 * A_SPAN * t1
+                mid = 0.5 * (a0 + a1)
+                chord = end_r * abs(a1 - a0) * 1.18
                 wood.extend(
                     add_box(
                         bm,
-                        pt(mid, xend),
-                        (0.028, chord * 1.02, STAVE_T * 1.05),
+                        pt(mid, xend, end_r),
+                        (0.042, chord, STAVE_T * 1.45),
                         WOOD_IDX,
                         euler=(mid, 0.0, 0.0),
                     )
                 )
 
-        for sx in (-TRAY_L * 0.32, TRAY_L * 0.32):
+        for a_lip in (-A_SPAN, A_SPAN):
+            wood.extend(
+                add_box(
+                    bm,
+                    pt(a_lip, cx),
+                    (TRAY_L + 0.050, 0.034, 0.030),
+                    WOOD_IDX,
+                    euler=(a_lip, 0.0, 0.0),
+                )
+            )
+
+        for sx in (-TRAY_L * 0.30, TRAY_L * 0.30):
             for ysign in (-1.0, 1.0):
-                top = (sx, ysign * 0.12, zc - TRAY_R - 0.02)
-                bot = (sx, ysign * 0.22, 0.02)
+                top = (sx, ysign * 0.10, zc - TRAY_R - 0.035)
+                bot = (sx, ysign * 0.24, 0.024)
                 wood.extend(
-                    add_oriented_box(bm, top, bot, (0.036, 0.036), WOOD_IDX)
+                    add_oriented_box(bm, top, bot, (0.050, 0.036), WOOD_IDX)
                 )
             wood.extend(
-                add_oriented_box(
+                add_box(
                     bm,
-                    (sx, -0.16, 0.13),
-                    (sx, 0.16, 0.13),
-                    (0.028, 0.028),
+                    (sx, 0.0, 0.115),
+                    (0.044, 0.38, 0.030),
                     WOOD_IDX,
                 )
             )
         wood.extend(
-            add_oriented_box(
+            add_box(
                 bm,
-                (-TRAY_L * 0.32, 0.0, 0.13),
-                (TRAY_L * 0.32, 0.0, 0.13),
-                (0.028, 0.028),
+                (0.0, 0.0, 0.115),
+                (TRAY_L * 0.62, 0.044, 0.030),
                 WOOD_IDX,
             )
         )
@@ -313,17 +335,41 @@ def pt(a, x):
                 metal.extend(
                     add_oriented_box(bm, p0, p1, (0.020, 0.010), METAL_IDX)
                 )
-        for sx in (-TRAY_L * 0.32, TRAY_L * 0.32):
+        for sx in (-TRAY_L * 0.30, TRAY_L * 0.30):
             for ysign in (-1.0, 1.0):
                 metal.extend(
                     add_box(
                         bm,
-                        (sx, ysign * 0.22, 0.012),
-                        (0.050, 0.042, 0.022),
+                        (sx, ysign * 0.24, 0.012),
+                        (0.056, 0.048, 0.024),
                         METAL_IDX,
                     )
                 )
 
+        n_w = 9
+        wr = TRAY_R - STAVE_T * 0.60
+        span = A_SPAN * 0.90
+        for i in range(n_w):
+            t0 = i / n_w
+            t1 = (i + 1.0) / n_w
+            a0 = -span + 2.0 * span * t0
+            a1 = -span + 2.0 * span * t1
+            mid = 0.5 * (a0 + a1)
+            chord = wr * abs(a1 - a0) * 1.16
+            add_box(
+                bm,
+                pt(mid, cx, wr),
+                (TRAY_L * 0.84, chord, 0.018),
+                WATER_IDX,
+                euler=(mid, 0.0, 0.0),
+            )
+        add_box(
+            bm,
+            (cx, 0.0, zc - TRAY_R * 0.28),
+            (TRAY_L * 0.84, TRAY_R * 1.50, 0.010),
+            WATER_IDX,
+        )
+
         xs = [v.co.x for v in bm.verts]
         ys = [v.co.y for v in bm.verts]
         zs = [v.co.z for v in bm.verts]
@@ -363,9 +409,9 @@ def principled(name, color, metallic, roughness):
     return mat
 
 
-def assign_slots(obj, wood, metal):
+def assign_slots(obj, wood, metal, water):
     mats = obj.data.materials
-    wanted = (wood, metal)
+    wanted = (wood, metal, water)
     for i, mat in enumerate(wanted):
         if i < len(mats):
             mats[i] = mat
@@ -498,8 +544,9 @@ def check(skip_decimate):
     high = build_trough_mesh("TroughHigh", bevel_offset=0.005, bevel_segments=4)
     wood = principled("TroughWood", (0.40, 0.22, 0.08, 1.0), 0.0, 0.58)
     metal = principled("TroughIron", (0.10, 0.105, 0.12, 1.0), 1.0, 0.30)
-    assign_slots(low, wood, metal)
-    assign_slots(high, wood, metal)
+    water = principled("TroughWater", (0.05, 0.13, 0.14, 1.0), 0.0, 0.14)
+    assign_slots(low, wood, metal, water)
+    assign_slots(high, wood, metal, water)
 
     if low.data is None or len(low.data.polygons) < 6:
         return fail("trough mesh did not build", 3), None, None, None, None, None
@@ -583,6 +630,11 @@ def check(skip_decimate):
             f"wood faces {idx_counts.get(WOOD_IDX, 0)} < {WOOD_FACES_MIN}",
             5,
         ), None, None, None, None, None
+    if idx_counts.get(WATER_IDX, 0) < WATER_FACES_MIN:
+        return fail(
+            f"water faces {idx_counts.get(WATER_IDX, 0)} < {WATER_FACES_MIN}",
+            5,
+        ), None, None, None, None, None
     if u0 < -UV_EPS or v0 < -UV_EPS or u1 > 1.0 + UV_EPS or v1 > 1.0 + UV_EPS:
         return fail(
             f"UVs outside 0..1: ({u0:.4f},{v0:.4f})-({u1:.4f},{v1:.4f})",
@@ -646,7 +698,7 @@ def render_still(low, wood, tex, path, engine):
             ob.hide_render = True
             ob.hide_viewport = True
 
-    low.rotation_euler.z = math.radians(-16.0)
+    low.rotation_euler.z = math.radians(-90.0)
     low.rotation_euler.x = math.radians(0.0)
 
     floor_me = bpy.data.meshes.new("Floor")
@@ -693,10 +745,10 @@ def light(name, loc, energy, size, col, rot):
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (1.43, -1.73, 0.88)
+    cam.location = (1.05, -2.00, 1.22)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.26)
+    aim.location = (0.0, 0.0, 0.22)
     scene.collection.objects.link(aim)
     con = cam.constraints.new("TRACK_TO")
     con.target = aim