diff --git a/docs/gallery/assets/fence-kit-hero.webp b/docs/gallery/assets/fence-kit-hero.webp
index 590a532..836bf9d 100644
Binary files a/docs/gallery/assets/fence-kit-hero.webp and b/docs/gallery/assets/fence-kit-hero.webp differ
diff --git a/docs/gallery/assets/hand-pump-hero.webp b/docs/gallery/assets/hand-pump-hero.webp
index aaa9171..d52e908 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/fence-kit/index.html b/docs/gallery/fence-kit/index.html
index a2d76d3..f4e7ada 100644
--- a/docs/gallery/fence-kit/index.html
+++ b/docs/gallery/fence-kit/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>fence-kit — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural post-and-rail fence section through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural post-and-rail fence section whose brace is an oriented box between named post stations, 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/fence-kit/" />
   <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="fence-kit — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural post-and-rail fence section through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural post-and-rail fence section whose brace is an oriented box between named post stations, 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/fence-kit/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/fence-kit-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="fence-kit — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural post-and-rail fence section through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural post-and-rail fence section whose brace is an oriented box between named post stations, 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/fence-kit-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,35 +246,52 @@
   </div>
   <header class="hero">
     <h1>fence-kit</h1>
-    <p>A procedural post-and-rail fence section through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural post-and-rail fence section whose brace is an oriented box between named post stations, 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 fence-kit render">
       <img src="../assets/fence-kit-hero.webp" alt="fence-kit 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: 1212 tris, two materials with 120 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.642×0.157×1.235 m, LOD ratios in band, convex collider 62 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 1092 tris, two materials with 156 metal and 390 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.624×0.134×1.232 m, grounded zmin, 2 iron shoes, brace-to-post gap 2.4 mm on both posts, rail-to-post gap 0.93 mm, rail span 1.390 m, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 32 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-shoes 16; --short-brace 17; --gap-rails 18; --long-rails 19.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/fence-kit/fence_kit.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 post-and-rail fence section (two posts, pyramidal caps, three rails, kickboard, brace, iron shoes 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 post-and-rail fence section (two posts, pyramidal caps, three rails, kickboard, a brace from named post stations, iron shoes and U-wrap straps) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>Posts, rails, kick, brace and collars share named stations (<code>POST_XS</code>, <code>RAIL_ZS</code>, <code>Y_BRACE</code>, <code>SHOE_H</code>). The brace is an oriented box from the left-post lower-rail station to the right-post upper-rail station on the back face, not a hypot-length box rotated about its centroid. Rails and kick tenon into the post volume; rail collars are U-wraps so the span-facing plate is not coplanar with the rail end.</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. AABB X is the tile width so adjacent copies meet; this piece does not re-witness the <code>modular-kit-snap</code> snap contract.</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>
+<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). Hygiene combinatorics match <code>examples/mesh-hygiene-audit</code> (copied, not imported).</p>
+<p>Intended size: 1.60 m bay, 1.14 m posts, 0.11 m post stock; outer AABB 1.624 × 0.134 × 1.232 m.</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 | 1160–1280 | 1212 / 1212 / 1212 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2195 / 0.2195 / 0.2079 | | Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 120 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.642, 0.157, 1.235) m ± 0.01 | (1.6418, 0.1574, 1.2350), zmin 0 | | Collider tris | ≤ 96 | 62 | | Export | written, size &gt; 0 | 93232 / 93232 / 93224 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.</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>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 1000–1400 | 1092 / 1092 / 1092 | | 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.1832 | | Materials | exactly 2 distinct, ≥48 metal, ≥24 wood | 2 slots, 156 metal / 390 wood | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.624, 0.134, 1.232) m ± 0.015 | (1.6240, 0.1340, 1.2320), zmin 0 | | Collider tris | ≤ 180 | 32 | | Export | written, size &gt; 0 | 82216 / 82216 / 82208 bytes |</p>
+<p>Base triangles dropped from <strong>1212 to 1092</strong> in the quality pass: rail collars became U-wraps (no span-facing plate). Outer AABB tightened from 1.642 × 0.157 × 1.235 m.</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>
+<h3>Hygiene</h3>
+<p>Recomputed from the generated mesh, not asserted about the script.</p>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Non-manifold edges | 0 | 0 | | Loose verts / edges | 0 / 0 | 0 / 0 | | Doubles merged at 1e-5 | 0 | 0 | | Zero-area faces | 0 | 0 | | N-gons | 0 | 0 | | Coplanar disjoint face pairs | 0 | 0 | | Grounded: <code>zmin</code> | within 1e-4 of 0 | 0.0000 | | Named shoes | 2, each <code>zmin</code> ≤ 0.002 | 2, 0.00000 |</p>
+<h3>Joint fit and span</h3>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Brace-to-post BVH gap (both posts) | ≤ 0.008 m | 0.00240 | | Rail-to-post BVH gap | ≤ 0.008 m | 0.00093 | | Rail span vs <code>2·RAIL_HALF</code> | ± 0.04 m | 1.3900 vs 1.390 |</p>
+<h3>Falsifiers</h3>
+<p>Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<p>| Flag | Budget violated | Exit | | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | | <code>--stray-vert</code> | loose vertex count is 0 | 15 | | <code>--lift-z</code> | bounding box <code>zmin</code> is 0 | 16 | | <code>--short-shoes</code> | named shoes plant at z=0 | 16 | | <code>--short-brace</code> | brace-to-post BVH gap (both posts) | 17 | | <code>--gap-rails</code> | rail-to-post BVH gap | 18 | | <code>--long-rails</code> | rail span vs <code>2·RAIL_HALF</code> | 19 |</p>
+<p><code>--short-shoes</code> lifts only the iron shoes. After recenter a post or kick is the AABB <code>zmin</code>, so the AABB gate would still pass; the named-shoe stations fail. <code>--short-brace</code> shortens the left station; <code>brace_gap</code> is the max of the per-post minima so a brace that still hits the right post cannot sneak through. <code>--long-rails</code> adds an extra spanning board; the tenoned rails stay put so the gap budget still passes.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python fence_kit.py --
 blender --background --python fence_kit.py -- --skip-decimate
+blender --background --python fence_kit.py -- --stray-vert
+blender --background --python fence_kit.py -- --lift-z
+blender --background --python fence_kit.py -- --short-shoes
+blender --background --python fence_kit.py -- --short-brace
+blender --background --python fence_kit.py -- --gap-rails
+blender --background --python fence_kit.py -- --long-rails
 blender --background --python fence_kit.py -- --output fence.png</code></pre>
-<p>Smoke does not pass <code>--output</code> or <code>--skip-decimate</code>.</p>
+<p>Smoke passes no flags.</p>
 <h2>Exit codes</h2>
-<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path.</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 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>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</p>
+<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 | | 15 | Hygiene (<code>--stray-vert</code> lands here) | | 16 | Grounded zmin / named shoes (<code>--lift-z</code>, <code>--short-shoes</code>) | | 17 | Brace-to-post gap (<code>--short-brace</code>) | | 18 | Rail-to-post gap (<code>--gap-rails</code>) | | 19 | Rail span (<code>--long-rails</code>) |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -289,9 +306,17 @@ <h2>Source</h2>
 materials, high-to-low normal bake, LOD chain, convex collider,
 Unity glTF export.
 
+Posts, rails, kick, brace and collars share named stations
+(``post_xs``, ``RAIL_ZS``, ``y_brace``). The brace is an oriented
+box between those stations, not a hypot-length cube rotated about
+its centroid. Rails and kick tenon into the post volume without
+sharing corner verts.
+
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+DECIMATE stage so the LOD-ratio budget fails. Hygiene family 15–19:
+``--stray-vert``, ``--lift-z`` / ``--short-shoes``, ``--short-brace``,
+``--gap-rails``, ``--long-rails``.
 
 No RNG. Construction is closed-form. AABB X is the tile width so
 adjacent copies meet; this piece does not re-witness the modular-kit
@@ -313,6 +338,7 @@ <h2>Source</h2>
 <span class="k">import</span> bmesh
 <span class="k">import</span> bpy
 <span class="k">from</span> mathutils <span class="k">import</span> Euler, Vector
+<span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -325,6 +351,7 @@ <h2>Source</h2>
 POST_W = <span class="n">0.110</span>
 POST_H = <span class="n">1.14</span>
 CAP_H = <span class="n">0.095</span>
+CAP_OVERHANG = <span class="n">0.012</span>
 RAIL_Y = <span class="n">0.055</span>
 RAIL_Z = <span class="n">0.064</span>
 RAIL_ZS = (<span class="n">0.30</span>, <span class="n">0.58</span>, <span class="n">0.86</span>)
@@ -333,12 +360,17 @@ <h2>Source</h2>
 BRACE_T = <span class="n">0.042</span>
 IRON_T = <span class="n">0.016</span>
 SHOE_H = <span class="n">0.034</span>
-SHOE_SCALE = <span class="n">1.38</span>
-
-BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">1.642</span>, <span class="n">0.157</span>, <span class="n">1.235</span>)
-BASE_TRIS_MIN = <span class="n">1160</span>
-BASE_TRIS_MAX = <span class="n">1280</span>
+TENON = <span class="n">0.005</span>
+POST_XS = (-(TILE / <span class="n">2.0</span> - POST_W / <span class="n">2.0</span>), TILE / <span class="n">2.0</span> - POST_W / <span class="n">2.0</span>)
+HX = POST_XS[<span class="n">1</span>]
+Y_BRACE = -(POST_W * <span class="n">0.5</span> - BRACE_T * <span class="n">0.30</span>)
+RAIL_HALF = HX - POST_W * <span class="n">0.5</span> + TENON
+COLLAR_BITE = <span class="n">0.004</span>
+
+BBOX_TOL = <span class="n">0.015</span>
+OUTER_SIZE = (<span class="n">1.624</span>, <span class="n">0.134</span>, <span class="n">1.232</span>)
+BASE_TRIS_MIN = <span class="n">1000</span>
+BASE_TRIS_MAX = <span class="n">1400</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>
@@ -348,14 +380,31 @@ <h2>Source</h2>
 MATERIAL_COUNT = <span class="n">2</span>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
-COLLIDER_TRIS_MAX = <span class="n">96</span>
+COLLIDER_TRIS_MAX = <span class="n">180</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.06</span>
-METAL_FACES_MIN = <span class="n">24</span>
+METAL_FACES_MIN = <span class="n">48</span>
+WOOD_FACES_MIN = <span class="n">48</span>
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
 
+DOUBLES_EPS = <span class="n">1e-5</span>
+AREA_EPS = <span class="n">1e-10</span>
+ZMIN_EPS = <span class="n">1e-4</span>
+ZFIGHT_EPS = <span class="n">0.002</span>
+ZFIGHT_COS = <span class="n">0.98</span>
+SHOE_COUNT = <span class="n">2</span>
+SHOE_ZMIN_MAX = <span class="n">0.002</span>
+BRACE_GAP_MAX = <span class="n">0.008</span>
+RAIL_GAP_MAX = <span class="n">0.008</span>
+SPAN_TOL = <span class="n">0.04</span>
+LIFT_Z = <span class="n">0.05</span>
+SHORT_SHOE = <span class="n">0.08</span>
+SHORT_BRACE = <span class="n">0.22</span>
+GAP_RAIL = <span class="n">0.10</span>
+LONG_RAIL = <span class="n">0.08</span>
+
 
 <span class="k">def</span> eevee_engine_id():
     <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE&quot;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&quot;BLENDER_EEVEE_NEXT&quot;</span>
@@ -403,6 +452,46 @@ <h2>Source</h2>
     <span class="k">return</span> verts
 
 
+<span class="k">def</span> add_oriented_box(bm, a, b, scale_xy, 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_box(
+        bm,
+        ((a + b) * <span class="n">0.5</span>),
+        (scale_xy[<span class="n">0</span>], scale_xy[<span class="n">1</span>], length),
+        mat_idx,
+        euler=(eul.x, eul.y, eul.z),
+    )
+
+
+<span class="k">def</span> add_collar(bm, px, z, half, t, h, mat_idx, closed=<span class="k">True</span>):
+    <span class="s">&quot;&quot;&quot;Plates around a post. Bite the host. U-wrap omits the span-facing plate.&quot;&quot;&quot;</span>
+    loc_y = half - COLLAR_BITE + t * <span class="n">0.5</span>
+    add_box(bm, (px, loc_y, z), (<span class="n">2.0</span> * half - t * <span class="n">0.50</span>, t, h), mat_idx)
+    add_box(bm, (px, -loc_y, z), (<span class="n">2.0</span> * half - t * <span class="n">0.50</span>, t, h), mat_idx)
+    loc_x = half - COLLAR_BITE + t * <span class="n">0.5</span>
+    sign = <span class="n">1.0</span> <span class="k">if</span> px &gt;= <span class="n">0.0</span> <span class="k">else</span> -<span class="n">1.0</span>
+    add_box(
+        bm,
+        (px + sign * loc_x, <span class="n">0.0</span>, z),
+        (t, <span class="n">2.0</span> * half - t * <span class="n">0.70</span>, h),
+        mat_idx,
+    )
+    <span class="k">if</span> closed:
+        add_box(
+            bm,
+            (px - sign * loc_x, <span class="n">0.0</span>, z),
+            (t, <span class="n">2.0</span> * half - t * <span class="n">0.70</span>, h),
+            mat_idx,
+        )
+
+
 <span class="k">def</span> add_cone(bm, loc, radius1, radius2, 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,
@@ -467,60 +556,68 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> build_fence_mesh(name, bevel_offset, bevel_segments):
+<span class="k">def</span> build_fence_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    short_brace=<span class="k">False</span>,
+    short_shoes=<span class="k">False</span>,
+    gap_rails=<span class="k">False</span>,
+    long_rails=<span class="k">False</span>,
+):
     bm = bmesh.new()
     <span class="k">try</span>:
         wood_verts = []
-        post_xs = (-(TILE / <span class="n">2.0</span> - POST_W / <span class="n">2.0</span>), TILE / <span class="n">2.0</span> - POST_W / <span class="n">2.0</span>)
+        post_xs = POST_XS
+        half = POST_W * <span class="n">0.5</span>
+        rail_half = RAIL_HALF - GAP_RAIL <span class="k">if</span> gap_rails <span class="k">else</span> RAIL_HALF
+
         <span class="k">for</span> px <span class="k">in</span> post_xs:
             wood_verts.extend(
-                add_box(bm, (px, <span class="n">0.0</span>, POST_H / <span class="n">2.0</span>), (POST_W, POST_W, POST_H), WOOD_IDX)
-            )
-            wood_verts.extend(
-                add_cone(
+                add_box(
                     bm,
-                    (px, <span class="n">0.0</span>, POST_H + CAP_H / <span class="n">2.0</span>),
-                    POST_W * <span class="n">0.72</span>,
-                    <span class="n">0.010</span>,
-                    CAP_H,
-                    <span class="n">4</span>,
+                    (px, <span class="n">0.0</span>, POST_H / <span class="n">2.0</span>),
+                    (POST_W, POST_W, POST_H),
                     WOOD_IDX,
-                    euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, math.pi / <span class="n">4.0</span>),
                 )
             )
 
-        rail_len = TILE - POST_W * <span class="n">0.18</span>
-        <span class="k">for</span> z <span class="k">in</span> RAIL_ZS:
+        <span class="k">for</span> i, z <span class="k">in</span> enumerate(RAIL_ZS):
+            ry = RAIL_Y * (<span class="n">1.0</span> + <span class="n">0.10</span> * math.sin(i * <span class="n">2.15</span> + <span class="n">0.3</span>))
+            rz = RAIL_Z * (<span class="n">1.0</span> + <span class="n">0.06</span> * math.sin(i * <span class="n">1.7</span> + <span class="n">1.1</span>))
             wood_verts.extend(
-                add_box(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, z), (rail_len, RAIL_Y, RAIL_Z), WOOD_IDX)
+                add_box(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, z), (<span class="n">2.0</span> * rail_half, ry, rz), WOOD_IDX)
             )
 
+        kick_z0 = SHOE_H - <span class="n">0.003</span>
         wood_verts.extend(
             add_box(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, KICK_Z / <span class="n">2.0</span>),
-                (TILE - POST_W * <span class="n">0.22</span>, KICK_Y, KICK_Z),
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, kick_z0 + KICK_Z / <span class="n">2.0</span>),
+                (<span class="n">2.0</span> * rail_half, KICK_Y, KICK_Z),
                 WOOD_IDX,
             )
         )
 
-        span = TILE - POST_W
-        rise = RAIL_ZS[-<span class="n">1</span>] - RAIL_ZS[<span class="n">0</span>]
-        brace_len = math.hypot(span, rise)
-        brace_ang = math.atan2(rise, span)
-        wood_verts.extend(
-            add_box(
-                bm,
-                (<span class="n">0.0</span>, -POST_W * <span class="n">0.55</span>, (RAIL_ZS[<span class="n">0</span>] + RAIL_ZS[-<span class="n">1</span>]) / <span class="n">2.0</span>),
-                (brace_len, BRACE_T, BRACE_T),
-                WOOD_IDX,
-                euler=(<span class="n">0.0</span>, -brace_ang, <span class="n">0.0</span>),
+        <span class="k">if</span> long_rails:
+            wood_verts.extend(
+                add_box(
+                    bm,
+                    (<span class="n">0.0</span>, <span class="n">0.0</span>, (RAIL_ZS[<span class="n">0</span>] + RAIL_ZS[<span class="n">1</span>]) * <span class="n">0.5</span>),
+                    (<span class="n">2.0</span> * (RAIL_HALF + LONG_RAIL), RAIL_Y, RAIL_Z),
+                    WOOD_IDX,
+                )
             )
-        )
+
+        a = Vector((post_xs[<span class="n">0</span>], Y_BRACE, RAIL_ZS[<span class="n">0</span>]))
+        b = Vector((post_xs[<span class="n">1</span>], Y_BRACE, RAIL_ZS[-<span class="n">1</span>]))
+        <span class="k">if</span> short_brace:
+            a = Vector((post_xs[<span class="n">0</span>] + SHORT_BRACE, Y_BRACE, RAIL_ZS[<span class="n">0</span>]))
+        wood_verts.extend(add_oriented_box(bm, a, b, (BRACE_T, BRACE_T), WOOD_IDX))
 
         <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
             edges = list({e <span class="k">for</span> v <span class="k">in</span> wood_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges})
-            bmesh.ops.bevel(
+            ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
                 offset=bevel_offset,
@@ -529,42 +626,36 @@ <h2>Source</h2>
                 affect=<span class="s">&quot;EDGES&quot;</span>,
                 clamp_overlap=<span class="k">True</span>,
             )
+            <span class="k">for</span> f <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
+                f.material_index = WOOD_IDX
 
+        cap_half = half + CAP_OVERHANG
         <span class="k">for</span> px <span class="k">in</span> post_xs:
-            add_box(
+            add_cone(
                 bm,
-                (px, <span class="n">0.0</span>, SHOE_H / <span class="n">2.0</span>),
-                (POST_W * SHOE_SCALE, POST_W * SHOE_SCALE, SHOE_H),
-                METAL_IDX,
+                (px, <span class="n">0.0</span>, POST_H + CAP_H / <span class="n">2.0</span> - <span class="n">0.003</span>),
+                cap_half * math.sqrt(<span class="n">2.0</span>),
+                <span class="n">0.020</span>,
+                CAP_H,
+                <span class="n">4</span>,
+                WOOD_IDX,
+                euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, math.pi / <span class="n">4.0</span>),
+            )
+
+        shoe_lift = SHORT_SHOE <span class="k">if</span> short_shoes <span class="k">else</span> <span class="n">0.0</span>
+        <span class="k">for</span> px <span class="k">in</span> post_xs:
+            add_collar(
+                bm, px, SHOE_H / <span class="n">2.0</span> + shoe_lift, half, IRON_T, SHOE_H, METAL_IDX,
+                closed=<span class="k">True</span>,
             )
-            sign = <span class="n">1.0</span> <span class="k">if</span> px &gt; <span class="n">0.0</span> <span class="k">else</span> -<span class="n">1.0</span>
             <span class="k">for</span> z <span class="k">in</span> RAIL_ZS:
-                add_box(
-                    bm,
-                    (px, POST_W / <span class="n">2.0</span> + IRON_T / <span class="n">2.0</span>, z),
-                    (POST_W * <span class="n">0.88</span>, IRON_T, RAIL_Z * <span class="n">1.40</span>),
-                    METAL_IDX,
-                )
-                add_box(
-                    bm,
-                    (px, -(POST_W / <span class="n">2.0</span> + IRON_T / <span class="n">2.0</span>), z),
-                    (POST_W * <span class="n">0.88</span>, IRON_T, RAIL_Z * <span class="n">1.40</span>),
-                    METAL_IDX,
-                )
-                add_box(
-                    bm,
-                    (px + sign * (POST_W / <span class="n">2.0</span> + IRON_T / <span class="n">2.0</span>), <span class="n">0.0</span>, z),
-                    (IRON_T, POST_W * <span class="n">0.88</span>, RAIL_Z * <span class="n">1.40</span>),
-                    METAL_IDX,
+                add_collar(
+                    bm, px, z, half, IRON_T, RAIL_Z * <span class="n">1.25</span>, METAL_IDX, closed=<span class="k">False</span>
                 )
 
-        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]
-        cy = <span class="n">0.5</span> * (min(ys) + max(ys))
         zmin = min(zs)
         <span class="k">for</span> v <span class="k">in</span> bm.verts:
-            v.co.y -= cy
             v.co.z -= zmin
             <span class="k">if</span> v.co.z &lt; <span class="n">0.0</span>:
                 v.co.z = <span class="n">0.0</span>
@@ -585,13 +676,25 @@ <h2>Source</h2>
     <span class="k">return</span> out
 
 
-<span class="k">def</span> principled(name, color, metallic, roughness):
+<span class="k">def</span> principled(name, color, metallic, roughness, noise_scale=<span class="n">0.0</span>, wear=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
-    bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = color
     bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
     bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = roughness
+    <span class="k">if</span> noise_scale &gt; <span class="n">0.0</span> <span class="k">and</span> wear <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        tex = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+        tex.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = noise_scale
+        tex.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+        mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+        mix.inputs[<span class="s">&quot;A&quot;</span>].default_value = color
+        mix.inputs[<span class="s">&quot;B&quot;</span>].default_value = wear
+        fac = mix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> mix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], fac)
+        nt.links.new(mix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
     <span class="k">return</span> mat
 
 
@@ -608,10 +711,11 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> world_bbox(obj):
-    corners = [obj.matrix_world @ Vector(c) <span class="k">for</span> c <span class="k">in</span> obj.bound_box]
-    xs = [c.x <span class="k">for</span> c <span class="k">in</span> corners]
-    ys = [c.y <span class="k">for</span> c <span class="k">in</span> corners]
-    zs = [c.z <span class="k">for</span> c <span class="k">in</span> corners]
+    mat = obj.matrix_world
+    pts = [mat @ v.co <span class="k">for</span> v <span class="k">in</span> obj.data.vertices]
+    xs = [p.x <span class="k">for</span> p <span class="k">in</span> pts]
+    ys = [p.y <span class="k">for</span> p <span class="k">in</span> pts]
+    zs = [p.z <span class="k">for</span> p <span class="k">in</span> pts]
     <span class="k">return</span> (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
@@ -674,6 +778,193 @@ <h2>Source</h2>
     <span class="k">return</span> collider
 
 
+<span class="k">def</span> face_area(me, poly):
+    vs = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> poly.vertices]
+    <span class="k">if</span> len(vs) &lt; <span class="n">3</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    v0 = vs[<span class="n">0</span>]
+    area = <span class="n">0.0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, len(vs) - <span class="n">1</span>):
+        area += (vs[i] - v0).cross(vs[i + <span class="n">1</span>] - v0).length * <span class="n">0.5</span>
+    <span class="k">return</span> area
+
+
+<span class="k">def</span> hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> len(p.vertices) &gt; <span class="n">4</span>)
+    zero_area = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> face_area(me, p) &lt;= AREA_EPS)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        loose_v = sum(<span class="n">1</span> <span class="k">for</span> v <span class="k">in</span> bm.verts <span class="k">if</span> len(v.link_edges) == <span class="n">0</span>)
+        loose_e = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> len(e.link_faces) == <span class="n">0</span>)
+        nonman = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> <span class="k">not</span> e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get(<span class="s">&quot;targetmap&quot;</span>) <span class="k">or</span> {})
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> {
+        <span class="s">&quot;nv&quot;</span>: nv, <span class="s">&quot;ne&quot;</span>: ne, <span class="s">&quot;nf&quot;</span>: nf, <span class="s">&quot;ngons&quot;</span>: ngons,
+        <span class="s">&quot;loose_v&quot;</span>: loose_v, <span class="s">&quot;loose_e&quot;</span>: loose_e, <span class="s">&quot;nonman&quot;</span>: nonman,
+        <span class="s">&quot;zero_area&quot;</span>: zero_area, <span class="s">&quot;doubles&quot;</span>: doubles, <span class="s">&quot;euler&quot;</span>: nv - ne + nf,
+    }
+
+
+<span class="k">def</span> zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        <span class="k">for</span> p <span class="k">in</span> me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(data)):
+        ci, ni, vi = data[i]
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(data)):
+            cj, nj, vj = data[j]
+            <span class="k">if</span> (cj - ci).length_squared &gt; eps2:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(ni.dot(nj)) &lt;= ZFIGHT_COS:
+                <span class="k">continue</span>
+            <span class="k">if</span> vi &amp; vj:
+                <span class="k">continue</span>
+            count += <span class="n">1</span>
+    <span class="k">return</span> count
+
+
+<span class="k">def</span> shells(me):
+    neighbors = [[] <span class="k">for</span> _ <span class="k">in</span> range(len(me.vertices))]
+    <span class="k">for</span> edge <span class="k">in</span> me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [<span class="k">False</span>] * len(me.vertices)
+    groups = []
+    <span class="k">for</span> start <span class="k">in</span> range(len(me.vertices)):
+        <span class="k">if</span> seen[start]:
+            <span class="k">continue</span>
+        seen[start] = <span class="k">True</span>
+        stack = [start]
+        group = []
+        <span class="k">while</span> stack:
+            current = stack.pop()
+            group.append(current)
+            <span class="k">for</span> nxt <span class="k">in</span> neighbors[current]:
+                <span class="k">if</span> <span class="k">not</span> seen[nxt]:
+                    seen[nxt] = <span class="k">True</span>
+                    stack.append(nxt)
+        groups.append(group)
+    <span class="k">return</span> groups
+
+
+<span class="k">def</span> shell_aabb(me, group):
+    pts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> group]
+    <span class="k">return</span> (
+        min(p.x <span class="k">for</span> p <span class="k">in</span> pts), min(p.y <span class="k">for</span> p <span class="k">in</span> pts), min(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+        max(p.x <span class="k">for</span> p <span class="k">in</span> pts), max(p.y <span class="k">for</span> p <span class="k">in</span> pts), max(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+    )
+
+
+<span class="k">def</span> mat_of(me, group):
+    member = set(group)
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        <span class="k">if</span> all(i <span class="k">in</span> member <span class="k">for</span> i <span class="k">in</span> poly.vertices):
+            <span class="k">return</span> poly.material_index
+    <span class="k">return</span> <span class="k">None</span>
+
+
+<span class="k">def</span> shell_bvh_gap(me, ga, gb):
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    <span class="k">try</span>:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        keep_a, keep_b = set(ga), set(gb)
+        drop_a = [f <span class="k">for</span> f <span class="k">in</span> bm_a.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep_a <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        drop_b = [f <span class="k">for</span> f <span class="k">in</span> bm_b.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep_b <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        <span class="k">if</span> drop_a:
+            bmesh.ops.delete(bm_a, geom=drop_a, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_a.faces <span class="k">or</span> <span class="k">not</span> bm_b.faces:
+            <span class="k">return</span> <span class="n">1e9</span>
+        tree = BVHTree.FromBMesh(bm_b)
+        best = <span class="n">1e9</span>
+        <span class="k">for</span> v <span class="k">in</span> bm_a.verts:
+            hit = tree.find_nearest(v.co)
+            <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+                best = min(best, hit[<span class="n">3</span>])
+        <span class="k">for</span> f <span class="k">in</span> bm_a.faces:
+            hit = tree.find_nearest(f.calc_center_median())
+            <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+                best = min(best, hit[<span class="n">3</span>])
+        <span class="k">return</span> best
+    <span class="k">finally</span>:
+        bm_a.free()
+        bm_b.free()
+
+
+<span class="k">def</span> add_stray_vert(me):
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, POST_H * <span class="n">0.55</span>))
+        bm.to_mesh(me)
+        me.update()
+    <span class="k">finally</span>:
+        bm.free()
+
+
+<span class="k">def</span> joint_audit(me):
+    groups = shells(me)
+    posts = []
+    rails = []
+    braces = []
+    shoes = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        mat = mat_of(me, g)
+        <span class="k">if</span> mat == WOOD_IDX <span class="k">and</span> dz &gt; <span class="n">0.70</span> <span class="k">and</span> dx &lt; <span class="n">0.18</span> <span class="k">and</span> dy &lt; <span class="n">0.18</span>:
+            posts.append((g, a))
+        <span class="k">if</span> mat == WOOD_IDX <span class="k">and</span> dx &gt; TILE * <span class="n">0.45</span> <span class="k">and</span> dz &lt; <span class="n">0.18</span>:
+            rails.append((g, a))
+        <span class="k">if</span> mat == WOOD_IDX <span class="k">and</span> dx &gt; <span class="n">0.40</span> <span class="k">and</span> dz &gt; <span class="n">0.25</span> <span class="k">and</span> dy &lt; <span class="n">0.12</span>:
+            braces.append((g, a))
+        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> a[<span class="n">2</span>] &lt; <span class="n">0.08</span> <span class="k">and</span> dz &lt; <span class="n">0.08</span> <span class="k">and</span> max(dx, dy) &lt; <span class="n">0.22</span>:
+            shoes.append((g, a))
+    left = [a <span class="k">for</span> _g, a <span class="k">in</span> shoes <span class="k">if</span> (a[<span class="n">0</span>] + a[<span class="n">3</span>]) * <span class="n">0.5</span> &lt; <span class="n">0.0</span>]
+    right = [a <span class="k">for</span> _g, a <span class="k">in</span> shoes <span class="k">if</span> (a[<span class="n">0</span>] + a[<span class="n">3</span>]) * <span class="n">0.5</span> &gt;= <span class="n">0.0</span>]
+    shoe_n = (<span class="n">1</span> <span class="k">if</span> left <span class="k">else</span> <span class="n">0</span>) + (<span class="n">1</span> <span class="k">if</span> right <span class="k">else</span> <span class="n">0</span>)
+    shoe_z = <span class="n">99.0</span>
+    <span class="k">if</span> shoes:
+        shoe_z = min(a[<span class="n">2</span>] <span class="k">for</span> _g, a <span class="k">in</span> shoes)
+    brace_gap = <span class="n">99.0</span>
+    <span class="k">if</span> braces <span class="k">and</span> posts:
+        per_post = [
+            min(shell_bvh_gap(me, b[<span class="n">0</span>], p[<span class="n">0</span>]) <span class="k">for</span> b <span class="k">in</span> braces) <span class="k">for</span> p <span class="k">in</span> posts
+        ]
+        brace_gap = max(per_post)
+    rail_gap = <span class="n">99.0</span>
+    <span class="k">if</span> rails <span class="k">and</span> posts:
+        rail_gap = min(
+            shell_bvh_gap(me, r[<span class="n">0</span>], p[<span class="n">0</span>]) <span class="k">for</span> r <span class="k">in</span> rails <span class="k">for</span> p <span class="k">in</span> posts
+        )
+    span_x = <span class="n">0.0</span>
+    <span class="k">if</span> rails:
+        xs = [v <span class="k">for</span> _g, a <span class="k">in</span> rails <span class="k">for</span> v <span class="k">in</span> (a[<span class="n">0</span>], a[<span class="n">3</span>])]
+        span_x = max(xs) - min(xs)
+    <span class="k">return</span> {
+        <span class="s">&quot;posts&quot;</span>: len(posts),
+        <span class="s">&quot;rails&quot;</span>: len(rails),
+        <span class="s">&quot;braces&quot;</span>: len(braces),
+        <span class="s">&quot;shoes&quot;</span>: shoe_n,
+        <span class="s">&quot;shoe_z&quot;</span>: shoe_z,
+        <span class="s">&quot;brace_gap&quot;</span>: brace_gap,
+        <span class="s">&quot;rail_gap&quot;</span>: rail_gap,
+        <span class="s">&quot;span_x&quot;</span>: span_x,
+    }
+
+
 <span class="k">def</span> setup_bake_image(obj, target_mat, size=BAKE_RES):
     <span class="k">if</span> <span class="k">not</span> obj.data.uv_layers:
         <span class="k">return</span> <span class="k">None</span>, <span class="k">None</span>
@@ -726,15 +1017,42 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> check(skip_decimate):
+<span class="k">def</span> check(
+    skip_decimate,
+    lift_z=<span class="k">False</span>,
+    stray_vert=<span class="k">False</span>,
+    short_brace=<span class="k">False</span>,
+    short_shoes=<span class="k">False</span>,
+    gap_rails=<span class="k">False</span>,
+    long_rails=<span class="k">False</span>,
+):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_fence_mesh(<span class="s">&quot;FenceLow&quot;</span>, bevel_offset=<span class="n">0.006</span>, bevel_segments=<span class="n">2</span>)
-    high = build_fence_mesh(<span class="s">&quot;FenceHigh&quot;</span>, bevel_offset=<span class="n">0.006</span>, bevel_segments=<span class="n">4</span>)
-    wood = principled(<span class="s">&quot;FenceWood&quot;</span>, (<span class="n">0.46</span>, <span class="n">0.24</span>, <span class="n">0.08</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.55</span>)
-    metal = principled(<span class="s">&quot;FenceIron&quot;</span>, (<span class="n">0.11</span>, <span class="n">0.115</span>, <span class="n">0.13</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.28</span>)
+    kw = dict(
+        short_brace=short_brace,
+        short_shoes=short_shoes,
+        gap_rails=gap_rails,
+        long_rails=long_rails,
+    )
+    low = build_fence_mesh(<span class="s">&quot;FenceLow&quot;</span>, bevel_offset=<span class="n">0.006</span>, bevel_segments=<span class="n">2</span>, **kw)
+    high = build_fence_mesh(<span class="s">&quot;FenceHigh&quot;</span>, bevel_offset=<span class="n">0.006</span>, bevel_segments=<span class="n">4</span>, **kw)
+    wood = principled(
+        <span class="s">&quot;FenceWood&quot;</span>, (<span class="n">0.46</span>, <span class="n">0.24</span>, <span class="n">0.08</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.55</span>,
+        noise_scale=<span class="n">16.0</span>, wear=(<span class="n">0.32</span>, <span class="n">0.16</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
+    )
+    metal = principled(
+        <span class="s">&quot;FenceIron&quot;</span>, (<span class="n">0.11</span>, <span class="n">0.115</span>, <span class="n">0.13</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.28</span>,
+        noise_scale=<span class="n">20.0</span>, wear=(<span class="n">0.18</span>, <span class="n">0.16</span>, <span class="n">0.12</span>, <span class="n">1.0</span>),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
+    <span class="k">if</span> stray_vert:
+        add_stray_vert(low.data)
+    <span class="k">if</span> lift_z:
+        <span class="k">for</span> v <span class="k">in</span> low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+
     <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;fence 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>
 
@@ -765,7 +1083,9 @@ <h2>Source</h2>
     r1 = lod1_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
     r2 = lod2_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
 
-    collider_src = build_fence_mesh(<span class="s">&quot;FenceColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>)
+    collider_src = build_fence_mesh(
+        <span class="s">&quot;FenceColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>, **kw
+    )
     collider = convex_hull_collider(collider_src, <span class="s">&quot;FenceCollider&quot;</span>)
     bpy.data.objects.remove(collider_src, do_unlink=<span class="k">True</span>)
     col_tris = triangle_count(collider.data)
@@ -779,6 +1099,10 @@ <h2>Source</h2>
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) <span class="k">if</span> os.path.isfile(export_path) <span class="k">else</span> <span class="n">0</span>
 
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    jnt = joint_audit(low.data)
+
     print(<span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>)
     print(
         <span class="s">f&quot;</span><span class="s">measured base_tris=</span>{base_tris}<span class="s"> lod1_tris=</span>{lod1_tris}<span class="s"> </span><span class="s">&quot;</span>
@@ -796,6 +1120,17 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">measured collider_tris=</span>{col_tris}<span class="s"> bake=</span>{bake_result}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">bake_has_data=</span>{img.has_data}<span class="s"> export_bytes=</span>{export_size}<span class="s">&quot;</span>
     )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>
+    )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured posts=</span>{jnt[<span class="s">&#x27;posts&#x27;</span>]}<span class="s"> rails=</span>{jnt[<span class="s">&#x27;rails&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">braces=</span>{jnt[<span class="s">&#x27;braces&#x27;</span>]}<span class="s"> shoes=</span>{jnt[<span class="s">&#x27;shoes&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">shoe_z=</span>{jnt[<span class="s">&#x27;shoe_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> brace_gap=</span>{jnt[<span class="s">&#x27;brace_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">rail_gap=</span>{jnt[<span class="s">&#x27;rail_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> span_x=</span>{jnt[<span class="s">&#x27;span_x&#x27;</span>]:<span class="s">.4f</span>}<span class="s">&quot;</span>
+    )
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
@@ -812,6 +1147,11 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">metal faces </span>{idx_counts.get(METAL_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{METAL_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(WOOD_IDX, <span class="n">0</span>) &lt; WOOD_FACES_MIN:
+        <span class="k">return</span> fail(
+            <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> 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>,
@@ -822,6 +1162,32 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">UV AABB overlap </span>{overlap:<span class="s">.6f</span>}<span class="s"> &gt; </span>{UV_OVERLAP_MAX}<span class="s">&quot;</span>,
             <span class="n">7</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> (
+        bb[<span class="n">2</span>] &gt; ZMIN_EPS
+        <span class="k">or</span> jnt[<span class="s">&quot;shoes&quot;</span>] != SHOE_COUNT
+        <span class="k">or</span> jnt[<span class="s">&quot;shoe_z&quot;</span>] &gt; SHOE_ZMIN_MAX
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">grounded zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.5f</span>}<span class="s"> shoes=</span>{jnt[<span class="s">&#x27;shoes&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">shoe_z=</span>{jnt[<span class="s">&#x27;shoe_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>,
+            <span class="n">16</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> jnt[<span class="s">&quot;braces&quot;</span>] &lt; <span class="n">1</span> <span class="k">or</span> jnt[<span class="s">&quot;posts&quot;</span>] &lt; <span class="n">2</span> <span class="k">or</span> jnt[<span class="s">&quot;brace_gap&quot;</span>] &gt; BRACE_GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">brace gap </span>{jnt[<span class="s">&#x27;brace_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> braces=</span>{jnt[<span class="s">&#x27;braces&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">posts=</span>{jnt[<span class="s">&#x27;posts&#x27;</span>]}<span class="s">&quot;</span>,
+            <span class="n">17</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> jnt[<span class="s">&quot;rails&quot;</span>] &lt; <span class="n">3</span> <span class="k">or</span> jnt[<span class="s">&quot;rail_gap&quot;</span>] &gt; RAIL_GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">rail gap </span>{jnt[<span class="s">&#x27;rail_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> rails=</span>{jnt[<span class="s">&#x27;rails&#x27;</span>]}<span class="s">&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> abs(jnt[<span class="s">&quot;span_x&quot;</span>] - <span class="n">2.0</span> * RAIL_HALF) &gt; SPAN_TOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">rail span </span>{jnt[<span class="s">&#x27;span_x&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{<span class="n">2.0</span> * RAIL_HALF}<span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> (
         abs(size_x - OUTER_SIZE[<span class="n">0</span>]) &gt; BBOX_TOL
         <span class="k">or</span> abs(size_y - OUTER_SIZE[<span class="n">1</span>]) &gt; BBOX_TOL
@@ -855,6 +1221,16 @@ <h2>Source</h2>
         ), <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> export_size &lt;= <span class="n">0</span>:
         <span class="k">return</span> fail(<span class="s">&quot;export file missing or empty&quot;</span>, <span class="n">13</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> (
+        hyg[<span class="s">&quot;loose_v&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;loose_e&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;nonman&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;zero_area&quot;</span>]
+        <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>] <span class="k">or</span> zf
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>,
+            <span class="n">15</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -968,14 +1344,24 @@ <h2>Source</h2>
     p = argparse.ArgumentParser()
     p.add_argument(<span class="s">&quot;--output&quot;</span>, default=<span class="k">None</span>)
     p.add_argument(<span class="s">&quot;--engine&quot;</span>, default=<span class="s">&quot;eevee&quot;</span>, choices=(<span class="s">&quot;eevee&quot;</span>, <span class="s">&quot;cycles&quot;</span>))
-    p.add_argument(
-        <span class="s">&quot;--skip-decimate&quot;</span>,
-        action=<span class="s">&quot;store_true&quot;</span>,
-        help=<span class="s">&quot;falsification: skip the LOD DECIMATE stage&quot;</span>,
-    )
+    p.add_argument(<span class="s">&quot;--skip-decimate&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--stray-vert&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--lift-z&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--short-shoes&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--short-brace&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--gap-rails&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--long-rails&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        short_brace=args.short_brace,
+        short_shoes=args.short_shoes,
+        gap_rails=args.gap_rails,
+        long_rails=args.long_rails,
+    )
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/docs/gallery/hand-pump/index.html b/docs/gallery/hand-pump/index.html
index e1c27d2..db4167c 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 with a gooseneck 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 whose gooseneck is a 6-gon tube from the lower-column radius, 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 with a gooseneck 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 whose gooseneck is a 6-gon tube from the lower-column radius, 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 with a gooseneck 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 whose gooseneck is a 6-gon tube from the lower-column radius, 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,35 +246,50 @@
   </div>
   <header class="hero">
     <h1>hand-pump</h1>
-    <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>
+    <p>A procedural village hand pump whose gooseneck is a 6-gon tube from the lower-column radius, 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: 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="callout"><span class="tag">witnesses</span> Recomputed: 1064 tris, two materials with 564 metal and 144 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.610×0.382×1.052 m, grounded zmin, spout-to-column gap 2.7 mm, flange-to-plinth gap 6.0 mm, column radius 62 mm, LOD ratios in band, convex collider 114 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z 16; --float-spout 17; --float-flange 18; --skinny-col 19.</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 (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>A showcase piece, not an example. Procedural cast-iron village hand pump (stepped wooden plinth, two-diameter column, 6-gon gooseneck tube from the lower-column radius, stuffing-box head, 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>The column stays on the origin; only zmin is snapped. The gooseneck is a tube about named stations on the lower-column radius, not a chain of cylinders. The flange and the plinth cap bite their hosts so stacked caps are not coplanar.</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>
+<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). Hygiene combinatorics match <code>examples/mesh-hygiene-audit</code> (copied, not imported).</p>
+<p>Intended size: ~1.05 m village pump, 0.34 m plinth, 0.76 m column; outer AABB 0.610 × 0.382 × 1.052 m.</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 | 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>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 900–2200 | 1064 / 1064 / 1064 | | 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.2162 | | Materials | exactly 2 distinct, ≥48 metal, ≥24 wood | 2 slots, 564 metal / 144 wood | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.610, 0.382, 1.052) m ± 0.015 | (0.6100, 0.3820, 1.0520), zmin 0 | | Collider tris | ≤ 220 | 114 | | Export | written, size &gt; 0 | 97304 / 97304 / 97296 bytes |</p>
+<p>Base triangles dropped from <strong>1164 to 1064</strong> in the quality pass: seven sausage cylinders became one gooseneck tube, and the wood grip is no longer beveled with the plinth. Outer AABB is 0.610 × 0.382 × 1.052 m (was 0.610 × 0.364 × 1.049 m).</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is slightly leaner 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>
+<h3>Hygiene</h3>
+<p>Recomputed from the generated mesh, not asserted about the script.</p>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Non-manifold edges | 0 | 0 | | Loose verts / edges | 0 / 0 | 0 / 0 | | Doubles merged at 1e-5 | 0 | 0 | | Zero-area faces | 0 | 0 | | N-gons | 0 | 0 | | Coplanar disjoint face pairs | 0 | 0 | | Grounded: <code>zmin</code> | within 1e-4 of 0 | 0.0000 | | Plinth <code>zmin</code> | within 1e-4 of 0 | 0.00000 |</p>
+<h3>Joint fit and column</h3>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Spout-to-column BVH gap | ≤ 0.008 m | 0.00272 | | Flange-to-plinth BVH gap | ≤ 0.008 m | 0.00600 | | Lower-column radius vs <code>COL_R_LO</code> | ± 0.008 m | 0.06200 |</p>
+<h3>Falsifiers</h3>
+<p>Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<p>| Flag | Budget violated | Exit | | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | | <code>--stray-vert</code> | loose vertex count is 0 | 15 | | <code>--lift-z</code> | bounding box <code>zmin</code> is 0 | 16 | | <code>--float-spout</code> | spout-to-column BVH gap | 17 | | <code>--float-flange</code> | flange-to-plinth BVH gap | 18 | | <code>--skinny-col</code> | lower-column radius | 19 |</p>
 <h2>Run</h2>
 <pre><code>blender --background --python hand_pump.py --
 blender --background --python hand_pump.py -- --skip-decimate
+blender --background --python hand_pump.py -- --stray-vert
+blender --background --python hand_pump.py -- --lift-z
+blender --background --python hand_pump.py -- --float-spout
+blender --background --python hand_pump.py -- --float-flange
+blender --background --python hand_pump.py -- --skinny-col
 blender --background --python hand_pump.py -- --output hand-pump.png</code></pre>
-<p>Smoke does not pass <code>--output</code> or <code>--skip-decimate</code>.</p>
+<p>Smoke passes no flags.</p>
 <h2>Exit codes</h2>
-<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path.</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>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</p>
+<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 | | 15 | Hygiene (<code>--stray-vert</code> lands here) | | 16 | Grounded zmin / plinth (<code>--lift-z</code>) | | 17 | Spout-to-column gap (<code>--float-spout</code>) | | 18 | Flange-to-plinth gap (<code>--float-flange</code>) | | 19 | Column radius (<code>--skinny-col</code>) |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -285,13 +300,19 @@ <h2>Source</h2>
       <pre><span class="s">&quot;&quot;&quot;Game-ready village hand pump — a showcase piece, not an example.
 
 Asserts budget conformance of a procedural cast-iron hand pump (plinth,
-column, spout, handle, and wooden grip) after composing shipped
-pipeline pieces: bmesh construction, UVs, two materials, high-to-low
-normal bake, LOD chain, convex collider, Unity glTF export.
+column, gooseneck, stuffing-box head, handle, wooden grip) after
+composing shipped pipeline pieces: bmesh construction, UVs, two
+materials, high-to-low normal bake, LOD chain, convex collider,
+Unity glTF export.
+
+The column stays on the origin; only zmin is snapped. The gooseneck is
+a 6-gon tube about named stations on the lower-column radius, not a
+chain of cylinders. The flange bites the plinth.
 
 Budgets are declared below and recomputed from the generated result.
-They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+They are not API-contract witnesses. Hygiene family 15–19:
+``--stray-vert``, ``--lift-z``, ``--float-spout``, ``--float-flange``,
+``--skinny-col``.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -311,6 +332,7 @@ <h2>Source</h2>
 <span class="k">import</span> bmesh
 <span class="k">import</span> bpy
 <span class="k">from</span> mathutils <span class="k">import</span> Euler, Vector
+<span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -320,17 +342,32 @@ <h2>Source</h2>
 <span class="k">import</span> gallery_framing  <span class="c"># noqa: E402</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">16</span>
-SPOUT_Z = <span class="n">0.46</span>
+SLAB_H = <span class="n">0.050</span>
+CAP_H = <span class="n">0.040</span>
+PLINTH_BITE = <span class="n">0.006</span>
+PLINTH_TOP = SLAB_H + CAP_H - PLINTH_BITE
+COL_R_LO = <span class="n">0.062</span>
+COL_R_HI = <span class="n">0.046</span>
+COL_SEGS = <span class="n">24</span>
+LOWER_H = <span class="n">0.40</span>
+UPPER_H = <span class="n">0.36</span>
+COL_H = LOWER_H + UPPER_H
+SPOUT_Z = PLINTH_TOP + <span class="n">0.36</span>
+SPOUT_R = <span class="n">0.13</span>
+SPOUT_T = <span class="n">0.036</span>
+SPOUT_N = <span class="n">10</span>
 HANDLE_LIFT = <span class="n">0.18</span>
-
-BBOX_TOL = <span class="n">0.01</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>
+FLANGE_R = <span class="n">0.095</span>
+FLANGE_H = <span class="n">0.028</span>
+FLANGE_BITE = <span class="n">0.006</span>
+BOLT_N = <span class="n">4</span>
+BOLT_R = <span class="n">0.008</span>
+BOLT_H = <span class="n">0.014</span>
+
+BBOX_TOL = <span class="n">0.015</span>
+OUTER_SIZE = (<span class="n">0.610</span>, <span class="n">0.382</span>, <span class="n">1.052</span>)
+BASE_TRIS_MIN = <span class="n">900</span>
+BASE_TRIS_MAX = <span class="n">2200</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>
@@ -340,15 +377,28 @@ <h2>Source</h2>
 MATERIAL_COUNT = <span class="n">2</span>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
-COLLIDER_TRIS_MAX = <span class="n">160</span>
+COLLIDER_TRIS_MAX = <span class="n">220</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.08</span>
-METAL_FACES_MIN = <span class="n">24</span>
-WOOD_FACES_MIN = <span class="n">12</span>
+METAL_FACES_MIN = <span class="n">48</span>
+WOOD_FACES_MIN = <span class="n">24</span>
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
 
+DOUBLES_EPS = <span class="n">1e-5</span>
+AREA_EPS = <span class="n">1e-10</span>
+ZMIN_EPS = <span class="n">1e-4</span>
+ZFIGHT_EPS = <span class="n">0.002</span>
+ZFIGHT_COS = <span class="n">0.98</span>
+SPOUT_GAP_MAX = <span class="n">0.008</span>
+FLANGE_GAP_MAX = <span class="n">0.008</span>
+COL_R_TOL = <span class="n">0.008</span>
+LIFT_Z = <span class="n">0.05</span>
+FLOAT_SPOUT = <span class="n">0.12</span>
+FLOAT_FLANGE = <span class="n">0.04</span>
+SKINNY = <span class="n">0.028</span>
+
 
 <span class="k">def</span> eevee_engine_id():
     <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE&quot;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&quot;BLENDER_EEVEE_NEXT&quot;</span>
@@ -438,7 +488,7 @@ <h2>Source</h2>
     geo = bmesh.ops.create_cone(
         bm,
         cap_ends=<span class="k">True</span>,
-        cap_tris=<span class="k">False</span>,
+        cap_tris=<span class="k">True</span>,
         segments=segments,
         radius1=radius,
         radius2=radius,
@@ -455,11 +505,63 @@ <h2>Source</h2>
     <span class="k">return</span> verts
 
 
+<span class="k">def</span> add_gooseneck(bm, x, y0, z0, radius, n, thick, mat_idx, t0=<span class="n">0.08</span>, t1=<span class="n">1.0</span>):
+    pts = []
+    <span class="k">for</span> i <span class="k">in</span> range(n + <span class="n">1</span>):
+        t = t0 + (t1 - t0) * (i / n)
+        ang = t * (math.pi / <span class="n">2.0</span>)
+        pts.append(
+            Vector(
+                (
+                    x,
+                    y0 - radius * math.sin(ang),
+                    z0 - radius * (<span class="n">1.0</span> - math.cos(ang)),
+                )
+            )
+        )
+    rings = <span class="n">6</span>
+    r = thick * <span class="n">0.5</span>
+    ring_verts = []
+    <span class="k">for</span> i, p <span class="k">in</span> enumerate(pts):
+        <span class="k">if</span> i &lt; n:
+            tangent = (pts[i + <span class="n">1</span>] - p).normalized()
+        <span class="k">else</span>:
+            tangent = (p - pts[i - <span class="n">1</span>]).normalized()
+        side = tangent.cross(Vector((<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)))
+        <span class="k">if</span> side.length &lt; <span class="n">1e-6</span>:
+            side = tangent.cross(Vector((<span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">0.0</span>)))
+        side.normalize()
+        up = tangent.cross(side).normalized()
+        ring = []
+        <span class="k">for</span> k <span class="k">in</span> range(rings):
+            ang = (<span class="n">2.0</span> * math.pi * k) / rings
+            offset = side * math.cos(ang) * r + up * math.sin(ang) * r
+            ring.append(bm.verts.new(p + offset))
+        ring_verts.append(ring)
+    bm.verts.ensure_lookup_table()
+    <span class="k">for</span> a, b <span class="k">in</span> zip(ring_verts, ring_verts[<span class="n">1</span>:]):
+        <span class="k">for</span> k <span class="k">in</span> range(rings):
+            k2 = (k + <span class="n">1</span>) % rings
+            face = bm.faces.new((a[k], a[k2], b[k2], b[k]))
+            face.material_index = mat_idx
+    <span class="k">for</span> end_i, p <span class="k">in</span> ((<span class="n">0</span>, pts[<span class="n">0</span>]), (-<span class="n">1</span>, pts[-<span class="n">1</span>])):
+        center = bm.verts.new(p)
+        ring = ring_verts[end_i]
+        <span class="k">for</span> k <span class="k">in</span> range(rings):
+            k2 = (k + <span class="n">1</span>) % rings
+            <span class="k">if</span> end_i == <span class="n">0</span>:
+                face = bm.faces.new((center, ring[k2], ring[k]))
+            <span class="k">else</span>:
+                face = bm.faces.new((center, ring[k], ring[k2]))
+            face.material_index = mat_idx
+    <span class="k">return</span> [v <span class="k">for</span> ring <span class="k">in</span> ring_verts <span class="k">for</span> v <span class="k">in</span> ring]
+
+
 <span class="k">def</span> add_cone(bm, loc, radius1, radius2, 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,
         cap_ends=<span class="k">True</span>,
-        cap_tris=<span class="k">False</span>,
+        cap_tris=<span class="k">True</span>,
         segments=segments,
         radius1=radius1,
         radius2=radius2,
@@ -559,45 +661,39 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> build_hand_pump_mesh(name, bevel_offset, bevel_segments):
+<span class="k">def</span> build_hand_pump_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    float_spout=<span class="k">False</span>,
+    float_flange=<span class="k">False</span>,
+    skinny_col=<span class="k">False</span>,
+):
     bm = bmesh.new()
     <span class="k">try</span>:
         wood = []
-        metal = []
-        slab_h = <span class="n">0.050</span>
-        cap_h = <span class="n">0.040</span>
-        top_z = slab_h + cap_h + COL_H
+        r_lo = COL_R_LO - SKINNY <span class="k">if</span> skinny_col <span class="k">else</span> COL_R_LO
+        r_hi = COL_R_HI - SKINNY * <span class="n">0.6</span> <span class="k">if</span> skinny_col <span class="k">else</span> COL_R_HI
+        top_z = PLINTH_TOP + COL_H
+        pivot = Vector((<span class="n">0.0</span>, r_hi + <span class="n">0.028</span>, top_z + <span class="n">0.010</span>))
+        grip_end = Vector((-<span class="n">0.38</span>, pivot.y + <span class="n">0.015</span>, pivot.z + HANDLE_LIFT))
 
         wood.extend(
             add_box(
                 bm,
-                (<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),
+                (<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,
             )
         )
         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.018</span>,
-                <span class="n">0.12</span>,
-                <span class="n">10</span>,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, SLAB_H - PLINTH_BITE + CAP_H / <span class="n">2.0</span>),
+                (<span class="n">0.26</span>, <span class="n">0.26</span>, CAP_H),
                 WOOD_IDX,
-                euler=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
             )
         )
-
         <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
             edges = list({e <span class="k">for</span> v <span class="k">in</span> wood <span class="k">for</span> e <span class="k">in</span> v.link_edges})
             ret = bmesh.ops.bevel(
@@ -612,146 +708,127 @@ <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(
+        wood.extend(
             add_cyl(
                 bm,
-                (<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,
+                (grip_end.x, grip_end.y, grip_end.z),
+                <span class="n">0.018</span>,
+                <span class="n">0.12</span>,
+                <span class="n">12</span>,
+                WOOD_IDX,
+                euler=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
             )
         )
-        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>, plinth_top + lower_h / <span class="n">2.0</span>),
-                <span class="n">0.062</span>,
-                lower_h,
-                COL_SEGS,
-                METAL_IDX,
-            )
+
+        flange_z = PLINTH_TOP - FLANGE_BITE + FLANGE_H / <span class="n">2.0</span>
+        <span class="k">if</span> float_flange:
+            flange_z += FLOAT_FLANGE
+        add_cyl(
+            bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, flange_z), FLANGE_R, FLANGE_H, COL_SEGS, METAL_IDX
         )
-        joint_z = plinth_top + lower_h
-        metal.extend(
+        bolt_ring = FLANGE_R * <span class="n">0.72</span>
+        <span class="k">for</span> i <span class="k">in</span> range(BOLT_N):
+            ang = math.pi / <span class="n">4.0</span> + i * (math.pi / <span class="n">2.0</span>)
             add_cyl(
                 bm,
-                (<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,
+                (
+                    bolt_ring * math.cos(ang),
+                    bolt_ring * math.sin(ang),
+                    flange_z + FLANGE_H / <span class="n">2.0</span> + BOLT_H / <span class="n">2.0</span> - <span class="n">0.002</span>,
+                ),
+                BOLT_R,
+                BOLT_H,
+                <span class="n">8</span>,
                 METAL_IDX,
             )
+
+        add_cyl(
+            bm,
+            (<span class="n">0.0</span>, <span class="n">0.0</span>, PLINTH_TOP + LOWER_H / <span class="n">2.0</span>),
+            r_lo,
+            LOWER_H,
+            COL_SEGS,
+            METAL_IDX,
         )
-        upper_h = <span class="n">0.36</span>
-        metal.extend(
-            add_cyl(
-                bm,
-                (<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,
-            )
+        joint_z = PLINTH_TOP + LOWER_H
+        add_cyl(
+            bm,
+            (<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.006</span>),
+            r_hi,
+            UPPER_H,
+            COL_SEGS,
+            METAL_IDX,
         )
-        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,
-            )
+
+        add_cyl(
+            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.052</span>,
+            <span class="n">0.048</span>,
+            COL_SEGS,
+            METAL_IDX,
         )
-        metal.extend(
-            add_cyl(
-                bm,
-                (<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,
-            )
+        add_cyl(
+            bm,
+            (<span class="n">0.0</span>, <span class="n">0.0</span>, top_z + <span class="n">0.044</span>),
+            <span class="n">0.032</span>,
+            <span class="n">0.030</span>,
+            <span class="n">8</span>,
+            METAL_IDX,
         )
 
-        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>, 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,
-            )
+        cheek_y = pivot.y
+        add_box(
+            bm,
+            (<span class="n">0.028</span>, cheek_y, pivot.z),
+            (<span class="n">0.016</span>, <span class="n">0.046</span>, <span class="n">0.044</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,
-            )
+        add_box(
+            bm,
+            (-<span class="n">0.028</span>, cheek_y, pivot.z),
+            (<span class="n">0.016</span>, <span class="n">0.046</span>, <span class="n">0.044</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,
-            )
+        add_cyl(
+            bm,
+            (<span class="n">0.0</span>, cheek_y, pivot.z),
+            <span class="n">0.010</span>,
+            <span class="n">0.068</span>,
+            <span class="n">10</span>,
+            METAL_IDX,
+            euler=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
         )
-        metal.extend(
-            add_cyl(
-                bm,
-                (<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=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
-            )
+        add_oriented_box(
+            bm,
+            (pivot.x, pivot.y, pivot.z),
+            (grip_end.x + <span class="n">0.03</span>, grip_end.y, grip_end.z),
+            (<span class="n">0.018</span>, <span class="n">0.014</span>),
+            METAL_IDX,
         )
-        metal.extend(
-            add_oriented_box(
-                bm,
-                (pivot.x, pivot.y, pivot.z),
-                (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,
-            )
+
+        y0 = -r_lo
+        z0 = SPOUT_Z
+        <span class="k">if</span> float_spout:
+            y0 -= FLOAT_SPOUT
+        add_gooseneck(
+            bm, <span class="n">0.0</span>, y0, z0, SPOUT_R, SPOUT_N, SPOUT_T, METAL_IDX, t0=-<span class="n">0.14</span>
+        )
+        nozzle_y = y0 - SPOUT_R
+        nozzle_z = z0 - SPOUT_R
+        add_cone(
+            bm,
+            (<span class="n">0.0</span>, nozzle_y, nozzle_z - <span class="n">0.028</span>),
+            <span class="n">0.014</span>,
+            <span class="n">0.020</span>,
+            <span class="n">0.044</span>,
+            <span class="n">12</span>,
+            METAL_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]
-        rcx = <span class="n">0.5</span> * (min(xs) + max(xs))
-        rcy = <span class="n">0.5</span> * (min(ys) + max(ys))
         zmin = min(zs)
         <span class="k">for</span> v <span class="k">in</span> bm.verts:
-            v.co.x -= rcx
-            v.co.y -= rcy
             v.co.z -= zmin
             <span class="k">if</span> v.co.z &lt; <span class="n">0.0</span>:
                 v.co.z = <span class="n">0.0</span>
@@ -759,12 +836,12 @@ <h2>Source</h2>
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
-            face.smooth = <span class="k">False</span>
+            face.smooth = face.material_index == METAL_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
         <span class="k">for</span> poly <span class="k">in</span> me.polygons:
-            poly.use_smooth = <span class="k">False</span>
+            poly.use_smooth = poly.material_index == METAL_IDX
     <span class="k">finally</span>:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -772,13 +849,25 @@ <h2>Source</h2>
     <span class="k">return</span> out
 
 
-<span class="k">def</span> principled(name, color, metallic, roughness):
+<span class="k">def</span> principled(name, color, metallic, roughness, noise_scale=<span class="n">0.0</span>, wear=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
-    bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = color
     bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
     bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = roughness
+    <span class="k">if</span> noise_scale &gt; <span class="n">0.0</span> <span class="k">and</span> wear <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        tex = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+        tex.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = noise_scale
+        tex.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+        mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+        mix.inputs[<span class="s">&quot;A&quot;</span>].default_value = color
+        mix.inputs[<span class="s">&quot;B&quot;</span>].default_value = wear
+        fac = mix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> mix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], fac)
+        nt.links.new(mix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
     <span class="k">return</span> mat
 
 
@@ -793,10 +882,11 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> world_bbox(obj):
-    corners = [obj.matrix_world @ Vector(c) <span class="k">for</span> c <span class="k">in</span> obj.bound_box]
-    xs = [c.x <span class="k">for</span> c <span class="k">in</span> corners]
-    ys = [c.y <span class="k">for</span> c <span class="k">in</span> corners]
-    zs = [c.z <span class="k">for</span> c <span class="k">in</span> corners]
+    mat = obj.matrix_world
+    pts = [mat @ v.co <span class="k">for</span> v <span class="k">in</span> obj.data.vertices]
+    xs = [p.x <span class="k">for</span> p <span class="k">in</span> pts]
+    ys = [p.y <span class="k">for</span> p <span class="k">in</span> pts]
+    zs = [p.z <span class="k">for</span> p <span class="k">in</span> pts]
     <span class="k">return</span> (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
@@ -859,6 +949,190 @@ <h2>Source</h2>
     <span class="k">return</span> collider
 
 
+<span class="k">def</span> face_area(me, poly):
+    vs = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> poly.vertices]
+    <span class="k">if</span> len(vs) &lt; <span class="n">3</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    v0 = vs[<span class="n">0</span>]
+    area = <span class="n">0.0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, len(vs) - <span class="n">1</span>):
+        area += (vs[i] - v0).cross(vs[i + <span class="n">1</span>] - v0).length * <span class="n">0.5</span>
+    <span class="k">return</span> area
+
+
+<span class="k">def</span> hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> len(p.vertices) &gt; <span class="n">4</span>)
+    zero_area = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> face_area(me, p) &lt;= AREA_EPS)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        loose_v = sum(<span class="n">1</span> <span class="k">for</span> v <span class="k">in</span> bm.verts <span class="k">if</span> len(v.link_edges) == <span class="n">0</span>)
+        loose_e = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> len(e.link_faces) == <span class="n">0</span>)
+        nonman = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> <span class="k">not</span> e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get(<span class="s">&quot;targetmap&quot;</span>) <span class="k">or</span> {})
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> {
+        <span class="s">&quot;nv&quot;</span>: nv, <span class="s">&quot;ne&quot;</span>: ne, <span class="s">&quot;nf&quot;</span>: nf, <span class="s">&quot;ngons&quot;</span>: ngons,
+        <span class="s">&quot;loose_v&quot;</span>: loose_v, <span class="s">&quot;loose_e&quot;</span>: loose_e, <span class="s">&quot;nonman&quot;</span>: nonman,
+        <span class="s">&quot;zero_area&quot;</span>: zero_area, <span class="s">&quot;doubles&quot;</span>: doubles, <span class="s">&quot;euler&quot;</span>: nv - ne + nf,
+    }
+
+
+<span class="k">def</span> zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        <span class="k">for</span> p <span class="k">in</span> me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(data)):
+        ci, ni, vi = data[i]
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(data)):
+            cj, nj, vj = data[j]
+            <span class="k">if</span> (cj - ci).length_squared &gt; eps2:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(ni.dot(nj)) &lt;= ZFIGHT_COS:
+                <span class="k">continue</span>
+            <span class="k">if</span> vi &amp; vj:
+                <span class="k">continue</span>
+            count += <span class="n">1</span>
+    <span class="k">return</span> count
+
+
+<span class="k">def</span> shells(me):
+    neighbors = [[] <span class="k">for</span> _ <span class="k">in</span> range(len(me.vertices))]
+    <span class="k">for</span> edge <span class="k">in</span> me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [<span class="k">False</span>] * len(me.vertices)
+    groups = []
+    <span class="k">for</span> start <span class="k">in</span> range(len(me.vertices)):
+        <span class="k">if</span> seen[start]:
+            <span class="k">continue</span>
+        seen[start] = <span class="k">True</span>
+        stack = [start]
+        group = []
+        <span class="k">while</span> stack:
+            current = stack.pop()
+            group.append(current)
+            <span class="k">for</span> nxt <span class="k">in</span> neighbors[current]:
+                <span class="k">if</span> <span class="k">not</span> seen[nxt]:
+                    seen[nxt] = <span class="k">True</span>
+                    stack.append(nxt)
+        groups.append(group)
+    <span class="k">return</span> groups
+
+
+<span class="k">def</span> shell_aabb(me, group):
+    pts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> group]
+    <span class="k">return</span> (
+        min(p.x <span class="k">for</span> p <span class="k">in</span> pts), min(p.y <span class="k">for</span> p <span class="k">in</span> pts), min(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+        max(p.x <span class="k">for</span> p <span class="k">in</span> pts), max(p.y <span class="k">for</span> p <span class="k">in</span> pts), max(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+    )
+
+
+<span class="k">def</span> mat_of(me, group):
+    member = set(group)
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        <span class="k">if</span> all(i <span class="k">in</span> member <span class="k">for</span> i <span class="k">in</span> poly.vertices):
+            <span class="k">return</span> poly.material_index
+    <span class="k">return</span> <span class="k">None</span>
+
+
+<span class="k">def</span> shell_bvh_gap(me, ga, gb):
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    <span class="k">try</span>:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        keep_a, keep_b = set(ga), set(gb)
+        drop_a = [f <span class="k">for</span> f <span class="k">in</span> bm_a.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep_a <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        drop_b = [f <span class="k">for</span> f <span class="k">in</span> bm_b.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep_b <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        <span class="k">if</span> drop_a:
+            bmesh.ops.delete(bm_a, geom=drop_a, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_a.faces <span class="k">or</span> <span class="k">not</span> bm_b.faces:
+            <span class="k">return</span> <span class="n">1e9</span>
+        tree = BVHTree.FromBMesh(bm_b)
+        best = <span class="n">1e9</span>
+        <span class="k">for</span> v <span class="k">in</span> bm_a.verts:
+            hit = tree.find_nearest(v.co)
+            <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+                best = min(best, hit[<span class="n">3</span>])
+        <span class="k">for</span> f <span class="k">in</span> bm_a.faces:
+            hit = tree.find_nearest(f.calc_center_median())
+            <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+                best = min(best, hit[<span class="n">3</span>])
+        <span class="k">return</span> best
+    <span class="k">finally</span>:
+        bm_a.free()
+        bm_b.free()
+
+
+<span class="k">def</span> add_stray_vert(me):
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, PLINTH_TOP + LOWER_H * <span class="n">0.5</span>))
+        bm.to_mesh(me)
+        me.update()
+    <span class="k">finally</span>:
+        bm.free()
+
+
+<span class="k">def</span> joint_audit(me):
+    groups = shells(me)
+    plinths = []
+    columns = []
+    spouts = []
+    flanges = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        mat = mat_of(me, g)
+        <span class="k">if</span> mat == WOOD_IDX <span class="k">and</span> dz &lt; <span class="n">0.08</span> <span class="k">and</span> dx &gt; <span class="n">0.20</span>:
+            plinths.append((g, a))
+        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> dz &gt; <span class="n">0.25</span> <span class="k">and</span> dx &lt; <span class="n">0.18</span> <span class="k">and</span> dy &lt; <span class="n">0.18</span>:
+            columns.append((g, a))
+        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> dy &gt; <span class="n">0.10</span> <span class="k">and</span> dx &lt; <span class="n">0.10</span> <span class="k">and</span> a[<span class="n">1</span>] &lt; -<span class="n">0.04</span>:
+            spouts.append((g, a))
+        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> dz &lt; <span class="n">0.05</span> <span class="k">and</span> dx &gt; <span class="n">0.14</span> <span class="k">and</span> a[<span class="n">2</span>] &lt; PLINTH_TOP + <span class="n">0.05</span>:
+            flanges.append((g, a))
+    spout_gap = <span class="n">99.0</span>
+    <span class="k">if</span> spouts <span class="k">and</span> columns:
+        spout_gap = min(
+            shell_bvh_gap(me, s[<span class="n">0</span>], c[<span class="n">0</span>]) <span class="k">for</span> s <span class="k">in</span> spouts <span class="k">for</span> c <span class="k">in</span> columns
+        )
+    flange_gap = <span class="n">99.0</span>
+    <span class="k">if</span> flanges <span class="k">and</span> plinths:
+        flange_gap = min(
+            shell_bvh_gap(me, f[<span class="n">0</span>], p[<span class="n">0</span>]) <span class="k">for</span> f <span class="k">in</span> flanges <span class="k">for</span> p <span class="k">in</span> plinths
+        )
+    col_r = <span class="n">0.0</span>
+    <span class="k">if</span> columns:
+        widest = max(columns, key=<span class="k">lambda</span> t: max(t[<span class="n">1</span>][<span class="n">3</span>] - t[<span class="n">1</span>][<span class="n">0</span>], t[<span class="n">1</span>][<span class="n">4</span>] - t[<span class="n">1</span>][<span class="n">1</span>]))
+        a = widest[<span class="n">1</span>]
+        col_r = <span class="n">0.5</span> * max(a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>])
+    plinth_z = <span class="n">99.0</span>
+    <span class="k">if</span> plinths:
+        plinth_z = min(a[<span class="n">2</span>] <span class="k">for</span> _g, a <span class="k">in</span> plinths)
+    <span class="k">return</span> {
+        <span class="s">&quot;plinths&quot;</span>: len(plinths),
+        <span class="s">&quot;columns&quot;</span>: len(columns),
+        <span class="s">&quot;spouts&quot;</span>: len(spouts),
+        <span class="s">&quot;flanges&quot;</span>: len(flanges),
+        <span class="s">&quot;spout_gap&quot;</span>: spout_gap,
+        <span class="s">&quot;flange_gap&quot;</span>: flange_gap,
+        <span class="s">&quot;col_r&quot;</span>: col_r,
+        <span class="s">&quot;plinth_z&quot;</span>: plinth_z,
+    }
+
+
 <span class="k">def</span> setup_bake_image(obj, target_mat, size=BAKE_RES):
     <span class="k">if</span> <span class="k">not</span> obj.data.uv_layers:
         <span class="k">return</span> <span class="k">None</span>, <span class="k">None</span>
@@ -911,15 +1185,40 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> check(skip_decimate):
+<span class="k">def</span> check(
+    skip_decimate,
+    lift_z=<span class="k">False</span>,
+    stray_vert=<span class="k">False</span>,
+    float_spout=<span class="k">False</span>,
+    float_flange=<span class="k">False</span>,
+    skinny_col=<span class="k">False</span>,
+):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    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.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>)
+    kw = dict(
+        float_spout=float_spout,
+        float_flange=float_flange,
+        skinny_col=skinny_col,
+    )
+    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>, **kw)
+    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>, **kw)
+    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>,
+        noise_scale=<span class="n">14.0</span>, wear=(<span class="n">0.22</span>, <span class="n">0.12</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
+    )
+    metal = principled(
+        <span class="s">&quot;HandPumpIron&quot;</span>, (<span class="n">0.18</span>, <span class="n">0.175</span>, <span class="n">0.17</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.38</span>,
+        noise_scale=<span class="n">18.0</span>, wear=(<span class="n">0.28</span>, <span class="n">0.24</span>, <span class="n">0.18</span>, <span class="n">1.0</span>),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
+    <span class="k">if</span> stray_vert:
+        add_stray_vert(low.data)
+    <span class="k">if</span> lift_z:
+        <span class="k">for</span> v <span class="k">in</span> low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+
     <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;hand pump 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>
 
@@ -951,7 +1250,7 @@ <h2>Source</h2>
     r2 = lod2_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
 
     collider_src = build_hand_pump_mesh(
-        <span class="s">&quot;HandPumpColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>
+        <span class="s">&quot;HandPumpColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>, **kw
     )
     collider = convex_hull_collider(collider_src, <span class="s">&quot;HandPumpCollider&quot;</span>)
     bpy.data.objects.remove(collider_src, do_unlink=<span class="k">True</span>)
@@ -966,6 +1265,10 @@ <h2>Source</h2>
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) <span class="k">if</span> os.path.isfile(export_path) <span class="k">else</span> <span class="n">0</span>
 
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    jnt = joint_audit(low.data)
+
     print(<span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>)
     print(
         <span class="s">f&quot;</span><span class="s">measured base_tris=</span>{base_tris}<span class="s"> lod1_tris=</span>{lod1_tris}<span class="s"> </span><span class="s">&quot;</span>
@@ -983,6 +1286,17 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">measured collider_tris=</span>{col_tris}<span class="s"> bake=</span>{bake_result}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">bake_has_data=</span>{img.has_data}<span class="s"> export_bytes=</span>{export_size}<span class="s">&quot;</span>
     )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>
+    )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured plinths=</span>{jnt[<span class="s">&#x27;plinths&#x27;</span>]}<span class="s"> columns=</span>{jnt[<span class="s">&#x27;columns&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">spouts=</span>{jnt[<span class="s">&#x27;spouts&#x27;</span>]}<span class="s"> flanges=</span>{jnt[<span class="s">&#x27;flanges&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">spout_gap=</span>{jnt[<span class="s">&#x27;spout_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> flange_gap=</span>{jnt[<span class="s">&#x27;flange_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">col_r=</span>{jnt[<span class="s">&#x27;col_r&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> plinth_z=</span>{jnt[<span class="s">&#x27;plinth_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>
+    )
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
@@ -1014,6 +1328,28 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">UV AABB overlap </span>{overlap:<span class="s">.6f</span>}<span class="s"> &gt; </span>{UV_OVERLAP_MAX}<span class="s">&quot;</span>,
             <span class="n">7</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> bb[<span class="n">2</span>] &gt; ZMIN_EPS <span class="k">or</span> jnt[<span class="s">&quot;plinth_z&quot;</span>] &gt; ZMIN_EPS:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">grounded zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.5f</span>}<span class="s"> plinth_z=</span>{jnt[<span class="s">&#x27;plinth_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>,
+            <span class="n">16</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> jnt[<span class="s">&quot;spouts&quot;</span>] &lt; <span class="n">1</span> <span class="k">or</span> jnt[<span class="s">&quot;columns&quot;</span>] &lt; <span class="n">1</span> <span class="k">or</span> jnt[<span class="s">&quot;spout_gap&quot;</span>] &gt; SPOUT_GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">spout gap </span>{jnt[<span class="s">&#x27;spout_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> spouts=</span>{jnt[<span class="s">&#x27;spouts&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">columns=</span>{jnt[<span class="s">&#x27;columns&#x27;</span>]}<span class="s">&quot;</span>,
+            <span class="n">17</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> jnt[<span class="s">&quot;flanges&quot;</span>] &lt; <span class="n">1</span> <span class="k">or</span> jnt[<span class="s">&quot;plinths&quot;</span>] &lt; <span class="n">1</span> <span class="k">or</span> jnt[<span class="s">&quot;flange_gap&quot;</span>] &gt; FLANGE_GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">flange gap </span>{jnt[<span class="s">&#x27;flange_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> flanges=</span>{jnt[<span class="s">&#x27;flanges&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">plinths=</span>{jnt[<span class="s">&#x27;plinths&#x27;</span>]}<span class="s">&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> abs(jnt[<span class="s">&quot;col_r&quot;</span>] - COL_R_LO) &gt; COL_R_TOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">column radius </span>{jnt[<span class="s">&#x27;col_r&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> off </span>{COL_R_LO}<span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> (
         abs(size_x - OUTER_SIZE[<span class="n">0</span>]) &gt; BBOX_TOL
         <span class="k">or</span> abs(size_y - OUTER_SIZE[<span class="n">1</span>]) &gt; BBOX_TOL
@@ -1047,6 +1383,16 @@ <h2>Source</h2>
         ), <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> export_size &lt;= <span class="n">0</span>:
         <span class="k">return</span> fail(<span class="s">&quot;export file missing or empty&quot;</span>, <span class="n">13</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> (
+        hyg[<span class="s">&quot;loose_v&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;loose_e&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;nonman&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;zero_area&quot;</span>]
+        <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>] <span class="k">or</span> zf
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>,
+            <span class="n">15</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1160,14 +1506,22 @@ <h2>Source</h2>
     p = argparse.ArgumentParser()
     p.add_argument(<span class="s">&quot;--output&quot;</span>, default=<span class="k">None</span>)
     p.add_argument(<span class="s">&quot;--engine&quot;</span>, default=<span class="s">&quot;eevee&quot;</span>, choices=(<span class="s">&quot;eevee&quot;</span>, <span class="s">&quot;cycles&quot;</span>))
-    p.add_argument(
-        <span class="s">&quot;--skip-decimate&quot;</span>,
-        action=<span class="s">&quot;store_true&quot;</span>,
-        help=<span class="s">&quot;falsification: skip the LOD DECIMATE stage&quot;</span>,
-    )
+    p.add_argument(<span class="s">&quot;--skip-decimate&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--stray-vert&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--lift-z&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-spout&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-flange&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--skinny-col&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        float_spout=args.float_spout,
+        float_flange=args.float_flange,
+        skinny_col=args.skinny_col,
+    )
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 8d201e3..9e644be 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -975,12 +975,12 @@ <h2><a href="terrain-scatter/">terrain-scatter</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="fence-kit/" aria-label="fence-kit example detail page">
-          <img src="assets/fence-kit-hero.webp" alt="fence-kit — A procedural post-and-rail fence section through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
+          <img src="assets/fence-kit-hero.webp" alt="fence-kit — A procedural post-and-rail fence section whose brace is an oriented box between named post stations, through UVs, bake, LOD, collider, and Unity glTF…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="fence-kit/">fence-kit</a></h2>
-          <p class="teaches">A procedural post-and-rail fence section 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: 1212 tris, two materials with 120 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.642×0.157×1.235 m, LOD ratios in band, convex collider 62 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural post-and-rail fence section whose brace is an oriented box between named post stations, 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: 1092 tris, two materials with 156 metal and 390 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.624×0.134×1.232 m, grounded zmin, 2 iron shoes, brace-to-post gap 2.4 mm on both posts, rail-to-post gap 0.93 mm, rail span 1.390 m, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 32 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-shoes 16; --short-brace 17; --gap-rails 18; --long-rails 19.</p>
           <a class="card-link" href="fence-kit/">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 with a gooseneck 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 whose gooseneck is a 6-gon tube from the lower-column radius, through UVs, bake, LOD, collider, and Unity glTF, asserting…" 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 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>
+          <p class="teaches">A procedural village hand pump whose gooseneck is a 6-gon tube from the lower-column radius, 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: 1064 tris, two materials with 564 metal and 144 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.610×0.382×1.052 m, grounded zmin, spout-to-column gap 2.7 mm, flange-to-plinth gap 6.0 mm, column radius 62 mm, LOD ratios in band, convex collider 114 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z 16; --float-spout 17; --float-flange 18; --skinny-col 19.</p>
           <a class="card-link" href="hand-pump/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/showcase/README.md b/showcase/README.md
index 673d997..f9dbeb8 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -79,6 +79,11 @@ entry in `showcase/gallery.json`, and a rendered still.
   the host's chamfer as a spike — that is the class this catches.
   Measure in the construction frame (un-rotate by any rake) so a tilted
   host does not inflate its own AABB.
+- **Diagonal from stations (exit 17).** A brace, gooseneck or scroll is
+  an oriented primitive or a tube between named host endpoints, not a
+  hypot-length box rotated about its centroid. The centroid form is
+  short of one host and punches through the other. `--short-brace` /
+  `--float-spout` (or the piece's equivalent) is the falsifier.
 - **Seat conformance (exit 18).** A band, hoop, strap or collar wrapped
   around a host asserts a **banded** seat depth — a minimum so it cannot
   float and a maximum so it cannot sink — sampled per angular segment
diff --git a/showcase/fence-kit/README.md b/showcase/fence-kit/README.md
index 4c3c6a1..9fcaba3 100644
--- a/showcase/fence-kit/README.md
+++ b/showcase/fence-kit/README.md
@@ -1,10 +1,17 @@
 # Fence kit
 
 A showcase piece, not an example. Procedural post-and-rail fence
-section (two posts, pyramidal caps, three rails, kickboard, brace,
-iron shoes and straps) then the shipped pipeline: unique-cell UVs,
-Cycles high-to-low normal bake, LOD chain, convex collider, Unity
-glTF export.
+section (two posts, pyramidal caps, three rails, kickboard, a brace
+from named post stations, iron shoes and U-wrap straps) then the
+shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD
+chain, convex collider, Unity glTF export.
+
+Posts, rails, kick, brace and collars share named stations
+(`POST_XS`, `RAIL_ZS`, `Y_BRACE`, `SHOE_H`). The brace is an oriented
+box from the left-post lower-rail station to the right-post upper-rail
+station on the back face, not a hypot-length box rotated about its
+centroid. Rails and kick tenon into the post volume; rail collars are
+U-wraps so the span-facing plate is not coplanar with the rail end.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -16,6 +23,11 @@ re-witness the `modular-kit-snap` snap contract.
 `bake_normal_high_to_low.py`, `setup_bake_target_image.py`,
 `lod_chain.py` / `decimate_to_budget.py`, `convex_hull_collider.py`,
 `export_preset_unity.py` (helpers copied, not imported as a package).
+Hygiene combinatorics match `examples/mesh-hygiene-audit` (copied, not
+imported).
+
+Intended size: 1.60 m bay, 1.14 m posts, 0.11 m post stock; outer AABB
+1.624 × 0.134 × 1.232 m.
 
 ## Budgets
 
@@ -24,37 +36,92 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 1160–1280 | 1212 / 1212 / 1212 |
+| Base triangles | 1000–1400 | 1092 / 1092 / 1092 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2195 / 0.2195 / 0.2079 |
-| Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 120 metal |
+| LOD2 ratio | 0.10–0.35 of base | 0.2198 / 0.2198 / 0.1832 |
+| Materials | exactly 2 distinct, ≥48 metal, ≥24 wood | 2 slots, 156 metal / 390 wood |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.642, 0.157, 1.235) m ± 0.01 | (1.6418, 0.1574, 1.2350), zmin 0 |
-| Collider tris | ≤ 96 | 62 |
-| Export | written, size > 0 | 93232 / 93232 / 93224 bytes |
+| Outer AABB | (1.624, 0.134, 1.232) m ± 0.015 | (1.6240, 0.1340, 1.2320), zmin 0 |
+| Collider tris | ≤ 180 | 32 |
+| Export | written, size > 0 | 82216 / 82216 / 82208 bytes |
+
+Base triangles dropped from **1212 to 1092** in the quality pass: rail
+collars became U-wraps (no span-facing plate). Outer AABB tightened from
+1.642 × 0.157 × 1.235 m.
 
 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
 exact count. Bake pixels are stochastic; the gate is `has_data` plus
 operator `FINISHED`, not byte-identity. Construction uses no RNG.
+Export byte counts differ by 8 B on 5.2.1 (glTF serializer), not a
+gated axis.
+
+### Hygiene
+
+Recomputed from the generated mesh, not asserted about the script.
+
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Non-manifold edges | 0 | 0 |
+| Loose verts / edges | 0 / 0 | 0 / 0 |
+| Doubles merged at 1e-5 | 0 | 0 |
+| Zero-area faces | 0 | 0 |
+| N-gons | 0 | 0 |
+| Coplanar disjoint face pairs | 0 | 0 |
+| Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
+| Named shoes | 2, each `zmin` ≤ 0.002 | 2, 0.00000 |
+
+### Joint fit and span
+
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Brace-to-post BVH gap (both posts) | ≤ 0.008 m | 0.00240 |
+| Rail-to-post BVH gap | ≤ 0.008 m | 0.00093 |
+| Rail span vs `2·RAIL_HALF` | ± 0.04 m | 1.3900 vs 1.390 |
+
+### Falsifiers
+
+Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1
+and returned the same code on each.
+
+| Flag | Budget violated | Exit |
+| --- | --- | --- |
+| `--skip-decimate` | LOD1 ratio band | 9 |
+| `--stray-vert` | loose vertex count is 0 | 15 |
+| `--lift-z` | bounding box `zmin` is 0 | 16 |
+| `--short-shoes` | named shoes plant at z=0 | 16 |
+| `--short-brace` | brace-to-post BVH gap (both posts) | 17 |
+| `--gap-rails` | rail-to-post BVH gap | 18 |
+| `--long-rails` | rail span vs `2·RAIL_HALF` | 19 |
 
-`--skip-decimate` skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and
-exit 9 fires. That is the named budget the falsifier violates.
+`--short-shoes` lifts only the iron shoes. After recenter a post or kick
+is the AABB `zmin`, so the AABB gate would still pass; the named-shoe
+stations fail. `--short-brace` shortens the left station; `brace_gap` is
+the max of the per-post minima so a brace that still hits the right post
+cannot sneak through. `--long-rails` adds an extra spanning board; the
+tenoned rails stay put so the gap budget still passes.
 
 ## Run
 
 ```bash
 blender --background --python fence_kit.py --
 blender --background --python fence_kit.py -- --skip-decimate
+blender --background --python fence_kit.py -- --stray-vert
+blender --background --python fence_kit.py -- --lift-z
+blender --background --python fence_kit.py -- --short-shoes
+blender --background --python fence_kit.py -- --short-brace
+blender --background --python fence_kit.py -- --gap-rails
+blender --background --python fence_kit.py -- --long-rails
 blender --background --python fence_kit.py -- --output fence.png
 ```
 
-Smoke does not pass `--output` or `--skip-decimate`.
+Smoke passes no flags.
 
 ## Exit codes
 
 File-local. `9` is a valid check code. `10` is reserved for
-`gallery_framing.check_framing` on the `--output` path.
+`gallery_framing.check_framing` on the `--output` path. `15`–`19` are the
+hygiene and joint-fit family.
 
 | Code | Meaning |
 | --- | --- |
@@ -63,7 +130,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 metal faces missing |
+| 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 |
@@ -73,3 +140,8 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 12 | Bake did not finish or image has no data |
 | 13 | Export file missing or empty |
 | 14 | `--output` produced no file |
+| 15 | Hygiene (`--stray-vert` lands here) |
+| 16 | Grounded zmin / named shoes (`--lift-z`, `--short-shoes`) |
+| 17 | Brace-to-post gap (`--short-brace`) |
+| 18 | Rail-to-post gap (`--gap-rails`) |
+| 19 | Rail span (`--long-rails`) |
diff --git a/showcase/fence-kit/fence_kit.py b/showcase/fence-kit/fence_kit.py
index 5ca5b7b..1744dcf 100644
--- a/showcase/fence-kit/fence_kit.py
+++ b/showcase/fence-kit/fence_kit.py
@@ -5,9 +5,17 @@
 materials, high-to-low normal bake, LOD chain, convex collider,
 Unity glTF export.
 
+Posts, rails, kick, brace and collars share named stations
+(``post_xs``, ``RAIL_ZS``, ``y_brace``). The brace is an oriented
+box between those stations, not a hypot-length cube rotated about
+its centroid. Rails and kick tenon into the post volume without
+sharing corner verts.
+
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+DECIMATE stage so the LOD-ratio budget fails. Hygiene family 15–19:
+``--stray-vert``, ``--lift-z`` / ``--short-shoes``, ``--short-brace``,
+``--gap-rails``, ``--long-rails``.
 
 No RNG. Construction is closed-form. AABB X is the tile width so
 adjacent copies meet; this piece does not re-witness the modular-kit
@@ -29,6 +37,7 @@
 import bmesh
 import bpy
 from mathutils import Euler, Vector
+from mathutils.bvhtree import BVHTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -41,6 +50,7 @@
 POST_W = 0.110
 POST_H = 1.14
 CAP_H = 0.095
+CAP_OVERHANG = 0.012
 RAIL_Y = 0.055
 RAIL_Z = 0.064
 RAIL_ZS = (0.30, 0.58, 0.86)
@@ -49,12 +59,17 @@
 BRACE_T = 0.042
 IRON_T = 0.016
 SHOE_H = 0.034
-SHOE_SCALE = 1.38
-
-BBOX_TOL = 0.01
-OUTER_SIZE = (1.642, 0.157, 1.235)
-BASE_TRIS_MIN = 1160
-BASE_TRIS_MAX = 1280
+TENON = 0.005
+POST_XS = (-(TILE / 2.0 - POST_W / 2.0), TILE / 2.0 - POST_W / 2.0)
+HX = POST_XS[1]
+Y_BRACE = -(POST_W * 0.5 - BRACE_T * 0.30)
+RAIL_HALF = HX - POST_W * 0.5 + TENON
+COLLAR_BITE = 0.004
+
+BBOX_TOL = 0.015
+OUTER_SIZE = (1.624, 0.134, 1.232)
+BASE_TRIS_MIN = 1000
+BASE_TRIS_MAX = 1400
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -64,14 +79,31 @@
 MATERIAL_COUNT = 2
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 96
+COLLIDER_TRIS_MAX = 180
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.06
-METAL_FACES_MIN = 24
+METAL_FACES_MIN = 48
+WOOD_FACES_MIN = 48
 
 WOOD_IDX = 0
 METAL_IDX = 1
 
+DOUBLES_EPS = 1e-5
+AREA_EPS = 1e-10
+ZMIN_EPS = 1e-4
+ZFIGHT_EPS = 0.002
+ZFIGHT_COS = 0.98
+SHOE_COUNT = 2
+SHOE_ZMIN_MAX = 0.002
+BRACE_GAP_MAX = 0.008
+RAIL_GAP_MAX = 0.008
+SPAN_TOL = 0.04
+LIFT_Z = 0.05
+SHORT_SHOE = 0.08
+SHORT_BRACE = 0.22
+GAP_RAIL = 0.10
+LONG_RAIL = 0.08
+
 
 def eevee_engine_id():
     return "BLENDER_EEVEE" if bpy.app.version >= (5, 0, 0) else "BLENDER_EEVEE_NEXT"
@@ -119,6 +151,46 @@ def add_box(bm, loc, scale, mat_idx, euler=(0.0, 0.0, 0.0)):
     return verts
 
 
+def add_oriented_box(bm, a, b, scale_xy, 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_box(
+        bm,
+        ((a + b) * 0.5),
+        (scale_xy[0], scale_xy[1], length),
+        mat_idx,
+        euler=(eul.x, eul.y, eul.z),
+    )
+
+
+def add_collar(bm, px, z, half, t, h, mat_idx, closed=True):
+    """Plates around a post. Bite the host. U-wrap omits the span-facing plate."""
+    loc_y = half - COLLAR_BITE + t * 0.5
+    add_box(bm, (px, loc_y, z), (2.0 * half - t * 0.50, t, h), mat_idx)
+    add_box(bm, (px, -loc_y, z), (2.0 * half - t * 0.50, t, h), mat_idx)
+    loc_x = half - COLLAR_BITE + t * 0.5
+    sign = 1.0 if px >= 0.0 else -1.0
+    add_box(
+        bm,
+        (px + sign * loc_x, 0.0, z),
+        (t, 2.0 * half - t * 0.70, h),
+        mat_idx,
+    )
+    if closed:
+        add_box(
+            bm,
+            (px - sign * loc_x, 0.0, z),
+            (t, 2.0 * half - t * 0.70, h),
+            mat_idx,
+        )
+
+
 def add_cone(bm, loc, radius1, radius2, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
     geo = bmesh.ops.create_cone(
         bm,
@@ -183,60 +255,68 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def build_fence_mesh(name, bevel_offset, bevel_segments):
+def build_fence_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    short_brace=False,
+    short_shoes=False,
+    gap_rails=False,
+    long_rails=False,
+):
     bm = bmesh.new()
     try:
         wood_verts = []
-        post_xs = (-(TILE / 2.0 - POST_W / 2.0), TILE / 2.0 - POST_W / 2.0)
+        post_xs = POST_XS
+        half = POST_W * 0.5
+        rail_half = RAIL_HALF - GAP_RAIL if gap_rails else RAIL_HALF
+
         for px in post_xs:
             wood_verts.extend(
-                add_box(bm, (px, 0.0, POST_H / 2.0), (POST_W, POST_W, POST_H), WOOD_IDX)
-            )
-            wood_verts.extend(
-                add_cone(
+                add_box(
                     bm,
-                    (px, 0.0, POST_H + CAP_H / 2.0),
-                    POST_W * 0.72,
-                    0.010,
-                    CAP_H,
-                    4,
+                    (px, 0.0, POST_H / 2.0),
+                    (POST_W, POST_W, POST_H),
                     WOOD_IDX,
-                    euler=(0.0, 0.0, math.pi / 4.0),
                 )
             )
 
-        rail_len = TILE - POST_W * 0.18
-        for z in RAIL_ZS:
+        for i, z in enumerate(RAIL_ZS):
+            ry = RAIL_Y * (1.0 + 0.10 * math.sin(i * 2.15 + 0.3))
+            rz = RAIL_Z * (1.0 + 0.06 * math.sin(i * 1.7 + 1.1))
             wood_verts.extend(
-                add_box(bm, (0.0, 0.0, z), (rail_len, RAIL_Y, RAIL_Z), WOOD_IDX)
+                add_box(bm, (0.0, 0.0, z), (2.0 * rail_half, ry, rz), WOOD_IDX)
             )
 
+        kick_z0 = SHOE_H - 0.003
         wood_verts.extend(
             add_box(
                 bm,
-                (0.0, 0.0, KICK_Z / 2.0),
-                (TILE - POST_W * 0.22, KICK_Y, KICK_Z),
+                (0.0, 0.0, kick_z0 + KICK_Z / 2.0),
+                (2.0 * rail_half, KICK_Y, KICK_Z),
                 WOOD_IDX,
             )
         )
 
-        span = TILE - POST_W
-        rise = RAIL_ZS[-1] - RAIL_ZS[0]
-        brace_len = math.hypot(span, rise)
-        brace_ang = math.atan2(rise, span)
-        wood_verts.extend(
-            add_box(
-                bm,
-                (0.0, -POST_W * 0.55, (RAIL_ZS[0] + RAIL_ZS[-1]) / 2.0),
-                (brace_len, BRACE_T, BRACE_T),
-                WOOD_IDX,
-                euler=(0.0, -brace_ang, 0.0),
+        if long_rails:
+            wood_verts.extend(
+                add_box(
+                    bm,
+                    (0.0, 0.0, (RAIL_ZS[0] + RAIL_ZS[1]) * 0.5),
+                    (2.0 * (RAIL_HALF + LONG_RAIL), RAIL_Y, RAIL_Z),
+                    WOOD_IDX,
+                )
             )
-        )
+
+        a = Vector((post_xs[0], Y_BRACE, RAIL_ZS[0]))
+        b = Vector((post_xs[1], Y_BRACE, RAIL_ZS[-1]))
+        if short_brace:
+            a = Vector((post_xs[0] + SHORT_BRACE, Y_BRACE, RAIL_ZS[0]))
+        wood_verts.extend(add_oriented_box(bm, a, b, (BRACE_T, BRACE_T), WOOD_IDX))
 
         if bevel_offset > 0.0:
             edges = list({e for v in wood_verts for e in v.link_edges})
-            bmesh.ops.bevel(
+            ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
                 offset=bevel_offset,
@@ -245,42 +325,36 @@ def build_fence_mesh(name, bevel_offset, bevel_segments):
                 affect="EDGES",
                 clamp_overlap=True,
             )
+            for f in ret.get("faces") or []:
+                f.material_index = WOOD_IDX
 
+        cap_half = half + CAP_OVERHANG
         for px in post_xs:
-            add_box(
+            add_cone(
                 bm,
-                (px, 0.0, SHOE_H / 2.0),
-                (POST_W * SHOE_SCALE, POST_W * SHOE_SCALE, SHOE_H),
-                METAL_IDX,
+                (px, 0.0, POST_H + CAP_H / 2.0 - 0.003),
+                cap_half * math.sqrt(2.0),
+                0.020,
+                CAP_H,
+                4,
+                WOOD_IDX,
+                euler=(0.0, 0.0, math.pi / 4.0),
+            )
+
+        shoe_lift = SHORT_SHOE if short_shoes else 0.0
+        for px in post_xs:
+            add_collar(
+                bm, px, SHOE_H / 2.0 + shoe_lift, half, IRON_T, SHOE_H, METAL_IDX,
+                closed=True,
             )
-            sign = 1.0 if px > 0.0 else -1.0
             for z in RAIL_ZS:
-                add_box(
-                    bm,
-                    (px, POST_W / 2.0 + IRON_T / 2.0, z),
-                    (POST_W * 0.88, IRON_T, RAIL_Z * 1.40),
-                    METAL_IDX,
-                )
-                add_box(
-                    bm,
-                    (px, -(POST_W / 2.0 + IRON_T / 2.0), z),
-                    (POST_W * 0.88, IRON_T, RAIL_Z * 1.40),
-                    METAL_IDX,
-                )
-                add_box(
-                    bm,
-                    (px + sign * (POST_W / 2.0 + IRON_T / 2.0), 0.0, z),
-                    (IRON_T, POST_W * 0.88, RAIL_Z * 1.40),
-                    METAL_IDX,
+                add_collar(
+                    bm, px, z, half, IRON_T, RAIL_Z * 1.25, METAL_IDX, closed=False
                 )
 
-        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]
-        cy = 0.5 * (min(ys) + max(ys))
         zmin = min(zs)
         for v in bm.verts:
-            v.co.y -= cy
             v.co.z -= zmin
             if v.co.z < 0.0:
                 v.co.z = 0.0
@@ -301,13 +375,25 @@ def build_fence_mesh(name, bevel_offset, bevel_segments):
     return out
 
 
-def principled(name, color, metallic, roughness):
+def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
-    bsdf = mat.node_tree.nodes["Principled BSDF"]
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = color
     bsdf.inputs["Metallic"].default_value = metallic
     bsdf.inputs["Roughness"].default_value = roughness
+    if noise_scale > 0.0 and wear is not None:
+        tex = nt.nodes.new("ShaderNodeTexNoise")
+        tex.inputs["Scale"].default_value = noise_scale
+        tex.inputs["Detail"].default_value = 6.0
+        mix = nt.nodes.new("ShaderNodeMix")
+        mix.data_type = "RGBA"
+        mix.inputs["A"].default_value = color
+        mix.inputs["B"].default_value = wear
+        fac = mix.inputs.get("Factor") or mix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], fac)
+        nt.links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])
     return mat
 
 
@@ -324,10 +410,11 @@ def assign_slots(obj, wood, metal):
 
 
 def world_bbox(obj):
-    corners = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
-    xs = [c.x for c in corners]
-    ys = [c.y for c in corners]
-    zs = [c.z for c in corners]
+    mat = obj.matrix_world
+    pts = [mat @ v.co for v in obj.data.vertices]
+    xs = [p.x for p in pts]
+    ys = [p.y for p in pts]
+    zs = [p.z for p in pts]
     return (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
@@ -390,6 +477,193 @@ def convex_hull_collider(obj, name):
     return collider
 
 
+def face_area(me, poly):
+    vs = [me.vertices[i].co for i in poly.vertices]
+    if len(vs) < 3:
+        return 0.0
+    v0 = vs[0]
+    area = 0.0
+    for i in range(1, len(vs) - 1):
+        area += (vs[i] - v0).cross(vs[i + 1] - v0).length * 0.5
+    return area
+
+
+def hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(1 for p in me.polygons if len(p.vertices) > 4)
+    zero_area = sum(1 for p in me.polygons if face_area(me, p) <= AREA_EPS)
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        loose_v = sum(1 for v in bm.verts if len(v.link_edges) == 0)
+        loose_e = sum(1 for e in bm.edges if len(e.link_faces) == 0)
+        nonman = sum(1 for e in bm.edges if not e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get("targetmap") or {})
+    finally:
+        bm.free()
+    return {
+        "nv": nv, "ne": ne, "nf": nf, "ngons": ngons,
+        "loose_v": loose_v, "loose_e": loose_e, "nonman": nonman,
+        "zero_area": zero_area, "doubles": doubles, "euler": nv - ne + nf,
+    }
+
+
+def zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        for p in me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = 0
+    for i in range(len(data)):
+        ci, ni, vi = data[i]
+        for j in range(i + 1, len(data)):
+            cj, nj, vj = data[j]
+            if (cj - ci).length_squared > eps2:
+                continue
+            if abs(ni.dot(nj)) <= ZFIGHT_COS:
+                continue
+            if vi & vj:
+                continue
+            count += 1
+    return count
+
+
+def shells(me):
+    neighbors = [[] for _ in range(len(me.vertices))]
+    for edge in me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [False] * len(me.vertices)
+    groups = []
+    for start in range(len(me.vertices)):
+        if seen[start]:
+            continue
+        seen[start] = True
+        stack = [start]
+        group = []
+        while stack:
+            current = stack.pop()
+            group.append(current)
+            for nxt in neighbors[current]:
+                if not seen[nxt]:
+                    seen[nxt] = True
+                    stack.append(nxt)
+        groups.append(group)
+    return groups
+
+
+def shell_aabb(me, group):
+    pts = [me.vertices[i].co for i in group]
+    return (
+        min(p.x for p in pts), min(p.y for p in pts), min(p.z for p in pts),
+        max(p.x for p in pts), max(p.y for p in pts), max(p.z for p in pts),
+    )
+
+
+def mat_of(me, group):
+    member = set(group)
+    for poly in me.polygons:
+        if all(i in member for i in poly.vertices):
+            return poly.material_index
+    return None
+
+
+def shell_bvh_gap(me, ga, gb):
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    try:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        keep_a, keep_b = set(ga), set(gb)
+        drop_a = [f for f in bm_a.faces if not all(v.index in keep_a for v in f.verts)]
+        drop_b = [f for f in bm_b.faces if not all(v.index in keep_b for v in f.verts)]
+        if drop_a:
+            bmesh.ops.delete(bm_a, geom=drop_a, context="FACES")
+        if drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context="FACES")
+        if not bm_a.faces or not bm_b.faces:
+            return 1e9
+        tree = BVHTree.FromBMesh(bm_b)
+        best = 1e9
+        for v in bm_a.verts:
+            hit = tree.find_nearest(v.co)
+            if hit[0] is not None:
+                best = min(best, hit[3])
+        for f in bm_a.faces:
+            hit = tree.find_nearest(f.calc_center_median())
+            if hit[0] is not None:
+                best = min(best, hit[3])
+        return best
+    finally:
+        bm_a.free()
+        bm_b.free()
+
+
+def add_stray_vert(me):
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.new((0.0, 0.0, POST_H * 0.55))
+        bm.to_mesh(me)
+        me.update()
+    finally:
+        bm.free()
+
+
+def joint_audit(me):
+    groups = shells(me)
+    posts = []
+    rails = []
+    braces = []
+    shoes = []
+    for g in groups:
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        mat = mat_of(me, g)
+        if mat == WOOD_IDX and dz > 0.70 and dx < 0.18 and dy < 0.18:
+            posts.append((g, a))
+        if mat == WOOD_IDX and dx > TILE * 0.45 and dz < 0.18:
+            rails.append((g, a))
+        if mat == WOOD_IDX and dx > 0.40 and dz > 0.25 and dy < 0.12:
+            braces.append((g, a))
+        if mat == METAL_IDX and a[2] < 0.08 and dz < 0.08 and max(dx, dy) < 0.22:
+            shoes.append((g, a))
+    left = [a for _g, a in shoes if (a[0] + a[3]) * 0.5 < 0.0]
+    right = [a for _g, a in shoes if (a[0] + a[3]) * 0.5 >= 0.0]
+    shoe_n = (1 if left else 0) + (1 if right else 0)
+    shoe_z = 99.0
+    if shoes:
+        shoe_z = min(a[2] for _g, a in shoes)
+    brace_gap = 99.0
+    if braces and posts:
+        per_post = [
+            min(shell_bvh_gap(me, b[0], p[0]) for b in braces) for p in posts
+        ]
+        brace_gap = max(per_post)
+    rail_gap = 99.0
+    if rails and posts:
+        rail_gap = min(
+            shell_bvh_gap(me, r[0], p[0]) for r in rails for p in posts
+        )
+    span_x = 0.0
+    if rails:
+        xs = [v for _g, a in rails for v in (a[0], a[3])]
+        span_x = max(xs) - min(xs)
+    return {
+        "posts": len(posts),
+        "rails": len(rails),
+        "braces": len(braces),
+        "shoes": shoe_n,
+        "shoe_z": shoe_z,
+        "brace_gap": brace_gap,
+        "rail_gap": rail_gap,
+        "span_x": span_x,
+    }
+
+
 def setup_bake_image(obj, target_mat, size=BAKE_RES):
     if not obj.data.uv_layers:
         return None, None
@@ -442,15 +716,42 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def check(
+    skip_decimate,
+    lift_z=False,
+    stray_vert=False,
+    short_brace=False,
+    short_shoes=False,
+    gap_rails=False,
+    long_rails=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_fence_mesh("FenceLow", bevel_offset=0.006, bevel_segments=2)
-    high = build_fence_mesh("FenceHigh", bevel_offset=0.006, bevel_segments=4)
-    wood = principled("FenceWood", (0.46, 0.24, 0.08, 1.0), 0.0, 0.55)
-    metal = principled("FenceIron", (0.11, 0.115, 0.13, 1.0), 1.0, 0.28)
+    kw = dict(
+        short_brace=short_brace,
+        short_shoes=short_shoes,
+        gap_rails=gap_rails,
+        long_rails=long_rails,
+    )
+    low = build_fence_mesh("FenceLow", bevel_offset=0.006, bevel_segments=2, **kw)
+    high = build_fence_mesh("FenceHigh", bevel_offset=0.006, bevel_segments=4, **kw)
+    wood = principled(
+        "FenceWood", (0.46, 0.24, 0.08, 1.0), 0.0, 0.55,
+        noise_scale=16.0, wear=(0.32, 0.16, 0.05, 1.0),
+    )
+    metal = principled(
+        "FenceIron", (0.11, 0.115, 0.13, 1.0), 1.0, 0.28,
+        noise_scale=20.0, wear=(0.18, 0.16, 0.12, 1.0),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
+    if stray_vert:
+        add_stray_vert(low.data)
+    if lift_z:
+        for v in low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+
     if low.data is None or len(low.data.polygons) < 6:
         return fail("fence mesh did not build", 3), None, None, None, None, None
 
@@ -481,7 +782,9 @@ def check(skip_decimate):
     r1 = lod1_tris / base_tris if base_tris else 0.0
     r2 = lod2_tris / base_tris if base_tris else 0.0
 
-    collider_src = build_fence_mesh("FenceColSrc", bevel_offset=0.0, bevel_segments=1)
+    collider_src = build_fence_mesh(
+        "FenceColSrc", bevel_offset=0.0, bevel_segments=1, **kw
+    )
     collider = convex_hull_collider(collider_src, "FenceCollider")
     bpy.data.objects.remove(collider_src, do_unlink=True)
     col_tris = triangle_count(collider.data)
@@ -495,6 +798,10 @@ def check(skip_decimate):
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
 
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    jnt = joint_audit(low.data)
+
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
         f"measured base_tris={base_tris} lod1_tris={lod1_tris} "
@@ -512,6 +819,17 @@ def check(skip_decimate):
         f"measured collider_tris={col_tris} bake={bake_result} "
         f"bake_has_data={img.has_data} export_bytes={export_size}"
     )
+    print(
+        f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+        f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+        f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}"
+    )
+    print(
+        f"measured posts={jnt['posts']} rails={jnt['rails']} "
+        f"braces={jnt['braces']} shoes={jnt['shoes']} "
+        f"shoe_z={jnt['shoe_z']:.5f} brace_gap={jnt['brace_gap']:.5f} "
+        f"rail_gap={jnt['rail_gap']:.5f} span_x={jnt['span_x']:.4f}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -528,6 +846,11 @@ def check(skip_decimate):
             f"metal faces {idx_counts.get(METAL_IDX, 0)} < {METAL_FACES_MIN}",
             5,
         ), None, None, None, None, None
+    if idx_counts.get(WOOD_IDX, 0) < WOOD_FACES_MIN:
+        return fail(
+            f"wood faces {idx_counts.get(WOOD_IDX, 0)} < {WOOD_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})",
@@ -538,6 +861,32 @@ def check(skip_decimate):
             f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}",
             7,
         ), None, None, None, None, None
+    if (
+        bb[2] > ZMIN_EPS
+        or jnt["shoes"] != SHOE_COUNT
+        or jnt["shoe_z"] > SHOE_ZMIN_MAX
+    ):
+        return fail(
+            f"grounded zmin={bb[2]:.5f} shoes={jnt['shoes']} "
+            f"shoe_z={jnt['shoe_z']:.5f}",
+            16,
+        ), None, None, None, None, None
+    if jnt["braces"] < 1 or jnt["posts"] < 2 or jnt["brace_gap"] > BRACE_GAP_MAX:
+        return fail(
+            f"brace gap {jnt['brace_gap']:.5f} braces={jnt['braces']} "
+            f"posts={jnt['posts']}",
+            17,
+        ), None, None, None, None, None
+    if jnt["rails"] < 3 or jnt["rail_gap"] > RAIL_GAP_MAX:
+        return fail(
+            f"rail gap {jnt['rail_gap']:.5f} rails={jnt['rails']}",
+            18,
+        ), None, None, None, None, None
+    if abs(jnt["span_x"] - 2.0 * RAIL_HALF) > SPAN_TOL:
+        return fail(
+            f"rail span {jnt['span_x']:.4f} off {2.0 * RAIL_HALF}",
+            19,
+        ), None, None, None, None, None
     if (
         abs(size_x - OUTER_SIZE[0]) > BBOX_TOL
         or abs(size_y - OUTER_SIZE[1]) > BBOX_TOL
@@ -571,6 +920,16 @@ def check(skip_decimate):
         ), None, None, None, None, None
     if export_size <= 0:
         return fail("export file missing or empty", 13), None, None, None, None, None
+    if (
+        hyg["loose_v"] or hyg["loose_e"] or hyg["nonman"] or hyg["zero_area"]
+        or hyg["doubles"] or hyg["ngons"] or zf
+    ):
+        return fail(
+            f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+            f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}",
+            15,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -684,14 +1043,24 @@ def main():
     p = argparse.ArgumentParser()
     p.add_argument("--output", default=None)
     p.add_argument("--engine", default="eevee", choices=("eevee", "cycles"))
-    p.add_argument(
-        "--skip-decimate",
-        action="store_true",
-        help="falsification: skip the LOD DECIMATE stage",
-    )
+    p.add_argument("--skip-decimate", action="store_true")
+    p.add_argument("--stray-vert", action="store_true")
+    p.add_argument("--lift-z", action="store_true")
+    p.add_argument("--short-shoes", action="store_true")
+    p.add_argument("--short-brace", action="store_true")
+    p.add_argument("--gap-rails", action="store_true")
+    p.add_argument("--long-rails", action="store_true")
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        short_brace=args.short_brace,
+        short_shoes=args.short_shoes,
+        gap_rails=args.gap_rails,
+        long_rails=args.long_rails,
+    )
     if code:
         return code
     if args.output:
diff --git a/showcase/fence-kit/preview.webp b/showcase/fence-kit/preview.webp
index 3957412..836bf9d 100644
Binary files a/showcase/fence-kit/preview.webp and b/showcase/fence-kit/preview.webp differ
diff --git a/showcase/gallery.json b/showcase/gallery.json
index eabb590..158a1a4 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -104,8 +104,8 @@
     {
       "name": "fence-kit",
       "dir": "showcase/fence-kit",
-      "teaches": "A procedural post-and-rail fence section through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 1212 tris, two materials with 120 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.642×0.157×1.235 m, LOD ratios in band, convex collider 62 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural post-and-rail fence section whose brace is an oriented box between named post stations, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 1092 tris, two materials with 156 metal and 390 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.624×0.134×1.232 m, grounded zmin, 2 iron shoes, brace-to-post gap 2.4 mm on both posts, rail-to-post gap 0.93 mm, rail span 1.390 m, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 32 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-shoes 16; --short-brace 17; --gap-rails 18; --long-rails 19.",
       "hero": "docs/gallery/assets/fence-kit-hero.webp",
       "preview": "showcase/fence-kit/preview.webp",
       "tags": [
@@ -212,8 +212,8 @@
     {
       "name": "hand-pump",
       "dir": "showcase/hand-pump",
-      "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.",
+      "teaches": "A procedural village hand pump whose gooseneck is a 6-gon tube from the lower-column radius, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 1064 tris, two materials with 564 metal and 144 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.610×0.382×1.052 m, grounded zmin, spout-to-column gap 2.7 mm, flange-to-plinth gap 6.0 mm, column radius 62 mm, LOD ratios in band, convex collider 114 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z 16; --float-spout 17; --float-flange 18; --skinny-col 19.",
       "hero": "docs/gallery/assets/hand-pump-hero.webp",
       "preview": "showcase/hand-pump/preview.webp",
       "tags": [
diff --git a/showcase/hand-pump/README.md b/showcase/hand-pump/README.md
index a57e62d..053fcb2 100644
--- a/showcase/hand-pump/README.md
+++ b/showcase/hand-pump/README.md
@@ -1,10 +1,15 @@
 # Hand pump
 
 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.
+pump (stepped wooden plinth, two-diameter column, 6-gon gooseneck
+tube from the lower-column radius, stuffing-box head, handle, wooden
+grip) then the shipped pipeline: unique-cell UVs, Cycles high-to-low
+normal bake, LOD chain, convex collider, Unity glTF export.
+
+The column stays on the origin; only zmin is snapped. The gooseneck is
+a tube about named stations on the lower-column radius, not a chain of
+cylinders. The flange and the plinth cap bite their hosts so stacked
+caps are not coplanar.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -14,6 +19,11 @@ witness an API contract. "It rendered without error" is not a check.
 `bake_normal_high_to_low.py`, `setup_bake_target_image.py`,
 `lod_chain.py` / `decimate_to_budget.py`, `convex_hull_collider.py`,
 `export_preset_unity.py` (helpers copied, not imported as a package).
+Hygiene combinatorics match `examples/mesh-hygiene-audit` (copied, not
+imported).
+
+Intended size: ~1.05 m village pump, 0.34 m plinth, 0.76 m column;
+outer AABB 0.610 × 0.382 × 1.052 m.
 
 ## Budgets
 
@@ -22,39 +32,84 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 1080–1240 | 1164 / 1164 / 1164 |
+| Base triangles | 900–2200 | 1064 / 1064 / 1064 |
 | 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 |
+| LOD2 ratio | 0.10–0.35 of base | 0.2199 / 0.2199 / 0.2162 |
+| Materials | exactly 2 distinct, ≥48 metal, ≥24 wood | 2 slots, 564 metal / 144 wood |
 | UVs | in `0..1`, 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 > 0 | 85944 / 85944 / 85936 bytes |
+| Outer AABB | (0.610, 0.382, 1.052) m ± 0.015 | (0.6100, 0.3820, 1.0520), zmin 0 |
+| Collider tris | ≤ 220 | 114 |
+| Export | written, size > 0 | 97304 / 97304 / 97296 bytes |
+
+Base triangles dropped from **1164 to 1064** in the quality pass: seven
+sausage cylinders became one gooseneck tube, and the wood grip is no
+longer beveled with the plinth. Outer AABB is 0.610 × 0.382 × 1.052 m
+(was 0.610 × 0.364 × 1.049 m).
 
 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
+5.2.1 is slightly leaner on LOD2. The gate is a ratio band, not an
 exact count. Bake pixels are stochastic; the gate is `has_data` plus
 operator `FINISHED`, not byte-identity. Construction uses no RNG.
 Export byte counts differ by 8 B on 5.2.1 (glTF serializer), not a
 gated axis.
 
-`--skip-decimate` skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and
-exit 9 fires. That is the named budget the falsifier violates.
+### Hygiene
+
+Recomputed from the generated mesh, not asserted about the script.
+
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Non-manifold edges | 0 | 0 |
+| Loose verts / edges | 0 / 0 | 0 / 0 |
+| Doubles merged at 1e-5 | 0 | 0 |
+| Zero-area faces | 0 | 0 |
+| N-gons | 0 | 0 |
+| Coplanar disjoint face pairs | 0 | 0 |
+| Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
+| Plinth `zmin` | within 1e-4 of 0 | 0.00000 |
+
+### Joint fit and column
+
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Spout-to-column BVH gap | ≤ 0.008 m | 0.00272 |
+| Flange-to-plinth BVH gap | ≤ 0.008 m | 0.00600 |
+| Lower-column radius vs `COL_R_LO` | ± 0.008 m | 0.06200 |
+
+### Falsifiers
+
+Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1
+and returned the same code on each.
+
+| Flag | Budget violated | Exit |
+| --- | --- | --- |
+| `--skip-decimate` | LOD1 ratio band | 9 |
+| `--stray-vert` | loose vertex count is 0 | 15 |
+| `--lift-z` | bounding box `zmin` is 0 | 16 |
+| `--float-spout` | spout-to-column BVH gap | 17 |
+| `--float-flange` | flange-to-plinth BVH gap | 18 |
+| `--skinny-col` | lower-column radius | 19 |
 
 ## Run
 
 ```bash
 blender --background --python hand_pump.py --
 blender --background --python hand_pump.py -- --skip-decimate
+blender --background --python hand_pump.py -- --stray-vert
+blender --background --python hand_pump.py -- --lift-z
+blender --background --python hand_pump.py -- --float-spout
+blender --background --python hand_pump.py -- --float-flange
+blender --background --python hand_pump.py -- --skinny-col
 blender --background --python hand_pump.py -- --output hand-pump.png
 ```
 
-Smoke does not pass `--output` or `--skip-decimate`.
+Smoke passes no flags.
 
 ## Exit codes
 
 File-local. `9` is a valid check code. `10` is reserved for
-`gallery_framing.check_framing` on the `--output` path.
+`gallery_framing.check_framing` on the `--output` path. `15`–`19` are the
+hygiene and joint-fit family.
 
 | Code | Meaning |
 | --- | --- |
@@ -73,3 +128,8 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 12 | Bake did not finish or image has no data |
 | 13 | Export file missing or empty |
 | 14 | `--output` produced no file |
+| 15 | Hygiene (`--stray-vert` lands here) |
+| 16 | Grounded zmin / plinth (`--lift-z`) |
+| 17 | Spout-to-column gap (`--float-spout`) |
+| 18 | Flange-to-plinth gap (`--float-flange`) |
+| 19 | Column radius (`--skinny-col`) |
diff --git a/showcase/hand-pump/hand_pump.py b/showcase/hand-pump/hand_pump.py
index a4f72c6..2c5639f 100644
--- a/showcase/hand-pump/hand_pump.py
+++ b/showcase/hand-pump/hand_pump.py
@@ -1,13 +1,19 @@
 """Game-ready village hand pump — a showcase piece, not an example.
 
 Asserts budget conformance of a procedural cast-iron hand pump (plinth,
-column, spout, handle, and wooden grip) after composing shipped
-pipeline pieces: bmesh construction, UVs, two materials, high-to-low
-normal bake, LOD chain, convex collider, Unity glTF export.
+column, gooseneck, stuffing-box head, handle, wooden grip) after
+composing shipped pipeline pieces: bmesh construction, UVs, two
+materials, high-to-low normal bake, LOD chain, convex collider,
+Unity glTF export.
+
+The column stays on the origin; only zmin is snapped. The gooseneck is
+a 6-gon tube about named stations on the lower-column radius, not a
+chain of cylinders. The flange bites the plinth.
 
 Budgets are declared below and recomputed from the generated result.
-They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+They are not API-contract witnesses. Hygiene family 15–19:
+``--stray-vert``, ``--lift-z``, ``--float-spout``, ``--float-flange``,
+``--skinny-col``.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -27,6 +33,7 @@
 import bmesh
 import bpy
 from mathutils import Euler, Vector
+from mathutils.bvhtree import BVHTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -36,17 +43,32 @@
 import gallery_framing  # noqa: E402
 
 PLINTH_XY = 0.34
-PLINTH_H = 0.090
-COL_R = 0.050
-COL_H = 0.78
-COL_SEGS = 16
-SPOUT_Z = 0.46
+SLAB_H = 0.050
+CAP_H = 0.040
+PLINTH_BITE = 0.006
+PLINTH_TOP = SLAB_H + CAP_H - PLINTH_BITE
+COL_R_LO = 0.062
+COL_R_HI = 0.046
+COL_SEGS = 24
+LOWER_H = 0.40
+UPPER_H = 0.36
+COL_H = LOWER_H + UPPER_H
+SPOUT_Z = PLINTH_TOP + 0.36
+SPOUT_R = 0.13
+SPOUT_T = 0.036
+SPOUT_N = 10
 HANDLE_LIFT = 0.18
-
-BBOX_TOL = 0.01
-OUTER_SIZE = (0.610, 0.364, 1.049)
-BASE_TRIS_MIN = 1080
-BASE_TRIS_MAX = 1240
+FLANGE_R = 0.095
+FLANGE_H = 0.028
+FLANGE_BITE = 0.006
+BOLT_N = 4
+BOLT_R = 0.008
+BOLT_H = 0.014
+
+BBOX_TOL = 0.015
+OUTER_SIZE = (0.610, 0.382, 1.052)
+BASE_TRIS_MIN = 900
+BASE_TRIS_MAX = 2200
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -56,15 +78,28 @@
 MATERIAL_COUNT = 2
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 160
+COLLIDER_TRIS_MAX = 220
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.08
-METAL_FACES_MIN = 24
-WOOD_FACES_MIN = 12
+METAL_FACES_MIN = 48
+WOOD_FACES_MIN = 24
 
 WOOD_IDX = 0
 METAL_IDX = 1
 
+DOUBLES_EPS = 1e-5
+AREA_EPS = 1e-10
+ZMIN_EPS = 1e-4
+ZFIGHT_EPS = 0.002
+ZFIGHT_COS = 0.98
+SPOUT_GAP_MAX = 0.008
+FLANGE_GAP_MAX = 0.008
+COL_R_TOL = 0.008
+LIFT_Z = 0.05
+FLOAT_SPOUT = 0.12
+FLOAT_FLANGE = 0.04
+SKINNY = 0.028
+
 
 def eevee_engine_id():
     return "BLENDER_EEVEE" if bpy.app.version >= (5, 0, 0) else "BLENDER_EEVEE_NEXT"
@@ -154,7 +189,7 @@ def add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
     geo = bmesh.ops.create_cone(
         bm,
         cap_ends=True,
-        cap_tris=False,
+        cap_tris=True,
         segments=segments,
         radius1=radius,
         radius2=radius,
@@ -171,11 +206,63 @@ def add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
     return verts
 
 
+def add_gooseneck(bm, x, y0, z0, radius, n, thick, mat_idx, t0=0.08, t1=1.0):
+    pts = []
+    for i in range(n + 1):
+        t = t0 + (t1 - t0) * (i / n)
+        ang = t * (math.pi / 2.0)
+        pts.append(
+            Vector(
+                (
+                    x,
+                    y0 - radius * math.sin(ang),
+                    z0 - radius * (1.0 - math.cos(ang)),
+                )
+            )
+        )
+    rings = 6
+    r = thick * 0.5
+    ring_verts = []
+    for i, p in enumerate(pts):
+        if i < n:
+            tangent = (pts[i + 1] - p).normalized()
+        else:
+            tangent = (p - pts[i - 1]).normalized()
+        side = tangent.cross(Vector((1.0, 0.0, 0.0)))
+        if side.length < 1e-6:
+            side = tangent.cross(Vector((0.0, 1.0, 0.0)))
+        side.normalize()
+        up = tangent.cross(side).normalized()
+        ring = []
+        for k in range(rings):
+            ang = (2.0 * math.pi * k) / rings
+            offset = side * math.cos(ang) * r + up * math.sin(ang) * r
+            ring.append(bm.verts.new(p + offset))
+        ring_verts.append(ring)
+    bm.verts.ensure_lookup_table()
+    for a, b in zip(ring_verts, ring_verts[1:]):
+        for k in range(rings):
+            k2 = (k + 1) % rings
+            face = bm.faces.new((a[k], a[k2], b[k2], b[k]))
+            face.material_index = mat_idx
+    for end_i, p in ((0, pts[0]), (-1, pts[-1])):
+        center = bm.verts.new(p)
+        ring = ring_verts[end_i]
+        for k in range(rings):
+            k2 = (k + 1) % rings
+            if end_i == 0:
+                face = bm.faces.new((center, ring[k2], ring[k]))
+            else:
+                face = bm.faces.new((center, ring[k], ring[k2]))
+            face.material_index = mat_idx
+    return [v for ring in ring_verts for v in ring]
+
+
 def add_cone(bm, loc, radius1, radius2, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
     geo = bmesh.ops.create_cone(
         bm,
         cap_ends=True,
-        cap_tris=False,
+        cap_tris=True,
         segments=segments,
         radius1=radius1,
         radius2=radius2,
@@ -275,45 +362,39 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def build_hand_pump_mesh(name, bevel_offset, bevel_segments):
+def build_hand_pump_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    float_spout=False,
+    float_flange=False,
+    skinny_col=False,
+):
     bm = bmesh.new()
     try:
         wood = []
-        metal = []
-        slab_h = 0.050
-        cap_h = 0.040
-        top_z = slab_h + cap_h + COL_H
+        r_lo = COL_R_LO - SKINNY if skinny_col else COL_R_LO
+        r_hi = COL_R_HI - SKINNY * 0.6 if skinny_col else COL_R_HI
+        top_z = PLINTH_TOP + COL_H
+        pivot = Vector((0.0, r_hi + 0.028, top_z + 0.010))
+        grip_end = Vector((-0.38, pivot.y + 0.015, pivot.z + HANDLE_LIFT))
 
         wood.extend(
             add_box(
                 bm,
-                (0.0, 0.0, slab_h / 2.0),
-                (PLINTH_XY, PLINTH_XY, slab_h),
+                (0.0, 0.0, SLAB_H / 2.0),
+                (PLINTH_XY, PLINTH_XY, SLAB_H),
                 WOOD_IDX,
             )
         )
         wood.extend(
             add_box(
                 bm,
-                (0.0, 0.0, slab_h + cap_h / 2.0),
-                (0.26, 0.26, cap_h),
+                (0.0, 0.0, SLAB_H - PLINTH_BITE + 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.018,
-                0.12,
-                10,
-                WOOD_IDX,
-                euler=(0.0, math.pi / 2.0, 0.0),
-            )
-        )
-
         if bevel_offset > 0.0:
             edges = list({e for v in wood for e in v.link_edges})
             ret = bmesh.ops.bevel(
@@ -328,146 +409,127 @@ 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(
+        wood.extend(
             add_cyl(
                 bm,
-                (0.0, 0.0, plinth_top + 0.016),
-                0.095,
-                0.032,
-                COL_SEGS,
-                METAL_IDX,
+                (grip_end.x, grip_end.y, grip_end.z),
+                0.018,
+                0.12,
+                12,
+                WOOD_IDX,
+                euler=(0.0, math.pi / 2.0, 0.0),
             )
         )
-        lower_h = 0.40
-        metal.extend(
-            add_cyl(
-                bm,
-                (0.0, 0.0, plinth_top + lower_h / 2.0),
-                0.062,
-                lower_h,
-                COL_SEGS,
-                METAL_IDX,
-            )
+
+        flange_z = PLINTH_TOP - FLANGE_BITE + FLANGE_H / 2.0
+        if float_flange:
+            flange_z += FLOAT_FLANGE
+        add_cyl(
+            bm, (0.0, 0.0, flange_z), FLANGE_R, FLANGE_H, COL_SEGS, METAL_IDX
         )
-        joint_z = plinth_top + lower_h
-        metal.extend(
+        bolt_ring = FLANGE_R * 0.72
+        for i in range(BOLT_N):
+            ang = math.pi / 4.0 + i * (math.pi / 2.0)
             add_cyl(
                 bm,
-                (0.0, 0.0, joint_z),
-                0.078,
-                0.026,
-                COL_SEGS,
+                (
+                    bolt_ring * math.cos(ang),
+                    bolt_ring * math.sin(ang),
+                    flange_z + FLANGE_H / 2.0 + BOLT_H / 2.0 - 0.002,
+                ),
+                BOLT_R,
+                BOLT_H,
+                8,
                 METAL_IDX,
             )
+
+        add_cyl(
+            bm,
+            (0.0, 0.0, PLINTH_TOP + LOWER_H / 2.0),
+            r_lo,
+            LOWER_H,
+            COL_SEGS,
+            METAL_IDX,
         )
-        upper_h = 0.36
-        metal.extend(
-            add_cyl(
-                bm,
-                (0.0, 0.0, joint_z + upper_h / 2.0),
-                0.046,
-                upper_h,
-                COL_SEGS,
-                METAL_IDX,
-            )
+        joint_z = PLINTH_TOP + LOWER_H
+        add_cyl(
+            bm,
+            (0.0, 0.0, joint_z + UPPER_H / 2.0 - 0.006),
+            r_hi,
+            UPPER_H,
+            COL_SEGS,
+            METAL_IDX,
         )
-        metal.extend(
-            add_box(
-                bm,
-                (0.0, 0.0, top_z + 0.012),
-                (0.10, 0.10, 0.085),
-                METAL_IDX,
-            )
+
+        add_cyl(
+            bm,
+            (0.0, 0.0, top_z + 0.012),
+            0.052,
+            0.048,
+            COL_SEGS,
+            METAL_IDX,
         )
-        metal.extend(
-            add_cyl(
-                bm,
-                (0.0, 0.0, top_z + 0.068),
-                0.034,
-                0.036,
-                COL_SEGS,
-                METAL_IDX,
-            )
+        add_cyl(
+            bm,
+            (0.0, 0.0, top_z + 0.044),
+            0.032,
+            0.030,
+            8,
+            METAL_IDX,
         )
 
-        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, last[1], last[2] - 0.028),
-                0.016,
-                0.056,
-                10,
-                METAL_IDX,
-            )
+        cheek_y = pivot.y
+        add_box(
+            bm,
+            (0.028, cheek_y, pivot.z),
+            (0.016, 0.046, 0.044),
+            METAL_IDX,
         )
-
-        metal.extend(
-            add_box(
-                bm,
-                (0.028, pivot.y, pivot.z),
-                (0.022, 0.048, 0.050),
-                METAL_IDX,
-            )
+        add_box(
+            bm,
+            (-0.028, cheek_y, pivot.z),
+            (0.016, 0.046, 0.044),
+            METAL_IDX,
         )
-        metal.extend(
-            add_box(
-                bm,
-                (-0.028, pivot.y, pivot.z),
-                (0.022, 0.048, 0.050),
-                METAL_IDX,
-            )
+        add_cyl(
+            bm,
+            (0.0, cheek_y, pivot.z),
+            0.010,
+            0.068,
+            10,
+            METAL_IDX,
+            euler=(0.0, math.pi / 2.0, 0.0),
         )
-        metal.extend(
-            add_cyl(
-                bm,
-                (0.0, pivot.y, pivot.z),
-                0.012,
-                0.072,
-                10,
-                METAL_IDX,
-                euler=(0.0, math.pi / 2.0, 0.0),
-            )
+        add_oriented_box(
+            bm,
+            (pivot.x, pivot.y, pivot.z),
+            (grip_end.x + 0.03, grip_end.y, grip_end.z),
+            (0.018, 0.014),
+            METAL_IDX,
         )
-        metal.extend(
-            add_oriented_box(
-                bm,
-                (pivot.x, pivot.y, pivot.z),
-                (grip_end.x + 0.03, grip_end.y, grip_end.z),
-                (0.020, 0.016),
-                METAL_IDX,
-            )
+
+        y0 = -r_lo
+        z0 = SPOUT_Z
+        if float_spout:
+            y0 -= FLOAT_SPOUT
+        add_gooseneck(
+            bm, 0.0, y0, z0, SPOUT_R, SPOUT_N, SPOUT_T, METAL_IDX, t0=-0.14
+        )
+        nozzle_y = y0 - SPOUT_R
+        nozzle_z = z0 - SPOUT_R
+        add_cone(
+            bm,
+            (0.0, nozzle_y, nozzle_z - 0.028),
+            0.014,
+            0.020,
+            0.044,
+            12,
+            METAL_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]
-        rcx = 0.5 * (min(xs) + max(xs))
-        rcy = 0.5 * (min(ys) + max(ys))
         zmin = min(zs)
         for v in bm.verts:
-            v.co.x -= rcx
-            v.co.y -= rcy
             v.co.z -= zmin
             if v.co.z < 0.0:
                 v.co.z = 0.0
@@ -475,12 +537,12 @@ def build_hand_pump_mesh(name, bevel_offset, bevel_segments):
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         for face in bm.faces:
-            face.smooth = False
+            face.smooth = face.material_index == METAL_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
         for poly in me.polygons:
-            poly.use_smooth = False
+            poly.use_smooth = poly.material_index == METAL_IDX
     finally:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -488,13 +550,25 @@ def build_hand_pump_mesh(name, bevel_offset, bevel_segments):
     return out
 
 
-def principled(name, color, metallic, roughness):
+def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
-    bsdf = mat.node_tree.nodes["Principled BSDF"]
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = color
     bsdf.inputs["Metallic"].default_value = metallic
     bsdf.inputs["Roughness"].default_value = roughness
+    if noise_scale > 0.0 and wear is not None:
+        tex = nt.nodes.new("ShaderNodeTexNoise")
+        tex.inputs["Scale"].default_value = noise_scale
+        tex.inputs["Detail"].default_value = 6.0
+        mix = nt.nodes.new("ShaderNodeMix")
+        mix.data_type = "RGBA"
+        mix.inputs["A"].default_value = color
+        mix.inputs["B"].default_value = wear
+        fac = mix.inputs.get("Factor") or mix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], fac)
+        nt.links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])
     return mat
 
 
@@ -509,10 +583,11 @@ def assign_slots(obj, wood, metal):
 
 
 def world_bbox(obj):
-    corners = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
-    xs = [c.x for c in corners]
-    ys = [c.y for c in corners]
-    zs = [c.z for c in corners]
+    mat = obj.matrix_world
+    pts = [mat @ v.co for v in obj.data.vertices]
+    xs = [p.x for p in pts]
+    ys = [p.y for p in pts]
+    zs = [p.z for p in pts]
     return (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
@@ -575,6 +650,190 @@ def convex_hull_collider(obj, name):
     return collider
 
 
+def face_area(me, poly):
+    vs = [me.vertices[i].co for i in poly.vertices]
+    if len(vs) < 3:
+        return 0.0
+    v0 = vs[0]
+    area = 0.0
+    for i in range(1, len(vs) - 1):
+        area += (vs[i] - v0).cross(vs[i + 1] - v0).length * 0.5
+    return area
+
+
+def hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(1 for p in me.polygons if len(p.vertices) > 4)
+    zero_area = sum(1 for p in me.polygons if face_area(me, p) <= AREA_EPS)
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        loose_v = sum(1 for v in bm.verts if len(v.link_edges) == 0)
+        loose_e = sum(1 for e in bm.edges if len(e.link_faces) == 0)
+        nonman = sum(1 for e in bm.edges if not e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get("targetmap") or {})
+    finally:
+        bm.free()
+    return {
+        "nv": nv, "ne": ne, "nf": nf, "ngons": ngons,
+        "loose_v": loose_v, "loose_e": loose_e, "nonman": nonman,
+        "zero_area": zero_area, "doubles": doubles, "euler": nv - ne + nf,
+    }
+
+
+def zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        for p in me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = 0
+    for i in range(len(data)):
+        ci, ni, vi = data[i]
+        for j in range(i + 1, len(data)):
+            cj, nj, vj = data[j]
+            if (cj - ci).length_squared > eps2:
+                continue
+            if abs(ni.dot(nj)) <= ZFIGHT_COS:
+                continue
+            if vi & vj:
+                continue
+            count += 1
+    return count
+
+
+def shells(me):
+    neighbors = [[] for _ in range(len(me.vertices))]
+    for edge in me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [False] * len(me.vertices)
+    groups = []
+    for start in range(len(me.vertices)):
+        if seen[start]:
+            continue
+        seen[start] = True
+        stack = [start]
+        group = []
+        while stack:
+            current = stack.pop()
+            group.append(current)
+            for nxt in neighbors[current]:
+                if not seen[nxt]:
+                    seen[nxt] = True
+                    stack.append(nxt)
+        groups.append(group)
+    return groups
+
+
+def shell_aabb(me, group):
+    pts = [me.vertices[i].co for i in group]
+    return (
+        min(p.x for p in pts), min(p.y for p in pts), min(p.z for p in pts),
+        max(p.x for p in pts), max(p.y for p in pts), max(p.z for p in pts),
+    )
+
+
+def mat_of(me, group):
+    member = set(group)
+    for poly in me.polygons:
+        if all(i in member for i in poly.vertices):
+            return poly.material_index
+    return None
+
+
+def shell_bvh_gap(me, ga, gb):
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    try:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        keep_a, keep_b = set(ga), set(gb)
+        drop_a = [f for f in bm_a.faces if not all(v.index in keep_a for v in f.verts)]
+        drop_b = [f for f in bm_b.faces if not all(v.index in keep_b for v in f.verts)]
+        if drop_a:
+            bmesh.ops.delete(bm_a, geom=drop_a, context="FACES")
+        if drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context="FACES")
+        if not bm_a.faces or not bm_b.faces:
+            return 1e9
+        tree = BVHTree.FromBMesh(bm_b)
+        best = 1e9
+        for v in bm_a.verts:
+            hit = tree.find_nearest(v.co)
+            if hit[0] is not None:
+                best = min(best, hit[3])
+        for f in bm_a.faces:
+            hit = tree.find_nearest(f.calc_center_median())
+            if hit[0] is not None:
+                best = min(best, hit[3])
+        return best
+    finally:
+        bm_a.free()
+        bm_b.free()
+
+
+def add_stray_vert(me):
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.new((0.0, 0.0, PLINTH_TOP + LOWER_H * 0.5))
+        bm.to_mesh(me)
+        me.update()
+    finally:
+        bm.free()
+
+
+def joint_audit(me):
+    groups = shells(me)
+    plinths = []
+    columns = []
+    spouts = []
+    flanges = []
+    for g in groups:
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        mat = mat_of(me, g)
+        if mat == WOOD_IDX and dz < 0.08 and dx > 0.20:
+            plinths.append((g, a))
+        if mat == METAL_IDX and dz > 0.25 and dx < 0.18 and dy < 0.18:
+            columns.append((g, a))
+        if mat == METAL_IDX and dy > 0.10 and dx < 0.10 and a[1] < -0.04:
+            spouts.append((g, a))
+        if mat == METAL_IDX and dz < 0.05 and dx > 0.14 and a[2] < PLINTH_TOP + 0.05:
+            flanges.append((g, a))
+    spout_gap = 99.0
+    if spouts and columns:
+        spout_gap = min(
+            shell_bvh_gap(me, s[0], c[0]) for s in spouts for c in columns
+        )
+    flange_gap = 99.0
+    if flanges and plinths:
+        flange_gap = min(
+            shell_bvh_gap(me, f[0], p[0]) for f in flanges for p in plinths
+        )
+    col_r = 0.0
+    if columns:
+        widest = max(columns, key=lambda t: max(t[1][3] - t[1][0], t[1][4] - t[1][1]))
+        a = widest[1]
+        col_r = 0.5 * max(a[3] - a[0], a[4] - a[1])
+    plinth_z = 99.0
+    if plinths:
+        plinth_z = min(a[2] for _g, a in plinths)
+    return {
+        "plinths": len(plinths),
+        "columns": len(columns),
+        "spouts": len(spouts),
+        "flanges": len(flanges),
+        "spout_gap": spout_gap,
+        "flange_gap": flange_gap,
+        "col_r": col_r,
+        "plinth_z": plinth_z,
+    }
+
+
 def setup_bake_image(obj, target_mat, size=BAKE_RES):
     if not obj.data.uv_layers:
         return None, None
@@ -627,15 +886,40 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def check(
+    skip_decimate,
+    lift_z=False,
+    stray_vert=False,
+    float_spout=False,
+    float_flange=False,
+    skinny_col=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    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.22, 0.21, 0.20, 1.0), 1.0, 0.35)
+    kw = dict(
+        float_spout=float_spout,
+        float_flange=float_flange,
+        skinny_col=skinny_col,
+    )
+    low = build_hand_pump_mesh("HandPumpLow", bevel_offset=0.004, bevel_segments=2, **kw)
+    high = build_hand_pump_mesh("HandPumpHigh", bevel_offset=0.004, bevel_segments=4, **kw)
+    wood = principled(
+        "HandPumpWood", (0.36, 0.19, 0.07, 1.0), 0.0, 0.60,
+        noise_scale=14.0, wear=(0.22, 0.12, 0.05, 1.0),
+    )
+    metal = principled(
+        "HandPumpIron", (0.18, 0.175, 0.17, 1.0), 1.0, 0.38,
+        noise_scale=18.0, wear=(0.28, 0.24, 0.18, 1.0),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
+    if stray_vert:
+        add_stray_vert(low.data)
+    if lift_z:
+        for v in low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+
     if low.data is None or len(low.data.polygons) < 6:
         return fail("hand pump mesh did not build", 3), None, None, None, None, None
 
@@ -667,7 +951,7 @@ def check(skip_decimate):
     r2 = lod2_tris / base_tris if base_tris else 0.0
 
     collider_src = build_hand_pump_mesh(
-        "HandPumpColSrc", bevel_offset=0.0, bevel_segments=1
+        "HandPumpColSrc", bevel_offset=0.0, bevel_segments=1, **kw
     )
     collider = convex_hull_collider(collider_src, "HandPumpCollider")
     bpy.data.objects.remove(collider_src, do_unlink=True)
@@ -682,6 +966,10 @@ def check(skip_decimate):
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
 
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    jnt = joint_audit(low.data)
+
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
         f"measured base_tris={base_tris} lod1_tris={lod1_tris} "
@@ -699,6 +987,17 @@ def check(skip_decimate):
         f"measured collider_tris={col_tris} bake={bake_result} "
         f"bake_has_data={img.has_data} export_bytes={export_size}"
     )
+    print(
+        f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+        f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+        f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}"
+    )
+    print(
+        f"measured plinths={jnt['plinths']} columns={jnt['columns']} "
+        f"spouts={jnt['spouts']} flanges={jnt['flanges']} "
+        f"spout_gap={jnt['spout_gap']:.5f} flange_gap={jnt['flange_gap']:.5f} "
+        f"col_r={jnt['col_r']:.5f} plinth_z={jnt['plinth_z']:.5f}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -730,6 +1029,28 @@ def check(skip_decimate):
             f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}",
             7,
         ), None, None, None, None, None
+    if bb[2] > ZMIN_EPS or jnt["plinth_z"] > ZMIN_EPS:
+        return fail(
+            f"grounded zmin={bb[2]:.5f} plinth_z={jnt['plinth_z']:.5f}",
+            16,
+        ), None, None, None, None, None
+    if jnt["spouts"] < 1 or jnt["columns"] < 1 or jnt["spout_gap"] > SPOUT_GAP_MAX:
+        return fail(
+            f"spout gap {jnt['spout_gap']:.5f} spouts={jnt['spouts']} "
+            f"columns={jnt['columns']}",
+            17,
+        ), None, None, None, None, None
+    if jnt["flanges"] < 1 or jnt["plinths"] < 1 or jnt["flange_gap"] > FLANGE_GAP_MAX:
+        return fail(
+            f"flange gap {jnt['flange_gap']:.5f} flanges={jnt['flanges']} "
+            f"plinths={jnt['plinths']}",
+            18,
+        ), None, None, None, None, None
+    if abs(jnt["col_r"] - COL_R_LO) > COL_R_TOL:
+        return fail(
+            f"column radius {jnt['col_r']:.5f} off {COL_R_LO}",
+            19,
+        ), None, None, None, None, None
     if (
         abs(size_x - OUTER_SIZE[0]) > BBOX_TOL
         or abs(size_y - OUTER_SIZE[1]) > BBOX_TOL
@@ -763,6 +1084,16 @@ def check(skip_decimate):
         ), None, None, None, None, None
     if export_size <= 0:
         return fail("export file missing or empty", 13), None, None, None, None, None
+    if (
+        hyg["loose_v"] or hyg["loose_e"] or hyg["nonman"] or hyg["zero_area"]
+        or hyg["doubles"] or hyg["ngons"] or zf
+    ):
+        return fail(
+            f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+            f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}",
+            15,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -876,14 +1207,22 @@ def main():
     p = argparse.ArgumentParser()
     p.add_argument("--output", default=None)
     p.add_argument("--engine", default="eevee", choices=("eevee", "cycles"))
-    p.add_argument(
-        "--skip-decimate",
-        action="store_true",
-        help="falsification: skip the LOD DECIMATE stage",
-    )
+    p.add_argument("--skip-decimate", action="store_true")
+    p.add_argument("--stray-vert", action="store_true")
+    p.add_argument("--lift-z", action="store_true")
+    p.add_argument("--float-spout", action="store_true")
+    p.add_argument("--float-flange", action="store_true")
+    p.add_argument("--skinny-col", action="store_true")
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        float_spout=args.float_spout,
+        float_flange=args.float_flange,
+        skinny_col=args.skinny_col,
+    )
     if code:
         return code
     if args.output:
diff --git a/showcase/hand-pump/preview.webp b/showcase/hand-pump/preview.webp
index 89d748c..d52e908 100644
Binary files a/showcase/hand-pump/preview.webp and b/showcase/hand-pump/preview.webp differ